@aloma.io/integration-sdk 3.0.0-7 → 3.0.0-8

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

@@ -1,41 +0,0 @@
-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

@@ -1,21 +0,0 @@
-"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

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

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

@@ -1,53 +0,0 @@
-"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

@@ -1,11 +0,0 @@
-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

@@ -1,31 +0,0 @@
-"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

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

package/build/internal/websocket/index.cjs

@@ -1,41 +0,0 @@
-"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

@@ -1,16 +0,0 @@
-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

@@ -1,61 +0,0 @@
-"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

@@ -1,20 +0,0 @@
-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

@@ -1,148 +0,0 @@
-"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

@@ -1,37 +0,0 @@
-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

@@ -1,44 +0,0 @@
-"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

@@ -1,16 +0,0 @@
-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

@@ -1,58 +0,0 @@
-"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

@@ -1,11 +0,0 @@
-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>;
-}