@aloma.io/integration-sdk 3.0.1-1 → 3.0.1-10

package/build/internal/websocket/transport/index.cjs

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const fetch = require('node-fetch');
-const C = require('../connection/constants.cjs');
-const cuid = require('@paralleldrive/cuid2').init({ length: 32 });
-const { DurableWebsocket } = require('./durable.cjs');
-const WebSocket = require('ws');
-const { Packet, Callback } = require('./packet.cjs');
+const fetch = require("node-fetch");
+const C = require("../connection/constants.cjs");
+const cuid = require("@paralleldrive/cuid2").init({ length: 32 });
+const { DurableWebsocket } = require("./durable.cjs");
+const WebSocket = require("ws");
+const { Packet, Callback } = require("./packet.cjs");
 const cleanInterval = 45 * 1000;
 const pingInterval = 30 * 1000;
 class Transport {
@@ -38,7 +38,7 @@ class Transport {
             local.ws.send(JSON.stringify({ p: packets }));
         }
         catch (e) {
-            console.log('could not send packets ', e);
+            console.log("could not send packets ", e);
             packets.forEach((packet) => local.packets.unshift(packet));
         }
     }
@@ -48,20 +48,20 @@ class Transport {
             return;
         local.close();
         this.running = true;
-        const ws = (local.ws = new WebSocket(config.wsUrl(), ['connector'], C.augmentRequest({ headers: {} }, config)));
-        ws.on('open', () => {
-            console.log('websocket connected');
+        const ws = (local.ws = new WebSocket(config.wsUrl(), ["connector"], C.augmentRequest({ headers: {} }, config)));
+        ws.on("open", () => {
+            console.log("websocket connected");
             local.connected = true;
             local.pinger = setInterval(() => ws.ping(() => null), pingInterval);
             local.onConnect(local);
         });
-        ws.on('message', (message) => {
+        ws.on("message", (message) => {
             setTimeout(() => local.onMessages(JSON.parse(message)), 0);
         });
-        ws.on('error', (message) => {
-            console.log('error:', message);
+        ws.on("error", (message) => {
+            console.log("error:", message);
         });
-        ws.on('close', (message) => {
+        ws.on("close", (message) => {
             local.connected = false;
             clearInterval(local.pinger);
             if (local.running)
@@ -92,7 +92,7 @@ class Transport {
                 this.callbacks[packet.cb()].cb(packet.args());
             }
             catch (e) {
-                console.log('error processing packet', e, packet);
+                console.log("error processing packet", e, packet);
             }
             finally {
                 delete this.callbacks[packet.cb()];
@@ -117,12 +117,12 @@ class Transport {
             if (!cb)
                 return;
             if (cb.created < then) {
-                console.log('callback timeout', key);
+                console.log("callback timeout", key);
                 try {
-                    cb.cb({ error: 'timeout' });
+                    cb.cb({ error: "timeout" });
                 }
                 catch (e) {
-                    console.log('error while callback', key, cb, e);
+                    console.log("error while callback", key, cb, e);
                 }
                 delete local.callbacks[key];
             }

package/build/internal/websocket/transport/packet.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const fetch = require('node-fetch');
-const cuid = require('@paralleldrive/cuid2').init({ length: 32 });
+const fetch = require("node-fetch");
+const cuid = require("@paralleldrive/cuid2").init({ length: 32 });
 class Packet {
     constructor(data = {}) {
         this.data = data;

package/build/internal/websocket/transport/processor.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const { Packet, Callback } = require('./packet.cjs');
+const { Packet, Callback } = require("./packet.cjs");
 class Processor {
     constructor({ transport, processPacket }) {
         var local = this;
@@ -33,24 +33,24 @@ class Processor {
                 callbacks[packet.cb()](packet.args());
             }
             catch (e) {
-                console.log('error in callback', callbacks[packet.cb()], packet);
+                console.log("error in callback", callbacks[packet.cb()], packet);
             }
             delete local.transport.callbacks[packet.cb()];
         }
         else if (packet.event()) {
-            console.log('handle event packet', packet);
+            console.log("handle event packet", packet);
         }
         else {
             try {
                 const result = await local._processPacket(packet);
                 const reply = local.transport.newPacket({});
-                reply.method('connector.reply');
+                reply.method("connector.reply");
                 reply.cb(original.cb());
                 reply.args({ ...result });
                 local.transport.send(reply);
             }
             catch (e) {
-                console.log('error processing packet', e, packet);
+                console.log("error processing packet", e, packet);
             }
         }
     }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@aloma.io/integration-sdk",
-  "version": "3.0.1-1",
+  "version": "3.0.1-10",
   "description": "",
   "author": "aloma.io",
   "license": "Apache-2.0",
   "type": "module",
   "bin": {
-    "create-react-app": "./build/cli.js"
+    "aloma": "./build/cli.mjs"
   },
   "scripts": {
     "dev": "./node_modules/typescript/bin/tsc --watch",
@@ -27,6 +27,7 @@
   "dependencies": {
     "@paralleldrive/cuid2": "^2",
     "@ts-ast-parser/core": "^0",
+    "commander": "^11",
     "dotenv": "*",
     "express": "^4",
     "jose": "^4",

package/src/builder/index.mts

@@ -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));
 
@@ -13,17 +13,19 @@ const notEmpty = (what, name) => {
 };
 
 export class Builder {
-  private data: any = {controller: './build/controller/.controller-for-types.mts'};
+  private data: any = {
+    controller: "./build/controller/.controller-for-types.mts",
+  };
 
   config(arg: any): Builder {
     this.data.config = arg;
-    
+
     return this;
   }
 
   options(arg: any): Builder {
     this.data.options = arg;
-    
+
     return this;
   }
 
@@ -37,28 +39,33 @@ export class Builder {
     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);
   }
 
-  private async parsePackageJson()
-  {
+  private 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");
   }
 
   private 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);
+    const { text, methods } = parseTypes(this.data.controller);
 
-    this.data.types   = text;
+    this.data.types = text;
     this.data.methods = methods;
   }
 }

package/src/builder/runtime-context.mts

@@ -1,15 +1,16 @@
-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 {
   constructor(private controller: AbstractController, private data: any) {}
 
   async start(): Promise<void> {
     const controller = this.controller;
-    
-    if (!(controller instanceof AbstractController)) throw new Error('the controller needs to extend AbstractController');
-    const data:any = this.data;
-    
+
+    if (!(controller instanceof AbstractController))
+      throw new Error("the controller needs to extend AbstractController");
+    const data: any = this.data;
+
     const connector = new Connector({
       id: data.id,
       version: data.version,
@@ -19,7 +20,12 @@ export default class RuntimeContext {
     const configuration = connector.configure().config(data.config || {});
 
     const resolvers: any = {};
-    const methods: string[] = [...data.methods, '__endpoint', '__configQuery', '__default'];
+    const methods: string[] = [
+      ...data.methods,
+      "__endpoint",
+      "__configQuery",
+      "__default",
+    ];
 
     methods.forEach((method) => {
       resolvers[method] = async (args) => {
@@ -28,29 +34,33 @@ export default class RuntimeContext {
         return controller[method](args);
       };
     });
-    
-    configuration
-      .types(data.types)
-      .resolvers(resolvers);
-    
-    if (data.options?.endpoint?.enabled)
-    {
+
+    configuration.types(data.types).resolvers(resolvers);
+
+    if (data.options?.endpoint?.enabled) {
       configuration.endpoint((arg) => controller.__endpoint(arg));
     }
-    
-    if (data.auth?.oauth)
-    {
+
+    if (data.auth?.oauth) {
       configuration.oauth(data.auth?.oauth);
     }
-      
-      configuration.main(async ({newTask, updateTask, config, oauth, getClient}) => {
+
+    configuration.main(
+      async ({ newTask, updateTask, config, oauth, getClient }) => {
         try {
           await controller._doStop();
-          await controller._doStart(config, oauth, newTask, updateTask, getClient);
+          await controller._doStart(
+            config,
+            oauth,
+            newTask,
+            updateTask,
+            getClient
+          );
         } catch (e) {
           console.log(e);
         }
-      });
+      }
+    );
 
     connector.run();
   }

package/src/builder/transform/index.mts

@@ -1,11 +1,11 @@
-import {parseFromFiles} from '@ts-ast-parser/core';
+import { parseFromFiles } from "@ts-ast-parser/core";
 
 const transform = (meta: any) => {
-  if (!meta?.length) throw new Error('metadata is empty');
+  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');
+    throw new Error("connector file needs to export default class");
   }
 
   const methods = {};
@@ -15,9 +15,9 @@ const transform = (meta: any) => {
     return !(
       member.isStatic() ||
       member.isInherited() ||
-      member.getKind() !== 'Method' ||
-      member.getModifier() !== 'public' ||
-      member.getName().startsWith('_')
+      member.getKind() !== "Method" ||
+      member.getModifier() !== "public" ||
+      member.getName().startsWith("_")
     );
   });
 
@@ -29,15 +29,19 @@ const transform = (meta: any) => {
         .getSignatures()
         .map((sig: any) => {
           const docs = sig.getJSDoc().serialize() || [];
-          const desc = docs.find((what: any) => what.kind === 'description')?.value;
+          const desc = docs.find(
+            (what: any) => what.kind === "description"
+          )?.value;
 
           const paramDocs =
             docs
-              .filter((what: any) => what.kind === 'param')
+              .filter((what: any) => what.kind === "param")
               .map((what: any) => {
-                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()
@@ -49,37 +53,38 @@ const transform = (meta: any) => {
                   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)};
+  return { text, methods: Object.keys(methods) };
 };
 
 export default (path: string) => {

package/src/cli.mts

@@ -0,0 +1,107 @@
+#!/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);
+
+    extract({ ...options, target, name });
+    await generateKeys({target});
+  });
+
+program
+  .command("build")
+  .description("Build the current connector project")
+  .action(async (str, options) => {
+    console.log('building');
+    const {stdout, stderr} = await exec(`rm -rf build; mkdir -p build/controller; cp ./src/controller/index.mts ./build/controller/.controller-for-types.mts; ./node_modules/typescript/bin/tsc`);
+    
+    console.log(stdout, stderr);
+  });
+
+program.parse();

package/src/controller/index.mts

@@ -11,23 +11,23 @@ export abstract class AbstractController {
   }
 
   protected fallback(arg: any): Promise<any> {
-    throw new Error('method not found');
+    throw new Error("method not found");
   }
 
   protected endpoint(arg: any): Promise<any> {
-    throw new Error('method not found');
+    throw new Error("method not found");
   }
 
   protected async newTask(name: string, data: any): Promise<string> {
-    throw new Error('not implemented');
+    throw new Error("not implemented");
   }
 
-  protected getClient({baseUrl}: {baseUrl: string}): Promise<any> {
-    throw new Error('not implemented');
+  protected getClient({ baseUrl }: { baseUrl: string }): Promise<any> {
+    throw new Error("not implemented");
   }
 
   protected async updateTask(name: string, data: any): Promise<string> {
-    throw new Error('not implemented');
+    throw new Error("not implemented");
   }
 
   async __endpoint(arg: any): Promise<any | null> {
@@ -42,7 +42,13 @@ export abstract class AbstractController {
     return this.fallback(arg);
   }
 
-  async _doStart(config: any, client: any, newTask: any, updateTask: any, getClient: any): Promise<void> {
+  async _doStart(
+    config: any,
+    client: any,
+    newTask: any,
+    updateTask: any,
+    getClient: any
+  ): Promise<void> {
     this.config = config;
     this.client = client;
     this.newTask = newTask;

package/src/index.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";