@seidor-cloud-produtos/orbit-backend-lib 0.0.65 → 0.0.66

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

@@ -0,0 +1,12 @@
+import { CacheClient } from './client';
+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[]>;
+  delBatch(patterns: string[]): Promise<void>;
+  isRunning(): Promise<any>;
+}

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

@@ -0,0 +1,33 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.Cache = void 0;
+const env_1 = require('../../infra/environment/env');
+class Cache {
+  constructor() {
+    this.DEFAULT_EXPIRATION_SECONDS = env_1.env.DEFAULT_CACHE_EXPIRATION;
+  }
+  async start() {
+    await this.client.start();
+    console.log('Cache Connected');
+  }
+  async get(keyCache) {
+    const dataFromCache = await this.client.get(keyCache);
+    return dataFromCache ? dataFromCache : null;
+  }
+  async set(keyCache, data, expiration = this.DEFAULT_EXPIRATION_SECONDS) {
+    return await this.client.set(keyCache, JSON.stringify(data), expiration);
+  }
+  async del(keyCache) {
+    return await this.client.del(keyCache);
+  }
+  async getKeys(pattern) {
+    return await this.client.getKeys(pattern);
+  }
+  async delBatch(patterns) {
+    return await this.client.delBatch(patterns);
+  }
+  async isRunning() {
+    return await this.client.isRunning();
+  }
+}
+exports.Cache = Cache;

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

@@ -0,0 +1,9 @@
+export declare abstract class CacheClient {
+  abstract start(): Promise<void>;
+  abstract get(keyCache: string): Promise<any>;
+  abstract set(keyCache: string, data: any, expiration: number): Promise<void>;
+  abstract del(keyCache: string): Promise<void>;
+  abstract delBatch(keyCache: string[]): Promise<void>;
+  abstract getKeys(pattern?: string): Promise<string[]>;
+  isRunning(): Promise<any>;
+}

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

@@ -0,0 +1,13 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.CacheClient = void 0;
+const unique_entity_id_1 = require('../../domain/entities/unique-entity-id');
+class CacheClient {
+  async isRunning() {
+    const key = new unique_entity_id_1.UniqueEntityId().toValue();
+    await this.set(key, JSON.stringify({ ping: true }), 60);
+    const cachedData = await this.get(key);
+    return cachedData?.ping || false;
+  }
+}
+exports.CacheClient = CacheClient;

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

@@ -0,0 +1,13 @@
+import { CacheClient } from '../../../application/cache/client';
+export declare class NodeCache extends CacheClient {
+  private client;
+  start(): Promise<void>;
+  get(key: string): Promise<any>;
+  protected hasFreeMemory(): boolean;
+  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[]>;
+}
+declare const _default: NodeCache;
+export default _default;

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

@@ -0,0 +1,40 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.NodeCache = void 0;
+const tslib_1 = require('tslib');
+const client_1 = require('../../../application/cache/client');
+const node_cache_1 = tslib_1.__importDefault(require('node-cache'));
+class NodeCache extends client_1.CacheClient {
+  async start() {
+    this.client = new node_cache_1.default();
+  }
+  async get(key) {
+    const data = await this.client.get(key);
+    if (!data) return null;
+    return JSON.parse(data);
+  }
+  hasFreeMemory() {
+    const maxSizeMB = 50;
+    const maxSizeByte = maxSizeMB * 1000000;
+    const stats = this.client.getStats();
+    const currentSize = stats.vsize + stats.ksize;
+    return currentSize < maxSizeByte;
+  }
+  async set(key, data, expiration) {
+    if (!this.hasFreeMemory()) return;
+    this.client.set(key, data, expiration);
+  }
+  async del(keyCache) {
+    this.client.del(keyCache);
+  }
+  async delBatch(keyCache) {
+    await Promise.all(keyCache.map(this.del));
+  }
+  async getKeys(pattern) {
+    const keys = this.client.keys();
+    if (!pattern) return keys;
+    return keys.filter(new RegExp(pattern).test);
+  }
+}
+exports.NodeCache = NodeCache;
+exports.default = new NodeCache();

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

@@ -0,0 +1,14 @@
+import { RedisOptions } from 'ioredis';
+import { CacheClient } from '../../../application/cache/client';
+export declare abstract class Redis extends CacheClient {
+  protected connection: RedisOptions;
+  private client;
+  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[]>;
+}

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

@@ -0,0 +1,49 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.Redis = void 0;
+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(connection) {
+    super();
+    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.connection);
+  }
+  async get(key) {
+    const get = async () => {
+      const data = await this.client.get(key);
+      if (!data) return null;
+      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) {
+    const set = async () => {
+      await this.client.set(key, data);
+      await this.client.expire(key, expiration);
+    };
+    // If redis not connected the set method never returns
+    await Promise.race([set(), Redis.delayOperation()]);
+  }
+  async del(keyCache) {
+    await this.client.del(keyCache);
+  }
+  async delBatch(keyCache) {
+    const pipeline = this.client.pipeline();
+    keyCache.forEach(key => pipeline.del(key));
+    await pipeline.exec();
+  }
+  async getKeys(pattern) {
+    return await this.client.keys(pattern || '*');
+  }
+}
+exports.Redis = Redis;

package/dist/clean-arch/infra/environment/env.d.ts

@@ -0,0 +1,7 @@
+import 'dotenv/config';
+import { ENVIRONMENT_TYPES } from './environment';
+export declare const env: {
+  NODE_ENV: 'test' | 'production';
+  CURRENT_ENVIRONMENT: ENVIRONMENT_TYPES;
+  DEFAULT_CACHE_EXPIRATION: number;
+};

package/dist/clean-arch/infra/environment/env.js

@@ -0,0 +1,21 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.env = void 0;
+require('dotenv/config');
+const zod_1 = require('zod');
+const environment_1 = require('./environment');
+const envSchema = zod_1.z.object({
+  NODE_ENV: zod_1.z.enum(['test', 'production']).default('production'),
+  CURRENT_ENVIRONMENT: zod_1.z
+    .enum([
+      environment_1.ENVIRONMENT_TYPES.TEST,
+      environment_1.ENVIRONMENT_TYPES.LOCAL,
+      environment_1.ENVIRONMENT_TYPES.DEVELOPMENT,
+      environment_1.ENVIRONMENT_TYPES.HOMOLOGATION,
+      environment_1.ENVIRONMENT_TYPES.PRODUCTION,
+    ])
+    .default(environment_1.ENVIRONMENT_TYPES.LOCAL),
+  DEFAULT_CACHE_EXPIRATION: zod_1.z.number().default(360),
+});
+const _env = envSchema.safeParse(process.env);
+exports.env = _env.data;

package/dist/clean-arch/infra/environment/environment.d.ts

@@ -0,0 +1,7 @@
+export declare enum ENVIRONMENT_TYPES {
+  PRODUCTION = 'prod',
+  HOMOLOGATION = 'hmg',
+  DEVELOPMENT = 'dev',
+  LOCAL = 'local',
+  TEST = 'test',
+}

package/dist/clean-arch/infra/environment/environment.js

@@ -0,0 +1,11 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.ENVIRONMENT_TYPES = void 0;
+var ENVIRONMENT_TYPES;
+(function (ENVIRONMENT_TYPES) {
+  ENVIRONMENT_TYPES['PRODUCTION'] = 'prod';
+  ENVIRONMENT_TYPES['HOMOLOGATION'] = 'hmg';
+  ENVIRONMENT_TYPES['DEVELOPMENT'] = 'dev';
+  ENVIRONMENT_TYPES['LOCAL'] = 'local';
+  ENVIRONMENT_TYPES['TEST'] = 'test';
+})(ENVIRONMENT_TYPES || (exports.ENVIRONMENT_TYPES = ENVIRONMENT_TYPES = {}));

package/dist/infra/http/api-gateway/mapping-model.spec.js

@@ -58,6 +58,7 @@ describe('MappingModel', () => {
       expect(instance['getBody'].mock.calls.length).toBe(1);
       expect(instance['setHeader'].mock.calls).toStrictEqual([
         ['authorizations', ['test']],
+        ['accept-encoding', 'identity'],
       ]);
       expect(instance['deleteParams'].mock.calls.length).toBe(1);
       expect(instance['next'].mock.calls.length).toBe(1);
@@ -115,6 +116,7 @@ describe('MappingModel', () => {
         ['header_name_2', 'header_value_2'],
         ['accept', 'new_header_accept'],
         ['authorizations', ['test']],
+        ['accept-encoding', 'identity'],
       ]);
       expect(instance['setQuery'].mock.calls).toStrictEqual([
         ['query_string_name_1', 'query_string_value_1'],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seidor-cloud-produtos/orbit-backend-lib",
-  "version": "0.0.65",
+  "version": "0.0.66",
   "description": "Internal lib for backend components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -79,10 +79,13 @@
   "dependencies": {
     "@fastify/cors": "8.3.0",
     "@nestjs/common": "8.4.7",
-    "tslib": "2.6.2",
     "amqplib": "0.10.4",
     "compression": "1.7.4",
     "express": "4.19.2",
-    "fastify": "4.18.0"
+    "fastify": "4.18.0",
+    "ioredis": "5.4.1",
+    "node-cache": "5.1.2",
+    "tslib": "2.6.2",
+    "zod": "3.23.8"
   }
 }