@aloma.io/integration-sdk 3.8.10 → 3.8.12

package/src/internal/util/index.mts

@@ -1,27 +1,24 @@
 export 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}}));
 };
 
 export 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 } }));
+  transport.send(transport.newPacket({c: packet.cb(), a: {...arg}}));
 };
 
 export const unwrap0 = (ret, body, options) => {
   if (options?.bodyOnly === false) {
-    return { status: ret.status, headers: ret.headers, body };
+    return {status: ret.status, headers: ret.headers, body};
   } else {
     return body;
   }
@@ -30,13 +27,13 @@ export const unwrap0 = (ret, body, options) => {
 export const unwrap = async (ret, options) => {
   if (options?.text) return unwrap0(ret, await ret.text(), options);
   if (options?.base64) {
-    const base64 = Buffer.from(await ret.arrayBuffer()).toString("base64");
+    const base64 = Buffer.from(await ret.arrayBuffer()).toString('base64');
 
     return unwrap0(ret, base64, options);
   }
 
   if (options?.skipResponseBody) {
-    return { status: ret.status, headers: ret.headers };
+    return {status: ret.status, headers: ret.headers};
   }
 
   const text = await ret.text();
@@ -44,7 +41,7 @@ export const unwrap = async (ret, options) => {
   try {
     return unwrap0(ret, JSON.parse(text), options);
   } catch (e) {
-    throw e + " " + text;
+    throw e + ' ' + text;
   }
 };
 

package/src/internal/util/jwe/cli.mts

@@ -1,11 +1,11 @@
-import JWE from "./index.mjs";
+import JWE from './index.mjs';
 
 const main = async () => {
   const jwe = new JWE({});
   await jwe.newPair();
 
-  console.log("PRIVATE_KEY=" + (await jwe.exportPrivateAsBase64()));
-  console.log("PUBLIC_KEY=" + (await jwe.exportPublicAsBase64()));
+  console.log('PRIVATE_KEY=' + (await jwe.exportPrivateAsBase64()));
+  console.log('PUBLIC_KEY=' + (await jwe.exportPublicAsBase64()));
 };
 
 setTimeout(() => null, 100);

package/src/internal/util/jwe/index.mts

@@ -1,11 +1,11 @@
-import * as jose from "jose";
+import * as jose from 'jose';
 
 class JWE {
   issuer: string;
   algorithm: string;
   pair?: jose.GenerateKeyPairResult<jose.KeyLike>;
-  constructor({ algorithm = "PS256" }) {
-    this.issuer = "home.aloma.io";
+  constructor({algorithm = 'PS256'}) {
+    this.issuer = 'home.aloma.io';
     this.algorithm = algorithm;
   }
 
@@ -23,51 +23,47 @@ 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 }) {
+  async importPair({publicKey, privateKey, algorithm}) {
     this.pair = {
       publicKey: await jose.importSPKI(publicKey, algorithm),
       privateKey: await jose.importPKCS8(privateKey, algorithm),
     };
   }
 
-  async importBase64Pair({ publicKey, privateKey, algorithm }) {
+  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") {
-    const item = new jose.EncryptJWT({ _data: { ...what } })
-      .setProtectedHeader({ alg: algorithm, enc: "A256GCM" })
+  async encrypt(what, expiration = '7d', audience, algorithm = 'RSA-OAEP-256') {
+    const item = new jose.EncryptJWT({_data: {...what}})
+      .setProtectedHeader({alg: algorithm, enc: 'A256GCM'})
       .setIssuedAt()
       .setIssuer(this.issuer)
       .setAudience(audience);
 
-    if (expiration && expiration !== "none") item.setExpirationTime(expiration);
+    if (expiration && expiration !== 'none') item.setExpirationTime(expiration);
 
     return await item.encrypt(this.pair!.publicKey);
   }
 
   async decrypt(what, audience) {
-    const { payload, protectedHeader } = await jose.jwtDecrypt(
-      what,
-      this.pair!.privateKey,
-      {
-        issuer: this.issuer,
-        audience,
-      },
-    );
+    const {payload, protectedHeader} = await jose.jwtDecrypt(what, this.pair!.privateKey, {
+      issuer: this.issuer,
+      audience,
+    });
 
     return payload._data;
   }

package/src/internal/websocket/config.mjs

@@ -1,5 +1,5 @@
-import C from "./connection/constants.mjs";
-import JWE from "../util/jwe/index.mjs";
+import C from './connection/constants.mjs';
+import JWE from '../util/jwe/index.mjs';
 
 class Config {
   constructor({
@@ -30,19 +30,15 @@ class Config {
     this._configSchema = configSchema;
     this._icon = icon;
 
-    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 (!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");
+    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");
+    if (!this._privateKey || !this._publicKey) throw new Error('need private and public key');
 
     await this._jwe.importBase64Pair({
       publicKey: this._publicKey,
@@ -110,4 +106,4 @@ class Config {
   }
 }
 
-export { Config };
+export {Config};

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

@@ -1,10 +1,10 @@
-const AUTHORIZATION = "Authorization";
+const AUTHORIZATION = 'Authorization';
 
 export default {
   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()}`;
@@ -15,7 +15,7 @@ export default {
   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()}`;

package/src/internal/websocket/connection/index.mjs

@@ -1,8 +1,8 @@
-import { Registration } from "./registration.mjs";
-import C from "./constants.mjs";
+import {Registration} from './registration.mjs';
+import C from './constants.mjs';
 
 class Connection {
-  constructor({ config, onStart }) {
+  constructor({config, onStart}) {
     this.config = config;
     this.onStart = onStart;
   }
@@ -13,16 +13,16 @@ class Connection {
 
     try {
       const response = await fetch(
-        config.url() + "connect",
+        config.url() + 'connect',
         C.augmentRequest(
           {
-            method: "POST",
+            method: 'POST',
             body: JSON.stringify({}),
-            headers: { "Content-Type": "application/json" },
+            headers: {'Content-Type': 'application/json'},
             signal: AbortSignal.timeout(60 * 1000),
           },
-          config,
-        ),
+          config
+        )
       );
 
       if (response.status === 401) {
@@ -51,16 +51,16 @@ class Connection {
   async close() {
     try {
       await fetch(
-        this.config.url() + "disconnect",
+        this.config.url() + 'disconnect',
         C.augmentRequest(
           {
-            method: "POST",
+            method: 'POST',
             body: JSON.stringify({}),
-            headers: { "Content-Type": "application/json" },
+            headers: {'Content-Type': 'application/json'},
             signal: AbortSignal.timeout(60 * 1000),
           },
-          this.config,
-        ),
+          this.config
+        )
       );
     } catch (e) {
       // blank
@@ -68,4 +68,4 @@ class Connection {
   }
 }
 
-export { Connection };
+export {Connection};

package/src/internal/websocket/connection/registration.mjs

@@ -1,4 +1,4 @@
-import C from "./constants.mjs";
+import C from './constants.mjs';
 
 class Registration {
   constructor(config) {
@@ -13,30 +13,30 @@ class Registration {
     const icon = config.icon();
 
     const response = await fetch(
-      config.url() + "register",
+      config.url() + 'register',
       C.augmentRegistration(
         {
-          method: "POST",
+          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 },
+            schema: {configSchema, introspect: intro},
             icon,
           }),
-          headers: { "Content-Type": "application/json" },
+          headers: {'Content-Type': 'application/json'},
           signal: AbortSignal.timeout(60 * 1000),
         },
-        config,
-      ),
+        config
+      )
     );
 
     if (response.status === 200) return (await response.json()).key;
 
-    throw new Error("authentication failed");
+    throw new Error('authentication failed');
   }
 }
 
-export { Registration };
+export {Registration};

package/src/internal/websocket/index.mjs

@@ -1,12 +1,12 @@
-import WebSocket from "ws";
-import { Connection } from "./connection/index.mjs";
-import { Transport } from "./transport/index.mjs";
+import WebSocket from 'ws';
+import {Connection} from './connection/index.mjs';
+import {Transport} from './transport/index.mjs';
 
 class WebsocketConnector {
-  constructor({ config, onMessage, onConnect }) {
+  constructor({config, onMessage, onConnect}) {
     var local = this;
     this.config = config;
-    this.transport = new Transport({ config, onMessage, onConnect });
+    this.transport = new Transport({config, onMessage, onConnect});
   }
 
   async start() {
@@ -43,4 +43,4 @@ class WebsocketConnector {
   }
 }
 
-export { WebsocketConnector };
+export {WebsocketConnector};

package/src/internal/websocket/transport/durable.mjs

@@ -1,7 +1,7 @@
-import WebSocket from "ws";
+import WebSocket from 'ws';
 
 class DurableWebsocket {
-  constructor({ endpoint, secret, onConnect, onMessage }) {
+  constructor({endpoint, secret, onConnect, onMessage}) {
     this.endpoint = endpoint;
     this.secret = secret;
     this.onConnect = onConnect;
@@ -27,10 +27,10 @@ class DurableWebsocket {
 
     const ws = (local.ws = new WebSocket(local.endpoint, [], {
       rejectUnauthorized: false,
-      headers: { Authorization: `Bearer ${local.secret}` },
+      headers: {Authorization: `Bearer ${local.secret}`},
     }));
 
-    ws.on("open", () => {
+    ws.on('open', () => {
       local.connecting = false;
       local.fails = 0;
 
@@ -43,17 +43,17 @@ class DurableWebsocket {
       local.onConnect(local);
     });
 
-    ws.on("message", (message) => {
+    ws.on('message', (message) => {
       setImmediate(() => local.onMessage(JSON.parse(message)));
     });
 
-    ws.on("error", (message) => {
-      if (local.fails > 50) console.log("error:", message.message);
+    ws.on('error', (message) => {
+      if (local.fails > 50) 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);
@@ -68,4 +68,4 @@ class DurableWebsocket {
   }
 }
 
-export { DurableWebsocket };
+export {DurableWebsocket};

package/src/internal/websocket/transport/index.mjs

@@ -1,16 +1,16 @@
-import { init } from "@paralleldrive/cuid2";
-import C from "../connection/constants.mjs";
-const cuid = init({ length: 32 });
+import {init} from '@paralleldrive/cuid2';
+import C from '../connection/constants.mjs';
+const cuid = init({length: 32});
 
-import WebSocket from "ws";
-import { DurableWebsocket } from "./durable.mjs";
-import { Callback, Packet } from "./packet.mjs";
+import WebSocket from 'ws';
+import {DurableWebsocket} from './durable.mjs';
+import {Callback, Packet} from './packet.mjs';
 
 const cleanInterval = 45 * 1000;
 const pingInterval = 30 * 1000;
 
 class Transport {
-  constructor({ config, onMessage, onConnect }) {
+  constructor({config, onMessage, onConnect}) {
     var local = this;
 
     this.config = config;
@@ -45,9 +45,9 @@ class Transport {
     if (!packets.length) return;
 
     try {
-      local.ws.send(JSON.stringify({ p: packets }));
+      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));
     }
   }
@@ -62,22 +62,18 @@ class Transport {
 
     this.running = true;
 
-    const ws = (local.ws = new WebSocket(
-      config.wsUrl(),
-      ["connector"],
-      C.augmentRequest({ headers: {} }, config),
-    ));
+    const ws = (local.ws = new WebSocket(config.wsUrl(), ['connector'], C.augmentRequest({headers: {}}, config)));
 
     ws.onPing = function () {
       clearTimeout(this.pingTimeout);
       this.pingTimeout = setTimeout(() => {
-        console.log("terminating ws");
+        console.log('terminating ws');
         if (local.running) this.terminate();
       }, 30000 + 15000);
     };
 
-    ws.on("open", () => {
-      console.log("transport connected");
+    ws.on('open', () => {
+      console.log('transport connected');
       local.connected = true;
       ws.onPing();
       local.pinger = setInterval(() => ws.ping(() => null), pingInterval);
@@ -85,17 +81,17 @@ class Transport {
       local.onConnect(local);
     });
 
-    ws.on("message", (message) => {
+    ws.on('message', (message) => {
       setTimeout(() => local.onMessages(JSON.parse(message)), 0);
     });
 
-    ws.on("ping", () => ws.onPing());
+    ws.on('ping', () => ws.onPing());
 
-    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);
 
@@ -103,8 +99,8 @@ class Transport {
     });
   }
 
-  newDurableWebsocket({ endpoint, secret, onConnect, onMessage }) {
-    return new DurableWebsocket({ endpoint, secret, onConnect, onMessage });
+  newDurableWebsocket({endpoint, secret, onConnect, onMessage}) {
+    return new DurableWebsocket({endpoint, secret, onConnect, onMessage});
   }
 
   send(packet) {
@@ -131,7 +127,7 @@ class Transport {
       try {
         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()];
       }
@@ -143,10 +139,10 @@ class Transport {
   }
 
   newPacket(data, cb, cbKey) {
-    const packet = new Packet({ ...data });
+    const packet = new Packet({...data});
 
     if (cb) {
-      this.callbacks[cbKey || packet.id()] = new Callback({ cb });
+      this.callbacks[cbKey || packet.id()] = new Callback({cb});
       packet.cb(cbKey || packet.id());
     }
 
@@ -155,7 +151,7 @@ class Transport {
 
   clean() {
     var local = this;
-    const cbs = { ...this.callbacks },
+    const cbs = {...this.callbacks},
       then = Date.now() - 5 * 60 * 1000;
 
     Object.keys(cbs).forEach((key) => {
@@ -163,12 +159,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];
@@ -196,4 +192,4 @@ class Transport {
   }
 }
 
-export { Transport };
+export {Transport};

package/src/internal/websocket/transport/packet.mjs

@@ -1,5 +1,5 @@
-import { init } from "@paralleldrive/cuid2";
-const cuid = init({ length: 32 });
+import {init} from '@paralleldrive/cuid2';
+const cuid = init({length: 32});
 
 class Packet {
   constructor(data = {}) {
@@ -45,10 +45,10 @@ class Packet {
 }
 
 class Callback {
-  constructor({ cb }) {
+  constructor({cb}) {
     this.cb = cb;
     this.created = Date.now();
   }
 }
 
-export { Callback, Packet };
+export {Callback, Packet};

package/src/internal/websocket/transport/processor.mjs

@@ -1,7 +1,7 @@
-import { Packet, Callback } from "./packet.mjs";
+import {Packet, Callback} from './packet.mjs';
 
 class Processor {
-  constructor({ transport, processPacket }) {
+  constructor({transport, processPacket}) {
     var local = this;
 
     this.transport = transport;
@@ -26,10 +26,7 @@ class Processor {
     var local = this;
 
     if (packet.args().packet) {
-      await local.processPacket0(
-        local.transport.newPacket(packet.args().packet),
-        packet,
-      );
+      await local.processPacket0(local.transport.newPacket(packet.args().packet), packet);
     } else {
       await local.processPacket0(packet, packet);
     }
@@ -43,27 +40,27 @@ class Processor {
       try {
         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 });
+        reply.args({...result});
 
         local.transport.send(reply);
       } catch (e) {
-        console.log("error processing packet", e, packet);
+        console.log('error processing packet', e, packet);
       }
     }
   }
 }
 
-export { Processor };
+export {Processor};