@aloma.io/integration-sdk 3.0.0-4

package/src/internal/websocket/config.cjs

@@ -0,0 +1,103 @@
+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;
+    this._registrationToken = registrationToken;
+    this._version = version;
+    this._name = name;
+    this._endpoint = endpoint;
+    this._wsEndpoint = wsEndpoint;
+    this._id = id;
+    this._data = {};
+    this._privateKey = privateKey;
+    this._publicKey = publicKey;
+    this._jwe = new JWE({});
+    this._introspect = introspect;
+    this._configSchema = configSchema;
+
+    if (!registrationToken) throw new Error('empty registration token (set env.REGISTRATION_TOKEN)');
+    if (!endpoint) throw new Error('empty endpoint (set env.DEVICE_ENDPOINT)');
+    if (!wsEndpoint) throw new Error('empty registration token (set env.WEBSOCKET_ENDPOINT)');
+
+    if (!this._id || !this._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');
+
+    await this._jwe.importBase64Pair({
+      publicKey: this._publicKey,
+      privateKey: this._privateKey,
+      algorithm,
+    });
+
+    return this._jwe;
+  }
+
+  data(what) {
+    if (what) {
+      this._data = what;
+    }
+
+    return this._data;
+  }
+
+  introspect() {
+    return this._introspect();
+  }
+
+  configSchema() {
+    return this._configSchema();
+  }
+
+  publicKey() {
+    return this._publicKey;
+  }
+
+  id() {
+    return this._id;
+  }
+
+  version() {
+    return this._version;
+  }
+
+  name() {
+    return this._name;
+  }
+
+  url() {
+    return this._endpoint;
+  }
+
+  wsUrl() {
+    return this._wsEndpoint;
+  }
+
+  registrationToken() {
+    return this._registrationToken;
+  }
+
+  token() {
+    return this._token;
+  }
+
+  setToken(what) {
+    this._token = what;
+  }
+}
+
+module.exports = {Config};

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

@@ -0,0 +1,25 @@
+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/src/internal/websocket/connection/index.cjs

@@ -0,0 +1,70 @@
+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/src/internal/websocket/connection/registration.cjs

@@ -0,0 +1,40 @@
+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/src/internal/websocket/index.cjs

@@ -0,0 +1,46 @@
+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/src/internal/websocket/transport/durable.cjs

@@ -0,0 +1,71 @@
+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/src/internal/websocket/transport/index.cjs

@@ -0,0 +1,183 @@
+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/src/internal/websocket/transport/packet.cjs

@@ -0,0 +1,54 @@
+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/src/internal/websocket/transport/processor.cjs

@@ -0,0 +1,66 @@
+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/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "es2022",     
+    "skipLibCheck": true,                     
+    "module": "node16",
+    "moduleResolution": "node16",
+    "lib": ["es2015", "es6", "esnext"],           
+    "declaration": true,          
+    "allowJs": true,
+    "outDir": "build",                          
+    "rootDir": "src/",
+    "strict": true,         
+    "noImplicitAny": false,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules/**/*",
+    "dist/**/*"
+  ]
+}