@aloma.io/integration-sdk 3.7.49 → 3.8.0

package/build/internal/connector/server/on-connect.mjs

@@ -0,0 +1,297 @@
+import { init } from "@paralleldrive/cuid2";
+import Fetcher from "../../fetcher/fetcher.mjs";
+import { OAuth } from "../../fetcher/oauth-fetcher.mjs";
+const cuid = init({ length: 32 });
+export const onConnect = ({ dispatcher, configSchema, config, start }) => {
+    return (transport) => {
+        dispatcher.onConfig = async function (secrets) {
+            const decrypted = {};
+            const fields = configSchema().fields;
+            const keys = Object.keys(secrets);
+            const jwe = await config.validateKeys("RSA-OAEP-256");
+            for (var i = 0; i < keys.length; ++i) {
+                const key = keys[i];
+                const value = secrets[key];
+                if (!value)
+                    continue;
+                if (fields[key]?.plain || ["endpointUrl"].includes(key)) {
+                    decrypted[key] = value;
+                }
+                else {
+                    try {
+                        decrypted[key] = await jwe.decrypt(value, config.id());
+                    }
+                    catch (e) {
+                        console.log("failed to decrypt key", key, config.id(), e);
+                    }
+                }
+            }
+            dispatcher.startOAuth = async function () {
+                if (!dispatcher._oauth)
+                    throw new Error("oauth not configured");
+                const authorizationURL = process.env.OAUTH_AUTHORIZATION_URL ||
+                    decrypted.authorizationURL ||
+                    that._oauth.authorizationURL;
+                if (!authorizationURL)
+                    throw new Error("authorizationURL not configured");
+                const clientId = decrypted.clientId ||
+                    process.env.OAUTH_CLIENT_ID ||
+                    dispatcher._oauth.clientId;
+                if (!clientId)
+                    throw new Error("clientId not configured");
+                const scopes = process.env.OAUTH_SCOPE ||
+                    decrypted.scope ||
+                    dispatcher._oauth.scope ||
+                    "";
+                const useCodeChallenge = !!that._oauth.useCodeChallenge;
+                return {
+                    url: authorizationURL
+                        .replace(/\{\{clientId\}\}/gi, encodeURIComponent(clientId))
+                        .replace(/\{\{scope\}\}/gi, encodeURIComponent(scopes)),
+                    useCodeChallenge,
+                };
+            };
+            dispatcher.finishOAuth = async function (arg) {
+                var that = this;
+                const tokenURL = process.env.OAUTH_TOKEN_URL ||
+                    decrypted.tokenURL ||
+                    that._oauth.tokenURL;
+                if (!dispatcher._oauth)
+                    throw new Error("oauth not configured");
+                if (!tokenURL && !dispatcher._oauth.finishOAuth)
+                    throw new Error("need tokenURL or finishOAuth(arg)");
+                var data = null;
+                const doFinish = async () => {
+                    if (!arg.code || !arg.redirectURI)
+                        throw new Error("need code and redirectUri");
+                    const clientId = decrypted.clientId ||
+                        process.env.OAUTH_CLIENT_ID ||
+                        that._oauth.clientId;
+                    if (!clientId)
+                        throw new Error("clientId not configured");
+                    const clientSecret = decrypted.clientSecret ||
+                        process.env.OAUTH_CLIENT_SECRET ||
+                        that._oauth.clientSecret;
+                    if (!clientSecret)
+                        throw new Error("clientSecret not configured");
+                    const additionalTokenArgs = that._oauth.additionalTokenArgs || {};
+                    const useAuthHeader = !!that._oauth.useAuthHeader;
+                    const useCodeChallenge = !!that._oauth.useCodeChallenge;
+                    let body = {
+                        grant_type: "authorization_code",
+                        ...additionalTokenArgs,
+                        code: arg.code,
+                        redirect_uri: arg.redirectURI,
+                    };
+                    if (useCodeChallenge) {
+                        body.code_verifier = arg.codeVerifier;
+                    }
+                    let headers = {
+                        "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
+                        Accept: "application/json",
+                    };
+                    if (useAuthHeader) {
+                        headers = {
+                            ...headers,
+                            Authorization: `Basic ${btoa(`${clientId}:${clientSecret}`)}`,
+                        };
+                    }
+                    else {
+                        body = {
+                            ...body,
+                            client_id: clientId,
+                            client_secret: clientSecret,
+                        };
+                    }
+                    const response = await fetch(tokenURL, {
+                        method: "POST",
+                        body: new URLSearchParams(body),
+                        headers,
+                        signal: AbortSignal.timeout(60 * 1000),
+                    });
+                    const status = await response.status;
+                    const text = await response.text();
+                    if (status === 200) {
+                        const ret = JSON.parse(text);
+                        if (ret.error) {
+                            throw new Error(`${status} ${ret.error} ${ret.error_description || ""}`);
+                        }
+                        else if (ret.access_token) {
+                            return { ...ret };
+                        }
+                        else {
+                            throw new Error(status + " response has no access_token - " + text);
+                        }
+                    }
+                    else {
+                        throw new Error(status + " " + text);
+                    }
+                };
+                if (dispatcher._oauth.finishOAuth) {
+                    data = await dispatcher._oauth.finishOAuth({
+                        arg,
+                        doFinish,
+                        transport,
+                    });
+                }
+                else {
+                    data = await doFinish();
+                }
+                const jwe = await config.validateKeys("RSA-OAEP-256");
+                return { value: await jwe.encrypt(data, "none", config.id()) };
+            };
+            const saveOAuthResult = async (what) => {
+                const jwe = await config.validateKeys("RSA-OAEP-256");
+                const value = await jwe.encrypt(what, "none", config.id());
+                const packet = transport.newPacket({});
+                packet.method("connector.config-update");
+                packet.args({
+                    value,
+                });
+                transport.send(packet);
+            };
+            const that = this;
+            const getRefreshToken = async (refreshToken) => {
+                const tokenURL = process.env.OAUTH_TOKEN_URL ||
+                    decrypted.tokenURL ||
+                    that._oauth.tokenURL;
+                const clientId = decrypted.clientId ||
+                    process.env.OAUTH_CLIENT_ID ||
+                    that._oauth.clientId;
+                if (!clientId)
+                    throw new Error("clientId not configured");
+                const clientSecret = decrypted.clientSecret ||
+                    process.env.OAUTH_CLIENT_SECRET ||
+                    that._oauth.clientSecret;
+                if (!clientSecret)
+                    throw new Error("clientSecret not configured");
+                const useAuthHeader = !!that._oauth.useAuthHeader;
+                let headers = {};
+                if (useAuthHeader) {
+                    headers = {
+                        ...headers,
+                        Authorization: `Basic ${btoa(`${clientId}:${clientSecret}`)}`,
+                    };
+                }
+                const response = await fetch(tokenURL, {
+                    method: "POST",
+                    body: new URLSearchParams({
+                        grant_type: "refresh_token",
+                        refresh_token: refreshToken,
+                        client_id: clientId,
+                        client_secret: clientSecret,
+                    }),
+                    headers: {
+                        "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
+                        Accept: "application/json",
+                        ...headers,
+                    },
+                    signal: AbortSignal.timeout(60 * 1000),
+                });
+                const status = await response.status;
+                const text = await response.text();
+                if (status === 200) {
+                    return JSON.parse(text);
+                }
+                else {
+                    throw new Error("could not get refresh token " + status + " " + text);
+                }
+            };
+            const theOAuth = that._oauth
+                ? new OAuth(decrypted.oauthResult, saveOAuthResult, getRefreshToken)
+                : null;
+            if (theOAuth) {
+                clearInterval(dispatcher._refreshOAuthToken);
+                if (!(dispatcher._oauth.noPeriodicTokenRefresh === false)) {
+                    dispatcher._refreshOAuthToken = setInterval(async () => {
+                        try {
+                            console.log("refreshing oauth token");
+                            await theOAuth.periodicRefresh();
+                        }
+                        catch (e) {
+                            console.log("periodic refresh", e);
+                        }
+                    }, dispatcher._oauth.tokenRefreshPeriod || 4 * 60 * 60 * 15000);
+                }
+            }
+            const getBlob = (id) => {
+                return new Promise((resolve, reject) => {
+                    const packet = transport.newPacket({}, (ret) => (ret?.error ? reject(ret.error) : resolve(ret)), `_req-${cuid()}`);
+                    packet.method("connector.blob.get");
+                    packet.args({
+                        id,
+                    });
+                    transport.send(packet);
+                });
+            };
+            const getBlobContent = (id) => {
+                return new Promise((resolve, reject) => {
+                    const packet = transport.newPacket({}, (ret) => ret?.error ? reject(ret.error) : resolve(ret?.content), `_req-${cuid()}`);
+                    packet.method("connector.blob.get-content");
+                    packet.args({
+                        id,
+                    });
+                    transport.send(packet);
+                });
+            };
+            const createBlob = (args = {}) => {
+                return new Promise((resolve, reject) => {
+                    const packet = transport.newPacket({}, (ret) => (ret?.error ? reject(ret.error) : resolve(ret?.id)), `_req-${cuid()}`);
+                    packet.method("connector.blob.create");
+                    packet.args(args);
+                    transport.send(packet);
+                });
+            };
+            let oauthClient;
+            start({
+                config: decrypted,
+                oauth: theOAuth,
+                getBlob,
+                getBlobContent,
+                createBlob,
+                healthCheck: async (controller) => {
+                    let result = { ok: true, error: null };
+                    try {
+                        if (oauthClient) {
+                            await oauthClient.__healthCheck();
+                        }
+                        await controller.__healthCheck();
+                    }
+                    catch (e) {
+                        result.ok = false;
+                        result.error = e.message;
+                    }
+                    const packet = transport.newPacket({});
+                    packet.method("connector.health.check");
+                    packet.args(result);
+                    transport.send(packet);
+                },
+                getClient: (arg) => theOAuth
+                    ? (oauthClient = theOAuth.getClient(arg))
+                    : new Fetcher(arg),
+                newTask: (name, data) => {
+                    return new Promise((resolve, reject) => {
+                        const packet = transport.newPacket({}, (ret) => (ret?.error ? reject(ret.error) : resolve(ret)), `_req-${cuid()}`);
+                        packet.method("connector.task.new");
+                        packet.args({
+                            name,
+                            a: data,
+                        });
+                        transport.send(packet);
+                    });
+                },
+                updateTask: (id, data) => {
+                    return new Promise((resolve, reject) => {
+                        const packet = transport.newPacket({}, (ret) => (ret?.error ? reject(ret.error) : resolve(ret)), `_req-${cuid()}`);
+                        packet.method("connector.task.update");
+                        packet.args({
+                            id,
+                            a: data,
+                        });
+                        transport.send(packet);
+                    });
+                },
+            });
+        };
+    };
+};

package/build/internal/connector/server/on-message.d.mts

@@ -0,0 +1 @@
+export declare const onMessage: (processPacket: any) => (packet: any, transport: any) => Promise<void>;

package/build/internal/connector/server/on-message.mjs

@@ -0,0 +1,14 @@
+import { handlePacketError, reply } from "../../util/index.mjs";
+export const onMessage = (processPacket) => {
+    return async (packet, transport) => {
+        try {
+            const ret = await processPacket(packet);
+            if (ret)
+                reply(ret, packet, transport);
+        }
+        catch (e) {
+            console.log(e);
+            handlePacketError(packet, e, transport);
+        }
+    };
+};

package/build/internal/dispatcher/index.d.mts

@@ -4,6 +4,7 @@ export default class Dispatcher {
     _oauth: any;
     private _types;
     private _resolvers;
+    _refreshOAuthToken?: any;
     constructor();
     main(what: any): this;
     oauth(arg: any): this;
@@ -11,8 +12,17 @@ export default class Dispatcher {
     config({ fields, oauth, description, summary }: any): this;
     resolvers(what: any): this;
     endpoint(what: any, notOptional: any): this;
-    startOAuth(): void;
-    finishOAuth(): void;
+    startOAuth(): Promise<{
+        url: string;
+        useCodeChallenge: boolean;
+    }>;
+    finishOAuth(arg: {
+        code: string;
+        redirectURI: string;
+        codeVerifier?: string;
+    }): Promise<{
+        value: string;
+    }>;
     build(): {
         introspect: () => any;
         configSchema: () => any;

package/build/internal/dispatcher/index.mjs

@@ -4,6 +4,7 @@ export default class Dispatcher {
     _oauth;
     _types;
     _resolvers;
+    _refreshOAuthToken;
     constructor() {
         this._config = { fields: {} };
     }
@@ -68,7 +69,7 @@ export default class Dispatcher {
                         placeholder: "e.g. x y z",
                         type: "line",
                         description: `Default Scope:
-            
+
 ${arg.configurableClientScope}
 `,
                         optional: true,
@@ -109,10 +110,10 @@ ${arg.configurableClientScope}
         this.resolvers({ _endpoint: what });
         return this;
     }
-    startOAuth() {
+    async startOAuth() {
         throw new Error("oauth not configured");
     }
-    finishOAuth() {
+    async finishOAuth(arg) {
         throw new Error("oauth not configured");
     }
     build() {

package/build/internal/index.d.mts

@@ -1,17 +1,2 @@
-import { Dispatcher } from "./dispatcher/index.mjs";
-declare class Connector {
-    id: any;
-    version: any;
-    name: any;
-    icon: any;
-    dispatcher?: Dispatcher;
-    constructor({ version, id, name, icon }: {
-        version: any;
-        id: any;
-        name: any;
-        icon: any;
-    });
-    configure(): Dispatcher;
-    run(): Promise<void>;
-}
+import { Connector } from './connector/index.mjs';
 export { Connector };