@aloma.io/integration-sdk 3.8.48 → 3.8.50

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

@@ -16,7 +16,8 @@ export const decryptConfig = async ({ configSchema, config, secrets }) => {
                 decrypted[key] = await jwe.decrypt(value, config.id());
             }
             catch (e) {
-                console.log('failed to decrypt key', key, config.id(), e);
+                const errorMsg = String(e).replaceAll(value, '***');
+                console.log('failed to decrypt key', key, config.id(), errorMsg);
             }
         }
     }

package/build/internal/fetcher/fetcher.mjs

@@ -73,7 +73,6 @@ export default class Fetcher {
                 options0?.headers?.['Content-type'] === 'application/json') {
                 options0.body = JSON.stringify(options0.body);
             }
-            console.dir(options0, { depth: null });
             const timeout = Math.min(options0?.timeout || 30 * 60 * 1000, 30 * 60 * 1000);
             const ret = await fetch(theURL, {
                 ...options0,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aloma.io/integration-sdk",
-  "version": "3.8.48",
+  "version": "3.8.50",
   "description": "",
   "author": "aloma.io",
   "license": "Apache-2.0",

package/src/internal/connector/server/on-connect/decrypt-config.mts

@@ -17,7 +17,8 @@ export const decryptConfig = async ({configSchema, config, secrets}) => {
       try {
         decrypted[key] = await jwe.decrypt(value, config.id());
       } catch (e) {
-        console.log('failed to decrypt key', key, config.id(), e);
+        const errorMsg = String(e).replaceAll(value, '***');
+        console.log('failed to decrypt key', key, config.id(), errorMsg);
       }
     }
   }

package/src/internal/fetcher/fetcher.mts

@@ -119,8 +119,6 @@ export default class Fetcher {
         options0.body = JSON.stringify(options0.body);
       }
 
-      console.dir(options0, {depth: null})
-
       const timeout = Math.min(options0?.timeout || 30 * 60 * 1000, 30 * 60 * 1000);
       const ret = await fetch(theURL, {
         ...options0,

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

@@ -1,8 +0,0 @@
-import Dispatcher from "../../dispatcher/index.mjs";
-import { Config } from "../../websocket/config.mjs";
-export declare const onConnect: ({ dispatcher, configSchema, config, start }: {
-    config: Config;
-    configSchema: any;
-    start: any;
-    dispatcher: Dispatcher;
-}) => (transport: any) => void;

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

@@ -1,297 +0,0 @@
-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);
-                    });
-                },
-            });
-        };
-    };
-};