@aloma.io/integration-sdk 3.0.0-4

package/build/internal/websocket/config.d.cts

@@ -0,0 +1,41 @@
+export class Config {
+    constructor({ registrationToken, version, name, id, endpoint, wsEndpoint, privateKey, publicKey, introspect, configSchema, }: {
+        registrationToken: any;
+        version: any;
+        name: any;
+        id: any;
+        endpoint: any;
+        wsEndpoint: any;
+        privateKey: any;
+        publicKey: any;
+        introspect: any;
+        configSchema: any;
+    });
+    _token: any;
+    _registrationToken: any;
+    _version: any;
+    _name: any;
+    _endpoint: any;
+    _wsEndpoint: any;
+    _id: any;
+    _data: {};
+    _privateKey: any;
+    _publicKey: any;
+    _jwe: JWE;
+    _introspect: any;
+    _configSchema: any;
+    validateKeys(algorithm: any): Promise<JWE>;
+    data(what: any): {};
+    introspect(): any;
+    configSchema(): any;
+    publicKey(): any;
+    id(): any;
+    version(): any;
+    name(): any;
+    url(): any;
+    wsUrl(): any;
+    registrationToken(): any;
+    token(): any;
+    setToken(what: any): void;
+}
+import JWE = require("../util/jwe/index.cjs");

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

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

package/build/internal/websocket/connection/constants.d.cts

@@ -0,0 +1,2 @@
+export function augmentRequest(what: any, config: any): any;
+export function augmentRegistration(what: any, config: any): any;

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fetch = require('node-fetch');
+const { Registration } = require('./registration.cjs');
+const C = require('./constants.cjs');
+class Connection {
+    constructor({ config, onStart }) {
+        this.config = config;
+        this.onStart = onStart;
+    }
+    async start() {
+        var local = this, config = local.config;
+        try {
+            const response = await fetch(config.url() + 'connect', C.augmentRequest({
+                method: 'POST',
+                body: JSON.stringify({}),
+                headers: { 'Content-Type': 'application/json' },
+            }, config));
+            if (response.status === 401) {
+                config.setToken(await new Registration(local.config).run());
+                return await local.start();
+            }
+            else if (response.status === 200) {
+                config.data(await response.json());
+                await local.onStart(() => local.onDisconnect());
+            }
+            else {
+                setTimeout(() => local.start(), 5000);
+            }
+        }
+        catch (e) {
+            console.log(e);
+            setTimeout(() => local.start(), 5000);
+        }
+    }
+    onDisconnect() {
+        var local = this;
+        setTimeout(() => local.start(), 5000);
+    }
+    async close() {
+        try {
+            await fetch(this.config.url() + 'disconnect', C.augmentRequest({
+                method: 'POST',
+                body: JSON.stringify({}),
+                headers: { 'Content-Type': 'application/json' },
+            }, this.config));
+        }
+        catch (e) {
+            // blank
+        }
+    }
+}
+module.exports = { Connection };

package/build/internal/websocket/connection/index.d.cts

@@ -0,0 +1,11 @@
+export class Connection {
+    constructor({ config, onStart }: {
+        config: any;
+        onStart: any;
+    });
+    config: any;
+    onStart: any;
+    start(): any;
+    onDisconnect(): void;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fetch = require('node-fetch');
+const C = require('./constants.cjs');
+class Registration {
+    constructor(config) {
+        this.config = config;
+    }
+    async run() {
+        var local = this;
+        const config = this.config;
+        const configSchema = config.configSchema();
+        const intro = await config.introspect();
+        const response = await fetch(config.url() + 'register', C.augmentRegistration({
+            method: 'POST',
+            body: JSON.stringify({
+                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' },
+        }, config));
+        if (response.status === 200)
+            return (await response.json()).key;
+        throw new Error('authentication failed');
+    }
+}
+module.exports = { Registration };

package/build/internal/websocket/connection/registration.d.cts

@@ -0,0 +1,5 @@
+export class Registration {
+    constructor(config: any);
+    config: any;
+    run(): Promise<any>;
+}

package/build/internal/websocket/index.cjs

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+        this.config = config;
+        this.transport = new Transport({ config, onMessage, onConnect });
+    }
+    async start() {
+        var local = this;
+        const config = this.config;
+        local.connection = new Connection({
+            config,
+            onStart: () => {
+                local.transport.start(() => setTimeout(() => local.start(), 1000));
+            },
+        });
+        await local.connection.start();
+    }
+    send(message) {
+        if (!message)
+            return;
+        this.transport.send(this.transport.newPacket(message));
+    }
+    async close() {
+        var local = this;
+        if (local.transport)
+            await local.transport.close();
+    }
+    async leaving() {
+        var local = this;
+        if (local.transport)
+            await local.transport.leaving();
+        if (local.connection)
+            await local.connection.close();
+    }
+}
+module.exports = { WebsocketConnector };

package/build/internal/websocket/index.d.cts

@@ -0,0 +1,16 @@
+export class WebsocketConnector {
+    constructor({ config, onMessage, onConnect }: {
+        config: any;
+        onMessage: any;
+        onConnect: any;
+    });
+    config: any;
+    transport: Transport;
+    start(): Promise<void>;
+    connection: Connection | undefined;
+    send(message: any): void;
+    close(): Promise<void>;
+    leaving(): Promise<void>;
+}
+import { Transport } from "./transport/index.cjs";
+import { Connection } from "./connection/index.cjs";

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const WebSocket = require('ws');
+class DurableWebsocket {
+    constructor({ endpoint, secret, onConnect, onMessage }) {
+        this.endpoint = endpoint;
+        this.secret = secret;
+        this.onConnect = onConnect;
+        this.onMessage = onMessage;
+        this.failed = [];
+        this.fails = 0;
+        this.start();
+    }
+    async send(what) {
+        try {
+            return await this.ws.send(JSON.stringify(what));
+        }
+        catch (e) {
+            this.failed.push(what);
+        }
+    }
+    start() {
+        var local = this;
+        if (local.connecting || local.closed)
+            return;
+        local.connecting = true;
+        const ws = (local.ws = new WebSocket(local.endpoint, [], {
+            rejectUnauthorized: false,
+            headers: { Authorization: `Bearer ${local.secret}` },
+        }));
+        ws.on('open', () => {
+            local.connecting = false;
+            local.fails = 0;
+            var item;
+            while ((item = local.failed.shift())) {
+                local.send(item);
+            }
+            local.onConnect(local);
+        });
+        ws.on('message', (message) => {
+            setImmediate(() => local.onMessage(JSON.parse(message)));
+        });
+        ws.on('error', (message) => {
+            if (local.fails > 50)
+                console.log('error:', message.message);
+            ++local.fails;
+        });
+        ws.on('close', (message) => {
+            local.connecting = false;
+            if (!local.closed)
+                setTimeout(() => local.start(), 5000);
+        });
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        await this.ws?.close();
+    }
+}
+module.exports = { DurableWebsocket };

package/build/internal/websocket/transport/durable.d.cts

@@ -0,0 +1,20 @@
+export class DurableWebsocket {
+    constructor({ endpoint, secret, onConnect, onMessage }: {
+        endpoint: any;
+        secret: any;
+        onConnect: any;
+        onMessage: any;
+    });
+    endpoint: any;
+    secret: any;
+    onConnect: any;
+    onMessage: any;
+    failed: any[];
+    fails: number;
+    send(what: any): Promise<any>;
+    start(): void;
+    connecting: boolean | undefined;
+    ws: any;
+    close(): Promise<void>;
+    closed: boolean | undefined;
+}

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

@@ -0,0 +1,148 @@
+"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 cleanInterval = 45 * 1000;
+const pingInterval = 30 * 1000;
+class Transport {
+    constructor({ config, onMessage, onConnect }) {
+        var local = this;
+        this.config = config;
+        this.callbacks = {};
+        this.running = true;
+        this.pinger = null;
+        this.cleaner = setInterval(() => local.clean(), cleanInterval);
+        this.acks = [];
+        this.packets = [];
+        this.onConnect = onConnect;
+        this._onMessage = onMessage;
+    }
+    schedule() {
+        var local = this;
+        setTimeout(() => local.schedule0(), 0);
+    }
+    schedule0() {
+        var local = this, packets = [], packet;
+        if (!local.packets.length || !local.connected)
+            return;
+        while ((packet = local.packets.shift())) {
+            packets.push(packet.data);
+        }
+        if (!packets.length)
+            return;
+        try {
+            local.ws.send(JSON.stringify({ p: packets }));
+        }
+        catch (e) {
+            console.log('could not send packets ', e);
+            packets.forEach((packet) => local.packets.unshift(packet));
+        }
+    }
+    async start(ondisconnect) {
+        var local = this, config = local.config;
+        if (local._leaving)
+            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');
+            local.connected = true;
+            local.pinger = setInterval(() => ws.ping(() => null), pingInterval);
+            local.onConnect(local);
+        });
+        ws.on('message', (message) => {
+            setTimeout(() => local.onMessages(JSON.parse(message)), 0);
+        });
+        ws.on('error', (message) => {
+            console.log('error:', message);
+        });
+        ws.on('close', (message) => {
+            local.connected = false;
+            clearInterval(local.pinger);
+            if (local.running)
+                ondisconnect();
+        });
+    }
+    newDurableWebsocket({ endpoint, secret, onConnect, onMessage }) {
+        return new DurableWebsocket({ endpoint, secret, onConnect, onMessage });
+    }
+    send(packet) {
+        if (!packet)
+            return;
+        this.packets.push(packet);
+        this.schedule();
+    }
+    onMessages(msgs) {
+        var local = this;
+        msgs.p?.forEach((item) => {
+            local.onMessage(item);
+        });
+    }
+    onMessage(data) {
+        if (!data)
+            return;
+        const packet = new Packet(data);
+        if (packet.cb() && this.callbacks[packet.cb()]) {
+            try {
+                this.callbacks[packet.cb()].cb(packet.args());
+            }
+            catch (e) {
+                console.log('error processing packet', e, packet);
+            }
+            finally {
+                delete this.callbacks[packet.cb()];
+            }
+            return;
+        }
+        return this._onMessage(packet, this);
+    }
+    newPacket(data, cb, cbKey) {
+        const packet = new Packet({ ...data });
+        if (cb) {
+            this.callbacks[cbKey || packet.id()] = new Callback({ cb });
+            packet.cb(cbKey || packet.id());
+        }
+        return packet;
+    }
+    clean() {
+        var local = this;
+        const cbs = { ...this.callbacks }, then = Date.now() - 5 * 60 * 1000;
+        Object.keys(cbs).forEach((key) => {
+            const cb = cbs[key];
+            if (!cb)
+                return;
+            if (cb.created < then) {
+                console.log('callback timeout', key);
+                try {
+                    cb.cb({ error: 'timeout' });
+                }
+                catch (e) {
+                    console.log('error while callback', key, cb, e);
+                }
+                delete local.callbacks[key];
+            }
+        });
+    }
+    leaving() {
+        this._leaving = true;
+        this.running = false;
+    }
+    close() {
+        clearInterval(this.pinger);
+        clearInterval(this.cleaner);
+        this.running = false;
+        this.connected = false;
+        try {
+            local.ws.terminate();
+        }
+        catch (e) {
+            // blank
+        }
+    }
+}
+module.exports = { Transport };

package/build/internal/websocket/transport/index.d.cts

@@ -0,0 +1,37 @@
+export class Transport {
+    constructor({ config, onMessage, onConnect }: {
+        config: any;
+        onMessage: any;
+        onConnect: any;
+    });
+    config: any;
+    callbacks: {};
+    running: boolean;
+    pinger: any;
+    cleaner: NodeJS.Timer;
+    acks: any[];
+    packets: any[];
+    onConnect: any;
+    _onMessage: any;
+    schedule(): void;
+    schedule0(): void;
+    start(ondisconnect: any): Promise<void>;
+    ws: any;
+    newDurableWebsocket({ endpoint, secret, onConnect, onMessage }: {
+        endpoint: any;
+        secret: any;
+        onConnect: any;
+        onMessage: any;
+    }): DurableWebsocket;
+    send(packet: any): void;
+    onMessages(msgs: any): void;
+    onMessage(data: any): any;
+    newPacket(data: any, cb: any, cbKey: any): Packet;
+    clean(): void;
+    leaving(): void;
+    _leaving: boolean | undefined;
+    close(): void;
+    connected: boolean | undefined;
+}
+import { DurableWebsocket } from "./durable.cjs";
+import { Packet } from "./packet.cjs";

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fetch = require('node-fetch');
+const cuid = require('@paralleldrive/cuid2').init({ length: 32 });
+class Packet {
+    constructor(data = {}) {
+        this.data = data;
+        this.data.id ||= cuid();
+    }
+    id() {
+        return this.data.id;
+    }
+    cb(what) {
+        if (what) {
+            this.data.c = what;
+        }
+        return this.data.c;
+    }
+    method(what) {
+        if (what) {
+            this.data.m = what;
+        }
+        return this.data.m;
+    }
+    event(what) {
+        if (what) {
+            this.data.e = what;
+        }
+        return this.data.e;
+    }
+    args(what) {
+        if (what) {
+            this.data.a = what;
+        }
+        return this.data.a;
+    }
+}
+class Callback {
+    constructor({ cb }) {
+        this.cb = cb;
+        this.created = Date.now();
+    }
+}
+module.exports = { Callback, Packet };

package/build/internal/websocket/transport/packet.d.cts

@@ -0,0 +1,16 @@
+export class Callback {
+    constructor({ cb }: {
+        cb: any;
+    });
+    cb: any;
+    created: number;
+}
+export class Packet {
+    constructor(data?: {});
+    data: {};
+    id(): any;
+    cb(what: any): any;
+    method(what: any): any;
+    event(what: any): any;
+    args(what: any): any;
+}

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { Packet, Callback } = require('./packet.cjs');
+class Processor {
+    constructor({ transport, processPacket }) {
+        var local = this;
+        this.transport = transport;
+        this._processPacket = processPacket;
+    }
+    async onMessages(what) {
+        var local = this;
+        const messages = what.p;
+        const packets = messages.map((message) => {
+            const packet = new Packet(message);
+            local.transport.acks.push(packet.id());
+            return local.processPacket(packet);
+        });
+        await Promise.all(packets);
+    }
+    async processPacket(packet) {
+        var local = this;
+        if (packet.args().packet) {
+            await local.processPacket0(local.transport.newPacket(packet.args().packet), packet);
+        }
+        else {
+            await local.processPacket0(packet, packet);
+        }
+    }
+    async processPacket0(packet, original) {
+        var local = this, callbacks = local.transport.callbacks;
+        if (packet.cb() && callbacks[packet.cb()]) {
+            try {
+                callbacks[packet.cb()](packet.args());
+            }
+            catch (e) {
+                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);
+        }
+        else {
+            try {
+                const result = await local._processPacket(packet);
+                const reply = local.transport.newPacket({});
+                reply.method('connector.reply');
+                reply.cb(original.cb());
+                reply.args({ ...result });
+                local.transport.send(reply);
+            }
+            catch (e) {
+                console.log('error processing packet', e, packet);
+            }
+        }
+    }
+}
+module.exports = { Processor };

package/build/internal/websocket/transport/processor.d.cts

@@ -0,0 +1,11 @@
+export class Processor {
+    constructor({ transport, processPacket }: {
+        transport: any;
+        processPacket: any;
+    });
+    transport: any;
+    _processPacket: any;
+    onMessages(what: any): Promise<void>;
+    processPacket(packet: any): Promise<void>;
+    processPacket0(packet: any, original: any): Promise<void>;
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@aloma.io/integration-sdk",
+  "version": "3.0.0-4",
+  "description": "",
+  "author": "aloma.io",
+  "license": "Apache-2.0",
+  "type": "module",
+  "scripts": {
+    "dev": "./node_modules/typescript/bin/tsc --watch",
+    "build": "./node_modules/typescript/bin/tsc",
+    "test": "./node_modules/mocha/bin/_mocha --recursive",
+    "format": "yarn prettier --write src/"
+  },
+  "main": "./build/index.js",
+  "exports": {
+    ".": {
+      "import": "./build/index.mjs",
+      "require": "./build/index.js"
+    },
+    "./build/*": "./build/*",
+    "./package": "./package.json",
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@paralleldrive/cuid2": "^2",
+    "dotenv": "*",
+    "express": "^4",
+    "jose": "^4",
+    "node-fetch": "^2",
+    "prom-client": "^14",
+    "ws": "^8"
+  },
+  "optionalDependencies": {
+    "bufferutil": "^4",
+    "utf-8-validate": "^6"
+  },
+  "devDependencies": {
+    "@ts-ast-parser/core": "^0",
+    "@types/node": "^18",
+    "mocha": "^10",
+    "prettier": "^2",
+    "typescript": "^5"
+  }
+}