@pathscale/wss-adapter 1.0.0

package/dist/types/index.d.ts

@@ -0,0 +1,68 @@
+interface IService {
+    remote: string;
+    methods: {
+        [methodCode: string]: {
+            name: string;
+            parameters: string[];
+        };
+    };
+}
+interface IServiceConfig extends IService {
+    onDisconnect: () => void | null;
+}
+interface IServices {
+    [serviceName: string]: IServiceConfig;
+}
+interface IErrors {
+    [errorCode: number]: string;
+}
+interface IConfiguration {
+    timeout: number;
+    services: IServices;
+    errors: IErrors;
+    onError: (error: {
+        error: number;
+        message: string;
+    }) => void;
+}
+interface IServiceConnect {
+    connect<T>(payload: string | string[] | undefined): Promise<T>;
+    disconnect: () => void;
+}
+interface IWssAdapter {
+    services: {
+        [serviceName: string]: IServiceConnect;
+    };
+    sessions: {
+        [serviceName: string]: unknown;
+    };
+    configure: (configuration: IConfiguration) => void;
+}
+interface ISequence {
+    value: number;
+    getSeq: () => number;
+    decreaseSeq: () => void;
+}
+interface ISessions {
+    [serviceName: string]: WebSocket;
+}
+interface IPendingPromises {
+    [seq: number]: {
+        resolve: (payload: unknown) => void;
+        reject: (error: Error) => void;
+        toHandler: ReturnType<typeof setTimeout>;
+    };
+}
+interface IStore {
+    timeout: number;
+    errors: IErrors;
+    services: IServices;
+    sequence: ISequence;
+    sessions: ISessions;
+    pendingPromises: IPendingPromises;
+    onError: (error: {
+        error: number;
+        message: string;
+    }) => void;
+}
+export { IStore, IWssAdapter, IServiceConfig, IConfiguration, IErrors, IServices, IService };

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/wssAdapter.d.ts

@@ -0,0 +1,3 @@
+import { IWssAdapter } from './types';
+declare const wssAdapter: IWssAdapter;
+export default wssAdapter;

package/dist/wssAdapter.js

@@ -0,0 +1,169 @@
+"use strict";
+/* eslint-disable compat/compat */
+/* eslint-disable promise/avoid-new */
+/* eslint-disable @typescript-eslint/no-empty-function */
+Object.defineProperty(exports, "__esModule", { value: true });
+var wssAdapter = {
+    services: {},
+    sessions: {},
+    configure: function () { },
+};
+var store = {
+    timeout: 0,
+    errors: {},
+    services: {},
+    sequence: {
+        value: 1,
+        getSeq: function () {
+            store.sequence.value += 1;
+            return store.sequence.value;
+        },
+        decreaseSeq: function () {
+            store.sequence.value -= 1;
+        },
+    },
+    sessions: {},
+    pendingPromises: {},
+    onError: function () { },
+};
+wssAdapter.configure = function (configuration) {
+    var timeout = configuration.timeout, services = configuration.services, errors = configuration.errors, onError = configuration.onError;
+    // save some stuff for later retrieval
+    store.timeout = timeout;
+    store.errors = errors;
+    store.services = services;
+    store.onError = onError;
+    var _loop_1 = function (serviceName, serviceConfig) {
+        // construct services objects with two simple functions
+        // intended use: `wssAdapter.services.admin.connect([1, 2, 3])` or `wssAdapter.services.auth.connect([1, 2, 3])`
+        wssAdapter.services[serviceName] = {
+            connect: function (payload) {
+                return connectHandler(serviceName, serviceConfig, payload);
+            },
+            disconnect: function () { return disconnectHandler(serviceName); },
+        };
+        // construct sessions objects that contain a proxy so you can ask unknown property
+        // intended use: `wssAdapter.sessions.admin.updatePassword({ newPassword: 'hotdog6737637' })`
+        wssAdapter.sessions[serviceName] = new Proxy({}, {
+            get: function (target, methodName) { return function (payload) {
+                return sendHandler(serviceName, serviceConfig, methodName, payload);
+            }; },
+        });
+    };
+    for (var _i = 0, _a = Object.entries(services); _i < _a.length; _i++) {
+        var _b = _a[_i], serviceName = _b[0], serviceConfig = _b[1];
+        _loop_1(serviceName, serviceConfig);
+    }
+};
+var connectHandler = function (serviceName, serviceConfig, payload) {
+    return new Promise(function (resolve, reject) {
+        store.sessions[serviceName] = new WebSocket(serviceConfig.remote, payload);
+        store.sessions[serviceName].onmessage = function (event) {
+            var _a;
+            var response = JSON.parse(event.data);
+            console.log(response);
+            if (response.params.error) {
+                reject(new Error((_a = store.errors[response.params.error]) !== null && _a !== void 0 ? _a : 'Something went wrong'));
+                return;
+            }
+            store.sessions[serviceName].onmessage = receiveHandler;
+            resolve(response.params);
+        };
+        store.sessions[serviceName].onclose = serviceConfig.onDisconnect;
+    });
+};
+var disconnectHandler = function (serviceName) {
+    var _a;
+    (_a = store.sessions[serviceName]) === null || _a === void 0 ? void 0 : _a.close();
+};
+var sendHandler = function (serviceName, serviceConfig, methodName, params) {
+    var _a;
+    var methodCode = (_a = Object.entries(serviceConfig.methods)
+        .map(function (_a) {
+        var code = _a[0], info = _a[1];
+        return ({ code: code, info: info });
+    })
+        .find(function (_a) {
+        var info = _a.info;
+        return info.name === methodName;
+    })) === null || _a === void 0 ? void 0 : _a.code;
+    if (!methodCode) {
+        throw new Error("method ".concat(methodName, " not available in ").concat(serviceName, " service"));
+    }
+    if (!Object.keys(params).every(function (param) {
+        return serviceConfig.methods[methodCode].parameters.includes(param);
+    })) {
+        throw new Error("method ".concat(methodCode, " is being called with missing parameters"));
+    }
+    var purgedParams = {};
+    serviceConfig.methods[methodCode].parameters.forEach(function (k) {
+        purgedParams[k] = params[k];
+    });
+    var difference = Object.keys(params).filter(function (x) { return !serviceConfig.methods[methodCode].parameters.includes(x); });
+    if (difference.length) {
+        throw new Error("method ".concat(methodCode, " is being called with unknow parameters, ").concat(difference));
+    }
+    var payload = {
+        method: Number.parseInt(methodCode),
+        seq: store.sequence.getSeq(),
+        params: purgedParams,
+    };
+    console.log("".concat(serviceName, "::").concat(methodName, " sends:"), payload);
+    return new Promise(function (resolve, reject) {
+        store.sessions[serviceName].send(JSON.stringify(payload));
+        // save executor so that when response for this request comes the promise can be resolved
+        store.pendingPromises[payload.seq] = {
+            resolve: resolve,
+            reject: reject,
+            toHandler: setTimeout(function () {
+                reject(new Error(methodCode.toString() + ' took to long, aborting'));
+            }, store.timeout),
+        };
+    });
+};
+var receiveHandler = function (event) {
+    var response = JSON.parse(event.data);
+    console.log("app::".concat(response.method, " got:"), response);
+    var error = response.method === 0;
+    var done = response.method.toString().endsWith('1');
+    var resolve = function (payload, code) {
+        console.log(code);
+        var executor = store.pendingPromises[response.seq];
+        clearTimeout(store.pendingPromises[response.seq].toHandler);
+        delete store.pendingPromises[response.seq];
+        executor.resolve(payload);
+    };
+    // handle error
+    if (error) {
+        onError(response);
+    }
+    else if (done) {
+        var code = response.method - 1;
+        resolve(response, code);
+    }
+};
+function onError(response) {
+    var _a, _b;
+    var errorCode = response.params.error;
+    var errorMsg = (_a = store.errors[errorCode]) !== null && _a !== void 0 ? _a : 'Something went wrong';
+    if ([45349638, 45349637].includes(errorCode)) {
+        store.sequence.decreaseSeq();
+        console.log('seq has been decreased because of error');
+    }
+    (_b = store.onError) === null || _b === void 0 ? void 0 : _b.call(store, {
+        error: errorCode,
+        message: errorMsg,
+    });
+    // if there was only one executor saved in store.pendingPromises, then it was that request that failed
+    if (Object.keys(store.pendingPromises).length === 1) {
+        var onlyKey = Number.parseInt(Object.keys(store.pendingPromises)[0]);
+        clearTimeout(store.pendingPromises[onlyKey].toHandler);
+        store.pendingPromises[onlyKey].reject(new Error(errorMsg));
+        delete store.pendingPromises[onlyKey];
+    }
+    // if there were more than one, there is no way of knowing who failed
+    else {
+        throw new Error('Unkown request failed');
+    }
+}
+exports.default = wssAdapter;

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@pathscale/wss-adapter",
+  "version": "1.0.0",
+  "description": "Websocket adapter for the Pathscale WSS",
+  "main": "dist/wssAdapter.js",
+  "types": "dist/wssAdapter.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "author": "PathScale",
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^4.5.5"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/skaptox/wss-adapter.git"
+  },
+  "bugs": {
+    "url": "https://github.com/skaptox/wss-adapter/issues"
+  },
+  "homepage": "https://github.com/skaptox/wss-adapter#readme"
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "commonjs",
+    "lib": ["es2017", "es7", "es6", "dom"],
+    "declaration": true,
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true
+  },
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/types/index.ts

@@ -0,0 +1,73 @@
+interface IService {
+  remote: string
+  methods: {
+    [methodCode: string]: {
+      name: string
+      parameters: string[]
+    }
+  }
+}
+
+interface IServiceConfig extends IService {
+  onDisconnect: () => void | null
+}
+
+interface IServices {
+  [serviceName: string]: IServiceConfig
+}
+
+interface IErrors {
+  [errorCode: number]: string
+}
+
+interface IConfiguration {
+  timeout: number
+  services: IServices
+  errors: IErrors
+  onError: (error: { error: number; message: string }) => void
+}
+
+interface IServiceConnect {
+  connect<T>(payload: string | string[] | undefined): Promise<T>
+  disconnect: () => void
+}
+
+interface IWssAdapter {
+  services: {
+    [serviceName: string]: IServiceConnect
+  }
+  sessions: {
+    [serviceName: string]: unknown
+  }
+  configure: (configuration: IConfiguration) => void
+}
+
+interface ISequence {
+  value: number
+  getSeq: () => number
+  decreaseSeq: () => void
+}
+
+interface ISessions {
+  [serviceName: string]: WebSocket
+}
+
+interface IPendingPromises {
+  [seq: number]: {
+    resolve: (payload: unknown) => void
+    reject: (error: Error) => void
+    toHandler: ReturnType<typeof setTimeout>
+  }
+}
+
+interface IStore {
+  timeout: number
+  errors: IErrors
+  services: IServices
+  sequence: ISequence
+  sessions: ISessions
+  pendingPromises: IPendingPromises
+  onError: (error: { error: number; message: string }) => void
+}
+
+export { IStore, IWssAdapter, IServiceConfig, IConfiguration, IErrors, IServices, IService }

package/wssAdapter.ts

@@ -0,0 +1,213 @@
+/* eslint-disable compat/compat */
+/* eslint-disable promise/avoid-new */
+/* eslint-disable @typescript-eslint/no-empty-function */
+
+import { IStore, IWssAdapter, IServiceConfig } from './types'
+
+const wssAdapter: IWssAdapter = {
+  services: {},
+  sessions: {},
+  configure() {},
+}
+
+const store: IStore = {
+  timeout: 0,
+  errors: {},
+  services: {},
+
+  sequence: {
+    value: 1,
+    getSeq() {
+      store.sequence.value += 1
+      return store.sequence.value
+    },
+    decreaseSeq() {
+      store.sequence.value -= 1
+    },
+  },
+
+  sessions: {},
+  pendingPromises: {},
+  onError() {},
+}
+
+wssAdapter.configure = configuration => {
+  const { timeout, services, errors, onError } = configuration
+
+  // save some stuff for later retrieval
+  store.timeout = timeout
+  store.errors = errors
+  store.services = services
+  store.onError = onError
+
+  for (const [serviceName, serviceConfig] of Object.entries(services)) {
+    // construct services objects with two simple functions
+    // intended use: `wssAdapter.services.admin.connect([1, 2, 3])` or `wssAdapter.services.auth.connect([1, 2, 3])`
+    wssAdapter.services[serviceName] = {
+      connect: <T>(payload: string | string[] | undefined) =>
+        connectHandler<T>(serviceName, serviceConfig, payload),
+      disconnect: () => disconnectHandler(serviceName),
+    }
+
+    // construct sessions objects that contain a proxy so you can ask unknown property
+    // intended use: `wssAdapter.sessions.admin.updatePassword({ newPassword: 'hotdog6737637' })`
+    wssAdapter.sessions[serviceName] = new Proxy(
+      {},
+      {
+        get: (target, methodName: string) => (payload: Record<string, unknown>) =>
+          sendHandler(serviceName, serviceConfig, methodName, payload),
+      },
+    )
+  }
+}
+
+const connectHandler = <T>(
+  serviceName: string,
+  serviceConfig: IServiceConfig,
+  payload: string | string[] | undefined,
+) => {
+  return new Promise((resolve, reject) => {
+    store.sessions[serviceName] = new WebSocket(serviceConfig.remote, payload)
+
+    store.sessions[serviceName].onmessage = function (event: { data: string }) {
+      const response = JSON.parse(event.data)
+      console.log(response)
+
+      if (response.params.error) {
+        reject(new Error(store.errors[response.params.error] ?? 'Something went wrong'))
+        return
+      }
+
+      store.sessions[serviceName].onmessage = receiveHandler
+      resolve(response.params)
+    }
+
+    store.sessions[serviceName].onclose = serviceConfig.onDisconnect
+  }) as Promise<T>
+}
+
+const disconnectHandler = (serviceName: string) => {
+  store.sessions[serviceName]?.close()
+}
+
+const sendHandler = (
+  serviceName: string,
+  serviceConfig: IServiceConfig,
+  methodName: string,
+  params: Record<string, unknown>,
+) => {
+  const methodCode = Object.entries(serviceConfig.methods)
+    .map(([code, info]) => ({ code, info }))
+    .find(({ info }) => info.name === methodName)?.code
+
+  if (!methodCode) {
+    throw new Error(`method ${methodName} not available in ${serviceName} service`)
+  }
+
+  if (
+    !Object.keys(params).every(param =>
+      serviceConfig.methods[methodCode].parameters.includes(param),
+    )
+  ) {
+    throw new Error(`method ${methodCode} is being called with missing parameters`)
+  }
+
+  const purgedParams: Record<string, unknown> = {}
+  serviceConfig.methods[methodCode].parameters.forEach(k => {
+    purgedParams[k] = params[k]
+  })
+
+  const difference = Object.keys(params).filter(
+    x => !serviceConfig.methods[methodCode].parameters.includes(x),
+  )
+
+  if (difference.length) {
+    throw new Error(`method ${methodCode} is being called with unknow parameters, ${difference}`)
+  }
+
+  const payload = {
+    method: Number.parseInt(methodCode),
+    seq: store.sequence.getSeq(),
+    params: purgedParams,
+  }
+
+  console.log(`${serviceName}::${methodName} sends:`, payload)
+
+  return new Promise((resolve, reject) => {
+    store.sessions[serviceName].send(JSON.stringify(payload))
+
+    // save executor so that when response for this request comes the promise can be resolved
+    store.pendingPromises[payload.seq] = {
+      resolve,
+      reject,
+      toHandler: setTimeout(() => {
+        reject(new Error(methodCode.toString() + ' took to long, aborting'))
+      }, store.timeout),
+    }
+  })
+}
+
+const receiveHandler = (event: { data: string }) => {
+  const response = JSON.parse(event.data)
+  console.log(`app::${response.method} got:`, response)
+
+  const error = response.method === 0
+  const done = response.method.toString().endsWith('1')
+
+  const resolve = (payload: unknown, code: number) => {
+    console.log(code)
+    const executor = store.pendingPromises[response.seq]
+    clearTimeout(store.pendingPromises[response.seq].toHandler)
+    delete store.pendingPromises[response.seq]
+    executor.resolve(payload)
+  }
+
+  // handle error
+  if (error) {
+    onError(response)
+  } else if (done) {
+    const code = response.method - 1
+    resolve(response, code)
+  }
+}
+
+// if it was one of these guys
+// 1) protocol violation
+// 2) malformed request
+// seq must be decreased
+
+interface IResponse {
+  params: {
+    error: number
+  }
+}
+
+function onError(response: IResponse) {
+  const { error: errorCode } = response.params
+  const errorMsg = store.errors[errorCode] ?? 'Something went wrong'
+
+  if ([45349638, 45349637].includes(errorCode)) {
+    store.sequence.decreaseSeq()
+    console.log('seq has been decreased because of error')
+  }
+
+  store.onError?.({
+    error: errorCode,
+    message: errorMsg,
+  })
+
+  // if there was only one executor saved in store.pendingPromises, then it was that request that failed
+  if (Object.keys(store.pendingPromises).length === 1) {
+    const onlyKey = Number.parseInt(Object.keys(store.pendingPromises)[0])
+    clearTimeout(store.pendingPromises[onlyKey].toHandler)
+    store.pendingPromises[onlyKey].reject(new Error(errorMsg))
+    delete store.pendingPromises[onlyKey]
+  }
+
+  // if there were more than one, there is no way of knowing who failed
+  else {
+    throw new Error('Unkown request failed')
+  }
+}
+
+export default wssAdapter