@seidor-cloud-produtos/orbit-backend-lib 0.0.94 → 0.0.96

package/dist/clean-arch/application/cache/cache.d.ts

@@ -1,13 +1,23 @@
 import { CacheClient } from './client';
+export type MethodOptions = {
+    throwOnError?: boolean;
+};
+export type CacheOptions = {
+    throwOnError?: boolean;
+};
 export declare abstract class Cache {
     protected abstract client: CacheClient;
     protected DEFAULT_EXPIRATION_SECONDS: number;
-    start(): Promise<void>;
-    get(keyCache: string): Promise<any>;
-    set(keyCache: string, data: any, expiration?: number): Promise<void>;
-    del(keyCache: string): Promise<void>;
-    getKeys(pattern?: string): Promise<string[] | null>;
-    delBatch(patterns: string[]): Promise<void>;
-    isRunning(): Promise<any>;
-    close(): Promise<void>;
+    private options?;
+    constructor(options?: CacheOptions);
+    private setOptions;
+    start(options?: MethodOptions): Promise<void>;
+    get(keyCache: string, options?: MethodOptions): Promise<any>;
+    set(keyCache: string, data: any, expiration?: number, options?: MethodOptions): Promise<void>;
+    del(keyCache: string, options?: MethodOptions): Promise<void>;
+    getKeys(pattern?: string, options?: MethodOptions): Promise<string[] | null>;
+    delBatch(patterns: string[], options?: MethodOptions): Promise<void>;
+    flush(): Promise<void>;
+    isRunning(options?: MethodOptions): Promise<any>;
+    close(options?: MethodOptions): Promise<void>;
 }

package/dist/clean-arch/application/cache/cache.js

@@ -3,41 +3,116 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cache = void 0;
 const env_1 = require("../../infra/environment/env");
 class Cache {
-    constructor() {
+    constructor(options) {
         this.DEFAULT_EXPIRATION_SECONDS = env_1.env.DEFAULT_CACHE_EXPIRATION;
+        if (options)
+            this.setOptions(options);
     }
-    async start() {
-        await this.client.start();
+    setOptions(options) {
+        this.options = {
+            ...options,
+            throwOnError: options.throwOnError === undefined ? true : options.throwOnError,
+        };
+    }
+    async start(options) {
+        try {
+            await this.client.start();
+        }
+        catch (e) {
+            if (options?.throwOnError || this.options?.throwOnError) {
+                throw e;
+            }
+            return;
+        }
         if (process.env.NODE_ENV !== 'test') {
             console.log('\n');
             console.log('💾 Cache Connected');
         }
     }
-    async get(keyCache) {
-        const dataFromCache = await this.client.get(keyCache);
-        return dataFromCache ? dataFromCache : null;
+    async get(keyCache, options) {
+        try {
+            const dataFromCache = await this.client.get(keyCache);
+            return dataFromCache ? dataFromCache : null;
+        }
+        catch (e) {
+            if (options?.throwOnError || this.options?.throwOnError) {
+                throw e;
+            }
+            return null;
+        }
     }
-    async set(keyCache, data, expiration = this.DEFAULT_EXPIRATION_SECONDS) {
-        return await this.client.set(keyCache, JSON.stringify(data), expiration);
+    async set(keyCache, data, expiration = this.DEFAULT_EXPIRATION_SECONDS, options) {
+        try {
+            return await this.client.set(keyCache, JSON.stringify(data), expiration);
+        }
+        catch (e) {
+            if (options?.throwOnError || this.options?.throwOnError) {
+                throw e;
+            }
+            return;
+        }
+    }
+    async del(keyCache, options) {
+        try {
+            return await this.client.del(keyCache);
+        }
+        catch (e) {
+            if (options?.throwOnError || this.options?.throwOnError) {
+                throw e;
+            }
+            return;
+        }
     }
-    async del(keyCache) {
-        return await this.client.del(keyCache);
+    async getKeys(pattern, options) {
+        try {
+            return await this.client.getKeys(pattern);
+        }
+        catch (e) {
+            if (options?.throwOnError || this.options?.throwOnError) {
+                throw e;
+            }
+            return null;
+        }
     }
-    async getKeys(pattern) {
-        return await this.client.getKeys(pattern);
+    async delBatch(patterns, options) {
+        try {
+            return await this.client.delBatch(patterns);
+        }
+        catch (e) {
+            if (options?.throwOnError || this.options?.throwOnError) {
+                throw e;
+            }
+            return;
+        }
     }
-    async delBatch(patterns) {
-        return await this.client.delBatch(patterns);
+    async flush() {
+        return await this.client.flush();
     }
-    async isRunning() {
-        return await this.client.isRunning();
+    async isRunning(options) {
+        try {
+            return await this.client.isRunning();
+        }
+        catch (e) {
+            if (options?.throwOnError || this.options?.throwOnError) {
+                throw e;
+            }
+            return false;
+        }
     }
-    async close() {
+    async close(options) {
         if (process.env.NODE_ENV !== 'test') {
             console.log('\n');
             console.log('💾 Cache closed');
         }
-        return await this.client.close();
+        try {
+            return await this.client.close();
+        }
+        catch (e) {
+            if (options?.throwOnError || this.options?.throwOnError) {
+                throw e;
+            }
+            return;
+        }
     }
 }
 exports.Cache = Cache;

package/dist/clean-arch/application/cache/client.d.ts

@@ -6,5 +6,6 @@ export declare abstract class CacheClient {
     abstract del(keyCache: string): Promise<void>;
     abstract delBatch(keyCache: string[]): Promise<void>;
     abstract getKeys(pattern?: string): Promise<string[] | null>;
+    abstract flush(): Promise<void>;
     isRunning(): Promise<any>;
 }

package/dist/clean-arch/infra/cache/clients/node-cache.d.ts

@@ -9,6 +9,7 @@ export declare class NodeCache extends CacheClient {
     delBatch(keyCache: string[]): Promise<void>;
     getKeys(pattern?: string | undefined): Promise<string[]>;
     close(): Promise<void>;
+    flush(): Promise<void>;
 }
 declare const _default: NodeCache;
 export default _default;

package/dist/clean-arch/infra/cache/clients/node-cache.js

@@ -41,6 +41,9 @@ class NodeCache extends client_1.CacheClient {
     async close() {
         this.client.flushAll();
     }
+    async flush() {
+        return await this.client.flushAll();
+    }
 }
 exports.NodeCache = NodeCache;
 exports.default = new NodeCache();

package/dist/clean-arch/infra/cache/clients/redis.d.ts

@@ -1,17 +1,16 @@
 import { RedisOptions } from 'ioredis';
 import { CacheClient } from '../../../application/cache/client';
-export type RedisOptionsType = RedisOptions & {
-    throwOnError?: boolean;
-};
 export declare class Redis extends CacheClient {
-    protected options: RedisOptionsType;
+    protected connection: RedisOptions;
     private client;
-    constructor(options: RedisOptionsType);
+    constructor(connection: RedisOptions);
+    private static delayOperation;
     start(): Promise<void>;
     get(key: string): Promise<any>;
     set(key: string, data: string, expiration?: number): Promise<void>;
     del(keyCache: string): Promise<void>;
     delBatch(keyCache: string[]): Promise<void>;
     getKeys(pattern?: string | undefined): Promise<string[] | null>;
+    flush(): Promise<void>;
     close(): Promise<void>;
 }

package/dist/clean-arch/infra/cache/clients/redis.js

@@ -5,76 +5,57 @@ const tslib_1 = require("tslib");
 const ioredis_1 = tslib_1.__importDefault(require("ioredis"));
 const client_1 = require("../../../application/cache/client");
 class Redis extends client_1.CacheClient {
-    constructor(options) {
+    constructor(connection) {
         super();
-        this.options = options;
-        this.options.throwOnError =
-            this.options.throwOnError === undefined
-                ? true
-                : this.options.throwOnError;
+        this.connection = connection;
+    }
+    static async delayOperation() {
+        const maxDelayMs = 5000;
+        await new Promise(resolve => setTimeout(resolve, maxDelayMs));
+        return null;
     }
     async start() {
-        this.client = new ioredis_1.default(this.options);
+        this.client = new ioredis_1.default(this.connection);
     }
     async get(key) {
-        try {
-            return await this.client.get(key);
-        }
-        catch (e) {
-            if (this.options.throwOnError === false) {
+        const get = async () => {
+            const data = await this.client.get(key);
+            if (!data)
                 return null;
-            }
-            throw e;
-        }
+            return JSON.parse(data);
+        };
+        // If redis not connected the get method never returns
+        return await Promise.race([get(), Redis.delayOperation()]);
     }
     async set(key, data, expiration) {
-        try {
+        const set = async () => {
             await this.client.set(key, data);
             if (expiration) {
                 await this.client.expire(key, expiration);
             }
-        }
-        catch (e) {
-            if (this.options.throwOnError === false) {
-                return;
-            }
-            throw e;
-        }
+        };
+        // If redis not connected the set method never returns
+        await Promise.race([set(), Redis.delayOperation()]);
     }
     async del(keyCache) {
-        try {
-            await this.client.del(keyCache);
-        }
-        catch (e) {
-            if (this.options.throwOnError === false) {
-                return;
-            }
-            throw e;
-        }
+        await Promise.race([this.client.del(keyCache), Redis.delayOperation()]);
     }
     async delBatch(keyCache) {
-        try {
+        const delBatch = async () => {
             const pipeline = this.client.pipeline();
             keyCache.forEach(key => pipeline.del(key));
             await pipeline.exec();
-        }
-        catch (e) {
-            if (this.options.throwOnError === false) {
-                return;
-            }
-            throw e;
-        }
+        };
+        await Promise.race([delBatch(), Redis.delayOperation()]);
     }
     async getKeys(pattern) {
-        try {
-            return await this.client.keys(pattern || '*');
-        }
-        catch (e) {
-            if (this.options.throwOnError === false) {
-                return null;
-            }
-            throw e;
-        }
+        return await Promise.race([
+            this.client.keys(pattern || '*'),
+            Redis.delayOperation(),
+        ]);
+    }
+    async flush() {
+        await this.client.flushdb();
     }
     async close() {
         await this.client.quit();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seidor-cloud-produtos/orbit-backend-lib",
-  "version": "0.0.94",
+  "version": "0.0.96",
   "description": "Internal lib for backend components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",