@minimaltech/node-infra 0.5.9-2 → 0.5.9-21

package/dist/helpers/redis/default.helper.js

@@ -1,13 +1,4 @@
 "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 };
 };
@@ -17,8 +8,9 @@ const base_helper_1 = require("../../base/base.helper");
 const utilities_1 = require("../../utilities");
 const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
 const node_zlib_1 = __importDefault(require("node:zlib"));
-// -----------------------------------------------------------------------------------------------
 class DefaultRedisHelper extends base_helper_1.BaseHelper {
+    client;
+    name;
     constructor(opts) {
         super({ scope: opts.scope, identifier: opts.identifier });
         this.name = opts.identifier;
@@ -26,20 +18,20 @@ class DefaultRedisHelper extends base_helper_1.BaseHelper {
         const { onInitialized, onConnected, onReady, onError } = opts;
         this.client.on('connect', () => {
             this.logger.info('[%s][connect] Redis CONNECTED', this.name);
-            onConnected === null || onConnected === void 0 ? void 0 : onConnected({ name: this.name, helper: this });
+            onConnected?.({ name: this.name, helper: this });
         });
         this.client.on('ready', () => {
             this.logger.info('[%s][ready] Redis READY', this.name);
-            onReady === null || onReady === void 0 ? void 0 : onReady({ name: this.name, helper: this });
+            onReady?.({ name: this.name, helper: this });
         });
         this.client.on('error', error => {
             this.logger.error('[%s][error] Redis ERROR | Error: %s', this.name, error);
-            onError === null || onError === void 0 ? void 0 : onError({ name: this.name, helper: this, error });
+            onError?.({ name: this.name, helper: this, error });
         });
         this.client.on('reconnecting', () => {
             this.logger.warn('[%s][reconnecting] Redis client RECONNECTING', this.name);
         });
-        onInitialized === null || onInitialized === void 0 ? void 0 : onInitialized({ name: this.name, helper: this });
+        onInitialized?.({ name: this.name, helper: this });
     }
     getClient() {
         return this.client;
@@ -67,7 +59,6 @@ class DefaultRedisHelper extends base_helper_1.BaseHelper {
                 .catch(reject);
         });
     }
-    // ---------------------------------------------------------------------------------
     disconnect() {
         return new Promise((resolve, reject) => {
             const invalidStatuses = ['end', 'close'];
@@ -84,223 +75,187 @@ class DefaultRedisHelper extends base_helper_1.BaseHelper {
                 .catch(reject);
         });
     }
-    // ---------------------------------------------------------------------------------
-    set(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { key, value, options = { log: false } } = opts;
-            if (!this.client) {
-                this.logger.info('[set] No valid Redis connection!');
-                return;
-            }
-            const serialized = JSON.stringify(value);
-            yield this.client.set(key, serialized);
-            if (!(options === null || options === void 0 ? void 0 : options.log)) {
-                return;
-            }
-            this.logger.info(`[set] Set key: ${key} | value: ${serialized}`);
-        });
+    async set(opts) {
+        const { key, value, options = { log: false } } = opts;
+        if (!this.client) {
+            this.logger.info('[set] No valid Redis connection!');
+            return;
+        }
+        const serialized = JSON.stringify(value);
+        await this.client.set(key, serialized);
+        if (!options?.log) {
+            return;
+        }
+        this.logger.info(`[set] Set key: ${key} | value: ${serialized}`);
     }
-    // ---------------------------------------------------------------------------------
-    get(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { key, transform = (input) => input } = opts;
-            if (!this.client) {
-                this.logger.info('[get] No valid Redis connection!');
-                return null;
-            }
-            const value = yield this.client.get(key);
-            if (!value) {
-                return null;
-            }
-            return transform(value);
-        });
+    async get(opts) {
+        const { key, transform = (input) => input } = opts;
+        if (!this.client) {
+            this.logger.info('[get] No valid Redis connection!');
+            return null;
+        }
+        const value = await this.client.get(key);
+        if (!value) {
+            return null;
+        }
+        return transform(value);
     }
-    // ---------------------------------------------------------------------------------
     del(opts) {
         const { keys } = opts;
         return this.client.del(keys);
     }
-    // ---------------------------------------------------------------------------------
     getString(opts) {
         return this.get(opts);
     }
-    // ---------------------------------------------------------------------------------
     getStrings(opts) {
         return this.mget(opts);
     }
-    // ---------------------------------------------------------------------------------
     getObject(opts) {
-        return this.get(Object.assign(Object.assign({}, opts), { transform: (cached) => JSON.parse(cached) }));
+        return this.get({
+            ...opts,
+            transform: (cached) => JSON.parse(cached),
+        });
     }
-    // ---------------------------------------------------------------------------------
     getObjects(opts) {
-        return this.mget(Object.assign(Object.assign({}, opts), { transform: (cached) => JSON.parse(cached) }));
+        return this.mget({
+            ...opts,
+            transform: (cached) => JSON.parse(cached),
+        });
     }
-    // ---------------------------------------------------------------------------------
-    hset(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.client) {
-                this.logger.info('[hset] No valid Redis connection!');
-                return;
-            }
-            const { key, value, options } = opts;
-            const rs = yield this.client.hset(key, value);
-            if (!(options === null || options === void 0 ? void 0 : options.log)) {
-                return rs;
-            }
-            this.logger.info('[hset] Result: %j', rs);
+    async hset(opts) {
+        if (!this.client) {
+            this.logger.info('[hset] No valid Redis connection!');
+            return;
+        }
+        const { key, value, options } = opts;
+        const rs = await this.client.hset(key, value);
+        if (!options?.log) {
             return rs;
-        });
+        }
+        this.logger.info('[hset] Result: %j', rs);
+        return rs;
     }
-    // ---------------------------------------------------------------------------------
     hSet(opts) {
         return this.hset(opts);
     }
-    // ---------------------------------------------------------------------------------
-    hgetall(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { key, transform } = opts;
-            if (!this.client) {
-                this.logger.info('[get] No valid Redis connection!');
-                return null;
-            }
-            const value = yield this.client.hgetall(key);
-            if (!transform || !value) {
-                return value;
-            }
-            return transform(value);
-        });
+    async hgetall(opts) {
+        const { key, transform } = opts;
+        if (!this.client) {
+            this.logger.info('[get] No valid Redis connection!');
+            return null;
+        }
+        const value = await this.client.hgetall(key);
+        if (!transform || !value) {
+            return value;
+        }
+        return transform(value);
     }
-    // ---------------------------------------------------------------------------------
     hGetAll(opts) {
         return this.hgetall(opts);
     }
-    // ---------------------------------------------------------------------------------
-    mset(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.client) {
-                this.logger.info('[set] No valid Redis connection!');
-                return;
-            }
-            const { payload, options } = opts;
-            const serialized = payload === null || payload === void 0 ? void 0 : payload.reduce((current, el) => {
-                const { key, value } = el;
-                return Object.assign(Object.assign({}, current), { [key]: JSON.stringify(value) });
-            }, {});
-            yield this.client.mset(serialized);
-            if (!(options === null || options === void 0 ? void 0 : options.log)) {
-                return;
-            }
-            this.logger.info('[mset] Payload: %j', serialized);
-        });
+    async mset(opts) {
+        if (!this.client) {
+            this.logger.info('[set] No valid Redis connection!');
+            return;
+        }
+        const { payload, options } = opts;
+        const serialized = payload?.reduce((current, el) => {
+            const { key, value } = el;
+            return { ...current, [key]: JSON.stringify(value) };
+        }, {});
+        await this.client.mset(serialized);
+        if (!options?.log) {
+            return;
+        }
+        this.logger.info('[mset] Payload: %j', serialized);
     }
-    // ---------------------------------------------------------------------------------
     mSet(opts) {
         return this.mset(opts);
     }
-    // ---------------------------------------------------------------------------------
-    mget(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { keys, transform = (input) => input } = opts;
-            if (!this.client) {
-                this.logger.info('[get] No valid Redis connection!');
-                return null;
-            }
-            const values = yield this.client.mget(keys);
-            if (!(values === null || values === void 0 ? void 0 : values.length)) {
-                return null;
-            }
-            return values === null || values === void 0 ? void 0 : values.map(el => (el ? transform(el) : el));
-        });
+    async mget(opts) {
+        const { keys, transform = (input) => input } = opts;
+        if (!this.client) {
+            this.logger.info('[get] No valid Redis connection!');
+            return null;
+        }
+        const values = await this.client.mget(keys);
+        if (!values?.length) {
+            return null;
+        }
+        return values?.map(el => (el ? transform(el) : el));
     }
-    // ---------------------------------------------------------------------------------
     mGet(opts) {
         return this.mget(opts);
     }
-    // ---------------------------------------------------------------------------------
-    keys(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { key } = opts;
-            if (!this.client) {
-                this.logger.info('[keys] No valid Redis connection!');
-                return [];
-            }
-            const existedKeys = yield this.client.keys(key);
-            return existedKeys;
-        });
+    async keys(opts) {
+        const { key } = opts;
+        if (!this.client) {
+            this.logger.info('[keys] No valid Redis connection!');
+            return [];
+        }
+        const existedKeys = await this.client.keys(key);
+        return existedKeys;
     }
-    // ---------------------------------------------------------------------------------
     jSet(opts) {
         const { key, path, value } = opts;
         return this.execute('JSON.SET', [key, path, JSON.stringify(value)]);
     }
-    // ---------------------------------------------------------------------------------
     jGet(opts) {
         const { key, path = '$' } = opts;
         return this.execute('JSON.GET', [key, path]);
     }
-    // ---------------------------------------------------------------------------------
     jDelete(opts) {
         const { key, path = '$' } = opts;
         return this.execute('JSON.DEL', [key, path]);
     }
-    // ---------------------------------------------------------------------------------
     jNumberIncreaseBy(opts) {
         const { key, path, value } = opts;
         return this.execute('JSON.NUMINCRBY', [key, path, value]);
     }
-    // ---------------------------------------------------------------------------------
     jStringAppend(opts) {
         const { key, path, value } = opts;
         return this.execute('JSON.STRAPPEND', [key, path, value]);
     }
-    // ---------------------------------------------------------------------------------
     jPush(opts) {
         const { key, path, value } = opts;
         return this.execute('JSON.ARRAPPEND', [key, path, JSON.stringify(value)]);
     }
-    // ---------------------------------------------------------------------------------
     jPop(opts) {
         const { key, path } = opts;
         return this.execute('JSON.ARRPOP', [key, path]);
     }
-    // ---------------------------------------------------------------------------------
     execute(command, parameters) {
-        if (!(parameters === null || parameters === void 0 ? void 0 : parameters.length)) {
+        if (!parameters?.length) {
             return this.client.call(command);
         }
         return this.client.call(command, parameters);
     }
-    // ---------------------------------------------------------------------------------
-    publish(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { topics, payload, useCompress = false } = opts;
-            const validTopics = topics === null || topics === void 0 ? void 0 : topics.filter(topic => !(0, isEmpty_1.default)(topic));
-            if (!(validTopics === null || validTopics === void 0 ? void 0 : validTopics.length)) {
-                this.logger.error('[publish] No topic(s) to publish!');
-                return;
-            }
-            if (!payload) {
-                this.logger.error('[publish] Invalid payload to publish!');
-                return;
+    async publish(opts) {
+        const { topics, payload, useCompress = false } = opts;
+        const validTopics = topics?.filter(topic => !(0, isEmpty_1.default)(topic));
+        if (!validTopics?.length) {
+            this.logger.error('[publish] No topic(s) to publish!');
+            return;
+        }
+        if (!payload) {
+            this.logger.error('[publish] Invalid payload to publish!');
+            return;
+        }
+        if (!this.client) {
+            this.logger.error('[publish] No valid Redis connection!');
+            return;
+        }
+        await Promise.all(validTopics.map(topic => {
+            let packet;
+            if (useCompress) {
+                packet = node_zlib_1.default.deflateSync(Buffer.from(JSON.stringify(payload)));
             }
-            if (!this.client) {
-                this.logger.error('[publish] No valid Redis connection!');
-                return;
+            else {
+                packet = Buffer.from(JSON.stringify(payload));
             }
-            yield Promise.all(validTopics.map(topic => {
-                let packet;
-                if (useCompress) {
-                    packet = node_zlib_1.default.deflateSync(Buffer.from(JSON.stringify(payload)));
-                }
-                else {
-                    packet = Buffer.from(JSON.stringify(payload));
-                }
-                return this.client.publish(topic, packet);
-            }));
-        });
+            return this.client.publish(topic, packet);
+        }));
     }
-    // ---------------------------------------------------------------------------------
     subscribe(opts) {
         const { topic } = opts;
         if (!topic || (0, isEmpty_1.default)(topic)) {
@@ -323,4 +278,3 @@ class DefaultRedisHelper extends base_helper_1.BaseHelper {
     }
 }
 exports.DefaultRedisHelper = DefaultRedisHelper;
-//# sourceMappingURL=default.helper.js.map

package/dist/helpers/redis/index.js

@@ -18,4 +18,3 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./default.helper"), exports);
 __exportStar(require("./redis-cluster.helper"), exports);
 __exportStar(require("./redis.helper"), exports);
-//# sourceMappingURL=index.js.map

package/dist/helpers/redis/redis-cluster.helper.js

@@ -6,17 +6,21 @@ const ioredis_1 = require("ioredis");
 const default_helper_1 = require("./default.helper");
 class RedisClusterHelper extends default_helper_1.DefaultRedisHelper {
     constructor(opts) {
-        super(Object.assign(Object.assign({}, opts), { scope: RedisClusterHelper.name, identifier: opts.name, client: new ioredis_1.Cluster(opts.nodes.map(node => {
+        super({
+            ...opts,
+            scope: RedisClusterHelper.name,
+            identifier: opts.name,
+            client: new ioredis_1.Cluster(opts.nodes.map(node => {
                 return {
                     host: node.host,
                     port: (0, utilities_1.int)(node.port),
                     password: node.password,
                 };
-            }), opts.clusterOptions) }));
+            }), opts.clusterOptions),
+        });
     }
     getClient() {
         return this.client;
     }
 }
 exports.RedisClusterHelper = RedisClusterHelper;
-//# sourceMappingURL=redis-cluster.helper.js.map

package/dist/helpers/redis/redis.helper.js

@@ -9,10 +9,12 @@ const ioredis_1 = __importDefault(require("ioredis"));
 const default_helper_1 = require("./default.helper");
 class RedisHelper extends default_helper_1.DefaultRedisHelper {
     constructor(opts) {
-        const { name, host, port, password, 
-        // Optional
-        database = 0, autoConnect = true, maxRetry = 0, } = opts;
-        super(Object.assign(Object.assign({}, opts), { scope: RedisHelper.name, identifier: name, client: new ioredis_1.default({
+        const { name, host, port, password, database = 0, autoConnect = true, maxRetry = 0, } = opts;
+        super({
+            ...opts,
+            scope: RedisHelper.name,
+            identifier: name,
+            client: new ioredis_1.default({
                 name,
                 host,
                 port: (0, parse_utility_1.int)(port),
@@ -28,11 +30,11 @@ class RedisHelper extends default_helper_1.DefaultRedisHelper {
                     return strategy;
                 },
                 maxRetriesPerRequest: null,
-            }) }));
+            }),
+        });
     }
     getClient() {
         return this.client;
     }
 }
 exports.RedisHelper = RedisHelper;
-//# sourceMappingURL=redis.helper.js.map

package/dist/helpers/redis/types.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map

package/dist/helpers/storage/di-container.helper.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DIContainerHelper = void 0;
 class DIContainerHelper {
+    static instance;
+    container;
     constructor() {
         this.container = Object.assign({});
     }
@@ -34,4 +36,3 @@ class DIContainerHelper {
     }
 }
 exports.DIContainerHelper = DIContainerHelper;
-//# sourceMappingURL=di-container.helper.js.map

package/dist/helpers/storage/index.js

@@ -16,4 +16,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./di-container.helper"), exports);
 __exportStar(require("./minio.helper"), exports);
-//# sourceMappingURL=index.js.map