@nextage/nx-frame-be 1.0.1

package/build/common/manager/bulk-manager.js

@@ -0,0 +1,103 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkManager = void 0;
+const async_1 = __importDefault(require("async"));
+const constants_1 = require("../constants");
+const utils_1 = require("../utils");
+class BulkManager {
+    constructor(model, logClass, logger) {
+        this.model = model;
+        this.logClass = logClass || this;
+        this.logger = logger || constants_1.APP.logger;
+        this.reset();
+    }
+    /**
+     *
+     */
+    reset() {
+        if (!this.model)
+            return;
+        this.bulk = { index: 0, count: 0, value: [] };
+        this.bulk.value.push(this.model.initBulk());
+    }
+    /**
+     *
+     * @param selector
+     * @param update
+     * @param multi
+     * @param upsert
+     * @returns
+     */
+    add(selector, update, multi = false, upsert = false) {
+        var _a, _b, _c, _d, _e;
+        if (!this.model)
+            return;
+        if (update.$set && !Object.keys(update.$set).length)
+            delete update.$set;
+        if (update.$unset && !Object.keys(update.$unset).length)
+            delete update.$unset;
+        if (!Object.keys(update).length)
+            return;
+        if (multi)
+            (_a = this.bulk) === null || _a === void 0 ? void 0 : _a.value[this.bulk.index].find(selector).update(update);
+        else if (upsert)
+            (_b = this.bulk) === null || _b === void 0 ? void 0 : _b.value[this.bulk.index].find(selector).upsert().updateOne(update);
+        else
+            (_c = this.bulk) === null || _c === void 0 ? void 0 : _c.value[this.bulk.index].find(selector).updateOne(update);
+        this.bulk.count++;
+        if (((_d = this.bulk) === null || _d === void 0 ? void 0 : _d.count) === 50000) {
+            this.bulk.value.push(this.model.initBulk());
+            this.bulk.index++;
+            this.bulk.count = 0;
+        }
+        return (_e = this.bulk) === null || _e === void 0 ? void 0 : _e.index;
+    }
+    /**
+     *
+     * @param {*} res
+     */
+    parseRes(res) {
+        if (!this.model || !res)
+            return;
+        this.logger.debug(`bulk result - inserted: ${res.insertedCount || 0}, updated: ${res.modifiedCount || 0}, removed: ${res.deletedCount || 0}`, (0, utils_1.logClassCtx)(this.logClass));
+    }
+    /**
+     *
+     * @param {*} callback
+     */
+    apply(callback) {
+        if (!this.model)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            var _a;
+            async_1.default.eachSeries(((_a = this.bulk) === null || _a === void 0 ? void 0 : _a.value) || [], (bulk, cb) => __awaiter(this, void 0, void 0, function* () {
+                this.logger.debug('bulk update', (0, utils_1.logClassCtx)(this.logClass));
+                try {
+                    const res = yield bulk.execute();
+                    this.parseRes(res);
+                }
+                catch (e) {
+                    this.logger.error(`bulk update error %o`, e, (0, utils_1.logClassCtx)(this));
+                }
+                cb();
+            }), (err) => {
+                this.reset();
+                callback();
+                resolve();
+            });
+        });
+    }
+}
+exports.BulkManager = BulkManager;

package/build/common/manager/crypto-manager.d.ts

@@ -0,0 +1,88 @@
+/// <reference types="node" />
+import { Stream } from 'stream';
+import { RSAKeyPair } from '../crypto';
+import { KeyCypheredStreamPair, SymmetricKey } from '../crypto';
+import { KeyOptions } from '../crypto';
+export declare class CryptoManager {
+    private logger;
+    private secret;
+    constructor({ logger, secret }?: {
+        logger?: any;
+        secret?: string;
+    });
+    /**
+     * Cypher a stream using a random generated AES-256 key
+     *
+     * @param { Stream } toCypherStream the stream to be cyphered
+     * @returns { KeyCypheredStreamPair } the symKey generated and the cypheredStream
+     */
+    cypherStream(toCypherStream: string | Stream): Promise<KeyCypheredStreamPair>;
+    /**
+     * Decypher a stream using the keyoptions provided to get the right key from database
+     *
+     * @param { KeyOptions } keyOptions
+     * @param { Stream } streamToDecypher
+     */
+    decypherStream(keyOptions: {
+        privateKeyOptions: KeyOptions;
+        symmetricKeyOptions: KeyOptions;
+    }, streamToDecypher: Stream): Promise<string | Stream>;
+    /**
+     * Cypher symmetric key provided with publicKey and save it by keyOptions
+     *
+     * @param { SymmetricKey } symmetricKey
+     * @param { { symmetricKey: KeyOptions, publicKey: KeyOptions } } keysOptions
+     */
+    saveAESKey(symmetricKey: KeyOptions, { publicKeyOptions, symmetricKeyOptions }: {
+        publicKeyOptions: KeyOptions;
+        symmetricKeyOptions: KeyOptions;
+    }): Promise<void>;
+    /**
+     * Get the SymmetricKey by keyOptions and decypher it using privateKey
+     *
+     * @param { { symmetricKey: KeyOptions, privateKey: KeyOptions } } keysOptions
+     */
+    getAESKey({ privateKeyOptions, symmetricKeyOptions }: {
+        privateKeyOptions: KeyOptions;
+        symmetricKeyOptions: KeyOptions;
+    }): Promise<SymmetricKey>;
+    /**
+     * Generate Private/Public Rsa KeyPair using KeyOptions
+     *
+     * @param {KeyOptions | object} publicKeyOpt options used to locate the publicKey and it's characteristics
+     * @param {KeyOptions | object} privateKeyOpt options used to locate the privateKey and it's characteristics
+     */
+    getRSAKeyPair(publicKeyOptions: KeyOptions, privateKeyOptions: KeyOptions): Promise<RSAKeyPair>;
+    /**
+     * Save RSA KeyPair to the database using KeyOptions
+     *
+     * @param { RSAKeyOptions | object } publicKeyOptions  options used to identify the publicKey saving characteristics
+     * @param { RSAKeyOptions | object } privateKeyOptions options used to identify the privateKey saving characteristics
+     */
+    saveRSAKeyPair(publicKeyOptions: KeyOptions, privateKeyOptions: KeyOptions): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * @private
+     * Save a generic Key using KeyOptions
+     *
+     * @param {*} key
+     * @param { KeyOptions | object} keyOptions
+     */
+    _saveKey(key: string, keyOptions: KeyOptions): Promise<any>;
+    /**
+     * @private
+     * Get a generic Key using provided options
+     *
+     * @param { KeyOptions | object } keyOptions options used to locate the key and it's characteristics
+     */
+    _getKey(keyOptions: KeyOptions): Promise<string>;
+    /**
+     * Verify if the chunk size given, it's valid based on chunks
+     *
+     * @param { String[] } chunks the chunks
+     * @param { number }   chunkSize size of everyChunks
+     */
+    _verifyChunkSize(chunks: string[], chunkSize: number): boolean;
+}

package/build/common/manager/crypto-manager.js

@@ -0,0 +1,200 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoManager = void 0;
+const constants_1 = require("../constants");
+const crypto_1 = require("../crypto");
+const crypto_2 = require("../crypto");
+const constants_2 = require("../constants");
+const crypto_constants_1 = require("../crypto/crypto.constants");
+const crypto_constants_2 = require("../crypto/crypto.constants");
+const crypto_error_1 = require("../crypto/crypto.error");
+const utils_1 = require("../utils");
+const utils_2 = require("../utils");
+const utils_3 = require("../utils");
+// const KEY_TYPES = Object.freeze({
+//   PUBLIC   : 'publicKeyOptions',
+//   PRIVATE  : 'privateKeyOptions',
+//   SYMMETRIC: 'symmetricKeyOptions'
+// });
+class CryptoManager {
+    constructor({ logger, secret } = {}) {
+        this.logger = logger || constants_2.APP.logger;
+        this.secret = secret || constants_2.APP.dataScr || '';
+        // console.log('asd', APP.dataScr)
+        if (!this.secret)
+            throw new Error('Secret is not defined');
+    }
+    /**
+     * Cypher a stream using a random generated AES-256 key
+     *
+     * @param { Stream } toCypherStream the stream to be cyphered
+     * @returns { KeyCypheredStreamPair } the symKey generated and the cypheredStream
+     */
+    cypherStream(toCypherStream) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const symKey = yield constants_1.cryptoUtils.generateRndSymKey(crypto_constants_2.CRYPTO_SYM_BITSIZE);
+            const cypheredStream = yield constants_1.cryptoUtils.cypherSym(symKey, toCypherStream);
+            return new crypto_2.KeyCypheredStreamPair(symKey, cypheredStream);
+        });
+    }
+    /**
+     * Decypher a stream using the keyoptions provided to get the right key from database
+     *
+     * @param { KeyOptions } keyOptions
+     * @param { Stream } streamToDecypher
+     */
+    decypherStream(keyOptions, streamToDecypher) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const keyObj = yield this.getAESKey(keyOptions);
+            return yield constants_1.cryptoUtils.decypherSym(keyObj, streamToDecypher);
+        });
+    }
+    /**
+     * Cypher symmetric key provided with publicKey and save it by keyOptions
+     *
+     * @param { SymmetricKey } symmetricKey
+     * @param { { symmetricKey: KeyOptions, publicKey: KeyOptions } } keysOptions
+     */
+    saveAESKey(symmetricKey_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (symmetricKey, { publicKeyOptions, symmetricKeyOptions }) {
+            const publicKey = yield this._getKey(publicKeyOptions);
+            const encryptedKey = yield constants_1.cryptoUtils.cypherAsym(publicKey, JSON.stringify(symmetricKey));
+            yield this._saveKey(encryptedKey, symmetricKeyOptions);
+        });
+    }
+    /**
+     * Get the SymmetricKey by keyOptions and decypher it using privateKey
+     *
+     * @param { { symmetricKey: KeyOptions, privateKey: KeyOptions } } keysOptions
+     */
+    getAESKey(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ privateKeyOptions, symmetricKeyOptions }) {
+            const privateKey = yield this._getKey(privateKeyOptions);
+            if (!privateKey) {
+                const error = crypto_constants_2.CRYPTO_ERRORS.PRIV_KEY_NOT_FOUND;
+                this.logger.error(`[${error.code}] ${error.message}`, (0, utils_1.logClassCtx)(this, 'getAESKey'));
+                throw new crypto_error_1.CryptoError(error.message, error.code);
+            }
+            const encryptedKey = yield this._getKey(symmetricKeyOptions);
+            if (!encryptedKey) {
+                const error = crypto_constants_2.CRYPTO_ERRORS.ENC_SYM_NOT_FOUND;
+                this.logger.error(`[${error.code}] ${error.message}`, (0, utils_1.logClassCtx)(this, 'getAESKey'));
+                throw new crypto_error_1.CryptoError(error.message, error.code);
+            }
+            const decryptedKey = yield constants_1.cryptoUtils.decypherAsym(privateKey, encryptedKey);
+            return JSON.parse(decryptedKey);
+        });
+    }
+    /**
+     * Generate Private/Public Rsa KeyPair using KeyOptions
+     *
+     * @param {KeyOptions | object} publicKeyOpt options used to locate the publicKey and it's characteristics
+     * @param {KeyOptions | object} privateKeyOpt options used to locate the privateKey and it's characteristics
+     */
+    getRSAKeyPair(publicKeyOptions, privateKeyOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const keyPair = { publicKey: '', privateKey: '' };
+            const options = new crypto_1.RSAKeyPairOptions(publicKeyOptions, privateKeyOptions);
+            keyPair.privateKey = yield this._getKey(options.privateKeyOptions);
+            keyPair.publicKey = yield this._getKey(options.publicKeyOptions);
+            return keyPair;
+        });
+    }
+    /**
+     * Save RSA KeyPair to the database using KeyOptions
+     *
+     * @param { RSAKeyOptions | object } publicKeyOptions  options used to identify the publicKey saving characteristics
+     * @param { RSAKeyOptions | object } privateKeyOptions options used to identify the privateKey saving characteristics
+     */
+    saveRSAKeyPair(publicKeyOptions, privateKeyOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = new crypto_1.RSAKeyPairOptions(publicKeyOptions, privateKeyOptions);
+            const keypair = yield constants_1.cryptoUtils.generateAsymKeys(crypto_constants_1.CRYPTO_ASYM_BITSIZE);
+            if (!keypair) {
+                const error = crypto_constants_2.CRYPTO_ERRORS.GEN_KEY_PAIR;
+                this.logger.error(`[${error.code}] ${error.message}`, (0, utils_1.logClassCtx)(this, 'saveRSAKeyPair'));
+                throw new crypto_error_1.CryptoError(error.message, error.code);
+            }
+            const keys = Object.keys(keypair);
+            const promises = keys.map((property) => this._saveKey(keypair[property], options[`${property}Options`]));
+            const res = yield Promise.all(promises);
+            return { success: true, message: 'RSA KeyPair saved successfully' };
+        });
+    }
+    /**
+     * @private
+     * Save a generic Key using KeyOptions
+     *
+     * @param {*} key
+     * @param { KeyOptions | object} keyOptions
+     */
+    _saveKey(key, keyOptions) {
+        const tempEncKey = constants_1.cryptoUtils.encryptText(key, this.secret);
+        const encryptedKey = keyOptions.isChunked ? (0, utils_3.chunkString)(tempEncKey, keyOptions.chunkSize) : tempEncKey;
+        const data = keyOptions.hasFilter ? (0, utils_1.initObjectWithProperty)(keyOptions.path, encryptedKey) : (0, utils_2.initObjectFromDotNotation)(keyOptions.path, encryptedKey);
+        if (keyOptions.hasAdditionalFields) {
+            keyOptions.additionalFields.forEach((field) => {
+                keyOptions.hasFilter ? data[field.path] = field.value : (0, utils_3.setAttr)(data, field.path, field.value);
+            });
+        }
+        return keyOptions.hasFilter ? keyOptions.model.findOneAndUpdate(keyOptions.filter, data, {}) : keyOptions.model.create(data, {});
+    }
+    /**
+     * @private
+     * Get a generic Key using provided options
+     *
+     * @param { KeyOptions | object } keyOptions options used to locate the key and it's characteristics
+     */
+    _getKey(keyOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const logCtx = (0, utils_1.logClassCtx)(this, '_getKey');
+            if (!keyOptions) {
+                const error = crypto_constants_2.CRYPTO_ERRORS.KEY_OPTS_ARGS;
+                this.logger.error(`[${error.code}] ${error.message}`, logCtx);
+                throw new crypto_error_1.CryptoError(error.message, error.code);
+            }
+            if (keyOptions.key)
+                return keyOptions.key;
+            if (!keyOptions.model || !keyOptions.hasFilter) {
+                const error = crypto_constants_2.CRYPTO_ERRORS.KEY_OPTS_PROPS;
+                this.logger.error(`[${error.code}] ${error.message}`, logCtx);
+                throw new crypto_error_1.CryptoError(error.message, error.code);
+            }
+            const data = yield keyOptions.model.findOne(keyOptions.filter);
+            let encryptedKey = '';
+            if (keyOptions.isChunked) {
+                const chunks = (0, utils_3.getAttr)(data, keyOptions.path);
+                if (!this._verifyChunkSize(chunks, keyOptions.chunkSize)) {
+                    const error = crypto_constants_2.CRYPTO_ERRORS.CHUNK_SIZE;
+                    this.logger.error(`[${error.code}] ${error.message}`, logCtx);
+                    throw new crypto_error_1.CryptoError(error.message, error.code);
+                }
+                encryptedKey = chunks.join('');
+            }
+            else
+                encryptedKey = (0, utils_3.getAttr)(data, keyOptions.path);
+            return constants_1.cryptoUtils.decryptText(encryptedKey, this.secret);
+        });
+    }
+    /**
+     * Verify if the chunk size given, it's valid based on chunks
+     *
+     * @param { String[] } chunks the chunks
+     * @param { number }   chunkSize size of everyChunks
+     */
+    _verifyChunkSize(chunks, chunkSize) {
+        const origChunkNumber = chunks.length;
+        const newChunkNumber = (0, utils_3.chunkString)(chunks.join(''), chunkSize).length;
+        return origChunkNumber === newChunkNumber;
+    }
+}
+exports.CryptoManager = CryptoManager;

package/build/common/manager/index.d.ts

@@ -0,0 +1,5 @@
+export * from './bulk-manager';
+export * from './crypto-manager';
+export * from './pubsub-manager';
+export * from './socket-io-cli-manager';
+export * from './tunnel-manager';

package/build/common/manager/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bulk-manager"), exports);
+__exportStar(require("./crypto-manager"), exports);
+__exportStar(require("./pubsub-manager"), exports);
+__exportStar(require("./socket-io-cli-manager"), exports);
+__exportStar(require("./tunnel-manager"), exports);

package/build/common/manager/pubsub-manager.d.ts

@@ -0,0 +1,20 @@
+import { NxContext } from '../interfaces';
+export declare class PubSubManager {
+    /**
+     *
+     * @param {*} key
+     * @param {*} method
+     */
+    subscribe(key: string, method: Function): string;
+    /**
+     *
+     * @param {*} key
+     * @param {*} data
+     */
+    publish(key: string, data: any, context: NxContext): void;
+    /**
+     *
+     * @param {*} id
+     */
+    unsubscribe(id: string): void;
+}

package/build/common/manager/pubsub-manager.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PubSubManager = void 0;
+const events_1 = require("events");
+const utils_1 = require("../utils");
+const subs = {};
+const eventsEmitter = new events_1.EventEmitter();
+class PubSubManager {
+    /**
+     *
+     * @param {*} key
+     * @param {*} method
+     */
+    subscribe(key, method) {
+        if (!(0, utils_1.isFunction)(method))
+            return '';
+        const id = (0, utils_1.uuid)();
+        subs[id] = { key, method };
+        eventsEmitter.on(key, (data, context) => method(data, context));
+        return id;
+    }
+    /**
+     *
+     * @param {*} key
+     * @param {*} data
+     */
+    publish(key, data, context) {
+        eventsEmitter.emit(key, data, context);
+    }
+    /**
+     *
+     * @param {*} id
+     */
+    unsubscribe(id) {
+        eventsEmitter.off(subs[id].key, subs[id].method);
+    }
+}
+exports.PubSubManager = PubSubManager;

package/build/common/manager/shutdown-manager.d.ts

@@ -0,0 +1,27 @@
+export declare class ShutdownManager {
+    private isShuttingDown;
+    private shutdownHandlers;
+    shutdownTimeout: number;
+    constructor();
+    private setupSignalHandlers;
+    /**
+     *
+     * @param handler
+     */
+    addShutdownHandler(handler: () => Promise<void>): void;
+    /**
+     *
+     * @param exitCode
+     * @returns
+     */
+    private shutdown;
+    /**
+     *
+     */
+    private executeShutdownHandlers;
+    /**
+     *
+     * @returns
+     */
+    isShutdownInProgress(): boolean;
+}

package/build/common/manager/shutdown-manager.js

@@ -0,0 +1,118 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShutdownManager = void 0;
+const constants_1 = require("../constants");
+class ShutdownManager {
+    constructor() {
+        this.isShuttingDown = false;
+        this.shutdownHandlers = [];
+        this.shutdownTimeout = 3000;
+        this.setupSignalHandlers();
+    }
+    setupSignalHandlers() {
+        // SIGTERM Management (normal termination)
+        process.on('SIGTERM', () => {
+            constants_1.APP.logger.info('\n🛑 Received SIGTERM, starting graceful shutdown...');
+            this.shutdown();
+        });
+        // SIGINT Management (Ctrl+C)
+        process.on('SIGINT', () => {
+            constants_1.APP.logger.info('\n🛑 Received SIGINT (Ctrl+C), starting graceful shutdown...');
+            this.shutdown();
+        });
+        // SIGHUP Management (closed terminal)
+        process.on('SIGHUP', () => {
+            constants_1.APP.logger.info('\n🛑 Received SIGHUP, starting graceful shutdown...');
+            this.shutdown();
+        });
+        // SIGUSR2 Management (nodemon)
+        process.on('SIGUSR2', () => {
+            constants_1.APP.logger.info('\n🛑 Received SIGHUP, starting graceful shutdown...');
+            this.shutdown();
+        });
+        // Manages other exceptions
+        process.on('uncaughtException', (error) => {
+            constants_1.APP.logger.error('💥 Uncaught Exception: %o', error);
+            constants_1.APP.logger.info('🛑 Starting emergency shutdown...');
+            this.shutdown(1);
+        });
+        // Manages promise unhandled rejection
+        process.on('unhandledRejection', (reason, promise) => {
+            constants_1.APP.logger.error('💥 Unhandled Rejection at: %o reason: %o', promise, reason);
+            constants_1.APP.logger.info('🛑 Starting emergency shutdown...');
+            this.shutdown(1);
+        });
+    }
+    /**
+     *
+     * @param handler
+     */
+    addShutdownHandler(handler) {
+        this.shutdownHandlers.push(handler);
+    }
+    /**
+     *
+     * @param exitCode
+     * @returns
+     */
+    shutdown() {
+        return __awaiter(this, arguments, void 0, function* (exitCode = 0) {
+            if (this.isShuttingDown) {
+                constants_1.APP.logger.info('⚠️ Shutdown already in progress...');
+                return;
+            }
+            this.isShuttingDown = true;
+            const shutdownPromise = this.executeShutdownHandlers();
+            const timeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new Error(`Shutdown timeout after ${this.shutdownTimeout}ms`));
+                }, this.shutdownTimeout);
+            });
+            try {
+                yield Promise.race([shutdownPromise, timeoutPromise]);
+                constants_1.APP.logger.info('✅ Graceful shutdown completed');
+            }
+            catch (error) {
+                constants_1.APP.logger.error('❌ Shutdown timeout or error:', error);
+                exitCode = 1;
+            }
+            process.exit(exitCode);
+        });
+    }
+    /**
+     *
+     */
+    executeShutdownHandlers() {
+        return __awaiter(this, void 0, void 0, function* () {
+            constants_1.APP.logger.info(`🔄 Executing ${this.shutdownHandlers.length} shutdown handlers...`);
+            const promises = this.shutdownHandlers.map((handler, index) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield handler();
+                    constants_1.APP.logger.info(`✅ Shutdown handler ${index + 1} completed`);
+                }
+                catch (error) {
+                    constants_1.APP.logger.error(`❌ Shutdown handler ${index + 1} failed:`, error);
+                    throw error;
+                }
+            }));
+            yield Promise.all(promises);
+        });
+    }
+    /**
+     *
+     * @returns
+     */
+    isShutdownInProgress() {
+        return this.isShuttingDown;
+    }
+}
+exports.ShutdownManager = ShutdownManager;

package/build/common/manager/socket-io-cli-manager.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { ManagerOptions } from 'socket.io-client';
+export declare class SocketIoCliManager extends EventEmitter {
+    private params;
+    private host;
+    private port;
+    private protocol;
+    private manager?;
+    private socket?;
+    private uri?;
+    private logger;
+    private _listeners;
+    private _logCtx;
+    constructor(host: string, port: number, params?: Partial<ManagerOptions>, logger?: any);
+    /**
+     * Init Socket
+     *
+     * @param {*} encoding
+     */
+    private init;
+    /**
+     *
+     */
+    protected onConnect(): void;
+    /**
+     *
+     */
+    protected onDisconnect(): void;
+    /**
+     * Format and send message
+     * @param {*} event
+     * @param {*} data
+     * @param {*} callback
+     */
+    sendData(event: string, data: any, callback: Function): void;
+    /**
+     *
+     * @param {*} event
+     * @param {*} callback
+     */
+    addEventListener(event: string, callback: Function): void;
+    /**
+     *
+     * @param {*} event
+     * @param {*} callback
+     */
+    removeEventListener(event: string): void;
+    /**
+     * Close Socket
+     */
+    close(): void;
+}