grexxconnect-ess 1.1.1 → 1.2.1

package/client.js

@@ -91,6 +91,10 @@ class WebSocketClient extends EventEmitter {
         }
     }
 
+    disconnect(code, message) {
+        this.instance.close(code, message);
+    }
+
     reconnect( code, msg ) {
         this.log('connection failed'.red, `retry in ${this.autoReconnectInterval}ms`, code.toString().red, (msg || '').yellow);
         this.instance.removeAllListeners();

package/index.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014-2021 Grexx - All Rights Reserved
+ * Copyright (C) 2014-2022 Grexx - All Rights Reserved
  * Unauthorized copying of this file, via any medium is strictly prohibited
  * Proprietary and confidential
  */
@@ -8,8 +8,10 @@
 const EventEmitter = require('events');
 const WebSocket    = require('./client');
 
+const TIMEOUT_LONG = 30 * 1000; //== 30 seconds
+
 class EssConnect extends EventEmitter {
-    constructor( settings ) {
+    constructor(settings) {
         super();
 
         const thisVersion = require('./package.json').version;
@@ -21,51 +23,128 @@ class EssConnect extends EventEmitter {
             debug:   settings.debug
         });
 
-        const send = ( type, content ) => {
-            return new Promise(( resolve, reject ) => {
+        const _waitQueue           = {},
+              _unfinishedResponses = {};
+
+        const send = (type, content, timeout = TIMEOUT_LONG) => {
+            return new Promise((resolve, reject) => {
+                const essCorrelationId = content?.['ess-correlation-id'];
+
+                if (!essCorrelationId || !this._ackFunctional) {
+                    try {
+                        ws.send(JSON.stringify({
+                            type:      type,
+                            content:   content,
+                            timestamp: Date.now()
+                        }));
+                        return resolve();
+                    } catch (error) {
+                        return reject(error);
+                    }
+                }
+
+                const exceededTimeout = setTimeout(async () => {
+                    ws.debug(`timeout of ${timeout}ms exceeded for ack response from server`);
+                    return reject('Timeout exceeded');
+                }, timeout);
+
+                _waitQueue[essCorrelationId] = () => {
+                    clearTimeout(exceededTimeout);
+                    ws.debug(`ack response received from server`);
+                    return resolve('Ack response received from server');
+                };
+
                 ws.send(JSON.stringify({
                     type:      type,
                     content:   content,
                     timestamp: Date.now()
-                }), error => {
-                    if ( error ) {
-                        reject(error);
-                    } else {
-                        resolve();
+                }), (error) => {
+                    if (error) {
+                        return reject(error);
                     }
                 });
             });
         };
 
-        ws.on('close', ( code, msg ) => this.emit('disconnected', code, msg));
-        ws.on('message', _message => {
-            switch ( _message.type ) {
+        const sendAck = async (connectCorrelationId, message = '', type = 'ack') => {
+            this.ws.debug(`acknowledging message from server for message header ID: ${connectCorrelationId}`.gray);
+            await send(type, {'connect-correlation-id': connectCorrelationId, message});
+            this.emit(type);
+        };
+
+        const completeUnfinishedResponses = () => {
+            this.ws.debug(`checking for any incomplete message responses: ${Object.keys(_unfinishedResponses).length.toString().blue} unfinished responses`);
+            for (const key in _unfinishedResponses) {
+                const {type, content} = _unfinishedResponses[key];
+                send(type, content).then(() => {
+                    delete _unfinishedResponses[key];
+                }).catch(() => handleTimeout(type, content));
+            }
+        };
+
+        const handleTimeout = (type, content) => {
+            const id                 = content['ess-correlation-id'];
+            _unfinishedResponses[id] = {type, content};
+            ws.disconnect(1012, "Ack response from server timed out");
+        };
+
+        ws.on('close', (code, msg) => this.emit('disconnected', code, msg));
+        ws.on('message', async (_message) => {
+            const connectCorrelationId = _message['connect-correlation-id'],
+                  essCorrelationId     = _message['ess-correlation-id'];
+
+            switch (_message.type) {
                 case 'ping':
-                    this.ws.debug('responding to connection-ping');
-                    send('pong');
+                    this.ws.debug('responding to connection-ping'.gray);
                     this.emit('ping');
+                    await send('pong');
+                    break;
+                case 'ackFunctional':
+                    this.ws.debug('responding to functionality check'.green, 'acknowledgements'.blue);
+                    this._ackFunctional = true;
+                    await sendAck(connectCorrelationId, null, 'ackFunctional');
+                    completeUnfinishedResponses();
+                    break;
+                case 'ack':
+                    this.ws.debug(`received ack from GrexxConnect for message with header ID: ${essCorrelationId}`);
+                    if (typeof (essCorrelationId) != 'undefined' && typeof (_waitQueue[essCorrelationId]) == 'function') {
+                        const execFunc = _waitQueue[essCorrelationId];
+                        execFunc();
+                        delete _waitQueue[essCorrelationId];
+                    }
                     break;
                 case 'authorized':
                     this.log('connected and authorized for'.green, _message.namespace.blue);
                     this.emit('authorized', _message.namespace);
                     break;
+                case 'opened':
+                    this.log('open'.green, 'ready to receive messages'.blue);
+                    break;
                 case 'system':
                     this.handleSystemMessage(_message, send);
                     break;
                 case'message':
+                    await sendAck(connectCorrelationId, "message received and being processed");
                     this.emit('message', {
                         content: _message.content,
                         parsed:  this.parseMessage(_message.content.data),
                         resolve: outputData => {
-                            return send('response', {
-                                toMessage:  _message,
-                                outputData: outputData
+                            const type    = 'response',
+                                  content = {
+                                      'ess-correlation-id': connectCorrelationId,
+                                      toMessage:            _message,
+                                      outputData:           outputData
+                                  };
+
+                            return send(type, content).catch(() => {
+                                handleTimeout(type, content);
                             });
                         },
-                        reject:  ( publicMessage, debugMessage, additionalContext ) => {
+                        reject:  (publicMessage, debugMessage, additionalContext) => {
                             return send('reject', {
-                                toMessage:    _message,
-                                errorContext: Object.assign({
+                                'ess-correlation-id': connectCorrelationId,
+                                toMessage:            _message,
+                                errorContext:         Object.assign({
                                     publicMessage,
                                     debugMessage
                                 }, additionalContext)
@@ -96,27 +175,27 @@ class EssConnect extends EventEmitter {
     /**Set a monitoring function. Should return {status:'ok|warning|error', ...}
      * @param {function} statusFunction
      */
-    setMonitoringResponse( statusFunction ) {
+    setMonitoringResponse(statusFunction) {
         this._statusFunction = statusFunction;
     }
 
-    log( ...args ) {
+    log(...args) {
         console.info('  [ESS][MAIN]  '.gray, ...args);
     }
 
-    handleSystemMessage( message, send ) {
-        if ( message.content.action === 'ping' ) {
-            this.ws.debug('responding to system-ping');
+    handleSystemMessage(message, send) {
+        if (message.content.action === 'ping') {
+            this.ws.debug('responding to system-ping'.gray);
             send('system', {
                 action:      'pong',
                 client_data: typeof this._statusFunction === 'function' ?
-                                 this._statusFunction() : { status: 'ok' },
+                                 this._statusFunction() : {status: 'ok'},
                 server_data: message.content.id
             });
         }
     }
 
-    parseMessage( message = [] ) {
+    parseMessage(message = []) {
         const result = {};
 
         message.forEach(part => {

package/package.json

@@ -2,7 +2,8 @@
   "name"                : "grexxconnect-ess",
   "author"              : "Grexx <info@grexxboxx.com>",
   "description"         : "Grexx Connect - External System Service Helper",
-  "version"             : "1.1.1",
+  "version"             : "1.2.1",
+  "types"               : "./schema/index.d.ts",
   "contributors"        : [
     {
       "name" : "Jeffrey van Norden",
@@ -19,6 +20,6 @@
   },
   "license"             : "MIT",
   "engines"             : {
-    "node": ">=6.9.1"
+    "node": ">=12"
   }
 }

package/schema/client.d.ts

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2014-2022 Grexx - All Rights Reserved
+ * Unauthorized copying of this file, via any medium is strictly prohibited
+ * Proprietary and confidential
+ */
+
+export = WebSocketClient;
+declare class WebSocketClient extends EventEmitter {
+    constructor(url: any, options: any);
+    number: number;
+    autoReconnectInterval: number;
+    _debug: any;
+    log(...args: any[]): void;
+    debug(...args: any[]): void;
+    open(url: any, options: any): void;
+    url: any;
+    options: any;
+    instance: any;
+    send(data: any, option: any, cb: any): void;
+    reconnect(code: any, msg: any): void;
+    onOpen(...args: any[]): void;
+    onMessage(data: any, flags: any, number: any): void;
+    onError(error: any): void;
+    onClose(code: any, msg: any): void;
+}
+import EventEmitter = require("node/events");

package/schema/index.d.ts

@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2014-2022 Grexx - All Rights Reserved
+ * Unauthorized copying of this file, via any medium is strictly prohibited
+ * Proprietary and confidential
+ */
+
+export = EssConnect;
+declare class EssConnect extends EventEmitter {
+    constructor(settings: any);
+    ws: WebSocket;
+    /**Set a monitoring function. Should return {status:'ok|warning|error', ...}
+     * @param {function} statusFunction
+     */
+    setMonitoringResponse(statusFunction: Function): void;
+    _statusFunction: Function | undefined;
+    log(...args: any[]): void;
+    handleSystemMessage(message: any, send: any): void;
+    parseMessage(message?: any[]): {};
+}
+import EventEmitter = require("node/events");
+import WebSocket = require("./client");