wapi-client 0.7.2 → 0.8.1

package/dist/api/ws-client.cjs

@@ -0,0 +1,263 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/api/ws-client.ts
+var ws_client_exports = {};
+__export(ws_client_exports, {
+  WsClient: () => WsClient,
+  createWsClient: () => createWsClient
+});
+module.exports = __toCommonJS(ws_client_exports);
+var import_modern_isomorphic_ws = __toESM(require("modern-isomorphic-ws"), 1);
+var import_debug = require('../lib/debug.cjs');
+var import_errors = require('../lib/errors.cjs');
+var import_utils = require('../lib/utils.cjs');
+var import_base_client = require('./base-client.cjs');
+var import_connection = require('./connection/connection.enums.cjs');
+var import__ = require('../index.cjs');
+var _a;
+var CLIENT_VERSION = (_a = '0.8.1') != null ? _a : "";
+function createWsClient(opts) {
+  const initialConnection = createConnection(opts);
+  return new WsClient(initialConnection, opts);
+}
+function createConnection(opts) {
+  var _a2;
+  const config = Object.assign(
+    {
+      rejectUnauthorized: (_a2 = opts.rejectUnauthorized) != null ? _a2 : true,
+      clientVersion: CLIENT_VERSION
+    },
+    opts
+  );
+  const params = (0, import_utils.getConnectionParams)(config);
+  const ws = new import_modern_isomorphic_ws.default(...params);
+  let _resolve;
+  let _reject;
+  let isCleaned = false;
+  let _id;
+  ws.onclose = close;
+  ws.onerror = error;
+  ws.onmessage = message;
+  function close(event) {
+    (0, import_debug.debugLog)(
+      `createConnection>close(reason:${event.reason},code:${event.code},wasClean:${event.wasClean})`
+    );
+    if (event.code === import_connection.SocketStatuses.authError) {
+      return clean(
+        new import_errors.AuthenticationError({
+          message: import_errors.ERROR_MESSAGES.AUTHENTICATION_FAILED,
+          code: import_errors.ERROR_TYPES.AuthenticationError
+        })
+      );
+    }
+    clean(new Error("WS closed"));
+  }
+  function error(event) {
+    (0, import_debug.debugLog)(
+      `createConnection>error(message:${event.message},error:${event.error},type:${event.type})`
+    );
+    clean(event.error);
+  }
+  function message(event) {
+    (0, import_debug.debugLog)(`createConnection>message(type:${event.type},data:${event.data})`);
+    const { data } = event;
+    let obj;
+    try {
+      obj = JSON.parse(data.toString());
+    } catch (e) {
+      (0, import_debug.debugLog)("Invalid JSON response", e);
+      return clean(new Error("Invalid JSON response"));
+    }
+    if (obj.result !== import_connection.ConnectionStatus.ready) {
+      (0, import_debug.debugLog)("Invalid first message");
+      return clean(new Error("Invalid first message - " + JSON.stringify(obj)));
+    }
+    clean();
+  }
+  function clean(err) {
+    if (isCleaned) {
+      return;
+    }
+    delete ws.onmessage;
+    delete ws.onerror;
+    delete ws.onclose;
+    if (err) {
+      _reject(err);
+      ws.close();
+    } else {
+      _resolve(_id);
+    }
+    isCleaned = true;
+  }
+  const $connect = new Promise((resolve, reject) => {
+    _resolve = resolve;
+    _reject = reject;
+  });
+  return {
+    ws,
+    $connect
+  };
+}
+var WsClient = class extends import_base_client.BaseClient {
+  constructor(initial, config) {
+    super(initial.ws, import__.WapiClientType.ws, initial.$connect);
+    this._tryToReconnect = true;
+    this._config = config;
+    this.$connect.then((_id) => {
+      this.socId = _id;
+      return this._ready();
+    }).catch((err) => {
+      if (this.socId) {
+        return;
+      }
+      this._setErrored(err);
+    });
+  }
+  _setErrored(err) {
+    super._setErrored(err);
+    if (
+      // eslint-disable-next-line no-prototype-builtins
+      err.hasOwnProperty("code") && err.code === import_errors.ERROR_TYPES.AuthenticationError
+    ) {
+      this._tryToReconnect = false;
+    }
+  }
+  _ready() {
+    this._setConnected(true);
+    this._connection.onmessage = (event) => {
+      const { data, type } = event;
+      (0, import_debug.debugLog)(`message(type:${type},data:${data})`);
+      if (type === "message") {
+        const obj = JSON.parse(data.toString());
+        this._handleMessage(obj);
+        this._heartbeat();
+      }
+    };
+    this._connection.onerror = (event) => {
+      const { message, error, type } = event;
+      (0, import_debug.debugLog)(`error(message:${message},error:${error},type:${type})`);
+    };
+    this._connection.onclose = (event) => {
+      const { reason, code, wasClean } = event;
+      (0, import_debug.debugLog)(`close(reason:${reason},code:${code},wasClean:${wasClean})`);
+      this._setConnected(false);
+      clearTimeout(this._pingTimeout);
+      this._connectionLost();
+      this._reconnect();
+    };
+    this._heartbeat();
+  }
+  _reconnect() {
+    (0, import_debug.debugLog)("reconnect(),tryToReconnect:", this._tryToReconnect);
+    if (!this._tryToReconnect) {
+      return;
+    }
+    if (this.hooks.reconnect && !this.hooks.reconnect()) {
+      (0, import_debug.debugLog)("reconnect hook returned false");
+      return;
+    }
+    const nrOfAttempts = process.env.WAPI_RECONNECT_ATTEMPTS && parseInt(process.env.WAPI_RECONNECT_ATTEMPTS) || 10;
+    const maxWaitTime = process.env.WAPI_MAX_RECONNECT_WAIT && parseInt(process.env.WAPI_MAX_RECONNECT_WAIT) || 1e4;
+    this.$connect = (() => __async(this, null, function* () {
+      let _id;
+      for (let i = 0; i < nrOfAttempts + 1; i++) {
+        try {
+          (0, import_debug.debugLog)("Trying to connect, attempt:", i);
+          const { ws, $connect } = createConnection(this._config);
+          _id = yield $connect;
+          this.socId = _id;
+          this._connection = ws;
+          this._ready();
+          break;
+        } catch (err) {
+          if (err.code === import_errors.ERROR_TYPES.AuthenticationError) {
+            throw err;
+          }
+          if (i > nrOfAttempts - 1) {
+            throw err;
+          }
+          yield (0, import_utils.wait)(Math.min(Math.pow(1.5, i) * 1e3, maxWaitTime));
+        }
+      }
+      return _id;
+    }))();
+  }
+  _heartbeat() {
+    (0, import_debug.debugLog)("heartbeat");
+    clearTimeout(this._pingTimeout);
+    this._pingTimeout = setTimeout(() => {
+      if (this._sending.size) {
+        (0, import_debug.debugLog)("pingTimeout reached, but sending.size:", this._sending.size);
+        return this._heartbeat();
+      }
+      (0, import_debug.debugLog)("timeout");
+      this._connection.close();
+      this._setConnected(false);
+      this._reconnect();
+    }, 31e3);
+  }
+  _send(input) {
+    (0, import_debug.debugLog)("send()", input);
+    this._connection.send(JSON.stringify(input));
+  }
+  close() {
+    return __async(this, null, function* () {
+      (0, import_debug.debugLog)("close()");
+      this._tryToReconnect = false;
+      clearTimeout(this._pingTimeout);
+      this._setConnected(false);
+      return this._connection.close();
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WsClient,
+  createWsClient
+});

package/dist/api/ws-client.d.ts

@@ -1,7 +1,10 @@
+/// <reference types="ws" />
+import WebSocket from 'modern-isomorphic-ws';
 import { AuthenticationError } from '../lib/errors';
 import { BaseClient, ISocketId } from './base-client';
-import { JSONRPCRequest, JSONRPCResponse, WapiConnectionOptions } from './index';
-export declare function createClient(opts: WapiConnectionOptions): WsClient;
+import { JSONRPCRequest, JSONRPCResponse } from './jsonrpc/jsonrpc.enums';
+import { WapiConnectionOptions } from './index';
+export declare function createWsClient(opts: WapiConnectionOptions): WsClient;
 interface ConnectionWPromise {
     ws: WebSocket;
     $connect: Promise<ISocketId>;

package/dist/api/ws-client.js

@@ -0,0 +1,236 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/api/ws-client.ts
+import WebSocket from "modern-isomorphic-ws";
+import { debugLog } from "../lib/debug";
+import {
+  AuthenticationError,
+  ERROR_MESSAGES,
+  ERROR_TYPES
+} from "../lib/errors";
+import { getConnectionParams, wait } from "../lib/utils";
+import { BaseClient } from "./base-client";
+import {
+  ConnectionStatus,
+  SocketStatuses
+} from "./connection/connection.enums";
+import { WapiClientType } from "../index";
+var _a;
+var CLIENT_VERSION = (_a = '0.8.1') != null ? _a : "";
+function createWsClient(opts) {
+  const initialConnection = createConnection(opts);
+  return new WsClient(initialConnection, opts);
+}
+function createConnection(opts) {
+  var _a2;
+  const config = Object.assign(
+    {
+      rejectUnauthorized: (_a2 = opts.rejectUnauthorized) != null ? _a2 : true,
+      clientVersion: CLIENT_VERSION
+    },
+    opts
+  );
+  const params = getConnectionParams(config);
+  const ws = new WebSocket(...params);
+  let _resolve;
+  let _reject;
+  let isCleaned = false;
+  let _id;
+  ws.onclose = close;
+  ws.onerror = error;
+  ws.onmessage = message;
+  function close(event) {
+    debugLog(
+      `createConnection>close(reason:${event.reason},code:${event.code},wasClean:${event.wasClean})`
+    );
+    if (event.code === SocketStatuses.authError) {
+      return clean(
+        new AuthenticationError({
+          message: ERROR_MESSAGES.AUTHENTICATION_FAILED,
+          code: ERROR_TYPES.AuthenticationError
+        })
+      );
+    }
+    clean(new Error("WS closed"));
+  }
+  function error(event) {
+    debugLog(
+      `createConnection>error(message:${event.message},error:${event.error},type:${event.type})`
+    );
+    clean(event.error);
+  }
+  function message(event) {
+    debugLog(`createConnection>message(type:${event.type},data:${event.data})`);
+    const { data } = event;
+    let obj;
+    try {
+      obj = JSON.parse(data.toString());
+    } catch (e) {
+      debugLog("Invalid JSON response", e);
+      return clean(new Error("Invalid JSON response"));
+    }
+    if (obj.result !== ConnectionStatus.ready) {
+      debugLog("Invalid first message");
+      return clean(new Error("Invalid first message - " + JSON.stringify(obj)));
+    }
+    clean();
+  }
+  function clean(err) {
+    if (isCleaned) {
+      return;
+    }
+    delete ws.onmessage;
+    delete ws.onerror;
+    delete ws.onclose;
+    if (err) {
+      _reject(err);
+      ws.close();
+    } else {
+      _resolve(_id);
+    }
+    isCleaned = true;
+  }
+  const $connect = new Promise((resolve, reject) => {
+    _resolve = resolve;
+    _reject = reject;
+  });
+  return {
+    ws,
+    $connect
+  };
+}
+var WsClient = class extends BaseClient {
+  constructor(initial, config) {
+    super(initial.ws, WapiClientType.ws, initial.$connect);
+    this._tryToReconnect = true;
+    this._config = config;
+    this.$connect.then((_id) => {
+      this.socId = _id;
+      return this._ready();
+    }).catch((err) => {
+      if (this.socId) {
+        return;
+      }
+      this._setErrored(err);
+    });
+  }
+  _setErrored(err) {
+    super._setErrored(err);
+    if (
+      // eslint-disable-next-line no-prototype-builtins
+      err.hasOwnProperty("code") && err.code === ERROR_TYPES.AuthenticationError
+    ) {
+      this._tryToReconnect = false;
+    }
+  }
+  _ready() {
+    this._setConnected(true);
+    this._connection.onmessage = (event) => {
+      const { data, type } = event;
+      debugLog(`message(type:${type},data:${data})`);
+      if (type === "message") {
+        const obj = JSON.parse(data.toString());
+        this._handleMessage(obj);
+        this._heartbeat();
+      }
+    };
+    this._connection.onerror = (event) => {
+      const { message, error, type } = event;
+      debugLog(`error(message:${message},error:${error},type:${type})`);
+    };
+    this._connection.onclose = (event) => {
+      const { reason, code, wasClean } = event;
+      debugLog(`close(reason:${reason},code:${code},wasClean:${wasClean})`);
+      this._setConnected(false);
+      clearTimeout(this._pingTimeout);
+      this._connectionLost();
+      this._reconnect();
+    };
+    this._heartbeat();
+  }
+  _reconnect() {
+    debugLog("reconnect(),tryToReconnect:", this._tryToReconnect);
+    if (!this._tryToReconnect) {
+      return;
+    }
+    if (this.hooks.reconnect && !this.hooks.reconnect()) {
+      debugLog("reconnect hook returned false");
+      return;
+    }
+    const nrOfAttempts = process.env.WAPI_RECONNECT_ATTEMPTS && parseInt(process.env.WAPI_RECONNECT_ATTEMPTS) || 10;
+    const maxWaitTime = process.env.WAPI_MAX_RECONNECT_WAIT && parseInt(process.env.WAPI_MAX_RECONNECT_WAIT) || 1e4;
+    this.$connect = (() => __async(this, null, function* () {
+      let _id;
+      for (let i = 0; i < nrOfAttempts + 1; i++) {
+        try {
+          debugLog("Trying to connect, attempt:", i);
+          const { ws, $connect } = createConnection(this._config);
+          _id = yield $connect;
+          this.socId = _id;
+          this._connection = ws;
+          this._ready();
+          break;
+        } catch (err) {
+          if (err.code === ERROR_TYPES.AuthenticationError) {
+            throw err;
+          }
+          if (i > nrOfAttempts - 1) {
+            throw err;
+          }
+          yield wait(Math.min(Math.pow(1.5, i) * 1e3, maxWaitTime));
+        }
+      }
+      return _id;
+    }))();
+  }
+  _heartbeat() {
+    debugLog("heartbeat");
+    clearTimeout(this._pingTimeout);
+    this._pingTimeout = setTimeout(() => {
+      if (this._sending.size) {
+        debugLog("pingTimeout reached, but sending.size:", this._sending.size);
+        return this._heartbeat();
+      }
+      debugLog("timeout");
+      this._connection.close();
+      this._setConnected(false);
+      this._reconnect();
+    }, 31e3);
+  }
+  _send(input) {
+    debugLog("send()", input);
+    this._connection.send(JSON.stringify(input));
+  }
+  close() {
+    return __async(this, null, function* () {
+      debugLog("close()");
+      this._tryToReconnect = false;
+      clearTimeout(this._pingTimeout);
+      this._setConnected(false);
+      return this._connection.close();
+    });
+  }
+};
+export {
+  WsClient,
+  createWsClient
+};

package/dist/client-options.schema.json

@@ -0,0 +1,67 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "ClientOptions",
+  "description": "Client input options",
+  "type": "object",
+  "properties": {
+    "client": {
+      "$ref": "#/definitions/ClientType"
+    },
+    "connection": {
+      "anyOf": [
+        {
+          "$ref": "#/definitions/ws_connection"
+        },
+        {
+          "$ref": "#/definitions/https_connection"
+        }
+      ]
+    }
+  },
+  "required": ["client", "connection"],
+  "additionalProperties": false,
+  "definitions": {
+    "ClientType": {
+      "$id": "ClientType",
+      "type": "string",
+      "enum": [
+        "ws",
+        "https"
+      ]
+    },
+    "ws_connection": {
+      "description": "Connection options for ws api",
+      "type": "object",
+      "properties": {
+        "host": {
+          "description": "URL of the API",
+          "type": "string"
+        },
+        "apikey": {
+          "description": "API key for the client",
+          "type": "string"
+        },
+        "apisecret": {
+          "description": "API secret for the client",
+          "type": "string"
+        }
+      },
+      "required": ["host", "apikey", "apisecret"]
+    },
+    "https_connection": {
+      "description": "Connection options for https api",
+      "type": "object",
+      "properties": {
+        "host": {
+          "description": "URL of the API",
+          "type": "string"
+        },
+        "jwt": {
+          "description": "Auth token for calling api",
+          "type": "string"
+        }
+      },
+      "required": ["host"]
+    }
+  }
+}