neo.mjs 4.0.5 → 4.0.8

package/examples/remotesApi/basic/remotes-api-response.json

@@ -0,0 +1,3 @@
+{
+    "success": true
+}

package/examples/remotesApi/basic/remotes-api.json

@@ -1,16 +1,17 @@
 {
     "namespace": "MyApi",
-    "url"      : "./",
+    "url"      : "../../examples/remotesApi/basic/remotes-api-response.json",
 
-    "services": [{
-        "name"   : "FriendService",
-        "methods": [{
-            "name": "getAll"
-        }]
-    }, {
-        "name"   : "UserService",
-        "methods": [{
-            "name": "getAll"
-        }]
-    }]
+    "services": {
+        "FriendService": {
+            "methods": {
+                "getAll": {}
+            }
+        },
+        "UserService": {
+            "methods": {
+                "getAll": {}
+            }
+        }
+    }
 }

package/examples/tab/container/neo-config.json

@@ -3,5 +3,5 @@
     "basePath"   : "../../../",
     "environment": "development",
     "mainPath"   : "./Main.mjs",
-    "themes"     : ["neo-theme-dark"]
+    "themes"     : ["neo-theme-dark", "neo-theme-light"]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "neo.mjs",
-    "version": "4.0.5",
+    "version": "4.0.8",
     "description": "The webworkers driven UI framework",
     "type": "module",
     "repository": {
@@ -40,16 +40,16 @@
         "autoprefixer": "^10.4.4",
         "chalk": "^5.0.1",
         "clean-webpack-plugin": "^4.0.0",
-        "commander": "^9.1.0",
+        "commander": "^9.2.0",
         "cssnano": "^5.1.7",
         "envinfo": "^7.8.1",
-        "fs-extra": "^10.0.1",
+        "fs-extra": "^10.1.0",
         "highlightjs-line-numbers.js": "^2.8.0",
         "inquirer": "^8.2.2",
         "neo-jsdoc": "^1.0.1",
         "neo-jsdoc-x": "^1.0.4",
         "postcss": "^8.4.12",
-        "sass": "^1.50.0",
+        "sass": "^1.50.1",
         "webpack": "^5.72.0",
         "webpack-cli": "^4.9.2",
         "webpack-dev-server": "4.8.1",

package/src/collection/Base.mjs

@@ -705,7 +705,7 @@ class Base extends CoreBase {
     /**
      * Returns all items which match the property and value
      * @param {Object|String} property
-     * @param {String|Number} value
+     * @param {String|Number} [value] Optional, in case the first param is an object
      * @returns {Array} Returns an empty Array in case no items are found
      */
     find(property, value) {

package/src/data/connection/Fetch.mjs

@@ -95,24 +95,30 @@ class Fetch extends Base {
         if (!Neo.isString(url)) {
             config = url;
             url    = config.url;
+        } else {
+            config.url = config;
         }
 
-        return fetch(url)
-            .then(resp => {
-                console.log(resp);
+        return fetch(url, {
+            body  : data,
+            method: method || config.method
+        }).then(resp => {
+            let response = {
+                ok        : resp.ok,
+                redirected: resp.redirected,
+                request   : config,
+                status    : resp.status,
+                statusText: resp.statusText,
+                type      : resp.type,
+                url       : resp.url
+            };
 
-                let response = {
-                    ok        : resp.ok,
-                    redirected: resp.redirected,
-                    request   : config,
-                    status    : resp.status,
-                    statusText: resp.statusText,
-                    type      : resp.type,
-                    url       : resp.url
-                };
-
-                return response
-            })
+            return resp[config.responseType || 'json']()
+                .then(data => {
+                    response.data = data;
+                })
+                .then(() => (resp.ok ? response : Promise.reject(response)));
+        })
     }
 }
 

package/src/data/connection/WebSocket.mjs

@@ -0,0 +1,227 @@
+import Base        from '../../core/Base.mjs';
+import NeoFunction from '../../util/Function.mjs';
+import Observable  from '../../core/Observable.mjs';
+
+/**
+ * @class Neo.data.connection.WebSocket
+ * @extends Neo.core.Base
+ */
+class Socket extends Base {
+    /**
+     * @member {String|null} channel=null
+     */
+    channel = null
+    /**
+     * @member {Number} maxReconnectAttempts=5
+     */
+    maxReconnectAttempts = 5
+    /**
+     * @member {Number} reconnectAttempts=0
+     * @protected
+     */
+    reconnectAttempts = 0
+    /**
+     * @member {String|null} serverAddress=null
+     */
+    serverAddress = null
+
+    static getStaticConfig() {return {
+        /**
+         * True automatically applies the core.Observable mixin
+         * @member {Boolean} observable=true
+         * @static
+         */
+        observable: true
+    }}
+
+    static getConfig() {return {
+        /**
+         * @member {String} className='Neo.data.connection.WebSocket'
+         * @protected
+         */
+        className: 'Neo.data.connection.WebSocket',
+        /**
+         * @member {String} ntype='socket-connection'
+         * @protected
+         */
+        ntype: 'socket-connection',
+        /**
+         * @member {WebSocket|null} socket_=null
+         * @protected
+         */
+        socket_: null
+    }}
+
+    /**
+     * @param {Object} config
+     */
+    construct(config) {
+        super.construct(config);
+        this.createSocket();
+    }
+
+    /**
+     * @param {Function} callback
+     * @param {Object} scope
+     */
+    attemptReconnect(callback, scope) {
+        let me = this;
+
+        me.reconnectAttempts++;
+
+        if (me.reconnectAttempts < me.maxReconnectAttempts) {
+            me.createSocket();
+
+            callback && me.on('open', {
+                callback,
+                scope : scope || me,
+                single: true
+            });
+        }
+    }
+
+    /**
+     * Intercepts the WebSocket send calls
+     * @param {Object} data
+     * @returns {String}
+     */
+    beforeSend(data) {
+        let me      = this,
+            channel = me.channel;
+
+        console.log('WS: Sending message', (channel ? '\nChannel: ' + channel : ''), '\nData:', data);
+
+        return JSON.stringify(channel ? {channel, data} : data);
+    }
+
+    /**
+     * Triggered before the socket config gets changed.
+     * @param {WebSocket|null} value
+     * @param {WebSocket|null} oldValue
+     * @returns {WebSocket|null}
+     * @protected
+     */
+    beforeSetSocket(value, oldValue) {
+        if (value) {
+            let me = this;
+
+            Object.assign(value, {
+                onclose  : me.onClose  .bind(me),
+                onerror  : me.onError  .bind(me),
+                onmessage: me.onMessage.bind(me),
+                onopen   : me.onOpen   .bind(me)
+            });
+
+            NeoFunction.createInterceptor(value, 'send', me.beforeSend, me);
+        }
+
+        return value;
+    }
+
+    /**
+     * @param {Number} [code] defaults to 1000
+     * @param {String} [reason]
+     */
+    close(code, reason) {
+        this.socket.close(code, reason);
+    }
+
+    /**
+     *
+     */
+    createSocket() {
+        this.socket = new WebSocket(this.serverAddress);
+    }
+
+    /**
+     *
+     */
+    destroy(...args) {
+        this.close();
+        super.destroy(...args);
+    }
+
+    /**
+     * @param {CloseEvent} event The Websocket generated CloseEvent
+     * @param {Number}     event.code The WebSocket connection close code provided by the server
+     *
+     *        Code        Name                  Description
+     *        0-999                             Reserved and not used.
+     *        1000        CLOSE_NORMAL          Normal closure; the connection successfully completed whatever purpose for which it was created.
+     *        1001        CLOSE_GOING_AWAY      The endpoint is going away, either because of a server failure or because the browser is navigating away from the page that opened the connection.
+     *        1002        CLOSE_PROTOCOL_ERROR  The endpoint is terminating the connection due to a protocol error.
+     *        1003        CLOSE_UNSUPPORTED     The connection is being terminated because the endpoint received data of a type it cannot accept (for example, a text-only endpoint received binary data).
+     *        1004        CLOSE_TOO_LARGE       The endpoint is terminating the connection because a data frame was received that is too large.
+     *        1005        CLOSE_NO_STATUS       Reserved.  Indicates that no status code was provided even though one was expected.
+     *        1006        CLOSE_ABNORMAL        Reserved. Used to indicate that a connection was closed abnormally (that is, with no close frame being sent) when a status code is expected.
+     *        1007-1999                         Reserved for future use by the WebSocket standard.
+     *        2000-2999                         Reserved for use by WebSocket extensions.
+     *        3000-3999                         Available for use by libraries and frameworks. May not be used by applications.
+     *        4000-4999                         Available for use by applications.
+     *
+     * @param {String}     reason A string indicating the reason the server closed the connection. This is specific to the particular server and sub-protocol.
+     * @param {Boolean}    wasClean Indicates whether or not the connection was cleanly closed.
+     */
+    onClose(event, reason, wasClean) {
+        console.log('onClose', event, reason, wasClean);
+    }
+
+    /**
+     *
+     */
+    onError() {
+        console.log('onError', arguments);
+    }
+
+    /**
+     * @param {MessageEvent} event
+     */
+    onMessage(event) {
+        let data = JSON.parse(event.data);
+
+        console.log('onMessage', data);
+    }
+
+    /**
+     *
+     */
+    onOpen() {
+        this.fire('open', {scope: this});
+    }
+
+    /**
+     * @param {Object} data
+     */
+    sendMessage(data) {
+        let me     = this,
+            socket = me.socket,
+            d      = data;
+
+        // CONNECTING  0   The connection is not yet open.
+        // OPEN        1   The connection is open and ready to communicate.
+        // CLOSING     2   The connection is in the process of closing.
+        // CLOSED      3   The connection is closed or couldn't be opened.
+
+        // If socket is not yet ready let's defer to open then resend
+        switch (socket.readyState) {
+            case WebSocket.CLOSED:
+            case WebSocket.CLOSING:
+                me.attemptReconnect(function() {
+                    me.send(d);
+                });
+                break;
+            case WebSocket.CONNECTING:
+                me.on('open', function() {
+                    me.send(d);
+                }, me, {single: true});
+                break;
+            case WebSocket.OPEN:
+                socket.send(data);
+                break;
+        }
+    }
+}
+
+Neo.applyClassConfig(Socket);
+
+export default Socket;

package/src/manager/RpcApi.mjs

@@ -0,0 +1,46 @@
+import Base from './Base.mjs';
+
+/**
+ * @class Neo.manager.RpcApi
+ * @extends Neo.manager.Base
+ * @singleton
+ */
+class RpcApi extends Base {
+    static getConfig() {return {
+        /**
+         * @member {String} className='Neo.manager.RpcApi'
+         * @protected
+         */
+        className: 'Neo.manager.RpcApi',
+        /**
+         * @member {Boolean} singleton=true
+         * @protected
+         */
+        singleton: true
+    }}
+
+    /**
+     * Registers each service & method combination into the collection
+     * @param api
+     */
+    registerApi(api) {
+        Object.entries(api.services).forEach(([service, serviceValue]) => {
+            Object.entries(serviceValue.methods).forEach(([method, methodValue]) => {
+                this.register({
+                    id : `${service}.${method}`,
+                    method,
+                    service,
+                    url: methodValue.url || serviceValue.url || api.url
+                })
+            })
+        })
+    }
+}
+
+Neo.applyClassConfig(RpcApi);
+
+let instance = Neo.create(RpcApi);
+
+Neo.applyToGlobalNs(instance);
+
+export default instance;

package/src/manager/RpcMessage.mjs

@@ -0,0 +1,135 @@
+import Base     from './Base.mjs';
+import NeoArray from '../util/Array.mjs';
+
+/**
+ * @class Neo.manager.RpcMessage
+ * @extends Neo.manager.Base
+ * @singleton
+ */
+class RpcMessage extends Base {
+    /**
+     * Stores the urls of endpoints for which a setTimeout() call is in progress
+     * @member {String[]} endPointTimeouts=[]
+     */
+    endPointTimeouts = []
+    /**
+     * internal incrementing flag
+     * @member {Number} messageId=1
+     * @protected
+     */
+    messageId = 1
+    /**
+     * Time window in ms for buffering incoming message requests
+     * @member {Number} requestBuffer=20
+     */
+    requestBuffer = 20
+    /**
+     * internal incrementing flag
+     * @member {Number} transactionId=1
+     * @protected
+     */
+    transactionId = 1
+
+    static getConfig() {return {
+        /**
+         * @member {String} className='Neo.manager.RpcMessage'
+         * @protected
+         */
+        className: 'Neo.manager.RpcMessage',
+        /**
+         * @member {Boolean} singleton=true
+         * @protected
+         */
+        singleton: true,
+        /**
+         * @member {Object[]} sorters
+         */
+        sorters: [{
+            direction: 'ASC',
+            property : 'id'
+        }]
+    }}
+
+    /**
+     *
+     * @param {Object} msg
+     * @returns {Promise<any>}
+     */
+    onMessage(msg) {
+        return new Promise((resolve, reject) => {
+            let me     = this,
+                method = Neo.manager.RpcApi.get(`${msg.service}.${msg.method}`),
+                url    = method.url;
+
+            me.register({
+                id           : me.messageId,
+                method       : msg.method,
+                params       : msg.params,
+                reject,
+                resolve,
+                service      : msg.service,
+                transactionId: 0,
+                url
+            });
+
+            me.messageId++;
+
+            if (!me.endPointTimeouts.includes(url)) {
+                me.endPointTimeouts.push(url);
+
+                setTimeout(() => {
+                    me.resolveBufferTimeout(url);
+                }, me.requestBuffer)
+            }
+        });
+    }
+
+    /**
+     * @param {String} url
+     */
+    async resolveBufferTimeout(url) {
+        let me            = this,
+            itemIds       = [],
+            processItems  = me.find({transactionId: 0, url}),
+            requests      = [],
+            transactionId = me.transactionId,
+            response;
+
+        processItems.forEach(item => {
+            item.transactionId = transactionId;
+
+            itemIds.push(item.id);
+
+            requests.push({
+                id     : item.id,
+                method : item.method,
+                params : item.params,
+                service: item.service
+            });
+        });
+
+        NeoArray.remove(me.endPointTimeouts, url);
+
+        me.transactionId++;
+
+        response = await Neo.Fetch.request(url, {}, 'post', JSON.stringify({tid: transactionId, requests}));
+
+        processItems.forEach(item => {
+            // todo: pass the item which is included inside the response object
+            // todo: reject the Promise in case the item is missing
+
+            item.resolve();
+        });
+
+        // todo: remove only the items which are included inside the response
+        me.remove(itemIds);
+    }
+}
+
+Neo.applyClassConfig(RpcMessage);
+
+let instance = Neo.create(RpcMessage);
+
+Neo.applyToGlobalNs(instance);
+
+export default instance;

package/src/remotes/Api.mjs

@@ -51,21 +51,25 @@ class Api extends Base {
 
         fetch(path)
             .then(response => response.json())
-            .then(data => {this.register(data)})
+            .then(data => {
+                Neo.currentWorker.sendMessage('data', {action: 'registerApi', data});
+                this.register(data)
+            })
     }
 
     /**
-     * @param {Object} data
+     * @param {Object} api
      */
-    register(data) {
-        let method, ns, service;
+    register(api) {
+        let ns;
 
-        for (service of data.services) {
-            for (method of service.methods) {
-                ns = Neo.ns(`${data.namespace}.${service.name}`, true);
-                ns[method.name] = this.generateRemote(service.name, method.name);
-            }
-        }
+        Object.entries(api.services).forEach(([service, serviceValue]) => {
+            ns = Neo.ns(`${api.namespace}.${service}`, true);
+
+            Object.entries(serviceValue.methods).forEach(([method, methodValue]) => {
+                ns[method] = this.generateRemote(service, method);
+            })
+        })
     }
 }
 

package/src/util/Function.mjs

@@ -27,6 +27,22 @@ class NeoFunction extends Base {
         }
     }
 
+    /**
+     * Intended for functions with 1 param where the interceptor can change the value
+     * @param {Object} target
+     * @param {String} targetMethodName
+     * @param {Function} interceptFunction
+     * @param {Object} scope=target
+     * @returns {Function}
+     */
+    static createInterceptor(target, targetMethodName, interceptFunction, scope) {
+        let targetMethod = target[targetMethodName];
+
+        return (target[targetMethodName] = function(value) {
+            return targetMethod.call(target, interceptFunction.call(scope || target, value));
+        });
+    }
+
     /**
      * @param {Neo.core.Base} target
      * @param {String} methodName
@@ -44,20 +60,21 @@ class NeoFunction extends Base {
     }
 
     /**
-     * @param {Neo.core.Base} target
-     * @param {String} methodName
-     * @param {Function} fn
-     * @param {Object} scope
+     * The interceptor can prevent the targetMethod from getting executed in case it returns false.
+     * @param {Object} target
+     * @param {String} targetMethodName
+     * @param {Function} interceptFunction
+     * @param {Object} scope=target
+     * @param {*} preventedReturnValue=null The value to return in case the interceptFunction returns false
      * @returns {Function}
      */
-    static intercept(target, methodName, fn, scope) {
-        let method = target[methodName] || Neo.emptyFn;
-
-        return (target[methodName] = function() {
-            let returnValue = fn.apply(scope || this, arguments);
-            method.apply(this, arguments);
+    static intercept(target, targetMethodName, interceptFunction, scope, preventedReturnValue=null) {
+        let targetMethod = target[targetMethodName];
 
-            return returnValue;
+        return (target[targetMethodName] = function() {
+            return (interceptFunction.apply(scope || target, arguments) === false)
+                ? preventedReturnValue
+                : targetMethod.apply(target, arguments);
         });
     }
 }

package/src/worker/Data.mjs

@@ -15,10 +15,15 @@ import Xhr          from '../Xhr.mjs';
  */
 class Data extends Base {
     /**
-     * @member {Boolean} remotesManagerLoaded=false
+     * @member {Boolean} rpcApiManagerLoaded=false
      * @protected
      */
-    remotesManagerLoaded = false
+    rpcApiManagerLoaded = false
+    /**
+     * @member {Boolean} rpcMessageManagerLoaded=false
+     * @protected
+     */
+    rpcMessageManagerLoaded = false
 
     static getConfig() {return {
         /**
@@ -60,14 +65,25 @@ class Data extends Base {
         console.log('worker.Data onLoad');
     }
 
+    /**
+     * @param {Object} msg
+     * @param {Object} msg.data the API content
+     */
+    onRegisterApi(msg) {
+        import('../manager/RpcApi.mjs').then(module => {
+            module.default.registerApi(msg.data);
+            this.rpcApiManagerLoaded = true
+        })
+    }
+
     /**
      * @param {Object} msg
      */
     onRegisterNeoConfig(msg) {
         super.onRegisterNeoConfig(msg);
 
-        Neo.config.remotesApiUrl && import('../manager/RemotesApi.mjs').then(module => {
-            this.remotesManagerLoaded = true
+        Neo.config.remotesApiUrl && import('../manager/RpcMessage.mjs').then(module => {
+            this.rpcMessageManagerLoaded = true
         })
     }
 
@@ -80,13 +96,13 @@ class Data extends Base {
         let me = this,
             response;
 
-        if (!me.remotesManagerLoaded) {
+        if (!me.rpcMessageManagerLoaded) {
             // todo: we could store calls which arrive too early and pass them to the manager once it is ready
             console.warn('manager.RemotesApi not loaded yet', msg);
 
             me.reject(msg);
         } else {
-            response = await Neo.manager.RemotesApi.onMessage(msg);
+            response = await Neo.manager.RpcMessage.onMessage(msg);
 
             me.resolve(msg, response);
         }

package/src/data/connection/Socket.mjs

@@ -1,24 +0,0 @@
-import Base from '../../core/Base.mjs';
-
-/**
- * @class Neo.data.connection.Socket
- * @extends Neo.core.Base
- */
-class Socket extends Base {
-    static getConfig() {return {
-        /**
-         * @member {String} className='Neo.data.connection.Socket'
-         * @protected
-         */
-        className: 'Neo.data.connection.Socket',
-        /**
-         * @member {String} ntype='socket-connection'
-         * @protected
-         */
-        ntype: 'socket-connection'
-    }}
-}
-
-Neo.applyClassConfig(Socket);
-
-export default Socket;

package/src/manager/RemotesApi.mjs

@@ -1,40 +0,0 @@
-import Base from './Base.mjs';
-
-/**
- * @class Neo.manager.RemotesApi
- * @extends Neo.manager.Base
- * @singleton
- */
-class RemotesApi extends Base {
-    static getConfig() {return {
-        /**
-         * @member {String} className='Neo.manager.RemotesApi'
-         * @protected
-         */
-        className: 'Neo.manager.RemotesApi',
-        /**
-         * @member {Boolean} singleton=true
-         * @protected
-         */
-        singleton: true
-    }}
-
-    /**
-     *
-     * @param msg
-     * @returns {Promise<any>}
-     */
-    async onMessage(msg) {
-        let response = await Neo.Fetch.get(msg);
-
-        return response;
-    }
-}
-
-Neo.applyClassConfig(RemotesApi);
-
-let instance = Neo.create(RemotesApi);
-
-Neo.applyToGlobalNs(instance);
-
-export default instance;