@edirect/redis 11.0.0 → 11.0.7

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edirect/redis",
-  "version": "11.0.0",
+  "version": "11.0.6",
   "packageScope": "@edirect",
   "type": "module",
   "main": "./dist/index.esm.js",
@@ -20,10 +20,10 @@
     "!**/*.tsbuildinfo"
   ],
   "dependencies": {
-    "@edirect/config": "^11",
-    "@edirect/logger": "^11",
+    "@edirect/config": "workspace:*",
+    "@edirect/logger": "workspace:*",
     "@nestjs/common": "^11.1.6",
-    "@nx/rollup": "21.3.11"
+    "redis": "^5.8.2"
   },
   "devDependencies": {
     "@nx/rollup": "21.3.11"

package/dist/src/constants.js

@@ -0,0 +1,2 @@
+export const REDIS_CLIENT_KEY = 'REDIS_CLIENT';
+export const REDIS_SERVICE_KEY = 'REDIS_SERVICE';

package/dist/src/index.js

@@ -0,0 +1,5 @@
+export { REDIS_CLIENT_KEY, REDIS_SERVICE_KEY } from './constants';
+export { RedisClientModule } from './redis.client.module';
+export { RedisModule } from './redis.module';
+export { createRedisClientProvider, RedisClientProvider, RedisProviders, } from './redis.providers';
+export { RedisService } from './redis.service';

package/dist/src/redis.client.module.js

@@ -0,0 +1,22 @@
+var RedisClientModule_1;
+import { __decorate } from "tslib";
+import { Global, Module } from '@nestjs/common';
+import { createRedisClientProvider, RedisProviders } from './redis.providers';
+let RedisClientModule = RedisClientModule_1 = class RedisClientModule {
+    static forRoot(options, provide) {
+        const redisProviders = RedisProviders(provide);
+        return {
+            module: RedisClientModule_1,
+            providers: [
+                createRedisClientProvider(options),
+                ...redisProviders
+            ],
+            exports: [...redisProviders],
+        };
+    }
+};
+RedisClientModule = RedisClientModule_1 = __decorate([
+    Global(),
+    Module({})
+], RedisClientModule);
+export { RedisClientModule };

package/dist/src/redis.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/src/redis.module.js

@@ -0,0 +1,14 @@
+import { __decorate } from "tslib";
+import { Global, Module } from '@nestjs/common';
+import { RedisClientProvider, RedisProviders } from './redis.providers';
+const providers = RedisProviders();
+let RedisModule = class RedisModule {
+};
+RedisModule = __decorate([
+    Global(),
+    Module({
+        providers: [RedisClientProvider, ...providers],
+        exports: [...providers],
+    })
+], RedisModule);
+export { RedisModule };

package/dist/src/redis.providers.js

@@ -0,0 +1,57 @@
+import { ConfigService } from '@edirect/config';
+import { createClient } from 'redis';
+import { REDIS_CLIENT_KEY, REDIS_SERVICE_KEY } from './constants';
+import { RedisService } from './redis.service';
+import { LoggerService } from '@edirect/logger';
+const defaultOptions = (configService, loggerService) => ({
+    url: `redis://${configService.get('REDIS_HOST')}:${configService.get('REDIS_PORT')}`,
+    ...((configService.get('REDIS_PASS') ||
+        configService.get('REDIS_PASSWORD')) && {
+        password: configService.get('REDIS_PASS') ||
+            configService.get('REDIS_PASSWORD'),
+    }),
+    pingInterval: 1000,
+    socket: {
+        connectTimeout: 10000,
+        keepAlive: true,
+        noDelay: true,
+        reconnectStrategy(retries, cause) {
+            if (cause) {
+                loggerService.error('Error connecting to redis', JSON.stringify(cause));
+            }
+            return Math.min(retries * 50, 500);
+        },
+    },
+});
+export const createRedisClientProvider = (options) => ({
+    provide: REDIS_CLIENT_KEY,
+    useFactory: async (configService, loggerService) => {
+        const redisClient = createClient({
+            ...defaultOptions(configService, loggerService),
+            ...options,
+        });
+        await redisClient.connect();
+        return redisClient;
+    },
+    inject: [ConfigService, LoggerService],
+});
+export const RedisClientProvider = {
+    provide: REDIS_CLIENT_KEY,
+    useFactory: async (configService, loggerService) => {
+        const redisClient = createClient(defaultOptions(configService, loggerService));
+        await redisClient.connect();
+        return redisClient;
+    },
+    inject: [ConfigService, LoggerService],
+};
+export const RedisProviders = (provide) => [
+    {
+        provide: provide || REDIS_SERVICE_KEY,
+        useFactory: (redisClient, configService, loggerService) => new RedisService(redisClient, configService, loggerService),
+        inject: [REDIS_CLIENT_KEY, ConfigService, LoggerService],
+    },
+    {
+        provide: RedisService,
+        useExisting: provide || REDIS_SERVICE_KEY,
+    },
+];

package/dist/src/redis.service.js

@@ -0,0 +1,127 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { Injectable, Inject } from '@nestjs/common';
+import { ConfigService } from '@edirect/config';
+import { LoggerService } from '@edirect/logger';
+import { REDIS_CLIENT_KEY } from './constants';
+let RedisService = class RedisService {
+    redisClient;
+    configService;
+    loggerService;
+    constructor(redisClient, configService, loggerService) {
+        this.redisClient = redisClient;
+        this.configService = configService;
+        this.loggerService = loggerService;
+    }
+    async get(key) {
+        try {
+            const ret = await this.redisClient.get(key);
+            return ret ? JSON.parse(ret) : null;
+        }
+        catch (error) {
+            this.loggerService.error('Error when executing GET command in redis', JSON.stringify(error));
+            throw error;
+        }
+    }
+    async mget(keys) {
+        try {
+            const ret = await this.redisClient.mGet(keys);
+            return ret ? ret.map((item) => (item ? JSON.parse(item) : null)) : [];
+        }
+        catch (error) {
+            this.loggerService.error('Error when executing MGET command in redis', JSON.stringify(error));
+            throw error;
+        }
+    }
+    async hget(hash, field) {
+        try {
+            const ret = await this.redisClient.hGet(hash, field);
+            return ret ? JSON.parse(ret) : null;
+        }
+        catch (error) {
+            this.loggerService.error('Error when executing HGET command in redis', JSON.stringify(error));
+            throw error;
+        }
+    }
+    async hgetall(hash) {
+        try {
+            const ret = await this.redisClient.hGetAll(hash);
+            const result = {};
+            for (const [key, value] of Object.entries(ret)) {
+                result[key] = value ? JSON.parse(value) : null;
+            }
+            return result;
+        }
+        catch (error) {
+            this.loggerService.error('Error when executing HGETALL command in redis', JSON.stringify(error));
+            throw error;
+        }
+    }
+    async set(key, data, ttl, ttlType = 'EX') {
+        try {
+            if (!ttl)
+                ttl = parseInt(this.configService.get('REDIS_TTL') || '0', 10);
+            if (data instanceof Object)
+                data = JSON.stringify(data);
+            if (ttl > 0) {
+                await this.redisClient.set(key, data, {
+                    expiration: {
+                        type: ttlType,
+                        value: ttl,
+                    },
+                });
+            }
+            else {
+                await this.redisClient.set(key, data);
+            }
+        }
+        catch (error) {
+            this.loggerService.error(`Error when executing SET${ttlType === 'EX' ? '' : ttlType} command in redis`, JSON.stringify(error));
+            throw error;
+        }
+    }
+    async del(key) {
+        try {
+            await this.redisClient.del(key);
+        }
+        catch (error) {
+            this.loggerService.error('Error when executing DEL command in redis', JSON.stringify(error));
+            throw error;
+        }
+    }
+    async setnx(key, data) {
+        try {
+            if (data instanceof Object)
+                data = JSON.stringify(data);
+            return (await this.redisClient.setNX(key, data)) === 1;
+        }
+        catch (error) {
+            this.loggerService.error('Error when executing SETNX command in redis', JSON.stringify(error));
+            throw error;
+        }
+    }
+    async asyncPing() {
+        return (await this.redisClient.ping()) === 'PONG';
+    }
+    async keys(key) {
+        try {
+            const ret = await this.redisClient.keys(key);
+            if (Array.isArray(ret)) {
+                return ret.map((item) => (item ? JSON.parse(item) : null));
+            }
+            return ret ? JSON.parse(ret) : [];
+        }
+        catch (error) {
+            this.loggerService.error('Error when executing KEYS command in redis', JSON.stringify(error));
+            throw error;
+        }
+    }
+};
+RedisService = __decorate([
+    Injectable(),
+    __param(0, Inject(REDIS_CLIENT_KEY)),
+    __param(1, Inject(ConfigService)),
+    __param(2, Inject(LoggerService)),
+    __metadata("design:paramtypes", [Object, ConfigService,
+        LoggerService])
+], RedisService);
+export { RedisService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edirect/redis",
-  "version": "11.0.0",
+  "version": "11.0.7",
   "packageScope": "@edirect",
   "type": "module",
   "main": "./dist/index.esm.js",
@@ -21,9 +21,9 @@
   ],
   "dependencies": {
     "@nestjs/common": "^11.1.6",
-    "@nx/rollup": "21.3.11",
-    "@edirect/config": "11.0.0",
-    "@edirect/logger": "11.0.0"
+    "redis": "^5.8.2",
+    "@edirect/config": "11.0.7",
+    "@edirect/logger": "11.0.7"
   },
   "devDependencies": {
     "@nx/rollup": "21.3.11"