@aloma.io/integration-sdk 3.6.6 → 3.7.1

package/build/builder/index.d.mts

@@ -7,5 +7,5 @@ export declare class Builder {
     build(): Promise<RuntimeContext>;
     private checkIcon;
     private parsePackageJson;
-    private discoverTypes;
+    private loadTypes;
 }

package/build/builder/index.mjs

@@ -1,17 +1,13 @@
 import fs from "node:fs";
-import parseTypes from "./transform/index.mjs";
-import RuntimeContext from "./runtime-context.mjs";
-import { fileURLToPath } from "node:url";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { notEmpty } from "../internal/util/index.mjs";
+import RuntimeContext from "./runtime-context.mjs";
+const offset = '/../../../../../';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const notEmpty = (what, name) => {
-    if (!what?.trim())
-        throw new Error(`${name} cannot be empty`);
-    return what;
-};
 export class Builder {
     data = {
-        controller: "./build/controller/.controller-for-types.mts",
+        controller: "./build/.controller.json",
     };
     config(arg) {
         this.data.config = arg;
@@ -27,29 +23,29 @@ export class Builder {
     }
     async build() {
         await this.parsePackageJson();
-        await this.discoverTypes();
+        await this.loadTypes();
         await this.checkIcon();
         // @ts-ignore
-        const Controller = (await import(__dirname + "/../../../../../build/controller/index.mjs")).default;
+        const Controller = (await import(__dirname + offset + "build/controller/index.mjs")).default;
         return new RuntimeContext(new Controller(), this.data);
     }
     async checkIcon() {
         const data = this.data;
-        const root = __dirname + "/../../../../../";
+        const root = __dirname + offset;
         data.icon = `${root}/logo.png`;
     }
     async parsePackageJson() {
         const data = this.data;
-        const packageJson = JSON.parse(fs.readFileSync(__dirname + "/../../../../../package.json", {
+        const packageJson = JSON.parse(fs.readFileSync(__dirname + offset + "package.json", {
             encoding: "utf-8",
         }));
         notEmpty((data.id = packageJson.connectorId), "id");
         notEmpty((data.version = packageJson.version), "version");
     }
-    async discoverTypes() {
+    async loadTypes() {
         notEmpty(this.data.controller, "controller");
-        const content = fs.readFileSync(this.data.controller);
-        const { text, methods } = await parseTypes(this.data.controller);
+        const content = fs.readFileSync(this.data.controller, { encoding: 'utf-8' });
+        const { text, methods } = JSON.parse(content);
         this.data.types = text;
         this.data.methods = methods;
     }

package/build/builder/runtime-context.mjs

@@ -1,6 +1,6 @@
+import fs from "node:fs";
 import { AbstractController } from "../controller/index.mjs";
 import { Connector } from "../internal/index.mjs";
-import fs from "node:fs";
 export default class RuntimeContext {
     controller;
     data;
@@ -10,8 +10,9 @@ export default class RuntimeContext {
     }
     async start() {
         const controller = this.controller;
-        if (!(controller instanceof AbstractController))
+        if (!(controller instanceof AbstractController)) {
             throw new Error("the controller needs to extend AbstractController");
+        }
         const data = this.data;
         let icon;
         try {

package/build/cli.mjs

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
 import { Command } from "commander";
+import ChildProcess from "node:child_process";
 import fs from "node:fs";
-import { fileURLToPath } from "node:url";
 import path from "node:path";
-import JWE from "./internal/util/jwe/index.mjs";
+import { fileURLToPath } from "node:url";
 import util from "node:util";
-import ChildProcess from "node:child_process";
+import { notEmpty } from "./internal/util/index.mjs";
+import JWE from "./internal/util/jwe/index.mjs";
+import parseTypes from "./transform/index.mjs";
 const exec = util.promisify(ChildProcess.exec);
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const files = [
@@ -87,8 +89,17 @@ program
     .command("build")
     .description("Build the current connector project")
     .action(async (str, options) => {
-    const { stdout, stderr } = await exec(`rm -rf build; mkdir -p build/controller; cp ./src/controller/index.mts ./build/controller/.controller-for-types.mts;`);
+    const { stdout, stderr } = await exec(`rm -rf build; mkdir -p build`);
     if (stdout)
         console.log(stdout);
+    new Extractor().extract('./src/controller/index.mts', './build/.controller.json');
 });
+class Extractor {
+    async extract(source, target) {
+        notEmpty(source, "source");
+        fs.readFileSync(source);
+        const { text, methods } = await parseTypes(source);
+        fs.writeFileSync(target, JSON.stringify({ text, methods }), { encoding: 'utf-8' });
+    }
+}
 program.parse();

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

@@ -1,29 +1,21 @@
-export class Dispatcher {
-    _config: {
-        fields: {};
-    };
+export default class Dispatcher {
+    private _config;
+    private _main;
+    _oauth: any;
+    private _types;
+    private _resolvers;
+    constructor();
     main(what: any): this;
-    _main: any;
     oauth(arg: any): this;
-    _oauth: any;
     types(what: any): this;
-    _types: any;
-    config({ fields, oauth, description, summary }: {
-        fields: any;
-        oauth: any;
-        description: any;
-        summary: any;
-    }): this;
+    config({ fields, oauth, description, summary }: any): this;
     resolvers(what: any): this;
-    _resolvers: any;
     endpoint(what: any, notOptional: any): this;
     startOAuth(): void;
     finishOAuth(): void;
     build(): {
         introspect: () => any;
-        configSchema: () => {
-            fields: {};
-        };
+        configSchema: () => any;
         execute: ({ query, variables }: {
             query: any;
             variables: any;
@@ -31,4 +23,6 @@ export class Dispatcher {
         processPacket: (packet: any) => Promise<any>;
         start: (transport: any) => Promise<void>;
     };
+    onConfig(arg0: any): void;
 }
+export { Dispatcher };

package/build/internal/dispatcher/index.mjs

@@ -1,4 +1,9 @@
-class Dispatcher {
+export default class Dispatcher {
+    _config;
+    _main;
+    _oauth;
+    _types;
+    _resolvers;
     constructor() {
         this._config = { fields: {} };
     }
@@ -152,11 +157,14 @@ ${arg.configurableClientScope}
         const processPacket = async (packet) => {
             switch (packet.method()) {
                 case "connector.introspect":
+                    // @ts-ignore
                     const intro = await introspect({});
                     return { configSchema: local._config, introspect: intro };
                 case "connector.start-oauth":
+                    // @ts-ignore
                     return await local.startOAuth(packet.args());
                 case "connector.finish-oauth":
+                    // @ts-ignore
                     return await local.finishOAuth(packet.args());
                 case "connector.query":
                     const ret = await execute(packet.args());
@@ -178,5 +186,8 @@ ${arg.configurableClientScope}
             start,
         };
     }
+    onConfig(arg0) {
+        throw new Error("Method not implemented.");
+    }
 }
 export { Dispatcher };

package/build/internal/fetcher/fetcher.d.mts

@@ -0,0 +1,15 @@
+export default class Fetcher {
+    retry: number;
+    baseUrl: any;
+    onResponse: any;
+    customize0: any;
+    constructor({ retry, baseUrl, onResponse, customize }: {
+        retry?: number | undefined;
+        baseUrl: any;
+        onResponse: any;
+        customize: any;
+    });
+    customize(options?: {}, args?: {}): Promise<void>;
+    onError(e: any, url: string, options: any, retries: number, args: any, rateLimit?: any): Promise<unknown>;
+    fetch(url: string, options: any, retries: number, args?: any): Promise<any>;
+}

package/build/internal/fetcher/fetcher.mjs

@@ -0,0 +1,97 @@
+import { unwrap } from "../util/index.mjs";
+export default class Fetcher {
+    retry;
+    baseUrl;
+    onResponse;
+    customize0;
+    constructor({ retry = 5, baseUrl, onResponse, customize }) {
+        this.retry = retry;
+        this.baseUrl = baseUrl;
+        this.onResponse = onResponse;
+        if (customize)
+            this.customize0 = customize;
+    }
+    async customize(options = {}, args = {}) {
+        if (this.customize0)
+            await this.customize0(options, args);
+    }
+    async onError(e, url, options, retries, args, rateLimit) {
+        var local = this;
+        return new Promise((resolve, reject) => {
+            setTimeout(async () => {
+                try {
+                    resolve(await local.fetch(url, options, retries, args));
+                }
+                catch (e) {
+                    reject(e);
+                }
+            }, rateLimit ? 10000 : 500);
+        });
+    }
+    async fetch(url, options = {}, retries, args = {}) {
+        var local = this, baseUrl = local.baseUrl;
+        if (retries == null)
+            retries = local.retry;
+        let theURL = !baseUrl
+            ? url
+            : `${baseUrl?.endsWith("/") ? baseUrl : baseUrl + "/"}${url}`.replace(/\/\/+/gi, "/");
+        try {
+            options.url = url;
+            await local.customize(options, args);
+            url = options.url;
+            delete options.url;
+            theURL = !baseUrl
+                ? url
+                : `${baseUrl?.endsWith("/") ? baseUrl : baseUrl + "/"}${url}`.replace(/\/\/+/gi, "/");
+            if (!options?.headers || !options?.headers?.Accept) {
+                options.headers = {
+                    ...options.headers,
+                    Accept: "application/json",
+                };
+            }
+            if (!options?.headers || !options?.headers?.["Content-type"]) {
+                options.headers = {
+                    ...options.headers,
+                    "Content-type": "application/json",
+                };
+            }
+            if (!(options?.method === "GET" || options?.method === "HEAD") &&
+                options?.body &&
+                !(typeof options.body === "string") &&
+                options?.headers?.["Content-type"] === "application/json") {
+                options.body = JSON.stringify(options.body);
+            }
+            const timeout = Math.min(options?.timeout || 30 * 60 * 1000, 30 * 60 * 1000);
+            const ret = await fetch(theURL, {
+                ...options,
+                signal: AbortSignal.timeout(timeout),
+            });
+            const status = await ret.status;
+            if (status > 399) {
+                const text = await ret.text();
+                const e = new Error(status + " " + text);
+                e.status = status;
+                throw e;
+            }
+            if (local.onResponse) {
+                await local.onResponse(ret);
+            }
+            return unwrap(ret, options);
+        }
+        catch (e) {
+            // too many requests
+            if (e.status === 429) {
+                return local.onError(e, url, options, retries, args, true);
+            }
+            // bad request
+            if (e.status === 400 || e.status === 422) {
+                throw e;
+            }
+            --retries;
+            console.log(theURL, e);
+            if (retries <= 0)
+                throw e;
+            return local.onError(e, url, options, retries, args);
+        }
+    }
+}

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

@@ -0,0 +1 @@
+export {};

package/build/internal/fetcher/index.mjs

@@ -0,0 +1 @@
+export {};

package/build/internal/fetcher/oauth-fetcher.d.mts

@@ -0,0 +1,32 @@
+import Fetcher from "./fetcher.mjs";
+declare class OAuthFetcher extends Fetcher {
+    oauth: any;
+    _getToken: any;
+    constructor({ oauth, retry, getToken, baseUrl, onResponse, customize }: {
+        oauth: any;
+        retry?: number | undefined;
+        getToken: any;
+        baseUrl: any;
+        onResponse: any;
+        customize: any;
+    });
+    getToken(force: any): Promise<any>;
+    onError(e: any, url: any, options: any, retries: any, args: any, rateLimit: any): Promise<unknown>;
+    periodicRefresh(): Promise<void>;
+    customize(options: any, args?: any): Promise<void>;
+}
+export declare class OAuth {
+    _data: any;
+    saveOAuthResult: any;
+    obtainViaRefreshToken: any;
+    clients: any[];
+    constructor(data: any, saveOAuthResult: any, getRefreshToken: any);
+    data(): any;
+    accessToken(): any;
+    refreshToken(): any;
+    update(accessToken: any, refreshToken: any): Promise<void>;
+    periodicRefresh(): Promise<void>;
+    invalidate(err: any): Promise<void>;
+    getClient(arg?: any): OAuthFetcher;
+}
+export {};

package/build/internal/fetcher/oauth-fetcher.mjs

@@ -0,0 +1,114 @@
+import Fetcher from "./fetcher.mjs";
+class OAuthFetcher extends Fetcher {
+    oauth;
+    _getToken;
+    constructor({ oauth, retry = 5, getToken, baseUrl, onResponse, customize }) {
+        super({ retry, baseUrl, onResponse, customize });
+        this.oauth = oauth;
+        this._getToken = getToken;
+    }
+    async getToken(force) {
+        var local = this, oauth = local.oauth;
+        if (local._getToken)
+            return local._getToken(force);
+        if (!force && oauth.accessToken())
+            return oauth.accessToken();
+        const refreshToken = oauth.refreshToken();
+        try {
+            if (!refreshToken) {
+                throw new Error("have no access_token and no refresh_token");
+            }
+            const ret = await oauth.obtainViaRefreshToken(oauth.refreshToken());
+            if (ret.access_token) {
+                oauth.update(ret.access_token, ret.refresh_token);
+                return ret.access_token;
+            }
+            else {
+                throw new Error("could not obtain access token via refresh token");
+            }
+        }
+        catch (e) {
+            oauth.invalidate(e);
+            throw e;
+        }
+    }
+    async onError(e, url, options, retries, args, rateLimit) {
+        var local = this;
+        return new Promise((resolve, reject) => {
+            setTimeout(async () => {
+                try {
+                    resolve(await local.fetch(url, options, retries, {
+                        forceTokenRefresh: e.status === 401,
+                    }));
+                }
+                catch (e) {
+                    reject(e);
+                }
+            }, rateLimit ? 10000 : 500);
+        });
+    }
+    async periodicRefresh() {
+        const local = this, oauth = local.oauth;
+        console.log("refreshing oauth token, have token", !!oauth.refreshToken());
+        if (!oauth.refreshToken())
+            return;
+        await local.getToken(true);
+        console.log("refreshed oauth token");
+    }
+    async customize(options, args = {}) {
+        const local = this;
+        if (this.customize0)
+            await this.customize0(options, args);
+        const token = await local.getToken(args.forceTokenRefresh);
+        options.headers = {
+            ...options.headers,
+            Authorization: `Bearer ${token}`,
+        };
+    }
+}
+export class OAuth {
+    _data;
+    saveOAuthResult;
+    obtainViaRefreshToken;
+    clients;
+    constructor(data, saveOAuthResult, getRefreshToken) {
+        this._data = data || {};
+        this.saveOAuthResult = saveOAuthResult;
+        this.obtainViaRefreshToken = getRefreshToken;
+        this.clients = [];
+    }
+    data() {
+        return this._data;
+    }
+    accessToken() {
+        return this._data.access_token;
+    }
+    refreshToken() {
+        return this._data.refresh_token;
+    }
+    async update(accessToken, refreshToken) {
+        this._data.access_token = accessToken;
+        if (refreshToken) {
+            this._data.refresh_token = refreshToken;
+        }
+        await this.saveOAuthResult(this._data);
+    }
+    async periodicRefresh() {
+        const clients = this.clients;
+        console.log("refreshing oauth clients", clients.length);
+        for (let i = 0; i < clients.length; ++i) {
+            const client = clients[0];
+            await client.periodicRefresh();
+        }
+    }
+    async invalidate(err) {
+        if (true)
+            return;
+        //if (this._data.access_token === "invalid") return;
+    }
+    getClient(arg = {}) {
+        const client = new OAuthFetcher({ ...arg, oauth: this });
+        this.clients.push(client);
+        return client;
+    }
+}

package/build/internal/index.d.mts

@@ -1,16 +1,17 @@
-export class Connector {
+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;
     });
-    id: any;
-    version: any;
-    name: any;
-    icon: any;
     configure(): Dispatcher;
-    dispatcher: Dispatcher | undefined;
     run(): Promise<void>;
 }
-import { Dispatcher } from "./dispatcher/index.mjs";
+export { Connector };