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

Fathom's official TypeScript SDK.

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.InMemoryTokenStore = void 0;
exports.withAuthorization = withAuthorization;
const z = __importStar(require("zod"));
const config_js_1 = require("../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;
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": config_js_1.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": config_js_1.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);
        }
    };
}
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;
    }
}
exports.InMemoryTokenStore = InMemoryTokenStore;
//# sourceMappingURL=withAuthorization.js.map