@aloma.io/integration-sdk 3.0.1 → 3.0.2

package/README.md

@@ -1,9 +1,5 @@
 # nodejs - Aloma Integration SDK
 
-## Prerequisites
+## Creating a new Connector
 
-* You can find the `REGISTRATION_TOKEN` in your aloma workspace in the integration section when adding a connector.
-
-## Integration Examples
-
-See `examples` directory.
+With the aloma integration SDK cli you can simply create a new connector via `npx @aloma.io/integration-sdk 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,9 +10,7 @@ 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;
@@ -29,19 +27,17 @@ 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,12 +19,7 @@ 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))
@@ -32,7 +27,9 @@ 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/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,44 +110,33 @@ 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,

package/build/internal/index.cjs

@@ -1,27 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 // @ts-nocheck
-require("dotenv").config();
-const fs = require("fs");
-const { Config } = require("./websocket/config.cjs");
-const { Connection } = require("./websocket/connection/index.cjs");
-const { Transport } = require("./websocket/transport/index.cjs");
-const { Dispatcher } = require("./dispatcher/index.cjs");
-const { WebsocketConnector } = require("./websocket/index.cjs");
-const JWE = require("./util/jwe/index.cjs");
-const fetch = require("node-fetch");
-const cuid = require("@paralleldrive/cuid2").init({ length: 32 });
+require('dotenv').config();
+const fs = require('fs');
+const { Config } = require('./websocket/config.cjs');
+const { Connection } = require('./websocket/connection/index.cjs');
+const { Transport } = require('./websocket/transport/index.cjs');
+const { Dispatcher } = require('./dispatcher/index.cjs');
+const { WebsocketConnector } = require('./websocket/index.cjs');
+const JWE = require('./util/jwe/index.cjs');
+const fetch = require('node-fetch');
+const cuid = require('@paralleldrive/cuid2').init({ length: 32 });
 // TODO fetch with retry
 const handlePacketError = (packet, e, transport) => {
     if (!packet.cb()) {
-        console.dir({ msg: "packet error", e, packet }, { depth: null });
+        console.dir({ msg: 'packet error', e, packet }, { depth: null });
         return;
     }
-    transport.send(transport.newPacket({ c: packet.cb(), a: { error: "" + e } }));
+    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 });
+        console.dir({ msg: 'cannot reply to packet without cb', arg, packet }, { depth: null });
         return;
     }
     transport.send(transport.newPacket({ c: packet.cb(), a: { ...arg } }));
@@ -30,7 +30,7 @@ const unwrap = async (ret, options) => {
     if (options?.text)
         return await ret.text();
     if (options?.base64)
-        return (await ret.buffer()).toString("base64");
+        return (await ret.buffer()).toString('base64');
     return await ret.json();
 };
 class Fetcher {
@@ -57,13 +57,13 @@ class Fetcher {
         if (retries == null)
             retries = local.retry;
         try {
-            const theURL = `${baseUrl?.endsWith("/") ? baseUrl : baseUrl + "/"}${url}`.replace(/\/\/+/gi, "/");
+            const theURL = `${baseUrl?.endsWith('/') ? baseUrl : baseUrl + '/'}${url}`.replace(/\/\/+/gi, '/');
             await local.customize(options, args);
             const ret = await fetch(theURL, options);
             const status = await ret.status;
             if (status > 399) {
                 const text = await ret.text();
-                const e = new Error(status + " " + text);
+                const e = new Error(status + ' ' + text);
                 e.status = status;
                 throw e;
             }
@@ -92,14 +92,14 @@ class OAuthFetcher extends Fetcher {
             return oauth.accessToken();
         const refreshToken = oauth.refreshToken();
         if (!refreshToken)
-            throw new Error("have no access_token and no refresh_token");
+            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");
+            throw new Error('could not obtain access token via refresh token');
         }
     }
     async onError(e, url, options, retries, args) {
@@ -107,9 +107,7 @@ class OAuthFetcher extends Fetcher {
         return new Promise((resolve, reject) => {
             setTimeout(async () => {
                 try {
-                    resolve(await local.fetch(url, options, retries, {
-                        forceTokenRefresh: e.status === 401,
-                    }));
+                    resolve(await local.fetch(url, options, retries, { forceTokenRefresh: e.status === 401 }));
                 }
                 catch (e) {
                     reject(e);
@@ -165,36 +163,36 @@ class Connector {
     async run() {
         var local = this;
         const makeMetrics = () => {
-            const metrics = require("prom-client");
+            const metrics = require('prom-client');
             const defaultLabels = {
                 service: local.name,
                 connectorId: local.id,
                 connectorVersion: local.version,
-                node: process.env.HOSTNAME || "test",
+                node: process.env.HOSTNAME || 'test',
             };
             metrics.register.setDefaultLabels(defaultLabels);
             metrics.collectDefaultMetrics();
             return metrics;
         };
         const makeMetricsServer = (metrics) => {
-            const app = require("express")();
-            app.get("/metrics", async (request, response, next) => {
+            const app = require('express')();
+            app.get('/metrics', async (request, response, next) => {
                 response.status(200);
-                response.set("Content-type", metrics.contentType);
+                response.set('Content-type', metrics.contentType);
                 response.send(await metrics.register.metrics());
                 response.end();
             });
             return app;
         };
-        makeMetricsServer(makeMetrics()).listen(4050, "0.0.0.0");
+        makeMetricsServer(makeMetrics()).listen(4050, '0.0.0.0');
         const { processPacket, start, introspect, configSchema } = this.dispatcher.build();
         const config = new Config({
             id: this.id,
             version: this.version,
             name: process.env.HOSTNAME || this.name,
             registrationToken: process.env.REGISTRATION_TOKEN,
-            endpoint: process.env.DEVICE_ENDPOINT || "https://connect.aloma.io/",
-            wsEndpoint: process.env.WEBSOCKET_ENDPOINT || "wss://transport.aloma.io/transport/",
+            endpoint: process.env.DEVICE_ENDPOINT || 'https://connect.aloma.io/',
+            wsEndpoint: process.env.WEBSOCKET_ENDPOINT || 'wss://transport.aloma.io/transport/',
             privateKey: process.env.PRIVATE_KEY,
             publicKey: process.env.PUBLIC_KEY,
             introspect,
@@ -207,15 +205,15 @@ class Connector {
             catch (e) {
                 const haveKey = !!process.env.PRIVATE_KEY;
                 const jwe = new JWE({});
-                var text = "Please double check the env variables";
+                var text = 'Please double check the env variables';
                 if (!haveKey) {
                     await jwe.newPair();
                     text =
-                        "fresh keys generated, set environment variables: \n\nPRIVATE_KEY: " +
+                        'fresh keys generated, set environment variables: \n\nPRIVATE_KEY: ' +
                             (await jwe.exportPrivateAsBase64()) +
-                            "\n\nPUBLIC_KEY: " +
+                            '\n\nPUBLIC_KEY: ' +
                             (await jwe.exportPublicAsBase64()) +
-                            "\n";
+                            '\n';
                 }
                 console.log(`
 Error: 
@@ -234,7 +232,7 @@ ${text}
                     const decrypted = {};
                     const fields = configSchema().fields;
                     const keys = Object.keys(secrets);
-                    const jwe = await config.validateKeys("RSA-OAEP-256");
+                    const jwe = await config.validateKeys('RSA-OAEP-256');
                     for (var i = 0; i < keys.length; ++i) {
                         const key = keys[i];
                         const value = secrets[key];
@@ -248,22 +246,17 @@ ${text}
                                 decrypted[key] = await jwe.decrypt(value, config.id());
                             }
                             catch (e) {
-                                console.log("failed to decrypt key", key, config.id(), e);
+                                console.log('failed to decrypt key', key, config.id(), e);
                             }
                         }
                     }
                     this.startOAuth = async function (args) {
                         if (!this._oauth)
-                            throw new Error("oauth not configured");
-                        const clientId = this._oauth.clientId ||
-                            process.env.OAUTH_CLIENT_ID ||
-                            decrypted.clientId;
+                            throw new Error('oauth not configured');
+                        const clientId = this._oauth.clientId || process.env.OAUTH_CLIENT_ID || decrypted.clientId;
                         if (!clientId)
-                            throw new Error("clientId not configured");
-                        const scopes = this._oauth.scope ||
-                            process.env.OAUTH_SCOPE ||
-                            decrypted.scope ||
-                            "";
+                            throw new Error('clientId not configured');
+                        const scopes = this._oauth.scope || process.env.OAUTH_SCOPE || decrypted.scope || '';
                         const useCodeChallenge = !!that._oauth.useCodeChallenge;
                         return {
                             url: this._oauth.authorizationURL
@@ -275,23 +268,19 @@ ${text}
                     this.finishOAuth = async function (arg) {
                         var that = this;
                         if (!this._oauth)
-                            throw new Error("oauth not configured");
+                            throw new Error('oauth not configured');
                         if (!this._oauth.tokenURL && !this._oauth.finishOAuth)
-                            throw new Error("need tokenURL or finishOAuth(arg)");
+                            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 = that._oauth.clientId ||
-                                process.env.OAUTH_CLIENT_ID ||
-                                decrypted.clientId;
+                                throw new Error('need code and redirectUri');
+                            const clientId = that._oauth.clientId || process.env.OAUTH_CLIENT_ID || decrypted.clientId;
                             if (!clientId)
-                                throw new Error("clientId not configured");
-                            const clientSecret = that._oauth.clientSecret ||
-                                process.env.OAUTH_CLIENT_SECRET ||
-                                decrypted.clientSecret;
+                                throw new Error('clientId not configured');
+                            const clientSecret = that._oauth.clientSecret || process.env.OAUTH_CLIENT_SECRET || decrypted.clientSecret;
                             if (!clientSecret)
-                                throw new Error("clientSecret not configured");
+                                throw new Error('clientSecret not configured');
                             const additionalTokenArgs = that._oauth.additionalTokenArgs || {};
                             const useAuthHeader = !!that._oauth.useAuthHeader;
                             const useCodeChallenge = !!that._oauth.useCodeChallenge;
@@ -304,8 +293,8 @@ ${text}
                                 body.code_verifier = arg.codeVerifier;
                             }
                             let headers = {
-                                "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
-                                Accept: "application/json",
+                                'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
+                                Accept: 'application/json',
                             };
                             if (useAuthHeader) {
                                 headers = {
@@ -321,7 +310,7 @@ ${text}
                                 };
                             }
                             const response = await fetch(that._oauth.tokenURL, {
-                                method: "POST",
+                                method: 'POST',
                                 body: new URLSearchParams(body),
                                 headers,
                             });
@@ -330,17 +319,17 @@ ${text}
                             if (status === 200) {
                                 const ret = JSON.parse(text);
                                 if (ret.error) {
-                                    throw new Error(`${status} ${ret.error} ${ret.error_description || ""}`);
+                                    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);
+                                    throw new Error(status + ' response has no access_token - ' + text);
                                 }
                             }
                             else {
-                                throw new Error(status + " " + text);
+                                throw new Error(status + ' ' + text);
                             }
                         };
                         if (this._oauth.finishOAuth) {
@@ -353,30 +342,26 @@ ${text}
                         else {
                             data = await doFinish();
                         }
-                        const jwe = await config.validateKeys("RSA-OAEP-256");
-                        return { value: await jwe.encrypt(data, "none", config.id()) };
+                        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 jwe = await config.validateKeys('RSA-OAEP-256');
                         const packet = transport.newPacket({});
-                        packet.method("connector.config-update");
+                        packet.method('connector.config-update');
                         packet.args({
-                            value: await jwe.encrypt(what, "none", config.id()),
+                            value: await jwe.encrypt(what, 'none', config.id()),
                         });
                         transport.send(packet);
                     };
                     const that = this;
                     const getRefreshToken = async (refreshToken) => {
-                        const clientId = that._oauth.clientId ||
-                            process.env.OAUTH_CLIENT_ID ||
-                            decrypted.clientId;
+                        const clientId = that._oauth.clientId || process.env.OAUTH_CLIENT_ID || decrypted.clientId;
                         if (!clientId)
-                            throw new Error("clientId not configured");
-                        const clientSecret = that._oauth.clientSecret ||
-                            process.env.OAUTH_CLIENT_SECRET ||
-                            decrypted.clientSecret;
+                            throw new Error('clientId not configured');
+                        const clientSecret = that._oauth.clientSecret || process.env.OAUTH_CLIENT_SECRET || decrypted.clientSecret;
                         if (!clientSecret)
-                            throw new Error("clientSecret not configured");
+                            throw new Error('clientSecret not configured');
                         const useAuthHeader = !!that._oauth.useAuthHeader;
                         let headers = {};
                         if (useAuthHeader) {
@@ -386,16 +371,16 @@ ${text}
                             };
                         }
                         const response = await fetch(that._oauth.tokenURL, {
-                            method: "POST",
+                            method: 'POST',
                             body: new URLSearchParams({
-                                grant_type: "refresh_token",
+                                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",
+                                'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
+                                Accept: 'application/json',
                                 ...headers,
                             },
                         });
@@ -405,7 +390,7 @@ ${text}
                             return JSON.parse(text);
                         }
                         else {
-                            throw new Error("could not get refresh token " + status + " " + text);
+                            throw new Error('could not get refresh token ' + status + ' ' + text);
                         }
                     };
                     const theOAuth = decrypted.oauthResult
@@ -414,11 +399,11 @@ ${text}
                     start({
                         config: decrypted,
                         oauth: theOAuth,
-                        getClient: (arg) => theOAuth ? theOAuth.getClient(arg) : new Fetcher({ ...arg }),
+                        getClient: (arg) => (theOAuth ? 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.method('connector.task.new');
                                 packet.args({
                                     name,
                                     a: data,
@@ -429,7 +414,7 @@ ${text}
                         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.method('connector.task.update');
                                 packet.args({
                                     id,
                                     a: data,
@@ -462,14 +447,14 @@ ${text}
             });
             process.exit(0);
         };
-        process.on("uncaughtException", (e) => {
+        process.on('uncaughtException', (e) => {
             console.log(e);
         });
-        process.on("unhandledRejection", (e) => {
+        process.on('unhandledRejection', (e) => {
             console.log(e);
         });
-        process.on("SIGTERM", term);
-        process.on("SIGINT", term);
+        process.on('SIGTERM', term);
+        process.on('SIGINT', term);
         await server.start();
     }
 }

package/build/internal/util/jwe/cli.cjs

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const JWE = require("./index");
+const JWE = require('./index');
 const main = async () => {
     const jwe = new JWE({});
     await jwe.newPair();
-    console.log("private key");
+    console.log('private key');
     console.log(await jwe.exportPrivateAsBase64());
-    console.log("public key");
+    console.log('public key');
     console.log(await jwe.exportPublicAsBase64());
 };
 setTimeout(() => null, 100);

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

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const jose = require("jose");
+const jose = require('jose');
 class JWE {
-    constructor({ algorithm = "PS256" }) {
-        this.issuer = "home.aloma.io";
+    constructor({ algorithm = 'PS256' }) {
+        this.issuer = 'home.aloma.io';
         this.algorithm = algorithm;
     }
     async newPair() {
@@ -17,11 +17,11 @@ class JWE {
     }
     async exportPrivateAsBase64() {
         const pair = await this.exportPair();
-        return Buffer.from(pair.privateKey).toString("base64");
+        return Buffer.from(pair.privateKey).toString('base64');
     }
     async exportPublicAsBase64() {
         const pair = await this.exportPair();
-        return Buffer.from(pair.publicKey).toString("base64");
+        return Buffer.from(pair.publicKey).toString('base64');
     }
     async importPair({ publicKey, privateKey, algorithm }) {
         this.pair = {
@@ -31,18 +31,18 @@ class JWE {
     }
     async importBase64Pair({ publicKey, privateKey, algorithm }) {
         this.importPair({
-            publicKey: Buffer.from(publicKey, "base64").toString(),
-            privateKey: Buffer.from(privateKey, "base64").toString(),
+            publicKey: Buffer.from(publicKey, 'base64').toString(),
+            privateKey: Buffer.from(privateKey, 'base64').toString(),
             algorithm,
         });
     }
-    async encrypt(what, expiration = "7d", audience, algorithm = "RSA-OAEP-256") {
+    async encrypt(what, expiration = '7d', audience, algorithm = 'RSA-OAEP-256') {
         const item = new jose.EncryptJWT({ _data: { ...what } })
-            .setProtectedHeader({ alg: algorithm, enc: "A256GCM" })
+            .setProtectedHeader({ alg: algorithm, enc: 'A256GCM' })
             .setIssuedAt()
             .setIssuer(this.issuer)
             .setAudience(audience);
-        if (expiration && expiration !== "none")
+        if (expiration && expiration !== 'none')
             item.setExpirationTime(expiration);
         return await item.encrypt(this.pair.publicKey);
     }

package/build/internal/websocket/config.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const C = require("./connection/constants.cjs");
-const JWE = require("../util/jwe/index.cjs");
+const C = require('./connection/constants.cjs');
+const JWE = require('../util/jwe/index.cjs');
 class Config {
     constructor({ registrationToken, version, name, id, endpoint, wsEndpoint, privateKey, publicKey, introspect, configSchema, }) {
         this._token = null;
@@ -18,17 +18,17 @@ class Config {
         this._introspect = introspect;
         this._configSchema = configSchema;
         if (!registrationToken)
-            throw new Error("empty registration token (set env.REGISTRATION_TOKEN)");
+            throw new Error('empty registration token (set env.REGISTRATION_TOKEN)');
         if (!endpoint)
-            throw new Error("empty endpoint (set env.DEVICE_ENDPOINT)");
+            throw new Error('empty endpoint (set env.DEVICE_ENDPOINT)');
         if (!wsEndpoint)
-            throw new Error("empty registration token (set env.WEBSOCKET_ENDPOINT)");
+            throw new Error('empty registration token (set env.WEBSOCKET_ENDPOINT)');
         if (!this._id || !this._version)
-            throw new Error("need connector id and version");
+            throw new Error('need connector id and version');
     }
     async validateKeys(algorithm) {
         if (!this._privateKey || !this._publicKey)
-            throw new Error("need private and public key");
+            throw new Error('need private and public key');
         await this._jwe.importBase64Pair({
             publicKey: this._publicKey,
             privateKey: this._privateKey,

package/build/internal/websocket/connection/constants.cjs

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const AUTHORIZATION = "Authorization";
+const AUTHORIZATION = 'Authorization';
 module.exports = {
     augmentRequest: (what, config) => {
         what.headers = {
             ...what.headers,
-            "User-Agent": config.id() + "/" + config.version(),
+            'User-Agent': config.id() + '/' + config.version(),
         };
         what.headers[AUTHORIZATION] = `Connector ${config.token()}`;
         return what;
@@ -13,7 +13,7 @@ module.exports = {
     augmentRegistration: (what, config) => {
         what.headers = {
             ...what.headers,
-            "User-Agent": config.id() + "/" + config.version(),
+            'User-Agent': config.id() + '/' + config.version(),
         };
         what.headers[AUTHORIZATION] = `Connector ${config.registrationToken()}`;
         return what;

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const fetch = require("node-fetch");
-const { Registration } = require("./registration.cjs");
-const C = require("./constants.cjs");
+const fetch = require('node-fetch');
+const { Registration } = require('./registration.cjs');
+const C = require('./constants.cjs');
 class Connection {
     constructor({ config, onStart }) {
         this.config = config;
@@ -11,10 +11,10 @@ class Connection {
     async start() {
         var local = this, config = local.config;
         try {
-            const response = await fetch(config.url() + "connect", C.augmentRequest({
-                method: "POST",
+            const response = await fetch(config.url() + 'connect', C.augmentRequest({
+                method: 'POST',
                 body: JSON.stringify({}),
-                headers: { "Content-Type": "application/json" },
+                headers: { 'Content-Type': 'application/json' },
             }, config));
             if (response.status === 401) {
                 config.setToken(await new Registration(local.config).run());
@@ -39,10 +39,10 @@ class Connection {
     }
     async close() {
         try {
-            await fetch(this.config.url() + "disconnect", C.augmentRequest({
-                method: "POST",
+            await fetch(this.config.url() + 'disconnect', C.augmentRequest({
+                method: 'POST',
                 body: JSON.stringify({}),
-                headers: { "Content-Type": "application/json" },
+                headers: { 'Content-Type': 'application/json' },
             }, this.config));
         }
         catch (e) {

package/build/internal/websocket/connection/registration.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const fetch = require("node-fetch");
-const C = require("./constants.cjs");
+const fetch = require('node-fetch');
+const C = require('./constants.cjs');
 class Registration {
     constructor(config) {
         this.config = config;
@@ -11,21 +11,21 @@ class Registration {
         const config = this.config;
         const configSchema = config.configSchema();
         const intro = await config.introspect();
-        const response = await fetch(config.url() + "register", C.augmentRegistration({
-            method: "POST",
+        const response = await fetch(config.url() + 'register', C.augmentRegistration({
+            method: 'POST',
             body: JSON.stringify({
-                deployment: process.env.DEPLOYMENT || "",
+                deployment: process.env.DEPLOYMENT || '',
                 name: config.name(),
                 version: config.version(),
                 id: config.id(),
                 publicKey: config.publicKey(),
                 schema: { configSchema, introspect: intro },
             }),
-            headers: { "Content-Type": "application/json" },
+            headers: { 'Content-Type': 'application/json' },
         }, config));
         if (response.status === 200)
             return (await response.json()).key;
-        throw new Error("authentication failed");
+        throw new Error('authentication failed');
     }
 }
 module.exports = { Registration };

package/build/internal/websocket/index.cjs

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const WebSocket = require("ws");
-const { Connection } = require("./connection/index.cjs");
-const { Transport } = require("./transport/index.cjs");
+const WebSocket = require('ws');
+const { Connection } = require('./connection/index.cjs');
+const { Transport } = require('./transport/index.cjs');
 class WebsocketConnector {
     constructor({ config, onMessage, onConnect }) {
         var local = this;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const WebSocket = require("ws");
+const WebSocket = require('ws');
 class DurableWebsocket {
     constructor({ endpoint, secret, onConnect, onMessage }) {
         this.endpoint = endpoint;
@@ -28,7 +28,7 @@ class DurableWebsocket {
             rejectUnauthorized: false,
             headers: { Authorization: `Bearer ${local.secret}` },
         }));
-        ws.on("open", () => {
+        ws.on('open', () => {
             local.connecting = false;
             local.fails = 0;
             var item;
@@ -37,15 +37,15 @@ class DurableWebsocket {
             }
             local.onConnect(local);
         });
-        ws.on("message", (message) => {
+        ws.on('message', (message) => {
             setImmediate(() => local.onMessage(JSON.parse(message)));
         });
-        ws.on("error", (message) => {
+        ws.on('error', (message) => {
             if (local.fails > 50)
-                console.log("error:", message.message);
+                console.log('error:', message.message);
             ++local.fails;
         });
-        ws.on("close", (message) => {
+        ws.on('close', (message) => {
             local.connecting = false;
             if (!local.closed)
                 setTimeout(() => local.start(), 5000);

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,6 +1,6 @@
 {
   "name": "@aloma.io/integration-sdk",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "description": "",
   "author": "aloma.io",
   "license": "Apache-2.0",

package/build/cli.d.mts

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

package/build/cli.mjs

@@ -1,93 +0,0 @@
-#!/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();