@schukai/monster 3.1.2 → 3.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schukai/monster",
-  "version": "3.1.2",
+  "version": "3.3.0",
   "description": "Monster is a simple library for creating fast, robust and lightweight websites.",
   "keywords": [
     "framework",

package/source/data/datasource/websocket.mjs

@@ -6,54 +6,50 @@
  */
 
 import {internalSymbol, instanceSymbol} from "../../constants.mjs";
-import {isInteger, isString, isObject} from "../../types/is.mjs";
-import {Queue} from "../../types/queue.mjs";
+import {isString, isObject} from "../../types/is.mjs";
+import {WebConnect} from "../../net/webconnect.mjs";
+import {Message} from "../../net/webconnect/message.mjs";
 import {Datasource} from "../datasource.mjs";
 import {Pathfinder} from "../pathfinder.mjs";
 import {Pipe} from "../pipe.mjs";
 
 export {WebSocketDatasource}
 
-/**
- * @private
- * @type {Symbol}
- */
-const receiveQueueSymbol = Symbol("queue");
-
 
 /**
  * @private
  * @type {Symbol}
- * 
+ *
  * hint: this name is used in the tests. if you want to change it, please change it in the tests as well.
  */
-const connectionSymbol = Symbol("connection");
+const webConnectSymbol = Symbol("connection");
 
 /**
- * @private
- * @type {symbol}
+ *
+ * @param self
+ * @param obj
+ * @returns {*}
  */
-const manualCloseSymbol = Symbol("manualClose");
+function doTransform(type, obj) {
+    const self = this;
+    let transformation = self.getOption(type + '.mapping.transformer');
+    if (transformation !== undefined) {
+        const pipe = new Pipe(transformation);
+        const callbacks = self.getOption(type + '.mapping.callbacks')
+
+        if (isObject(callbacks)) {
+            for (const key in callbacks) {
+                if (callbacks.hasOwnProperty(key) && typeof callbacks[key] === 'function') {
+                    pipe.setCallback(key, callbacks[key]);
+                }
+            }
+        }
 
-/**
- * @see https://www.rfc-editor.org/rfc/rfc6455.html#section-7.4.1
- * @type {{"1000": string, "1011": string, "1010": string, "1008": string, "1007": string, "1006": string, "1005": string, "1004": string, "1015": string, "1003": string, "1002": string, "1001": string, "1009": string}}
- */
-const connectionStatusCode = {
-    1000: "Normal closure",
-    1001: "Going away",
-    1002: "Protocol error",
-    1003: "Unsupported data",
-    1004: "Reserved",
-    1005: "No status code",
-    1006: "Connection closed abnormally",
-    1007: "Invalid frame payload data",
-    1008: "Policy violation",
-    1009: "Message too big",
-    1010: "Mandatory extension",
-    1011: "Internal server error",
-    1015: "TLS handshake"
-};
+        obj = pipe.run(obj);
+    }
+
+    return obj;
+}
 
 /**
  * The RestAPI is a class that enables a REST API server.
@@ -73,6 +69,8 @@ class WebSocketDatasource extends Datasource {
      */
     constructor(options) {
         super();
+        
+        const self = this;
 
         if (isString(options)) {
             options = {url: options};
@@ -80,83 +78,32 @@ class WebSocketDatasource extends Datasource {
 
         if (!isObject(options)) options = {};
         this.setOptions(options);
-        this[receiveQueueSymbol] = new Queue();
-
-        this[connectionSymbol] = {};
-        this[connectionSymbol].socket = null;
-        this[connectionSymbol].reconnectCounter = 0;
-        this[manualCloseSymbol]=false;
+        this[webConnectSymbol] = new WebConnect({
+            url: self.getOption('url'),
+            connection: {
+                timeout: self.getOption('connection.timeout'),
+                reconnect: {
+                    timeout: self.getOption('connection.reconnect.timeout'),
+                    attempts: self.getOption('connection.reconnect.attempts'),
+                    enabled: self.getOption('connection.reconnect.enabled')
+                }
+            }
+        });
     }
 
     /**
      *
-     * @returns {Websocketdatasource}
-     * @throws {Error} No url defined for websocket datasource.
+     * @returns {Promise}
      */
     connect() {
-        const self = this;
-
-        let connected = false;
-        let reconnectTimeout = self.getOption('reconnect.timeout');
-        if (!isInteger(reconnectTimeout) || reconnectTimeout < 1000) reconnectTimeout = 1000;
-        let reconnectAttempts = self.getOption('reconnect.attempts');
-        if (!isInteger(reconnectAttempts) || reconnectAttempts < 1) reconnectAttempts = 1;
-        let reconnectEnabled = self.getOption('reconnect.enabled');
-        if (reconnectEnabled !== true) reconnectEnabled = false;
-
-        self[manualCloseSymbol] = false;
-        self[connectionSymbol].reconnectCounter++;
-
-        if (self[connectionSymbol].socket && self[connectionSymbol].socket.readyState < 2) {
-            self[connectionSymbol].socket.close();
-        }
-        self[connectionSymbol].socket = null;
-
-        const url = self.getOption('url');
-        if (!url) throw new Error('No url defined for websocket datasource.');
-
-        self[connectionSymbol].socket = new WebSocket(url);
-
-        self[connectionSymbol].socket.onmessage = function (event) {
-            self[receiveQueueSymbol].add(event);
-            setTimeout(function () {
-                self.read();
-            }, 0);
-        };
-
-        self[connectionSymbol].socket.onopen = function () {
-            connected = true;
-            self[connectionSymbol].reconnectCounter = 0;
-        };
-
-        self[connectionSymbol].socket.close = function (event) {
-            
-            if (self[manualCloseSymbol]) {
-                self[manualCloseSymbol] = false;
-                return;
-            }
-
-            if (reconnectEnabled && this[connectionSymbol].reconnectCounter < reconnectAttempts) {
-                setTimeout(() => {
-                    self.connect();
-                }, reconnectTimeout * this[connectionSymbol].reconnectCounter);
-            }
-
-        };
-
-        self[connectionSymbol].socket.onerror = (error) => {
-
-            if (reconnectEnabled && self[connectionSymbol].reconnectCounter < reconnectAttempts) {
-                setTimeout(() => {
-                    self.connect();
-                }, reconnectTimeout * this[connectionSymbol].reconnectCounter);
-            }
-
-        };
+        return this[webConnectSymbol].connect();
     }
 
+    /**
+     * @returns {boolean}
+     */
     isConnected() {
-        return this[connectionSymbol].socket && this[connectionSymbol].socket.readyState === 1;
+        return this[webConnectSymbol].isConnected();
     }
 
     /**
@@ -169,19 +116,20 @@ class WebSocketDatasource extends Datasource {
 
     /**
      * @property {string} url=undefined Defines the resource that you wish to fetch.
-     * @property {Number} reconnect.timeout The timeout in milliseconds for the reconnect.
-     * @property {Number} reconnect.attempts The maximum number of reconnects.
-     * @property {Bool} reconnect.enabled If the reconnect is enabled.
+     * @property {Object} connection
+     * @property {Object} connection.timeout=5000 Defines the timeout for the connection.
+     * @property {Number} connection.reconnect.timeout The timeout in milliseconds for the reconnect.
+     * @property {Number} connection.reconnect.attempts The maximum number of reconnects.
+     * @property {Bool} connection.reconnect.enabled If the reconnect is enabled.
      * @property {Object} write={} Options
      * @property {Object} write.mapping the mapping is applied before writing.
      * @property {String} write.mapping.transformer Transformer to select the appropriate entries
      * @property {Monster.Data.Datasource~exampleCallback[]} write.mapping.callback with the help of the callback, the structures can be adjusted before writing.
-     * @property {Object} write.report
-     * @property {String} write.report.path Path to validations
      * @property {Object} write.sheathing
      * @property {Object} write.sheathing.object Object to be wrapped
      * @property {string} write.sheathing.path Path to the data
      * @property {Object} read={} Options
+     * @property {String} read.path Path to data
      * @property {Object} read.mapping the mapping is applied after reading.
      * @property {String} read.mapping.transformer Transformer to select the appropriate entries
      * @property {Monster.Data.Datasource~exampleCallback[]} read.mapping.callback with the help of the callback, the structures can be adjusted after reading.
@@ -192,10 +140,7 @@ class WebSocketDatasource extends Datasource {
             write: {
                 mapping: {
                     transformer: undefined,
-                    callbacks: []
-                },
-                report: {
-                    path: undefined
+                    callbacks: {}
                 },
                 sheathing: {
                     object: undefined,
@@ -205,28 +150,28 @@ class WebSocketDatasource extends Datasource {
             read: {
                 mapping: {
                     transformer: undefined,
-                    callbacks: []
+                    callbacks: {}
                 },
+                path: undefined,
             },
-            reconnect: {
-                timeout: 1000,
-                attempts: 10,
-                enabled: true
+            connection: {
+                timeout: 5000,
+                reconnect: {
+                    timeout: 1000,
+                    attempts: 1,
+                    enabled: false,
+                }
             }
         });
     }
 
     /**
      * This method closes the connection.
-     * 
+     *
      * @returns {Promise}
      */
     close() {
-        this[manualCloseSymbol]=true;
-        if (this[connectionSymbol].socket) {
-            this[connectionSymbol].socket.close();
-        }
-        return this;
+        return this[webConnectSymbol].close();
     }
 
     /**
@@ -234,99 +179,130 @@ class WebSocketDatasource extends Datasource {
      */
     read() {
         const self = this;
-        let response;
-
-        if (self[connectionSymbol]?.socket?.readyState!==1) {
-            return Promise.reject('The connection is not established.');
-        }        
 
         return new Promise((resolve, reject) => {
-            if (self[receiveQueueSymbol].isEmpty()) {
-                resolve();
-            }
-
-            while (!self[receiveQueueSymbol].isEmpty()) {
-                
-                const event = self[receiveQueueSymbol].poll();
-                const body = event?.data;
-                if (!body) continue;
-
-                let obj;
-                try {
-                    obj = JSON.parse(body);
-                } catch (e) {
-
-                    let msg = 'the response does not contain a valid json (actual: ';
-
-                    if (body.length > 100) {
-                        msg += body.substring(0, 97) + '...';
-                    } else {
-                        msg += body;
-                    }
 
-                    msg += "; " + e.message + ')';
+            while (this[webConnectSymbol].dataReceived() === true) {
+                let obj = this[webConnectSymbol].poll();
+                if (!isObject(obj)) {
+                    reject(new Error('The received data is not an object.'));
+                    return;
+                }
 
-                    reject(msg);
+                if (!(obj instanceof Message)) {
+                    reject(new Error('The received data is not a Message.'));
+                    return;
                 }
 
-                let transformation = self.getOption('read.mapping.transformer');
-                if (transformation !== undefined) {
-                    const pipe = new Pipe(transformation);
+                obj = obj.getData();
 
-                    for (const callback of self.getOption('read.mapping.callbacks')) {
-                        pipe.setCallback(callback.constructor.name, callback);
-                    }
+                obj = self.transformServerPayload.call(self, obj);
+                self.set( obj);
+            }
 
-                    obj = pipe.run(obj);
-                }
+            resolve(self.get());
 
-                self.set(obj);
-                return response;
-            }
         })
-    }
+
+    };
+
+    // const self = this;
+    // let response;
+    //
+    // if (self[webConnectSymbol]?.socket?.readyState !== 1) {
+    //     return Promise.reject('The connection is not established.');
+    // }
+    //
+    // return new Promise((resolve, reject) => {
+    //     if (self[receiveQueueSymbol].isEmpty()) {
+    //         resolve();
+    //     }
+    //
+    //     while (!self[receiveQueueSymbol].isEmpty()) {
+    //
+    //         const event = self[receiveQueueSymbol].poll();
+    //         const body = event?.data;
+    //         if (!body) continue;
+    //
+    //         let obj;
+    //         try {
+    //             obj = JSON.parse(body);
+    //         } catch (e) {
+    //
+    //             let msg = 'the response does not contain a valid json (actual: ';
+    //
+    //             if (body.length > 100) {
+    //                 msg += body.substring(0, 97) + '...';
+    //             } else {
+    //                 msg += body;
+    //             }
+    //
+    //             msg += "; " + e.message + ')';
+    //
+    //             reject(msg);
+    //             return;
+    //         }
+    //
+    //         obj = self.transformServerPayload.call(self, obj);
+    //
+    //
+    //         self.set(obj);
+    //         return response;
+    //     }
+    // })
+//}
 
     /**
-     * @return {Promise}
+     * This prepares the data that comes from the server.
+     * Should not be called directly.
+     *
+     * @private
+     * @param {Object} payload
+     * @returns {Object}
      */
-    write() {
+    transformServerPayload(payload) {
         const self = this;
-        
-        if (self[connectionSymbol]?.socket?.readyState!==1) {
-            return Promise.reject('The connection is not established.');
+        payload = doTransform.call(self, 'read', payload);
+
+        const dataPath = self.getOption('read.path');
+        if (dataPath) {
+            payload = (new Pathfinder(payload)).getVia(dataPath);
         }
 
-        let obj = self.get();
-        let transformation = self.getOption('write.mapping.transformer');
-        if (transformation !== undefined) {
-            const pipe = new Pipe(transformation);
+        return payload;
+    }
 
-            for (const callback of self.getOption('write.mapping.callbacks')) {
-                pipe.setCallback(callback.constructor.name, callback);
-            }
+    /**
+     * This prepares the data for writing and should not be called directly.
+     *
+     * @private
+     * @param {Object} payload
+     * @returns {Object}
+     */
+    prepareServerPayload(payload) {
+        const self = this;
 
-            obj = pipe.run(obj);
-        }
+        payload = doTransform.call(self, 'write', payload);
 
         let sheathingObject = self.getOption('write.sheathing.object');
         let sheathingPath = self.getOption('write.sheathing.path');
-        let reportPath = self.getOption('write.report.path');
 
         if (sheathingObject && sheathingPath) {
-            const sub = obj;
-            obj = sheathingObject;
-            (new Pathfinder(obj)).setVia(sheathingPath, sub);
+            const sub = payload;
+            payload = sheathingObject;
+            (new Pathfinder(payload)).setVia(sheathingPath, sub);
         }
 
-        return new Promise((resolve, reject) => {
-            
-            if (self[connectionSymbol].socket.readyState !== 1) {
-                reject('the socket is not ready');
-            }
+        return payload;
+    }
 
-            self[connectionSymbol].socket.send(JSON.stringify(obj))
-            resolve();
-        });
+    /**
+     * @return {Promise}
+     */
+    write() {
+        const self = this;
+        let obj = self.prepareServerPayload(self.get());
+        return self[webConnectSymbol].send(obj)
     }
 
 

package/source/net/webconnect/message.mjs

@@ -0,0 +1,55 @@
+/**
+ * Copyright schukai GmbH and contributors 2022. All Rights Reserved.
+ * Node module: @schukai/monster
+ * This file is licensed under the AGPLv3 License.
+ * License text available at https://www.gnu.org/licenses/agpl-3.0.en.html
+ */
+
+import {Base} from "../../types/base.mjs";
+import {validateObject, validateString} from "../../types/validate.mjs";
+
+export {Message}
+
+const dataSymbol = Symbol("@@data");
+
+/**
+ * This class represents a WebSocket message.
+ */
+class Message extends Base {
+
+    /**
+     * @param {Object} data
+     * @throws {TypeError} value is not a object
+     */
+    constructor(data) {
+        super();
+        this[dataSymbol] = validateObject(data);
+    }
+    
+    /**
+     * Returns the raw message.
+     * 
+     * @returns {object}
+     */
+    getData() {
+        return this[dataSymbol];
+    }
+
+    /**
+     * @returns {*}
+     */
+    toJSON() {
+        return this[dataSymbol];
+    }
+
+    /**
+     * @param {string} json
+     * @returns {Message}
+     * @throws {TypeError} value is not a string
+     */
+    static fromJSON(json) {
+        validateString(json);
+        return new Message(JSON.parse(json));
+    }
+
+}