@aloma.io/integration-sdk 3.0.2 → 3.0.4

package/README.md

@@ -2,4 +2,4 @@
 
 ## Creating a new Connector
 
-With the aloma integration SDK cli you can simply create a new connector via `npx @aloma.io/integration-sdk create connectorName --connector-id 1234`.
+With the aloma integration SDK cli you can simply create a new connector via `npx @aloma.io/integration-sdk@latest create connectorName --connector-id 1234`.

package/build/builder/index.d.mts

@@ -1,4 +1,4 @@
-import RuntimeContext from './runtime-context.mjs';
+import RuntimeContext from "./runtime-context.mjs";
 export declare class Builder {
     private data;
     config(arg: any): Builder;

package/build/builder/index.mjs

@@ -1,8 +1,8 @@
-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 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";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const notEmpty = (what, name) => {
     if (!what?.trim())
@@ -10,7 +10,9 @@ const notEmpty = (what, name) => {
     return what;
 };
 export class Builder {
-    data = { controller: './build/controller/.controller-for-types.mts' };
+    data = {
+        controller: "./build/controller/.controller-for-types.mts",
+    };
     config(arg) {
         this.data.config = arg;
         return this;
@@ -27,17 +29,19 @@ export class Builder {
         await this.parsePackageJson();
         await this.discoverTypes();
         // @ts-ignore
-        const Controller = (await import(__dirname + '/../../../../../build/controller/index.mjs')).default;
+        const Controller = (await import(__dirname + "/../../../../../build/controller/index.mjs")).default;
         return new RuntimeContext(new Controller(), this.data);
     }
     async parsePackageJson() {
         const data = this.data;
-        const packageJson = JSON.parse(fs.readFileSync(__dirname + '/../../../../../package.json', { encoding: 'utf-8' }));
-        notEmpty(data.id = packageJson.connectorId, 'id');
-        notEmpty(data.version = packageJson.version, 'version');
+        const packageJson = JSON.parse(fs.readFileSync(__dirname + "/../../../../../package.json", {
+            encoding: "utf-8",
+        }));
+        notEmpty((data.id = packageJson.connectorId), "id");
+        notEmpty((data.version = packageJson.version), "version");
     }
     async discoverTypes() {
-        notEmpty(this.data.controller, 'controller');
+        notEmpty(this.data.controller, "controller");
         const content = fs.readFileSync(this.data.controller);
         const { text, methods } = parseTypes(this.data.controller);
         this.data.types = text;

package/build/builder/runtime-context.d.mts

@@ -1,4 +1,4 @@
-import { AbstractController } from '../controller/index.mjs';
+import { AbstractController } from "../controller/index.mjs";
 export default class RuntimeContext {
     private controller;
     private data;

package/build/builder/runtime-context.mjs

@@ -1,5 +1,5 @@
-import { AbstractController } from '../controller/index.mjs';
-import { Connector } from '../internal/index.cjs';
+import { AbstractController } from "../controller/index.mjs";
+import { Connector } from "../internal/index.cjs";
 export default class RuntimeContext {
     controller;
     data;
@@ -10,7 +10,7 @@ export default class RuntimeContext {
     async start() {
         const controller = this.controller;
         if (!(controller instanceof AbstractController))
-            throw new Error('the controller needs to extend AbstractController');
+            throw new Error("the controller needs to extend AbstractController");
         const data = this.data;
         const connector = new Connector({
             id: data.id,
@@ -19,7 +19,12 @@ export default class RuntimeContext {
         });
         const configuration = connector.configure().config(data.config || {});
         const resolvers = {};
-        const methods = [...data.methods, '__endpoint', '__configQuery', '__default'];
+        const methods = [
+            ...data.methods,
+            "__endpoint",
+            "__configQuery",
+            "__default",
+        ];
         methods.forEach((method) => {
             resolvers[method] = async (args) => {
                 if (!methods.includes(method))
@@ -27,9 +32,7 @@ export default class RuntimeContext {
                 return controller[method](args);
             };
         });
-        configuration
-            .types(data.types)
-            .resolvers(resolvers);
+        configuration.types(data.types).resolvers(resolvers);
         if (data.options?.endpoint?.enabled) {
             configuration.endpoint((arg) => controller.__endpoint(arg));
         }

package/build/builder/transform/index.mjs

@@ -1,19 +1,19 @@
-import { parseFromFiles } from '@ts-ast-parser/core';
+import { parseFromFiles } from "@ts-ast-parser/core";
 const transform = (meta) => {
     if (!meta?.length)
-        throw new Error('metadata is empty');
+        throw new Error("metadata is empty");
     meta = meta[0];
     if (meta.getDeclarations()?.length !== 1) {
-        throw new Error('connector file needs to export default class');
+        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('_'));
+            member.getKind() !== "Method" ||
+            member.getModifier() !== "public" ||
+            member.getName().startsWith("_"));
     });
     const text = members
         .map((member) => {
@@ -22,13 +22,13 @@ const transform = (meta) => {
             .getSignatures()
             .map((sig) => {
             const docs = sig.getJSDoc().serialize() || [];
-            const desc = docs.find((what) => what.kind === 'description')?.value;
+            const desc = docs.find((what) => what.kind === "description")?.value;
             const paramDocs = docs
-                .filter((what) => what.kind === 'param')
+                .filter((what) => what.kind === "param")
                 .map((what) => {
-                return ` * @param {${what.value.type}} ${what.value.name} - ${what.value.description || ''}`;
+                return ` * @param {${what.value.type}} ${what.value.name} - ${what.value.description || ""}`;
             })
-                .join('\n') || ' *';
+                .join("\n") || " *";
             const params = sig
                 .getParameters()
                 .map((param) => {
@@ -38,32 +38,32 @@ const transform = (meta) => {
                         const tmp = param
                             .getNamedElements()
                             .map((p) => {
-                            const defaultVal = p.default != null ? ' = ' + p.default : '';
+                            const defaultVal = p.default != null ? " = " + p.default : "";
                             return `${p.name}${defaultVal}`;
                         })
-                            .join('; ');
+                            .join("; ");
                         return `{${tmp}}: ${param.getType().text}`;
                     case false:
                         return `${param.getName()}: ${param.getType().text}`;
                 }
             })
-                .join(', ');
+                .join(", ");
             const retVal = sig
                 .getReturnType()
-                .type.text.replace(/^Promise</, '')
-                .replace(/>$/, '');
+                .type.text.replace(/^Promise</, "")
+                .replace(/>$/, "");
             return `
 /**
- * ${desc || ''}
+ * ${desc || ""}
  *
 ${paramDocs}
  **/    
 declare function ${member.getName()}(${params}): ${retVal};
       `;
         })
-            .join('\n');
+            .join("\n");
     })
-        .join('');
+        .join("");
     return { text, methods: Object.keys(methods) };
 };
 export default (path) => {

package/build/cli.d.mts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/cli.mjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import JWE from './internal/util/jwe/index.cjs';
+import util from 'node:util';
+import ChildProcess from 'node:child_process';
+const exec = util.promisify(ChildProcess.exec);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const files = [
+    { name: "index.mts", dir: "src/controller" },
+    { name: "index.mts", dir: "src" },
+    { name: "package.json", dir: "" },
+    { name: "Containerfile", dir: "" },
+    { name: "entrypoint.sh", dir: "" },
+    { name: "tsconfig.json", dir: "" },
+];
+const extract = ({ target, name, connectorId }) => {
+    const source = `${__dirname}/../template/connector/`;
+    if (!fs.existsSync(source)) {
+        throw new Error(`source ${source} does not exist`);
+    }
+    files.forEach(({ name, dir }) => {
+        if (dir) {
+            fs.mkdirSync(`${target}/${dir}`, { recursive: true });
+        }
+        const content = fs.readFileSync(`${source}/${dir}/${name}`, {
+            encoding: "utf-8",
+        });
+        fs.writeFileSync(`${target}/${dir}/${name}`, content);
+    });
+    const content = JSON.parse(fs.readFileSync(`${target}/package.json`, { encoding: "utf-8" }));
+    content.name = name;
+    content.connectorId = connectorId;
+    fs.writeFileSync(`${target}/package.json`, JSON.stringify(content, null, 2));
+    fs.writeFileSync(`${target}/.gitignore`, `.DS_Store
+node_modules
+build
+.env`);
+};
+const generateKeys = async ({ target }) => {
+    const jwe = new JWE({});
+    await jwe.newPair();
+    const priv = await jwe.exportPrivateAsBase64();
+    const pub = await jwe.exportPublicAsBase64();
+    const content = `REGISTRATION_TOKEN=
+PRIVATE_KEY=${priv}
+PUBLIC_KEY=${pub}
+`;
+    fs.writeFileSync(`${target}/.env`, content);
+};
+const program = new Command();
+program
+    .name("npx @aloma.io/integration-sdk")
+    .description("aloma.io integration sdk")
+    .version("0.8.0")
+    .showHelpAfterError();
+program
+    .command("create")
+    .description("Create a new connector project")
+    .argument("<name>", "name of the project")
+    .requiredOption("--connector-id <id>", "id of the connector")
+    .action(async (name, options) => {
+    name = name.replace(/[\/\.]/gi, "");
+    if (!name)
+        throw new Error("name is empty");
+    const target = `${process.cwd()}/${name}`;
+    fs.mkdirSync(target);
+    console.log('Creating connector ...');
+    extract({ ...options, target, name });
+    console.log('Generating keys ...');
+    await generateKeys({ target });
+    console.log('Installing dependencies ...');
+    await exec(`cd ${target}; yarn`);
+    console.log('Building ...');
+    await exec(`cd ${target}; yarn build`);
+    console.log(`
+Success!
+      
+1.) Add the connector to a workspace
+2.) Edit ./${name}/.env and insert the registration token
+3.) Start the connector with cd ./${name}/; yarn start`);
+});
+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;`);
+    if (stdout)
+        console.log(stdout);
+});
+program.parse();

package/build/controller/index.mjs

@@ -7,19 +7,19 @@ export class AbstractController {
         return Promise.resolve({});
     }
     fallback(arg) {
-        throw new Error('method not found');
+        throw new Error("method not found");
     }
     endpoint(arg) {
-        throw new Error('method not found');
+        throw new Error("method not found");
     }
     async newTask(name, data) {
-        throw new Error('not implemented');
+        throw new Error("not implemented");
     }
     getClient({ baseUrl }) {
-        throw new Error('not implemented');
+        throw new Error("not implemented");
     }
     async updateTask(name, data) {
-        throw new Error('not implemented');
+        throw new Error("not implemented");
     }
     async __endpoint(arg) {
         return this.endpoint(arg);

package/build/index.d.mts

@@ -1,2 +1,2 @@
-export * from './builder/index.mjs';
-export * from './controller/index.mjs';
+export * from "./builder/index.mjs";
+export * from "./controller/index.mjs";

package/build/index.mjs

@@ -1,2 +1,2 @@
-export * from './builder/index.mjs';
-export * from './controller/index.mjs';
+export * from "./builder/index.mjs";
+export * from "./controller/index.mjs";

package/build/internal/dispatcher/index.cjs

@@ -14,26 +14,26 @@ class Dispatcher {
                 oauth: true,
                 fields: {
                     oauthResult: {
-                        name: 'OAuth Result',
-                        placeholder: 'will be set by finishing the oauth flow',
-                        type: 'managed',
+                        name: "OAuth Result",
+                        placeholder: "will be set by finishing the oauth flow",
+                        type: "managed",
                     },
                 },
             });
             return this;
         }
         if (!arg.authorizationURL)
-            throw new Error('need a authorizationURL');
+            throw new Error("need a authorizationURL");
         if (!arg.tokenURL && !arg.finishOAuth)
-            throw new Error('need a tokenURL or finishOAuth()');
+            throw new Error("need a tokenURL or finishOAuth()");
         this._oauth = { ...arg };
         this.config({
             oauth: true,
             fields: {
                 oauthResult: {
-                    name: 'OAuth Result',
-                    placeholder: 'will be set by finishing the oauth flow',
-                    type: 'managed',
+                    name: "OAuth Result",
+                    placeholder: "will be set by finishing the oauth flow",
+                    type: "managed",
                 },
             },
         });
@@ -41,14 +41,14 @@ class Dispatcher {
             this.config({
                 fields: {
                     clientId: {
-                        name: 'OAuth Client ID',
-                        placeholder: 'e.g. 1234',
-                        type: 'line',
+                        name: "OAuth Client ID",
+                        placeholder: "e.g. 1234",
+                        type: "line",
                     },
                     clientSecret: {
-                        name: 'OAuth Client Secret',
-                        placeholder: 'e.g. axd5xde',
-                        type: 'line',
+                        name: "OAuth Client Secret",
+                        placeholder: "e.g. axd5xde",
+                        type: "line",
                     },
                 },
             });
@@ -72,9 +72,9 @@ class Dispatcher {
         this.config({
             fields: {
                 _endpointToken: {
-                    name: 'Endpoint Token (set to enable the endpoint)',
-                    placeholder: 'e.g. 1234',
-                    type: 'line',
+                    name: "Endpoint Token (set to enable the endpoint)",
+                    placeholder: "e.g. 1234",
+                    type: "line",
                     plain: true,
                     optional: true,
                 },
@@ -84,19 +84,19 @@ class Dispatcher {
         return this;
     }
     startOAuth() {
-        throw new Error('oauth not configured');
+        throw new Error("oauth not configured");
     }
     finishOAuth() {
-        throw new Error('oauth not configured');
+        throw new Error("oauth not configured");
     }
     build() {
         if (!this._types || !this._resolvers)
-            throw new Error('missing types or resolvers');
+            throw new Error("missing types or resolvers");
         var local = this;
         const _resolvers = { ...this._resolvers };
         const main = this._main || (() => { });
         const start = async (transport) => {
-            console.log('starting ...');
+            console.log("starting ...");
             await main(transport);
         };
         const resolveMethod = (query) => {
@@ -110,33 +110,44 @@ class Dispatcher {
             if (!Array.isArray(query))
                 query = [query];
             query = query
-                .filter((what) => !!what?.trim() && !['constructor', '__proto__', 'toString', 'toSource', 'prototype'].includes(what))
+                .filter((what) => !!what?.trim() &&
+                ![
+                    "constructor",
+                    "__proto__",
+                    "toString",
+                    "toSource",
+                    "prototype",
+                ].includes(what))
                 .slice(0, 20);
             const method = resolveMethod(query);
             if (!method && !_resolvers.__default)
                 throw new Error(`${query} not found`);
-            return method ? method(variables) : _resolvers.__default(variables ? { ...variables, __method: query } : variables);
+            return method
+                ? method(variables)
+                : _resolvers.__default(variables ? { ...variables, __method: query } : variables);
         };
         const introspect = () => local._types;
         const configSchema = () => local._config;
         const processPacket = async (packet) => {
             switch (packet.method()) {
-                case 'connector.introspect':
+                case "connector.introspect":
                     const intro = await introspect({});
                     return { configSchema: local._config, introspect: intro };
-                case 'connector.start-oauth':
+                case "connector.start-oauth":
                     return await local.startOAuth(packet.args());
-                case 'connector.finish-oauth':
+                case "connector.finish-oauth":
                     return await local.finishOAuth(packet.args());
-                case 'connector.query':
+                case "connector.query":
                     const ret = await execute(packet.args());
-                    return typeof ret === 'object' && !Array.isArray(ret) ? ret : { [packet.args().query]: ret };
-                case 'connector.set-config':
+                    return typeof ret === "object" && !Array.isArray(ret)
+                        ? ret
+                        : { [packet.args().query]: ret };
+                case "connector.set-config":
                     await local.onConfig({ ...packet.args().secrets });
                     return;
             }
             console.dir(packet, { depth: null });
-            throw new Error('cannot handle packet');
+            throw new Error("cannot handle packet");
         };
         return {
             introspect,