@aloma.io/integration-sdk 3.6.5 → 3.7.0

package/build/internal/index.mjs

@@ -2,251 +2,19 @@ import { init } from "@paralleldrive/cuid2";
 import express from "express";
 import PromClient from "prom-client";
 import { Dispatcher } from "./dispatcher/index.mjs";
+import Fetcher from "./fetcher/fetcher.mjs";
+import { OAuth } from "./fetcher/oauth-fetcher.mjs";
+import { handlePacketError, reply } from "./util/index.mjs";
 import JWE from "./util/jwe/index.mjs";
 import { Config } from "./websocket/config.mjs";
 import { WebsocketConnector } from "./websocket/index.mjs";
 const cuid = init({ length: 32 });
-const handlePacketError = (packet, e, transport) => {
-    if (!packet.cb()) {
-        console.dir({ msg: "packet error", e, packet }, { depth: null });
-        return;
-    }
-    transport.send(transport.newPacket({ c: packet.cb(), a: { error: "" + e } }));
-};
-const reply = (arg, packet, transport) => {
-    if (!packet.cb()) {
-        console.dir({ msg: "cannot reply to packet without cb", arg, packet }, { depth: null });
-        return;
-    }
-    transport.send(transport.newPacket({ c: packet.cb(), a: { ...arg } }));
-};
-const unwrap0 = (ret, body, options) => {
-    if (options?.bodyOnly === false) {
-        return { status: ret.status, headers: ret.headers, body };
-    }
-    else {
-        return body;
-    }
-};
-const unwrap = async (ret, options) => {
-    if (options?.text)
-        return unwrap0(ret, await ret.text(), options);
-    if (options?.base64) {
-        const base64 = Buffer.from(await ret.arrayBuffer()).toString("base64");
-        return unwrap0(ret, base64, options);
-    }
-    if (options?.skipResponseBody) {
-        return { status: ret.status, headers: ret.headers };
-    }
-    const text = await ret.text();
-    try {
-        return unwrap0(ret, JSON.parse(text), options);
-    }
-    catch (e) {
-        throw e + " " + text;
-    }
-};
-class Fetcher {
-    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);
-        }
-    }
-}
-class OAuthFetcher extends Fetcher {
-    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}`,
-        };
-    }
-}
-class OAuth {
-    constructor(data, saveOAuthResult, getRefreshToken) {
-        var local = this;
-        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;
-    }
-}
 class Connector {
+    id;
+    version;
+    name;
+    icon;
+    dispatcher;
     constructor({ version, id, name, icon }) {
         this.id = id;
         this.version = version;
@@ -325,6 +93,7 @@ ${text}
         const server = new WebsocketConnector({
             config,
             onConnect: (transport) => {
+                // @ts-ignore
                 local.dispatcher.onConfig = async function (secrets) {
                     const decrypted = {};
                     const fields = configSchema().fields;
@@ -347,6 +116,7 @@ ${text}
                             }
                         }
                     }
+                    // @ts-ignore
                     this.startOAuth = async function (args) {
                         if (!this._oauth)
                             throw new Error("oauth not configured");
@@ -367,6 +137,7 @@ ${text}
                             useCodeChallenge,
                         };
                     };
+                    // @ts-ignore
                     this.finishOAuth = async function (arg) {
                         var that = this;
                         if (!this._oauth)
@@ -511,8 +282,10 @@ ${text}
                         ? new OAuth(decrypted.oauthResult, saveOAuthResult, getRefreshToken)
                         : null;
                     if (theOAuth) {
+                        // @ts-ignore
                         clearInterval(this._refreshOAuthToken);
                         if (!(this._oauth.noPeriodicTokenRefresh === false)) {
+                            // @ts-ignore
                             this._refreshOAuthToken = setInterval(async () => {
                                 try {
                                     console.log("refreshing oauth token");
@@ -601,7 +374,7 @@ ${text}
             await new Promise((resolve) => {
                 setTimeout(async () => {
                     await server.close();
-                    resolve();
+                    resolve(null);
                 }, 10000);
             });
             process.exit(0);

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

@@ -0,0 +1,5 @@
+export declare const handlePacketError: (packet: any, e: any, transport: any) => void;
+export declare const reply: (arg: any, packet: any, transport: any) => void;
+export declare const unwrap0: (ret: any, body: any, options: any) => any;
+export declare const unwrap: (ret: any, options: any) => Promise<any>;
+export declare const notEmpty: (what: any, name: any) => any;

package/build/internal/util/index.mjs

@@ -0,0 +1,45 @@
+export const handlePacketError = (packet, e, transport) => {
+    if (!packet.cb()) {
+        console.dir({ msg: "packet error", e, packet }, { depth: null });
+        return;
+    }
+    transport.send(transport.newPacket({ c: packet.cb(), a: { error: "" + e } }));
+};
+export const reply = (arg, packet, transport) => {
+    if (!packet.cb()) {
+        console.dir({ msg: "cannot reply to packet without cb", arg, packet }, { depth: null });
+        return;
+    }
+    transport.send(transport.newPacket({ c: packet.cb(), a: { ...arg } }));
+};
+export const unwrap0 = (ret, body, options) => {
+    if (options?.bodyOnly === false) {
+        return { status: ret.status, headers: ret.headers, body };
+    }
+    else {
+        return body;
+    }
+};
+export const unwrap = async (ret, options) => {
+    if (options?.text)
+        return unwrap0(ret, await ret.text(), options);
+    if (options?.base64) {
+        const base64 = Buffer.from(await ret.arrayBuffer()).toString("base64");
+        return unwrap0(ret, base64, options);
+    }
+    if (options?.skipResponseBody) {
+        return { status: ret.status, headers: ret.headers };
+    }
+    const text = await ret.text();
+    try {
+        return unwrap0(ret, JSON.parse(text), options);
+    }
+    catch (e) {
+        throw e + " " + text;
+    }
+};
+export const notEmpty = (what, name) => {
+    if (!what?.trim())
+        throw new Error(`${name} cannot be empty`);
+    return what;
+};

package/build/internal/util/jwe/index.d.mts

@@ -1,15 +1,12 @@
-export default JWE;
+import * as jose from "jose";
 declare class JWE {
+    issuer: string;
+    algorithm: string;
+    pair?: jose.GenerateKeyPairResult<jose.KeyLike>;
     constructor({ algorithm }: {
         algorithm?: string | undefined;
     });
-    issuer: string;
-    algorithm: string;
     newPair(): Promise<void>;
-    pair: jose.GenerateKeyPairResult<jose.KeyLike> | {
-        publicKey: jose.KeyLike;
-        privateKey: jose.KeyLike;
-    } | undefined;
     exportPair(): Promise<{
         publicKey: string;
         privateKey: string;
@@ -29,4 +26,4 @@ declare class JWE {
     encrypt(what: any, expiration: string | undefined, audience: any, algorithm?: string): Promise<string>;
     decrypt(what: any, audience: any): Promise<unknown>;
 }
-import * as jose from "jose";
+export default JWE;

package/build/internal/util/jwe/index.mjs

@@ -1,5 +1,8 @@
 import * as jose from "jose";
 class JWE {
+    issuer;
+    algorithm;
+    pair;
     constructor({ algorithm = "PS256" }) {
         this.issuer = "home.aloma.io";
         this.algorithm = algorithm;

package/build/transform/index.d.mts

@@ -0,0 +1,5 @@
+declare const _default: (path: string) => Promise<{
+    text: any;
+    methods: string[];
+}>;
+export default _default;

package/build/transform/index.mjs

@@ -0,0 +1,79 @@
+import { parseFromFiles } from "@ts-ast-parser/core";
+const transform = (meta) => {
+    if (!meta?.length)
+        throw new Error("metadata is empty");
+    meta = meta[0];
+    if (meta.getDeclarations()?.length !== 1) {
+        throw new Error("connector file needs to export default class");
+    }
+    const methods = {};
+    const decl = meta.getDeclarations()[0];
+    const members = decl.getMethods().filter((member) => {
+        return !(member.isStatic() ||
+            member.isInherited() ||
+            member.getKind() !== "Method" ||
+            member.getModifier() !== "public" ||
+            member.getName().startsWith("_"));
+    });
+    const text = members
+        .map((member) => {
+        methods[member.getName()] = true;
+        return member
+            .getSignatures()
+            .map((sig) => {
+            const docs = sig.getJSDoc().serialize() || [];
+            const desc = docs.find((what) => what.kind === "description")?.value;
+            const example = docs.find((what) => what.kind === "example")?.value;
+            let eg;
+            if (example) {
+                const parts = example.split(/```/);
+                const backticks = "```";
+                eg = `@example ${parts[0] || "usage"}\n${backticks}${parts[1]}${backticks}`;
+            }
+            const paramDocs = docs.filter((what) => what.kind === "param");
+            const params = sig
+                .getParameters()
+                .filter((param) => param.isNamed())
+                .map((param) => {
+                const serialized = param.serialize();
+                const prefix = param
+                    .getNamedElements()
+                    .map((p) => {
+                    const defaultVal = p.getDefault() != null ? " = " + p.getDefault() : "";
+                    return `${p.getName()}${defaultVal}`;
+                })
+                    .join("; ");
+                const suffix = serialized.type.properties
+                    .map((p) => {
+                    const comment = paramDocs.find((what) => what.value.name === p.name);
+                    const desc = (comment?.value.description || "").replace(/\\@/gi, "@");
+                    return `\n/**\n${desc}\n */\n ${p.name}: ${p.type.text}`;
+                })
+                    .join("; ");
+                return `{${prefix}}: {${suffix}}`;
+            })
+                .join(", ");
+            const retVal = sig
+                .serialize()
+                .return.type.text.replace(/^Promise</, "")
+                .replace(/>$/, "");
+            return `
+/**
+ * ${desc || ""}
+ *
+ * ${eg || ""}
+ **/    
+declare function ${member.getName()}(${params}): ${retVal};
+      `;
+        })
+            .join("\n");
+    })
+        .join("");
+    return { text, methods: Object.keys(methods) };
+};
+export default async (path) => {
+    const parsed = await parseFromFiles([path]);
+    if (parsed.errors?.length)
+        throw new Error(path + " " + JSON.stringify(parsed.errors));
+    return transform(parsed.project?.getModules() || []);
+};

package/package.json

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

package/src/builder/index.mts

@@ -1,20 +1,17 @@
 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 __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-const notEmpty = (what, name) => {
-  if (!what?.trim()) throw new Error(`${name} cannot be empty`);
+//const offset = '/../../../../../'; 
+const offset = '/../../../..//../../../..//../../../..//../../../..//../../../..//Users/xg04123/NetBeansProjects/automation/connector-google-drive/'; 
 
-  return what;
-};
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 export class Builder {
   private data: any = {
-    controller: "./build/controller/.controller-for-types.mts",
+    controller: "./build/.controller.json",
   };
 
   config(arg: any): Builder {
@@ -36,12 +33,12 @@ export class Builder {
 
   async build(): Promise<RuntimeContext> {
     await this.parsePackageJson();
-    await this.discoverTypes();
+    await this.loadTypes();
     await this.checkIcon();
 
     // @ts-ignore
     const Controller = (
-      await import(__dirname + "/../../../../../build/controller/index.mjs")
+      await import(__dirname + offset + "build/controller/index.mjs")
     ).default;
 
     return new RuntimeContext(new Controller(), this.data);
@@ -49,7 +46,7 @@ export class Builder {
 
   private async checkIcon() {
     const data = this.data;
-    const root = __dirname + "/../../../../../";
+    const root = __dirname + offset;
 
     data.icon = `${root}/logo.png`;
   }
@@ -58,7 +55,7 @@ export class Builder {
     const data = this.data;
 
     const packageJson = JSON.parse(
-      fs.readFileSync(__dirname + "/../../../../../package.json", {
+      fs.readFileSync(__dirname + offset + "package.json", {
         encoding: "utf-8",
       }),
     );
@@ -67,11 +64,11 @@ export class Builder {
     notEmpty((data.version = packageJson.version), "version");
   }
 
-  private async discoverTypes() {
+  private 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/src/builder/runtime-context.mts

@@ -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 {
   constructor(
@@ -12,7 +12,10 @@ export default class RuntimeContext {
     const controller = this.controller;
 
     if (!(controller instanceof AbstractController))
+    {
       throw new Error("the controller needs to extend AbstractController");
+    }
+      
     const data: any = this.data;
 
     let icon;

package/src/cli.mts

@@ -1,12 +1,14 @@
 #!/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);
 
@@ -118,10 +120,23 @@ program
   .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;`,
+      `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/src/internal/dispatcher/{index.mjs → index.mts}

@@ -1,4 +1,10 @@
-class Dispatcher {
+export default class Dispatcher {
+  private _config: any;
+  private _main: any;
+  _oauth: any;
+  private _types: any;
+  private _resolvers: any;
+  
   constructor() {
     this._config = { fields: {} };
   }
@@ -90,7 +96,7 @@ ${arg.configurableClientScope}
     return this;
   }
 
-  config({ fields, oauth, description, summary }) {
+  config({ fields, oauth, description, summary }: any) {
     this._config.oauth = this._config.oauth || oauth;
     this._config.description = this._config.description || description;
     this._config.summary = this._config.summary || summary;
@@ -189,14 +195,17 @@ ${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":
@@ -224,6 +233,9 @@ ${arg.configurableClientScope}
       start,
     };
   }
+  onConfig(arg0: any) {
+    throw new Error("Method not implemented.");
+  }
 }
 
 export { Dispatcher };