@aloma.io/integration-sdk 3.0.1-9 → 3.0.2

package/build/internal/index.cjs

@@ -1,27 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 // @ts-nocheck
-require("dotenv").config();
-const fs = require("fs");
-const { Config } = require("./websocket/config.cjs");
-const { Connection } = require("./websocket/connection/index.cjs");
-const { Transport } = require("./websocket/transport/index.cjs");
-const { Dispatcher } = require("./dispatcher/index.cjs");
-const { WebsocketConnector } = require("./websocket/index.cjs");
-const JWE = require("./util/jwe/index.cjs");
-const fetch = require("node-fetch");
-const cuid = require("@paralleldrive/cuid2").init({ length: 32 });
+require('dotenv').config();
+const fs = require('fs');
+const { Config } = require('./websocket/config.cjs');
+const { Connection } = require('./websocket/connection/index.cjs');
+const { Transport } = require('./websocket/transport/index.cjs');
+const { Dispatcher } = require('./dispatcher/index.cjs');
+const { WebsocketConnector } = require('./websocket/index.cjs');
+const JWE = require('./util/jwe/index.cjs');
+const fetch = require('node-fetch');
+const cuid = require('@paralleldrive/cuid2').init({ length: 32 });
 // TODO fetch with retry
 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 } }));
 };
 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 } }));
@@ -30,7 +30,7 @@ const unwrap = async (ret, options) => {
     if (options?.text)
         return await ret.text();
     if (options?.base64)
-        return (await ret.buffer()).toString("base64");
+        return (await ret.buffer()).toString('base64');
     return await ret.json();
 };
 class Fetcher {
@@ -57,13 +57,13 @@ class Fetcher {
         if (retries == null)
             retries = local.retry;
         try {
-            const theURL = `${baseUrl?.endsWith("/") ? baseUrl : baseUrl + "/"}${url}`.replace(/\/\/+/gi, "/");
+            const theURL = `${baseUrl?.endsWith('/') ? baseUrl : baseUrl + '/'}${url}`.replace(/\/\/+/gi, '/');
             await local.customize(options, args);
             const ret = await fetch(theURL, options);
             const status = await ret.status;
             if (status > 399) {
                 const text = await ret.text();
-                const e = new Error(status + " " + text);
+                const e = new Error(status + ' ' + text);
                 e.status = status;
                 throw e;
             }
@@ -92,14 +92,14 @@ class OAuthFetcher extends Fetcher {
             return oauth.accessToken();
         const refreshToken = oauth.refreshToken();
         if (!refreshToken)
-            throw new Error("have no access_token and no refresh_token");
+            throw new Error('have no access_token and no refresh_token');
         const ret = await oauth.obtainViaRefreshToken(oauth.refreshToken());
         if (ret.access_token) {
             oauth.update(ret.access_token, ret.refresh_token);
             return ret.access_token;
         }
         else {
-            throw new Error("could not obtain access token via refresh token");
+            throw new Error('could not obtain access token via refresh token');
         }
     }
     async onError(e, url, options, retries, args) {
@@ -107,9 +107,7 @@ class OAuthFetcher extends Fetcher {
         return new Promise((resolve, reject) => {
             setTimeout(async () => {
                 try {
-                    resolve(await local.fetch(url, options, retries, {
-                        forceTokenRefresh: e.status === 401,
-                    }));
+                    resolve(await local.fetch(url, options, retries, { forceTokenRefresh: e.status === 401 }));
                 }
                 catch (e) {
                     reject(e);
@@ -165,36 +163,36 @@ class Connector {
     async run() {
         var local = this;
         const makeMetrics = () => {
-            const metrics = require("prom-client");
+            const metrics = require('prom-client');
             const defaultLabels = {
                 service: local.name,
                 connectorId: local.id,
                 connectorVersion: local.version,
-                node: process.env.HOSTNAME || "test",
+                node: process.env.HOSTNAME || 'test',
             };
             metrics.register.setDefaultLabels(defaultLabels);
             metrics.collectDefaultMetrics();
             return metrics;
         };
         const makeMetricsServer = (metrics) => {
-            const app = require("express")();
-            app.get("/metrics", async (request, response, next) => {
+            const app = require('express')();
+            app.get('/metrics', async (request, response, next) => {
                 response.status(200);
-                response.set("Content-type", metrics.contentType);
+                response.set('Content-type', metrics.contentType);
                 response.send(await metrics.register.metrics());
                 response.end();
             });
             return app;
         };
-        makeMetricsServer(makeMetrics()).listen(4050, "0.0.0.0");
+        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://transport.aloma.io/transport/",
+            endpoint: process.env.DEVICE_ENDPOINT || 'https://connect.aloma.io/',
+            wsEndpoint: process.env.WEBSOCKET_ENDPOINT || 'wss://transport.aloma.io/transport/',
             privateKey: process.env.PRIVATE_KEY,
             publicKey: process.env.PUBLIC_KEY,
             introspect,
@@ -207,15 +205,15 @@ class Connector {
             catch (e) {
                 const haveKey = !!process.env.PRIVATE_KEY;
                 const jwe = new JWE({});
-                var text = "Please double check the env variables";
+                var text = 'Please double check the env variables';
                 if (!haveKey) {
                     await jwe.newPair();
                     text =
-                        "fresh keys generated, set environment variables: \n\nPRIVATE_KEY: " +
+                        'fresh keys generated, set environment variables: \n\nPRIVATE_KEY: ' +
                             (await jwe.exportPrivateAsBase64()) +
-                            "\n\nPUBLIC_KEY: " +
+                            '\n\nPUBLIC_KEY: ' +
                             (await jwe.exportPublicAsBase64()) +
-                            "\n";
+                            '\n';
                 }
                 console.log(`
 Error: 
@@ -234,7 +232,7 @@ ${text}
                     const decrypted = {};
                     const fields = configSchema().fields;
                     const keys = Object.keys(secrets);
-                    const jwe = await config.validateKeys("RSA-OAEP-256");
+                    const jwe = await config.validateKeys('RSA-OAEP-256');
                     for (var i = 0; i < keys.length; ++i) {
                         const key = keys[i];
                         const value = secrets[key];
@@ -248,22 +246,17 @@ ${text}
                                 decrypted[key] = await jwe.decrypt(value, config.id());
                             }
                             catch (e) {
-                                console.log("failed to decrypt key", key, config.id(), e);
+                                console.log('failed to decrypt key', key, config.id(), e);
                             }
                         }
                     }
                     this.startOAuth = async function (args) {
                         if (!this._oauth)
-                            throw new Error("oauth not configured");
-                        const clientId = this._oauth.clientId ||
-                            process.env.OAUTH_CLIENT_ID ||
-                            decrypted.clientId;
+                            throw new Error('oauth not configured');
+                        const clientId = this._oauth.clientId || process.env.OAUTH_CLIENT_ID || decrypted.clientId;
                         if (!clientId)
-                            throw new Error("clientId not configured");
-                        const scopes = this._oauth.scope ||
-                            process.env.OAUTH_SCOPE ||
-                            decrypted.scope ||
-                            "";
+                            throw new Error('clientId not configured');
+                        const scopes = this._oauth.scope || process.env.OAUTH_SCOPE || decrypted.scope || '';
                         const useCodeChallenge = !!that._oauth.useCodeChallenge;
                         return {
                             url: this._oauth.authorizationURL
@@ -275,23 +268,19 @@ ${text}
                     this.finishOAuth = async function (arg) {
                         var that = this;
                         if (!this._oauth)
-                            throw new Error("oauth not configured");
+                            throw new Error('oauth not configured');
                         if (!this._oauth.tokenURL && !this._oauth.finishOAuth)
-                            throw new Error("need tokenURL or finishOAuth(arg)");
+                            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 = that._oauth.clientId ||
-                                process.env.OAUTH_CLIENT_ID ||
-                                decrypted.clientId;
+                                throw new Error('need code and redirectUri');
+                            const clientId = that._oauth.clientId || process.env.OAUTH_CLIENT_ID || decrypted.clientId;
                             if (!clientId)
-                                throw new Error("clientId not configured");
-                            const clientSecret = that._oauth.clientSecret ||
-                                process.env.OAUTH_CLIENT_SECRET ||
-                                decrypted.clientSecret;
+                                throw new Error('clientId not configured');
+                            const clientSecret = that._oauth.clientSecret || process.env.OAUTH_CLIENT_SECRET || decrypted.clientSecret;
                             if (!clientSecret)
-                                throw new Error("clientSecret not configured");
+                                throw new Error('clientSecret not configured');
                             const additionalTokenArgs = that._oauth.additionalTokenArgs || {};
                             const useAuthHeader = !!that._oauth.useAuthHeader;
                             const useCodeChallenge = !!that._oauth.useCodeChallenge;
@@ -304,8 +293,8 @@ ${text}
                                 body.code_verifier = arg.codeVerifier;
                             }
                             let headers = {
-                                "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
-                                Accept: "application/json",
+                                'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
+                                Accept: 'application/json',
                             };
                             if (useAuthHeader) {
                                 headers = {
@@ -321,7 +310,7 @@ ${text}
                                 };
                             }
                             const response = await fetch(that._oauth.tokenURL, {
-                                method: "POST",
+                                method: 'POST',
                                 body: new URLSearchParams(body),
                                 headers,
                             });
@@ -330,17 +319,17 @@ ${text}
                             if (status === 200) {
                                 const ret = JSON.parse(text);
                                 if (ret.error) {
-                                    throw new Error(`${status} ${ret.error} ${ret.error_description || ""}`);
+                                    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);
+                                    throw new Error(status + ' response has no access_token - ' + text);
                                 }
                             }
                             else {
-                                throw new Error(status + " " + text);
+                                throw new Error(status + ' ' + text);
                             }
                         };
                         if (this._oauth.finishOAuth) {
@@ -353,30 +342,26 @@ ${text}
                         else {
                             data = await doFinish();
                         }
-                        const jwe = await config.validateKeys("RSA-OAEP-256");
-                        return { value: await jwe.encrypt(data, "none", config.id()) };
+                        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 jwe = await config.validateKeys('RSA-OAEP-256');
                         const packet = transport.newPacket({});
-                        packet.method("connector.config-update");
+                        packet.method('connector.config-update');
                         packet.args({
-                            value: await jwe.encrypt(what, "none", config.id()),
+                            value: await jwe.encrypt(what, 'none', config.id()),
                         });
                         transport.send(packet);
                     };
                     const that = this;
                     const getRefreshToken = async (refreshToken) => {
-                        const clientId = that._oauth.clientId ||
-                            process.env.OAUTH_CLIENT_ID ||
-                            decrypted.clientId;
+                        const clientId = that._oauth.clientId || process.env.OAUTH_CLIENT_ID || decrypted.clientId;
                         if (!clientId)
-                            throw new Error("clientId not configured");
-                        const clientSecret = that._oauth.clientSecret ||
-                            process.env.OAUTH_CLIENT_SECRET ||
-                            decrypted.clientSecret;
+                            throw new Error('clientId not configured');
+                        const clientSecret = that._oauth.clientSecret || process.env.OAUTH_CLIENT_SECRET || decrypted.clientSecret;
                         if (!clientSecret)
-                            throw new Error("clientSecret not configured");
+                            throw new Error('clientSecret not configured');
                         const useAuthHeader = !!that._oauth.useAuthHeader;
                         let headers = {};
                         if (useAuthHeader) {
@@ -386,16 +371,16 @@ ${text}
                             };
                         }
                         const response = await fetch(that._oauth.tokenURL, {
-                            method: "POST",
+                            method: 'POST',
                             body: new URLSearchParams({
-                                grant_type: "refresh_token",
+                                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",
+                                'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
+                                Accept: 'application/json',
                                 ...headers,
                             },
                         });
@@ -405,7 +390,7 @@ ${text}
                             return JSON.parse(text);
                         }
                         else {
-                            throw new Error("could not get refresh token " + status + " " + text);
+                            throw new Error('could not get refresh token ' + status + ' ' + text);
                         }
                     };
                     const theOAuth = decrypted.oauthResult
@@ -414,11 +399,11 @@ ${text}
                     start({
                         config: decrypted,
                         oauth: theOAuth,
-                        getClient: (arg) => theOAuth ? theOAuth.getClient(arg) : new Fetcher({ ...arg }),
+                        getClient: (arg) => (theOAuth ? 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.method('connector.task.new');
                                 packet.args({
                                     name,
                                     a: data,
@@ -429,7 +414,7 @@ ${text}
                         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.method('connector.task.update');
                                 packet.args({
                                     id,
                                     a: data,
@@ -462,14 +447,14 @@ ${text}
             });
             process.exit(0);
         };
-        process.on("uncaughtException", (e) => {
+        process.on('uncaughtException', (e) => {
             console.log(e);
         });
-        process.on("unhandledRejection", (e) => {
+        process.on('unhandledRejection', (e) => {
             console.log(e);
         });
-        process.on("SIGTERM", term);
-        process.on("SIGINT", term);
+        process.on('SIGTERM', term);
+        process.on('SIGINT', term);
         await server.start();
     }
 }

package/build/internal/util/jwe/cli.cjs

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const JWE = require("./index");
+const JWE = require('./index');
 const main = async () => {
     const jwe = new JWE({});
     await jwe.newPair();
-    console.log("private key");
+    console.log('private key');
     console.log(await jwe.exportPrivateAsBase64());
-    console.log("public key");
+    console.log('public key');
     console.log(await jwe.exportPublicAsBase64());
 };
 setTimeout(() => null, 100);

package/build/internal/util/jwe/index.cjs

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const jose = require("jose");
+const jose = require('jose');
 class JWE {
-    constructor({ algorithm = "PS256" }) {
-        this.issuer = "home.aloma.io";
+    constructor({ algorithm = 'PS256' }) {
+        this.issuer = 'home.aloma.io';
         this.algorithm = algorithm;
     }
     async newPair() {
@@ -17,11 +17,11 @@ 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 }) {
         this.pair = {
@@ -31,18 +31,18 @@ class JWE {
     }
     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") {
+    async encrypt(what, expiration = '7d', audience, algorithm = 'RSA-OAEP-256') {
         const item = new jose.EncryptJWT({ _data: { ...what } })
-            .setProtectedHeader({ alg: algorithm, enc: "A256GCM" })
+            .setProtectedHeader({ alg: algorithm, enc: 'A256GCM' })
             .setIssuedAt()
             .setIssuer(this.issuer)
             .setAudience(audience);
-        if (expiration && expiration !== "none")
+        if (expiration && expiration !== 'none')
             item.setExpirationTime(expiration);
         return await item.encrypt(this.pair.publicKey);
     }

package/build/internal/websocket/config.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const C = require("./connection/constants.cjs");
-const JWE = require("../util/jwe/index.cjs");
+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;
@@ -18,17 +18,17 @@ class Config {
         this._introspect = introspect;
         this._configSchema = configSchema;
         if (!registrationToken)
-            throw new Error("empty registration token (set env.REGISTRATION_TOKEN)");
+            throw new Error('empty registration token (set env.REGISTRATION_TOKEN)');
         if (!endpoint)
-            throw new Error("empty endpoint (set env.DEVICE_ENDPOINT)");
+            throw new Error('empty endpoint (set env.DEVICE_ENDPOINT)');
         if (!wsEndpoint)
-            throw new Error("empty registration token (set env.WEBSOCKET_ENDPOINT)");
+            throw new Error('empty registration token (set env.WEBSOCKET_ENDPOINT)');
         if (!this._id || !this._version)
-            throw new Error("need connector id and 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");
+            throw new Error('need private and public key');
         await this._jwe.importBase64Pair({
             publicKey: this._publicKey,
             privateKey: this._privateKey,

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

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const AUTHORIZATION = "Authorization";
+const AUTHORIZATION = 'Authorization';
 module.exports = {
     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()}`;
         return what;
@@ -13,7 +13,7 @@ module.exports = {
     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()}`;
         return what;

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const fetch = require("node-fetch");
-const { Registration } = require("./registration.cjs");
-const C = require("./constants.cjs");
+const fetch = require('node-fetch');
+const { Registration } = require('./registration.cjs');
+const C = require('./constants.cjs');
 class Connection {
     constructor({ config, onStart }) {
         this.config = config;
@@ -11,10 +11,10 @@ class Connection {
     async start() {
         var local = this, config = local.config;
         try {
-            const response = await fetch(config.url() + "connect", C.augmentRequest({
-                method: "POST",
+            const response = await fetch(config.url() + 'connect', C.augmentRequest({
+                method: 'POST',
                 body: JSON.stringify({}),
-                headers: { "Content-Type": "application/json" },
+                headers: { 'Content-Type': 'application/json' },
             }, config));
             if (response.status === 401) {
                 config.setToken(await new Registration(local.config).run());
@@ -39,10 +39,10 @@ class Connection {
     }
     async close() {
         try {
-            await fetch(this.config.url() + "disconnect", C.augmentRequest({
-                method: "POST",
+            await fetch(this.config.url() + 'disconnect', C.augmentRequest({
+                method: 'POST',
                 body: JSON.stringify({}),
-                headers: { "Content-Type": "application/json" },
+                headers: { 'Content-Type': 'application/json' },
             }, this.config));
         }
         catch (e) {

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

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

package/build/internal/websocket/index.cjs

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const WebSocket = require("ws");
-const { Connection } = require("./connection/index.cjs");
-const { Transport } = require("./transport/index.cjs");
+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;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const WebSocket = require("ws");
+const WebSocket = require('ws');
 class DurableWebsocket {
     constructor({ endpoint, secret, onConnect, onMessage }) {
         this.endpoint = endpoint;
@@ -28,7 +28,7 @@ class DurableWebsocket {
             rejectUnauthorized: false,
             headers: { Authorization: `Bearer ${local.secret}` },
         }));
-        ws.on("open", () => {
+        ws.on('open', () => {
             local.connecting = false;
             local.fails = 0;
             var item;
@@ -37,15 +37,15 @@ class DurableWebsocket {
             }
             local.onConnect(local);
         });
-        ws.on("message", (message) => {
+        ws.on('message', (message) => {
             setImmediate(() => local.onMessage(JSON.parse(message)));
         });
-        ws.on("error", (message) => {
+        ws.on('error', (message) => {
             if (local.fails > 50)
-                console.log("error:", message.message);
+                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);