prime-sdk 1.1.4 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prime-sdk",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "swiss army knife",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -32,6 +32,7 @@
     "@nestjs/config": "^3.2.2",
     "@nestjs/core": "^10.0.0",
     "@nestjs/platform-express": "^10.0.0",
+    "ioredis": "^5.4.1",
     "reflect-metadata": "^0.2.0",
     "rxjs": "^7.8.1"
   },

package/src/app.module.ts

@@ -5,6 +5,10 @@ import { StorageModule } from './lib/storage/storage.module';
 import { EventModule } from './lib/events/event.module';
 import { CryptoModule } from './lib/crypto/crypto.module';
 import { EmailModule } from './lib/email/email.module';
+import { CacheModule } from './lib/cache/cache.module';
+import { TypeRedis } from './external/redis/types/ioredis.types';
+import { ICache } from './lib/cache/interfaces/cache.interface';
+import { Cache } from './lib/cache/cache';
 
 //Example
 @Module({
@@ -49,8 +53,18 @@ import { EmailModule } from './lib/email/email.module';
       endpoint: 'http://localhost:4566/',
       region: 'us-east-1',
     }),
+    CacheModule.forRoot({
+      type: TypeRedis.SIMPLE,
+      connection: {
+        host: 'localhost',
+        port: 6379,
+      },
+      redisOptions: {
+        db: 5,
+      },
+    }),
   ],
-  providers: [AppService],
+  providers: [AppService, { provide: ICache, useClass: Cache }],
   exports: [],
 })
 export class AppModule {}

package/src/app.service.ts

@@ -1,9 +1,10 @@
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
 import { IConsumer } from './lib/queue/interfaces/consumer.interface';
 import { Message } from '@aws-sdk/client-sqs';
 import { Queue } from './lib/queue/queue';
 import { Storage } from './lib/storage/storage';
 import { Events } from './lib/events/events';
+import { ICache } from './lib/cache/interfaces/cache.interface';
 
 @Injectable()
 export class AppService implements IConsumer {
@@ -11,6 +12,7 @@ export class AppService implements IConsumer {
     private readonly queueHandler: Queue,
     private readonly storage: Storage,
     private readonly event: Events,
+    @Inject(ICache) private readonly cache: ICache,
   ) {
     this.queueHandler.handler({
       QueueUrl: `${'teste'}`,
@@ -20,9 +22,19 @@ export class AppService implements IConsumer {
     });
   }
 
-  handleMessage(message: Message | Message[]): Promise<void> {
+  async handleMessage(message: Message | Message[]): Promise<void> {
     console.log(message);
 
+    const key = `data:${new Date().toISOString()}`;
+
+    this.cache.set(key, JSON.stringify(message));
+
+    const value = await this.cache.get(key);
+
+    console.log(value);
+
+    this.cache.delete(key);
+
     const data = JSON.stringify({ teste: new Date().toISOString() });
 
     this.event.triggerEvent({

package/src/external/redis/interfaces/redis.interface.ts

@@ -0,0 +1,13 @@
+export interface IRedisService {
+  setRedisKey(
+    key: string,
+    value: Date | number | Buffer | string,
+    ttl?: number,
+  ): Promise<void>;
+
+  getRedisKey(key: string): Promise<string>;
+
+  deleteRedisKey(key: string): Promise<void>;
+}
+
+export const IRedisService = Symbol('IRedisService');

package/src/external/redis/redis.provider.ts

@@ -0,0 +1,41 @@
+import { DynamicModule, Module } from '@nestjs/common';
+import { Redis, Cluster } from 'ioredis';
+import {
+  ClusterRedisSetup,
+  SimpleRedisSetup,
+  TypeRedis,
+} from './types/ioredis.types';
+
+const RedisProvider = (params: SimpleRedisSetup | ClusterRedisSetup) => {
+  return {
+    provide: 'CONNECTION_REDIS',
+    useFactory: (): Redis | Cluster => {
+      switch (params.type) {
+        case TypeRedis.SIMPLE:
+          return new Redis({
+            port: params.connection.port,
+            host: params.connection.host,
+            ...(params.redisOptions && { ...params.redisOptions }),
+          });
+        case TypeRedis.CLUSTER:
+          const cluster = new Redis.Cluster(
+            params.nodes,
+            params.clusterOptions,
+          );
+          return cluster;
+      }
+    },
+  };
+};
+
+@Module({})
+export class RedisModule {
+  static forRoot(params: SimpleRedisSetup | ClusterRedisSetup): DynamicModule {
+    const redisProvider = RedisProvider(params);
+    return {
+      module: RedisModule,
+      providers: [redisProvider],
+      exports: [redisProvider],
+    };
+  }
+}

package/src/external/redis/redis.service.ts

@@ -0,0 +1,32 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { Cluster, Redis } from 'ioredis';
+import { IRedisService } from './interfaces/redis.interface';
+
+@Injectable()
+export class RedisService implements IRedisService {
+  constructor(
+    @Inject('CONNECTION_REDIS') private readonly client: Cluster | Redis,
+  ) {}
+
+  async setRedisKey(
+    key: string,
+    value: Date | number | Buffer | string,
+    ttl?: number,
+  ): Promise<void> {
+    if (value instanceof Date) {
+      value = value.toISOString();
+    }
+    if (ttl) {
+      await this.client.set(key, value, 'EX', ttl);
+    } else {
+      await this.client.set(key, value);
+    }
+  }
+  async getRedisKey(key: string): Promise<string> {
+    return await this.client.get(key);
+  }
+
+  async deleteRedisKey(key: string): Promise<void> {
+    await this.client.del(key);
+  }
+}

package/src/external/redis/types/ioredis.types.ts

@@ -0,0 +1,23 @@
+import { ClusterOptions, RedisOptions } from 'ioredis';
+
+export enum TypeRedis {
+  SIMPLE = 'simple',
+  CLUSTER = 'cluster',
+}
+
+export type Connection = {
+  port: number;
+  host: string;
+};
+
+export type SimpleRedisSetup = {
+  type: TypeRedis.SIMPLE;
+  connection: Connection;
+  redisOptions?: RedisOptions;
+};
+
+export type ClusterRedisSetup = {
+  type: TypeRedis.CLUSTER;
+  nodes: Connection[];
+  clusterOptions?: ClusterOptions;
+};

package/src/index.ts

@@ -18,6 +18,15 @@ import { CryptoModule } from './lib/crypto/crypto.module';
 import { Crypto } from './lib/crypto/crypto';
 import { ICrypto } from './lib/crypto/interfaces/crypto.interface';
 
+import { CacheModule } from './lib/cache/cache.module';
+import { Cache } from './lib/cache/cache';
+import { ICache } from './lib/cache/interfaces/cache.interface';
+import {
+  SimpleRedisSetup,
+  ClusterRedisSetup,
+  TypeRedis,
+} from './external/redis/types/ioredis.types';
+
 export {
   QueueModule,
   Queue,
@@ -34,4 +43,10 @@ export {
   CryptoModule,
   Crypto,
   ICrypto,
+  CacheModule,
+  Cache,
+  ICache,
+  SimpleRedisSetup,
+  ClusterRedisSetup,
+  TypeRedis,
 };

package/src/lib/cache/cache.module.ts

@@ -0,0 +1,28 @@
+import { DynamicModule, Module } from '@nestjs/common';
+import { RedisModule } from '../../external/redis/redis.provider';
+import { RedisService } from '../../external/redis/redis.service';
+import {
+  ClusterRedisSetup,
+  SimpleRedisSetup,
+} from '../../external/redis/types/ioredis.types';
+import { IRedisService } from '../../external/redis/interfaces/redis.interface';
+import { ICache } from './interfaces/cache.interface';
+import { Cache } from './cache';
+
+@Module({})
+export class CacheModule {
+  static forRoot(params: SimpleRedisSetup | ClusterRedisSetup): DynamicModule {
+    return {
+      module: CacheModule,
+      imports: [RedisModule.forRoot(params)],
+      providers: [
+        { provide: ICache, useClass: Cache },
+        { provide: IRedisService, useClass: RedisService },
+      ],
+      exports: [
+        { provide: ICache, useClass: Cache },
+        { provide: IRedisService, useClass: RedisService },
+      ],
+    };
+  }
+}

package/src/lib/cache/cache.ts

@@ -0,0 +1,22 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { ICache } from './interfaces/cache.interface';
+import { IRedisService } from 'src/external/redis/interfaces/redis.interface';
+
+@Injectable()
+export class Cache implements ICache {
+  constructor(@Inject(IRedisService) private readonly client: IRedisService) {}
+  async set(
+    key: string,
+    value: string | number | Date | Buffer,
+    ttl?: number,
+  ): Promise<void> {
+    await this.client.setRedisKey(key, value, ttl);
+  }
+  async get(key: string): Promise<string> {
+    return await this.client.getRedisKey(key);
+  }
+
+  async delete(key: string): Promise<void> {
+    await this.client.deleteRedisKey(key);
+  }
+}

package/src/lib/cache/interfaces/cache.interface.ts

@@ -0,0 +1,13 @@
+export interface ICache {
+  set(
+    key: string,
+    value: Date | number | Buffer | string,
+    ttl?: number,
+  ): Promise<void>;
+
+  get(key: string): Promise<string>;
+
+  delete(key: string): Promise<void>;
+}
+
+export const ICache = Symbol('ICache');