fathom-typescript/dist/esm/funcs/withAuthorization.js

Fathom's official TypeScript SDK.

import * as z from "zod";
import { SDK_METADATA } from "../lib/config.js";
const tokenResponseSchema = z.object({
    access_token: z.string(),
    expires_in: z.number().positive(),
    refresh_token: z.string(),
    token_type: z.string().optional(),
    scope: z.string().optional(),
});
const tolerance = 5 * 60;
export function withAuthorization({ clientId, clientSecret, code, redirectUri, tokenStore, }) {
    const url = "https://fathom.video/external/v1/oauth2/token";
    return async () => {
        const session = await tokenStore.get();
        const now_seconds = Date.now() / 1000;
        if (session && session.token !== '' && session.expires > now_seconds) {
            return { bearerAuth: session.token };
        }
        if (session?.token === '') {
            try {
                const response = await fetch(url, {
                    method: "POST",
                    headers: {
                        "content-type": "application/x-www-form-urlencoded",
                        "user-agent": SDK_METADATA.userAgent,
                    },
                    body: new URLSearchParams({
                        client_id: clientId,
                        client_secret: clientSecret,
                        code: code,
                        redirect_uri: redirectUri,
                        grant_type: "authorization_code",
                    }),
                });
                if (!response.ok) {
                    throw new Error("Unexpected status code: " + response.status);
                }
                const json = await response.json();
                const data = tokenResponseSchema.parse(json);
                await tokenStore.set(data.access_token, data.refresh_token, now_seconds + data.expires_in - tolerance);
                return { bearerAuth: data.access_token };
            }
            catch (error) {
                throw new Error("Failed to obtain OAuth token: " + error);
            }
        }
        try {
            const response = await fetch(url, {
                method: "POST",
                headers: {
                    "content-type": "application/x-www-form-urlencoded",
                    "user-agent": SDK_METADATA.userAgent,
                },
                body: new URLSearchParams({
                    client_id: clientId,
                    client_secret: clientSecret,
                    refresh_token: session?.refresh_token || "",
                    grant_type: "refresh_token",
                }),
            });
            if (!response.ok) {
                throw new Error("Unexpected status code: " + response.status);
            }
            const json = await response.json();
            const data = tokenResponseSchema.parse(json);
            await tokenStore.set(data.access_token, data.refresh_token, now_seconds + data.expires_in - tolerance);
            return { bearerAuth: data.access_token };
        }
        catch (error) {
            throw new Error("Failed to obtain OAuth token: " + error);
        }
    };
}
export class InMemoryTokenStore {
    constructor() {
        this.token = "";
        this.refresh_token = "";
        this.expires = Date.now();
    }
    async get() {
        return { token: this.token, refresh_token: this.refresh_token, expires: this.expires };
    }
    async set(token, refresh_token, expires) {
        this.token = token;
        this.refresh_token = refresh_token;
        this.expires = expires;
    }
}
//# sourceMappingURL=withAuthorization.js.map