@aloma.io/integration-sdk 3.7.49 → 3.8.0

package/build/internal/index.mjs

@@ -1,424 +1,2 @@
-import { init } from "@paralleldrive/cuid2";
-import express from "express";
-import PromClient from "prom-client";
-import { Dispatcher } from "./dispatcher/index.mjs";
-import Fetcher from "./fetcher/fetcher.mjs";
-import { OAuth } from "./fetcher/oauth-fetcher.mjs";
-import { handlePacketError, reply } from "./util/index.mjs";
-import JWE from "./util/jwe/index.mjs";
-import { Config } from "./websocket/config.mjs";
-import { WebsocketConnector } from "./websocket/index.mjs";
-const cuid = init({ length: 32 });
-class Connector {
-    id;
-    version;
-    name;
-    icon;
-    dispatcher;
-    constructor({ version, id, name, icon }) {
-        this.id = id;
-        this.version = version;
-        this.name = name;
-        this.icon = icon;
-    }
-    configure() {
-        return (this.dispatcher = new Dispatcher());
-    }
-    async run() {
-        var local = this;
-        const makeMetrics = () => {
-            const metrics = PromClient;
-            const defaultLabels = {
-                service: local.name,
-                connectorId: local.id,
-                connectorVersion: local.version,
-                node: process.env.HOSTNAME || "test",
-            };
-            metrics.register.setDefaultLabels(defaultLabels);
-            metrics.collectDefaultMetrics();
-            return metrics;
-        };
-        const makeMetricsServer = (metrics) => {
-            const app = express();
-            app.get("/metrics", async (request, response, next) => {
-                response.status(200);
-                response.set("Content-type", metrics.contentType);
-                response.send(await metrics.register.metrics());
-                response.end();
-            });
-            return app;
-        };
-        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://connect.aloma.io/transport/",
-            privateKey: process.env.PRIVATE_KEY,
-            publicKey: process.env.PUBLIC_KEY,
-            introspect,
-            configSchema,
-            icon: this.icon,
-        });
-        if (Object.keys(configSchema().fields).length) {
-            try {
-                await config.validateKeys();
-            }
-            catch (e) {
-                const haveKey = !!process.env.PRIVATE_KEY;
-                const jwe = new JWE({});
-                var text = "Please double check the env variables";
-                if (!haveKey) {
-                    await jwe.newPair();
-                    text =
-                        "fresh keys generated, set environment variables: \n\nPRIVATE_KEY: " +
-                            (await jwe.exportPrivateAsBase64()) +
-                            "\n\nPUBLIC_KEY: " +
-                            (await jwe.exportPublicAsBase64()) +
-                            "\n";
-                }
-                console.log(`
-Error: 
-
-public (env.PUBLIC_KEY) and private key (env.PRIVATE_KEY) could not be loaded.
-      
-${text}
-        `);
-                return;
-            }
-        }
-        const server = new WebsocketConnector({
-            config,
-            onConnect: (transport) => {
-                // @ts-ignore
-                local.dispatcher.onConfig = async function (secrets) {
-                    const decrypted = {};
-                    const fields = configSchema().fields;
-                    const keys = Object.keys(secrets);
-                    const jwe = await config.validateKeys("RSA-OAEP-256");
-                    for (var i = 0; i < keys.length; ++i) {
-                        const key = keys[i];
-                        const value = secrets[key];
-                        if (!value)
-                            continue;
-                        if (fields[key]?.plain || ["endpointUrl"].includes(key)) {
-                            decrypted[key] = value;
-                        }
-                        else {
-                            try {
-                                decrypted[key] = await jwe.decrypt(value, config.id());
-                            }
-                            catch (e) {
-                                console.log("failed to decrypt key", key, config.id(), e);
-                            }
-                        }
-                    }
-                    // @ts-ignore
-                    this.startOAuth = async function (args) {
-                        if (!this._oauth)
-                            throw new Error("oauth not configured");
-                        const authorizationURL = process.env.OAUTH_AUTHORIZATION_URL ||
-                            decrypted.authorizationURL ||
-                            that._oauth.authorizationURL;
-                        if (!authorizationURL)
-                            throw new Error("authorizationURL not configured");
-                        const clientId = decrypted.clientId ||
-                            process.env.OAUTH_CLIENT_ID ||
-                            this._oauth.clientId;
-                        if (!clientId)
-                            throw new Error("clientId not configured");
-                        const scopes = process.env.OAUTH_SCOPE ||
-                            decrypted.scope ||
-                            this._oauth.scope ||
-                            "";
-                        const useCodeChallenge = !!that._oauth.useCodeChallenge;
-                        return {
-                            url: authorizationURL
-                                .replace(/\{\{clientId\}\}/gi, encodeURIComponent(clientId))
-                                .replace(/\{\{scope\}\}/gi, encodeURIComponent(scopes)),
-                            useCodeChallenge,
-                        };
-                    };
-                    // @ts-ignore
-                    this.finishOAuth = async function (arg) {
-                        var that = this;
-                        const tokenURL = process.env.OAUTH_TOKEN_URL ||
-                            decrypted.tokenURL ||
-                            that._oauth.tokenURL;
-                        if (!this._oauth)
-                            throw new Error("oauth not configured");
-                        if (!tokenURL && !this._oauth.finishOAuth)
-                            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 = decrypted.clientId ||
-                                process.env.OAUTH_CLIENT_ID ||
-                                that._oauth.clientId;
-                            if (!clientId)
-                                throw new Error("clientId not configured");
-                            const clientSecret = decrypted.clientSecret ||
-                                process.env.OAUTH_CLIENT_SECRET ||
-                                that._oauth.clientSecret;
-                            if (!clientSecret)
-                                throw new Error("clientSecret not configured");
-                            const additionalTokenArgs = that._oauth.additionalTokenArgs || {};
-                            const useAuthHeader = !!that._oauth.useAuthHeader;
-                            const useCodeChallenge = !!that._oauth.useCodeChallenge;
-                            let body = {
-                                grant_type: "authorization_code",
-                                ...additionalTokenArgs,
-                                code: arg.code,
-                                redirect_uri: arg.redirectURI,
-                            };
-                            if (useCodeChallenge) {
-                                body.code_verifier = arg.codeVerifier;
-                            }
-                            let headers = {
-                                "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
-                                Accept: "application/json",
-                            };
-                            if (useAuthHeader) {
-                                headers = {
-                                    ...headers,
-                                    Authorization: `Basic ${btoa(`${clientId}:${clientSecret}`)}`,
-                                };
-                            }
-                            else {
-                                body = {
-                                    ...body,
-                                    client_id: clientId,
-                                    client_secret: clientSecret,
-                                };
-                            }
-                            const response = await fetch(tokenURL, {
-                                method: "POST",
-                                body: new URLSearchParams(body),
-                                headers,
-                                signal: AbortSignal.timeout(60 * 1000),
-                            });
-                            const status = await response.status;
-                            const text = await response.text();
-                            if (status === 200) {
-                                const ret = JSON.parse(text);
-                                if (ret.error) {
-                                    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);
-                                }
-                            }
-                            else {
-                                throw new Error(status + " " + text);
-                            }
-                        };
-                        if (this._oauth.finishOAuth) {
-                            data = await this._oauth.finishOAuth({
-                                arg,
-                                doFinish,
-                                transport,
-                            });
-                        }
-                        else {
-                            data = await doFinish();
-                        }
-                        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 value = await jwe.encrypt(what, "none", config.id());
-                        const packet = transport.newPacket({});
-                        packet.method("connector.config-update");
-                        packet.args({
-                            value,
-                        });
-                        transport.send(packet);
-                    };
-                    const that = this;
-                    const getRefreshToken = async (refreshToken) => {
-                        const tokenURL = process.env.OAUTH_TOKEN_URL ||
-                            decrypted.tokenURL ||
-                            that._oauth.tokenURL;
-                        const clientId = decrypted.clientId ||
-                            process.env.OAUTH_CLIENT_ID ||
-                            that._oauth.clientId;
-                        if (!clientId)
-                            throw new Error("clientId not configured");
-                        const clientSecret = decrypted.clientSecret ||
-                            process.env.OAUTH_CLIENT_SECRET ||
-                            that._oauth.clientSecret;
-                        if (!clientSecret)
-                            throw new Error("clientSecret not configured");
-                        const useAuthHeader = !!that._oauth.useAuthHeader;
-                        let headers = {};
-                        if (useAuthHeader) {
-                            headers = {
-                                ...headers,
-                                Authorization: `Basic ${btoa(`${clientId}:${clientSecret}`)}`,
-                            };
-                        }
-                        const response = await fetch(tokenURL, {
-                            method: "POST",
-                            body: new URLSearchParams({
-                                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",
-                                ...headers,
-                            },
-                            signal: AbortSignal.timeout(60 * 1000),
-                        });
-                        const status = await response.status;
-                        const text = await response.text();
-                        if (status === 200) {
-                            return JSON.parse(text);
-                        }
-                        else {
-                            throw new Error("could not get refresh token " + status + " " + text);
-                        }
-                    };
-                    const theOAuth = that._oauth
-                        ? new OAuth(decrypted.oauthResult, saveOAuthResult, getRefreshToken)
-                        : null;
-                    if (theOAuth) {
-                        // @ts-ignore
-                        clearInterval(this._refreshOAuthToken);
-                        if (!(this._oauth.noPeriodicTokenRefresh === false)) {
-                            // @ts-ignore
-                            this._refreshOAuthToken = setInterval(async () => {
-                                try {
-                                    console.log("refreshing oauth token");
-                                    await theOAuth.periodicRefresh();
-                                }
-                                catch (e) {
-                                    console.log("periodic refresh", e);
-                                }
-                            }, this._oauth.tokenRefreshPeriod || 4 * 60 * 60 * 15000);
-                        }
-                    }
-                    const getBlob = (id) => {
-                        return new Promise((resolve, reject) => {
-                            const packet = transport.newPacket({}, (ret) => (ret?.error ? reject(ret.error) : resolve(ret)), `_req-${cuid()}`);
-                            packet.method("connector.blob.get");
-                            packet.args({
-                                id,
-                            });
-                            transport.send(packet);
-                        });
-                    };
-                    const getBlobContent = (id) => {
-                        return new Promise((resolve, reject) => {
-                            const packet = transport.newPacket({}, (ret) => ret?.error ? reject(ret.error) : resolve(ret?.content), `_req-${cuid()}`);
-                            packet.method("connector.blob.get-content");
-                            packet.args({
-                                id,
-                            });
-                            transport.send(packet);
-                        });
-                    };
-                    const createBlob = (args = {}) => {
-                        return new Promise((resolve, reject) => {
-                            const packet = transport.newPacket({}, (ret) => (ret?.error ? reject(ret.error) : resolve(ret?.id)), `_req-${cuid()}`);
-                            packet.method("connector.blob.create");
-                            packet.args(args);
-                            transport.send(packet);
-                        });
-                    };
-                    let oauthClient;
-                    start({
-                        config: decrypted,
-                        oauth: theOAuth,
-                        getBlob,
-                        getBlobContent,
-                        createBlob,
-                        healthCheck: async (controller) => {
-                            let result = { ok: true, error: null };
-                            try {
-                                if (oauthClient) {
-                                    await oauthClient.__healthCheck();
-                                }
-                                await controller.__healthCheck();
-                            }
-                            catch (e) {
-                                result.ok = false;
-                                result.error = e.message;
-                            }
-                            const packet = transport.newPacket({});
-                            packet.method("connector.health.check");
-                            packet.args(result);
-                            transport.send(packet);
-                        },
-                        getClient: (arg) => theOAuth
-                            ? (oauthClient = 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.args({
-                                    name,
-                                    a: data,
-                                });
-                                transport.send(packet);
-                            });
-                        },
-                        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.args({
-                                    id,
-                                    a: data,
-                                });
-                                transport.send(packet);
-                            });
-                        },
-                    });
-                };
-            },
-            onMessage: async (packet, transport) => {
-                try {
-                    const ret = await processPacket(packet);
-                    if (ret)
-                        reply(ret, packet, transport);
-                }
-                catch (e) {
-                    console.log(e);
-                    handlePacketError(packet, e, transport);
-                }
-            },
-        });
-        const term = async () => {
-            await server.leaving();
-            await new Promise((resolve) => {
-                setTimeout(async () => {
-                    await server.close();
-                    resolve(null);
-                }, 10000);
-            });
-            process.exit(0);
-        };
-        process.on("uncaughtException", (e) => {
-            console.log(e);
-        });
-        process.on("unhandledRejection", (e) => {
-            console.log(e);
-        });
-        process.on("SIGTERM", term);
-        process.on("SIGINT", term);
-        await server.start();
-    }
-}
+import { Connector } from './connector/index.mjs';
 export { Connector };

package/package.json

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

package/src/internal/connector/config.mts

@@ -0,0 +1,57 @@
+import JWE from "../util/jwe/index.mjs";
+import { Config } from "../websocket/config.mjs";
+
+export const makeConfig = async ({id, version, name, introspect, configSchema, icon}): Promise<Config> => {
+  const config = new Config({
+    id: id,
+    version: version,
+    name: process.env.HOSTNAME || name,
+    registrationToken: process.env.REGISTRATION_TOKEN,
+    endpoint: process.env.DEVICE_ENDPOINT || "https://connect.aloma.io/",
+    wsEndpoint:
+      process.env.WEBSOCKET_ENDPOINT || "wss://connect.aloma.io/transport/",
+    privateKey: process.env.PRIVATE_KEY,
+    publicKey: process.env.PUBLIC_KEY,
+    introspect,
+    configSchema,
+    icon: icon,
+  });
+
+  if (Object.keys(configSchema().fields).length) {
+    try {
+      await config.validateKeys();
+    } catch (e) {
+      const haveKey = !!process.env.PRIVATE_KEY;
+      const jwe = new JWE({});
+      var text = "Please double check the env variables";
+
+      if (!haveKey) {
+        await jwe.newPair();
+        text =
+          "fresh keys generated, set environment variables: \n\nPRIVATE_KEY: " +
+          (await jwe.exportPrivateAsBase64()) +
+          "\n\nPUBLIC_KEY: " +
+          (await jwe.exportPublicAsBase64()) +
+          "\n";
+      }
+
+      console.log(`
+Error:
+
+public (env.PUBLIC_KEY) and private key (env.PRIVATE_KEY) could not be loaded.
+
+${text}
+      `);
+
+      await new Promise((resolve) => {
+        setTimeout(() => {
+          resolve(null);
+        }, 2 * 60 * 1000);
+      });
+
+      throw new Error('could not start');
+    }
+  }
+
+  return config;
+}

package/src/internal/connector/index.mts

@@ -0,0 +1,48 @@
+import { Dispatcher } from "../dispatcher/index.mjs";
+import { makeConfig } from "./config.mjs";
+import { makeMetrics } from "./metrics.mjs";
+import { makeServer } from "./server/index.mjs";
+
+export class Connector {
+  id: any;
+  version: any;
+  name: any;
+  icon: any;
+  dispatcher?: Dispatcher;
+  constructor({ version, id, name, icon }) {
+    this.id = id;
+    this.version = version;
+    this.name = name;
+    this.icon = icon;
+  }
+
+  configure() {
+    return (this.dispatcher = new Dispatcher());
+  }
+
+  async run() {
+    console.log(`Running ${this.name}`);
+
+    const { processPacket, start, introspect, configSchema } = this.dispatcher!.build();
+
+    const config = await makeConfig({
+      id: this.id,
+      version: this.version,
+      name: this.name,
+      introspect,
+      configSchema,
+      icon: this.icon,
+    });
+
+    await makeMetrics({
+      id: this.id,
+      name: this.name,
+      version: this.version,
+    });
+
+    const server = await makeServer({config, configSchema, start, processPacket, dispatcher: this.dispatcher!})
+
+    await server.start();
+  }
+}
+

package/src/internal/connector/metrics.mts

@@ -0,0 +1,35 @@
+import express from "express";
+import PromClient from "prom-client";
+
+export const makeMetrics = async ({id, name, version}): Promise<void> => {
+  const newMetrics = () => {
+    const metrics = PromClient;
+
+    const defaultLabels = {
+      service: name,
+      connectorId: id,
+      connectorVersion: version,
+      node: process.env.HOSTNAME || "test",
+    };
+    metrics.register.setDefaultLabels(defaultLabels);
+    metrics.collectDefaultMetrics();
+
+    return metrics;
+  };
+
+  const makeMetricsServer = (metrics) => {
+    const app = express();
+
+    app.get("/metrics", async (request, response, next) => {
+      response.status(200);
+      response.set("Content-type", metrics.contentType);
+      response.send(await metrics.register.metrics());
+      response.end();
+    });
+
+    return app;
+  };
+
+  makeMetricsServer(newMetrics()).listen(4050, "0.0.0.0");
+
+}

package/src/internal/connector/server/index.mts

@@ -0,0 +1,39 @@
+import Dispatcher from "../../dispatcher/index.mjs";
+import { Config } from "../../websocket/config.mjs";
+import { WebsocketConnector } from "../../websocket/index.mjs";
+import { onConnect } from "./on-connect/index.mjs";
+import { onMessage } from "./on-message.mjs";
+
+export const makeServer = async ({config, configSchema, start, processPacket, dispatcher}: {config: Config, configSchema: any, start: any, processPacket: any, dispatcher: Dispatcher}): Promise<WebsocketConnector> => {
+  const server = new WebsocketConnector({
+    config,
+    onConnect: onConnect({config, configSchema, dispatcher, start}),
+    onMessage: onMessage(processPacket)
+  });
+
+  const term = async () => {
+    await server.leaving();
+
+    await new Promise((resolve) => {
+      setTimeout(async () => {
+        await server.close();
+        resolve(null);
+      }, 10000);
+    });
+
+    process.exit(0);
+  };
+
+  process.on("uncaughtException", (e) => {
+    console.log(e);
+  });
+
+  process.on("unhandledRejection", (e) => {
+    console.log(e);
+  });
+
+  process.on("SIGTERM", term);
+  process.on("SIGINT", term);
+
+  return server;
+}

package/src/internal/connector/server/on-connect/decrypt-config.mts

@@ -0,0 +1,27 @@
+
+export const decryptConfig = async ({configSchema, config, secrets}) => {
+  const decrypted: any = {};
+
+  const fields = configSchema().fields;
+
+  const keys = Object.keys(secrets);
+  const jwe = await config.validateKeys("RSA-OAEP-256");
+
+  for (var i = 0; i < keys.length; ++i) {
+    const key = keys[i];
+    const value = secrets[key];
+    if (!value) continue;
+
+    if (fields[key]?.plain || ["endpointUrl"].includes(key)) {
+      decrypted[key] = value;
+    } else {
+      try {
+        decrypted[key] = await jwe.decrypt(value, config.id());
+      } catch (e) {
+        console.log("failed to decrypt key", key, config.id(), e);
+      }
+    }
+  }
+
+  return decrypted;
+}