@ti-engine/core 1.6.1 → 1.7.2

package/components/exchange/message-memory-cache.js

@@ -1,191 +1,191 @@
-/*
- * The ti-engine is an open source, free to use—both for personal and commercial projects—framework for the creation of microservice-based solutions using node.js.
- * Copyright © 2021-2026 Boris Kostadinov <kostadinov.boris@gmail.com>
- * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
- * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
- * You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
-
-const config = require( "#config" );
-const tools = require( "#tools" );
-const exceptions = require( "#exceptions" );
-const redis = require( "#redis-integration" );
-
-/**
- * Used to create a Redis Cache client wrapped in a specialized message memory cache interface.
- *
- * @class MessageMemoryCache
- * @public
- */
-class MessageMemoryCache {
-
-    #redisClient = null;
-    #isShuttingDown = false;
-
-    /**
-     * @constructor
-     * @param {string} identifier The connection identifier for the Redis connection.
-     * @returns {MessageMemoryCache}
-     */
-    constructor( identifier ) {
-        this.#redisClient = redis.createRedisClient( identifier );
-    }
-
-    /* Public interface */
-
-    /**
-     * Used to initialize the cache service.
-     *
-     * @method
-     * @returns {Promise}
-     * @public
-     */
-    initialize() {
-        let host = config.getSetting( config.setting.MEMORY_CACHE_REDIS_HOST );
-        let port = config.getSetting( config.setting.MEMORY_CACHE_REDIS_PORT );
-        let db = config.getSetting( config.setting.MEMORY_CACHE_REDIS_DB );
-        let authKey = config.getSetting( config.setting.MEMORY_CACHE_AUTH_KEY );
-        let user = config.getSetting( config.setting.MEMORY_CACHE_USER );
-        let retryMaxAttempts = config.getSetting( config.setting.MEMORY_CACHE_RETRY_MAX_ATTEMPTS );
-        let retryMaxInterval = config.getSetting( config.setting.MEMORY_CACHE_RETRY_MAX_INTERVAL );
-
-        return this.#redisClient.initialize( host, port, authKey, user, db, retryMaxInterval, retryMaxAttempts );
-    }
-
-    /**
-     * Used to gracefully shut down the cache service.
-     *
-     * @method
-     * @param {number} [timeoutMs]
-     * @returns {Promise}
-     * @public
-     */
-    shutDown( timeoutMs ) {
-        this.#isShuttingDown = true;
-        return this.#redisClient.shutDown( timeoutMs );
-    }
-
-    /**
-     * Used to register a new {@link ConnectionObserver} for events related to the Redis connection state.
-     *
-     * @method
-     * @param {ConnectionObserver} connectionObserver The {@link ConnectionObserver} that will be notified of any changes.
-     * @public
-     */
-    addConnectionObserver( connectionObserver ) {
-        this.#redisClient.addConnectionObserver( connectionObserver );
-    }
-
-    /**
-     * Used to send a message to the specified route.
-     *
-     * @method
-     * @param {Message} message The message to send.
-     * @param {string} queue The destination queue for the message as recognized by the {@link MessageExchange} implementation.
-     * @returns {Promise<number>} Will return the destination queue length after adding the current message to it.
-     * @public
-     */
-    sendMessage( message, queue ) {
-        return new Promise( ( resolve, reject ) => {
-            if ( this.#isShuttingDown === true ) {
-                reject( exceptions.raise( exceptions.exceptionCode.E_COM_MESSAGE_SENDER_UNAVAILABLE ) );
-            } else {
-                let command = [ redis.cacheCommands.LIST_PUSH, queue, tools.stringifyJSON( message ) ];
-                this.#redisClient.executeCommands( [ command ] ).then( ( results ) => {
-                    results = results[ 0 ];
-                    resolve( ( results && results.length > 1 ) ? results[ 1 ] : undefined );
-                } ).catch( ( error ) => {
-                    reject( exceptions.raise( error ) );
-                } );
-            }
-        } );
-    }
-
-    /**
-     * Used to store a message payload.
-     *
-     * @method
-     * @param {Object} payload
-     * @param {string} storeLocation
-     * @returns {Promise<string>} Will return a unique ID of the storage location for the payload.
-     * @public
-     */
-    storeMessagePayload( payload, storeLocation ) {
-        return new Promise( ( resolve, reject ) => {
-            if ( payload ) {
-                let storeID = tools.getUUID();
-                let command = [ redis.cacheCommands.HASH_SET, storeLocation, storeID, tools.stringifyJSON( payload ) ];
-                this.#redisClient.executeCommands( [ command ] ).then( () => {
-                    resolve( storeID );
-                } ).catch( ( error ) => {
-                    reject( exceptions.raise( error ) );
-                } );
-            } else {
-                resolve();
-            }
-        } );
-    }
-
-    /**
-     * Used to receive a message from the specified queue.
-     *
-     * @method
-     * @param {string} queue
-     * @returns {Promise<Message>}
-     * @public
-     */
-    receiveMessage( queue ) {
-        return new Promise( ( resolve, reject ) => {
-            this.#redisClient.blockingCommand( redis.cacheCommands.LIST_POP_TAIL_BLOCKING, [ queue, 0 ] ).then( ( results ) => {
-                results = ( results && results.length > 1 ) ? results[ 1 ] : undefined;
-                resolve( tools.parseJSON( results ) );
-            } ).catch( ( error ) => {
-                if ( this.#isShuttingDown === true ) {
-                    reject( exceptions.raise( exceptions.exceptionCode.E_COM_MESSAGE_RECEIVER_UNAVAILABLE ) );
-                } else {
-                    reject( exceptions.raise( error ) );
-                }
-            } );
-        } );
-    }
-
-    /**
-     * Used to retrieve a message payload by its store ID.
-     *
-     * @method
-     * @param {Message} message
-     * @param {string} storeLocation
-     * @returns {Promise<Message>} Will return the message with its payload populated if such is found.
-     * @public
-     */
-    retrieveMessagePayload( message, storeLocation ) {
-        return new Promise( ( resolve, reject ) => {
-            if ( message.payload ) {
-                let command1 = [ redis.cacheCommands.HASH_GET, storeLocation, message.payload ];
-                let command2 = [ redis.cacheCommands.HASH_REMOVE, storeLocation, message.payload ];
-                this.#redisClient.executeCommands( [ command1, command2 ] ).then( ( results ) => {
-                    results = results[ 0 ];
-                    message.payload = ( results && results.length > 1 ) ? tools.parseJSON( results[ 1 ] ) : undefined;
-                    resolve( message );
-                } ).catch( ( error ) => {
-                    reject( exceptions.raise( error ) );
-                } );
-            } else {
-                resolve( message );
-            }
-        } );
-    }
-
-}
-
-/**
- * Used to create a new message memory cache.
- *
- * @method
- * @param {string} identifier The connection identifier for the Redis connection.
- * @returns {MessageMemoryCache}
- * @public
- */
-module.exports.create = ( identifier ) => {
-    return Object.freeze( new MessageMemoryCache( identifier ) );
+/*
+ * The ti-engine is an open source, free to use—both for personal and commercial projects—framework for the creation of microservice-based solutions using node.js.
+ * Copyright © 2021-2026 Boris Kostadinov <kostadinov.boris@gmail.com>
+ * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+const config = require( "#config" );
+const tools = require( "#tools" );
+const exceptions = require( "#exceptions" );
+const redis = require( "#redis-integration" );
+
+/**
+ * Used to create a Redis Cache client wrapped in a specialized message memory cache interface.
+ *
+ * @class MessageMemoryCache
+ * @public
+ */
+class MessageMemoryCache {
+
+    #redisClient = null;
+    #isShuttingDown = false;
+
+    /**
+     * @constructor
+     * @param {string} identifier The connection identifier for the Redis connection.
+     * @returns {MessageMemoryCache}
+     */
+    constructor( identifier ) {
+        this.#redisClient = redis.createRedisClient( identifier );
+    }
+
+    /* Public interface */
+
+    /**
+     * Used to initialize the cache service.
+     *
+     * @method
+     * @returns {Promise}
+     * @public
+     */
+    initialize() {
+        let host = config.getSetting( config.setting.MEMORY_CACHE_REDIS_HOST );
+        let port = config.getSetting( config.setting.MEMORY_CACHE_REDIS_PORT );
+        let db = config.getSetting( config.setting.MEMORY_CACHE_REDIS_DB );
+        let authKey = config.getSetting( config.setting.MEMORY_CACHE_AUTH_KEY );
+        let user = config.getSetting( config.setting.MEMORY_CACHE_USER );
+        let retryMaxAttempts = config.getSetting( config.setting.MEMORY_CACHE_RETRY_MAX_ATTEMPTS );
+        let retryMaxInterval = config.getSetting( config.setting.MEMORY_CACHE_RETRY_MAX_INTERVAL );
+
+        return this.#redisClient.initialize( host, port, authKey, user, db, retryMaxInterval, retryMaxAttempts );
+    }
+
+    /**
+     * Used to gracefully shut down the cache service.
+     *
+     * @method
+     * @param {number} [timeoutMs]
+     * @returns {Promise}
+     * @public
+     */
+    shutDown( timeoutMs ) {
+        this.#isShuttingDown = true;
+        return this.#redisClient.shutDown( timeoutMs );
+    }
+
+    /**
+     * Used to register a new {@link ConnectionObserver} for events related to the Redis connection state.
+     *
+     * @method
+     * @param {ConnectionObserver} connectionObserver The {@link ConnectionObserver} that will be notified of any changes.
+     * @public
+     */
+    addConnectionObserver( connectionObserver ) {
+        this.#redisClient.addConnectionObserver( connectionObserver );
+    }
+
+    /**
+     * Used to send a message to the specified route.
+     *
+     * @method
+     * @param {Message} message The message to send.
+     * @param {string} queue The destination queue for the message as recognized by the {@link MessageExchange} implementation.
+     * @returns {Promise<number>} Will return the destination queue length after adding the current message to it.
+     * @public
+     */
+    sendMessage( message, queue ) {
+        return new Promise( ( resolve, reject ) => {
+            if ( this.#isShuttingDown === true ) {
+                reject( exceptions.raise( exceptions.exceptionCode.E_COM_MESSAGE_SENDER_UNAVAILABLE ) );
+            } else {
+                let command = [ redis.cacheCommands.LIST_PUSH, queue, tools.stringifyJSON( message ) ];
+                this.#redisClient.executeCommands( [ command ] ).then( ( results ) => {
+                    results = results[ 0 ];
+                    resolve( ( results && results.length > 1 ) ? results[ 1 ] : undefined );
+                } ).catch( ( error ) => {
+                    reject( exceptions.raise( error ) );
+                } );
+            }
+        } );
+    }
+
+    /**
+     * Used to store a message payload.
+     *
+     * @method
+     * @param {Object} payload
+     * @param {string} storeLocation
+     * @returns {Promise<string>} Will return a unique ID of the storage location for the payload.
+     * @public
+     */
+    storeMessagePayload( payload, storeLocation ) {
+        return new Promise( ( resolve, reject ) => {
+            if ( payload ) {
+                let storeID = tools.getUUID();
+                let command = [ redis.cacheCommands.HASH_SET, storeLocation, storeID, tools.stringifyJSON( payload ) ];
+                this.#redisClient.executeCommands( [ command ] ).then( () => {
+                    resolve( storeID );
+                } ).catch( ( error ) => {
+                    reject( exceptions.raise( error ) );
+                } );
+            } else {
+                resolve();
+            }
+        } );
+    }
+
+    /**
+     * Used to receive a message from the specified queue.
+     *
+     * @method
+     * @param {string} queue
+     * @returns {Promise<Message>}
+     * @public
+     */
+    receiveMessage( queue ) {
+        return new Promise( ( resolve, reject ) => {
+            this.#redisClient.blockingCommand( redis.cacheCommands.LIST_POP_TAIL_BLOCKING, [ queue, 0 ] ).then( ( results ) => {
+                results = ( results && results.length > 1 ) ? results[ 1 ] : undefined;
+                resolve( tools.parseJSON( results ) );
+            } ).catch( ( error ) => {
+                if ( this.#isShuttingDown === true ) {
+                    reject( exceptions.raise( exceptions.exceptionCode.E_COM_MESSAGE_RECEIVER_UNAVAILABLE ) );
+                } else {
+                    reject( exceptions.raise( error ) );
+                }
+            } );
+        } );
+    }
+
+    /**
+     * Used to retrieve a message payload by its store ID.
+     *
+     * @method
+     * @param {Message} message
+     * @param {string} storeLocation
+     * @returns {Promise<Message>} Will return the message with its payload populated if such is found.
+     * @public
+     */
+    retrieveMessagePayload( message, storeLocation ) {
+        return new Promise( ( resolve, reject ) => {
+            if ( message.payload ) {
+                let command1 = [ redis.cacheCommands.HASH_GET, storeLocation, message.payload ];
+                let command2 = [ redis.cacheCommands.HASH_REMOVE, storeLocation, message.payload ];
+                this.#redisClient.executeCommands( [ command1, command2 ] ).then( ( results ) => {
+                    results = results[ 0 ];
+                    message.payload = ( results && results.length > 1 ) ? tools.parseJSON( results[ 1 ] ) : undefined;
+                    resolve( message );
+                } ).catch( ( error ) => {
+                    reject( exceptions.raise( error ) );
+                } );
+            } else {
+                resolve( message );
+            }
+        } );
+    }
+
+}
+
+/**
+ * Used to create a new message memory cache.
+ *
+ * @method
+ * @param {string} identifier The connection identifier for the Redis connection.
+ * @returns {MessageMemoryCache}
+ * @public
+ */
+module.exports.create = ( identifier ) => {
+    return Object.freeze( new MessageMemoryCache( identifier ) );
 };

package/components/exchange/message-observer.js

@@ -1,127 +1,127 @@
-/*
- * The ti-engine is an open source, free to use—both for personal and commercial projects—framework for the creation of microservice-based solutions using node.js.
- * Copyright © 2021-2026 Boris Kostadinov <kostadinov.boris@gmail.com>
- * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
- * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
- * You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
-
-const ConnectionObserver = require( "#connection-observer" );
-const _ = require( "lodash" );
-const exceptions = require( "#exceptions" );
-
-/**
- * An abstract class that allows the child class to observe and take action on message events.
- * <br/>
- * NOTE: This class inherits {@link ConnectionObserver} so it can also act in that capacity.
- *
- * @class MessageObserver
- * @extends ConnectionObserver
- * @abstract
- * @public
- */
-class MessageObserver extends ConnectionObserver {
-
-    #priority = 0;
-
-    /**
-     * @constructor
-     * @param {number} [priority=0] The priority of this observer. Higher values indicate higher priority.
-     * @throws {TiException.E_GEN_ABSTRACT_CLASS_INIT} If this class is instantiated directly.
-     */
-    constructor( priority = 0 ) {
-        super();
-
-        // make sure this abstract class cannot be instantiated:
-        if ( new.target === MessageObserver ) {
-            throw exceptions.raise( exceptions.exceptionCode.E_GEN_ABSTRACT_CLASS_INIT, { name: this.constructor.name } );
-        }
-
-        this.#priority = _.isNumber( priority ) ? priority : 0;
-    }
-
-    /**
-     * Returns the priority of this observer.
-     * <br/>
-     * NOTE: Higher values indicate higher priority.
-     *
-     * @property
-     * @returns {number}
-     */
-    get priority() {
-        return this.#priority;
-    }
-
-    /**
-     * Used to set the priority of this observer.
-     * <br/>
-     * NOTE: Higher values indicate higher priority.
-     *
-     * @property
-     * @param {number} value
-     */
-    set priority( value ) {
-        this.#priority = _.isNumber( value ) ? value : 0;
-    }
-
-    /**
-     * Needs to be invoked by the message handler once a message enters its logic for processing.
-     * <br/>
-     * NOTE: Override this to add custom functionality.
-     *
-     * @method
-     * @param {string} identifier The identifier of the observed connection.
-     * @param {Message} message The message for processing.
-     * @returns {Message} The message that was received.
-     * @virtual
-     * @public
-     */
-    onMessage( identifier, message ) {
-        return message;
-    }
-
-    /**
-     * Needs to be invoked by the connection handler when the connection is disrupted.
-     * <br/>
-     * NOTE: Override this to add custom functionality.
-     *
-     * @method
-     * @param {string} identifier The identifier of the observed connection.
-     * @virtual
-     * @public
-     */
-    onConnectionDisrupted( identifier ) {
-        super.onConnectionDisrupted( identifier );
-    }
-
-    /**
-     * Needs to be invoked by the connection handler when the connection is recovered.
-     * <br/>
-     * NOTE: Override this to add custom functionality.
-     *
-     * @method
-     * @param {string} identifier The identifier of the observed connection.
-     * @virtual
-     * @public
-     */
-    onConnectionRecovered( identifier ) {
-        super.onConnectionRecovered( identifier );
-    }
-
-    /**
-     * Needs to be invoked by the connection handler when the connection is irrevocably lost.
-     * <br/>
-     * NOTE: Override this to add custom functionality.
-     *
-     * @method
-     * @param {string} identifier The identifier of the observed connection.
-     * @virtual
-     * @public
-     */
-    onConnectionLost( identifier ) {
-        super.onConnectionLost( identifier );
-    }
-
-}
-
+/*
+ * The ti-engine is an open source, free to use—both for personal and commercial projects—framework for the creation of microservice-based solutions using node.js.
+ * Copyright © 2021-2026 Boris Kostadinov <kostadinov.boris@gmail.com>
+ * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+const ConnectionObserver = require( "#connection-observer" );
+const _ = require( "lodash" );
+const exceptions = require( "#exceptions" );
+
+/**
+ * An abstract class that allows the child class to observe and take action on message events.
+ * <br/>
+ * NOTE: This class inherits {@link ConnectionObserver} so it can also act in that capacity.
+ *
+ * @class MessageObserver
+ * @extends ConnectionObserver
+ * @abstract
+ * @public
+ */
+class MessageObserver extends ConnectionObserver {
+
+    #priority = 0;
+
+    /**
+     * @constructor
+     * @param {number} [priority=0] The priority of this observer. Higher values indicate higher priority.
+     * @throws {TiException.E_GEN_ABSTRACT_CLASS_INIT} If this class is instantiated directly.
+     */
+    constructor( priority = 0 ) {
+        super();
+
+        // make sure this abstract class cannot be instantiated:
+        if ( new.target === MessageObserver ) {
+            throw exceptions.raise( exceptions.exceptionCode.E_GEN_ABSTRACT_CLASS_INIT, { name: this.constructor.name } );
+        }
+
+        this.#priority = _.isNumber( priority ) ? priority : 0;
+    }
+
+    /**
+     * Returns the priority of this observer.
+     * <br/>
+     * NOTE: Higher values indicate higher priority.
+     *
+     * @property
+     * @returns {number}
+     */
+    get priority() {
+        return this.#priority;
+    }
+
+    /**
+     * Used to set the priority of this observer.
+     * <br/>
+     * NOTE: Higher values indicate higher priority.
+     *
+     * @property
+     * @param {number} value
+     */
+    set priority( value ) {
+        this.#priority = _.isNumber( value ) ? value : 0;
+    }
+
+    /**
+     * Needs to be invoked by the message handler once a message enters its logic for processing.
+     * <br/>
+     * NOTE: Override this to add custom functionality.
+     *
+     * @method
+     * @param {string} identifier The identifier of the observed connection.
+     * @param {Message} message The message for processing.
+     * @returns {Message} The message that was received.
+     * @virtual
+     * @public
+     */
+    onMessage( identifier, message ) {
+        return message;
+    }
+
+    /**
+     * Needs to be invoked by the connection handler when the connection is disrupted.
+     * <br/>
+     * NOTE: Override this to add custom functionality.
+     *
+     * @method
+     * @param {string} identifier The identifier of the observed connection.
+     * @virtual
+     * @public
+     */
+    onConnectionDisrupted( identifier ) {
+        super.onConnectionDisrupted( identifier );
+    }
+
+    /**
+     * Needs to be invoked by the connection handler when the connection is recovered.
+     * <br/>
+     * NOTE: Override this to add custom functionality.
+     *
+     * @method
+     * @param {string} identifier The identifier of the observed connection.
+     * @virtual
+     * @public
+     */
+    onConnectionRecovered( identifier ) {
+        super.onConnectionRecovered( identifier );
+    }
+
+    /**
+     * Needs to be invoked by the connection handler when the connection is irrevocably lost.
+     * <br/>
+     * NOTE: Override this to add custom functionality.
+     *
+     * @method
+     * @param {string} identifier The identifier of the observed connection.
+     * @virtual
+     * @public
+     */
+    onConnectionLost( identifier ) {
+        super.onConnectionLost( identifier );
+    }
+
+}
+
 module.exports = MessageObserver;