@nest-omni/core 2.0.1-9 → 3.1.1-11

package/setup/schedule.decorator.js

@@ -0,0 +1,233 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerCron = WorkerCron;
+exports.WorkerInterval = WorkerInterval;
+exports.WorkerTimeout = WorkerTimeout;
+exports.WorkerCronWithLock = WorkerCronWithLock;
+exports.WorkerIntervalWithLock = WorkerIntervalWithLock;
+exports.WorkerTimeoutWithLock = WorkerTimeoutWithLock;
+exports.WorkerCronSmart = WorkerCronSmart;
+exports.WorkerIntervalSmart = WorkerIntervalSmart;
+exports.WorkerCronAdvanced = WorkerCronAdvanced;
+const common_1 = require("@nestjs/common");
+const schedule_1 = require("@nestjs/schedule");
+const mode_setup_1 = require("./mode.setup");
+const redis_lock_service_1 = require("./redis-lock.service");
+function generateLockKey(className, methodName) {
+    return `${className}.${methodName}`;
+}
+function executeWithRetry(fn, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { retryCount = 0, retryDelay = 1000, useExponentialBackoff = false, maxRetryDelay = 60000, logger, taskName, } = options;
+        let lastError;
+        let attempt = 0;
+        while (attempt <= retryCount) {
+            try {
+                return yield fn();
+            }
+            catch (error) {
+                lastError = error;
+                attempt++;
+                if (attempt <= retryCount) {
+                    let delay = retryDelay;
+                    if (useExponentialBackoff) {
+                        delay = Math.min(retryDelay * Math.pow(2, attempt - 1), maxRetryDelay);
+                    }
+                    logger.warn(`Task "${taskName}" failed (attempt ${attempt}/${retryCount + 1}), ` +
+                        `retrying in ${delay}ms... Error: ${error.message}`);
+                    yield new Promise((resolve) => setTimeout(resolve, delay));
+                }
+            }
+        }
+        throw lastError;
+    });
+}
+function createWorkerDecorator(baseDecorator, decoratorName) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!(0, mode_setup_1.shouldProcessQueues)()) {
+                    return;
+                }
+                return originalMethod.apply(this, args);
+            });
+        };
+        baseDecorator(target, propertyKey, descriptor);
+        return descriptor;
+    };
+}
+function createWorkerDecoratorWithLock(baseDecorator, decoratorName, lockKey, options = {}) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const className = target.constructor.name;
+        const methodName = String(propertyKey);
+        const logger = new common_1.Logger(`${className}.${methodName}`);
+        const resolvedLockKey = typeof lockKey === 'function' ? lockKey() : lockKey;
+        descriptor.value = function (...args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!(0, mode_setup_1.shouldProcessQueues)()) {
+                    return;
+                }
+                const lockService = redis_lock_service_1.RedisLockService.getOrCreateGlobalInstance();
+                const { lockTtl = 3600000, retryCount = 0, retryDelay = 1000, useExponentialBackoff = false, maxRetryDelay = 60000, logExecution = true, lockKeyPrefix = 'schedule', autoExtendLock = 0, onSuccess, onError, skipIfLocked = true, } = options;
+                const fullLockKey = `${lockKeyPrefix}:${resolvedLockKey}`;
+                const startTime = Date.now();
+                if (logExecution) {
+                    logger.log(`Task starting...`);
+                }
+                try {
+                    const lockResult = yield lockService.acquireLock(resolvedLockKey, {
+                        ttl: lockTtl,
+                        keyPrefix: lockKeyPrefix,
+                        autoExtend: autoExtendLock,
+                    });
+                    if (!lockResult.acquired) {
+                        if (skipIfLocked) {
+                            logger.debug(`Lock "${fullLockKey}" is held by another instance, skipping execution`);
+                            return null;
+                        }
+                        else {
+                            throw new Error(`Failed to acquire lock "${fullLockKey}"`);
+                        }
+                    }
+                    try {
+                        const result = yield executeWithRetry(() => originalMethod.apply(this, args), {
+                            retryCount,
+                            retryDelay,
+                            useExponentialBackoff,
+                            maxRetryDelay,
+                            logger,
+                            taskName: `${className}.${methodName}`,
+                        });
+                        const duration = Date.now() - startTime;
+                        if (logExecution) {
+                            logger.log(`Task completed successfully in ${duration}ms`);
+                        }
+                        if (onSuccess) {
+                            yield onSuccess(duration);
+                        }
+                        return result;
+                    }
+                    finally {
+                        if (lockResult.autoExtendTimer) {
+                            clearInterval(lockResult.autoExtendTimer);
+                        }
+                        yield lockService.releaseLock(resolvedLockKey, lockResult.lockValue, lockKeyPrefix);
+                        if (logExecution) {
+                            logger.debug(`Lock "${fullLockKey}" released`);
+                        }
+                    }
+                }
+                catch (error) {
+                    const duration = Date.now() - startTime;
+                    if (logExecution) {
+                        logger.error(`Task failed after ${duration}ms: ${error.message}`, error.stack);
+                    }
+                    if (onError) {
+                        yield onError(error);
+                    }
+                    throw error;
+                }
+            });
+        };
+        baseDecorator(target, propertyKey, descriptor);
+        return descriptor;
+    };
+}
+function WorkerCron(cronTime, options) {
+    return createWorkerDecorator((0, schedule_1.Cron)(cronTime, options), 'WorkerCron');
+}
+function WorkerInterval(timeout, name) {
+    if (name) {
+        return createWorkerDecorator((0, schedule_1.Interval)(name, timeout), 'WorkerInterval');
+    }
+    return createWorkerDecorator((0, schedule_1.Interval)(timeout), 'WorkerInterval');
+}
+function WorkerTimeout(timeout, name) {
+    if (name) {
+        return createWorkerDecorator((0, schedule_1.Timeout)(name, timeout), 'WorkerTimeout');
+    }
+    return createWorkerDecorator((0, schedule_1.Timeout)(timeout), 'WorkerTimeout');
+}
+function WorkerCronWithLock(cronTime, lockKeyOrOptions, lockTtl, cronOptions) {
+    return function (target, propertyKey, descriptor) {
+        let lockKey;
+        let options;
+        if (typeof lockKeyOrOptions === 'string') {
+            lockKey = lockKeyOrOptions;
+            options = { lockTtl: lockTtl || 3600000 };
+        }
+        else {
+            lockKey = generateLockKey(target.constructor.name, String(propertyKey));
+            options = lockKeyOrOptions;
+        }
+        return createWorkerDecoratorWithLock((0, schedule_1.Cron)(cronTime, cronOptions), 'WorkerCronWithLock', lockKey, options)(target, propertyKey, descriptor);
+    };
+}
+function WorkerIntervalWithLock(timeout, lockKeyOrOptions, lockTtl) {
+    return function (target, propertyKey, descriptor) {
+        let lockKey;
+        let options;
+        if (typeof lockKeyOrOptions === 'string') {
+            lockKey = lockKeyOrOptions;
+            options = { lockTtl: lockTtl || Math.floor(timeout * 0.8) };
+        }
+        else {
+            lockKey = generateLockKey(target.constructor.name, String(propertyKey));
+            options = Object.assign({ lockTtl: Math.floor(timeout * 0.8) }, lockKeyOrOptions);
+        }
+        return createWorkerDecoratorWithLock((0, schedule_1.Interval)(timeout), 'WorkerIntervalWithLock', lockKey, options)(target, propertyKey, descriptor);
+    };
+}
+function WorkerTimeoutWithLock(timeout, lockKeyOrOptions, lockTtl) {
+    return function (target, propertyKey, descriptor) {
+        let lockKey;
+        let options;
+        if (typeof lockKeyOrOptions === 'string') {
+            lockKey = lockKeyOrOptions;
+            options = { lockTtl: lockTtl || 300000 };
+        }
+        else {
+            lockKey = generateLockKey(target.constructor.name, String(propertyKey));
+            options = lockKeyOrOptions;
+        }
+        return createWorkerDecoratorWithLock((0, schedule_1.Timeout)(timeout), 'WorkerTimeoutWithLock', lockKey, options)(target, propertyKey, descriptor);
+    };
+}
+function WorkerCronSmart(cronTime, options = {}, cronOptions) {
+    return function (target, propertyKey, descriptor) {
+        const lockKey = generateLockKey(target.constructor.name, String(propertyKey));
+        return createWorkerDecoratorWithLock((0, schedule_1.Cron)(cronTime, cronOptions), 'WorkerCronSmart', lockKey, Object.assign({ lockTtl: 3600000, logExecution: true }, options))(target, propertyKey, descriptor);
+    };
+}
+function WorkerIntervalSmart(timeout, options = {}) {
+    return function (target, propertyKey, descriptor) {
+        const lockKey = generateLockKey(target.constructor.name, String(propertyKey));
+        return createWorkerDecoratorWithLock((0, schedule_1.Interval)(timeout), 'WorkerIntervalSmart', lockKey, Object.assign({ lockTtl: Math.floor(timeout * 0.8), logExecution: true }, options))(target, propertyKey, descriptor);
+    };
+}
+function WorkerCronAdvanced(cronTime, lockKeyOrOptions, options, cronOptions) {
+    return function (target, propertyKey, descriptor) {
+        let lockKey;
+        let finalOptions;
+        if (typeof lockKeyOrOptions === 'string') {
+            lockKey = lockKeyOrOptions;
+            finalOptions = Object.assign({ lockTtl: 3600000, logExecution: true }, options);
+        }
+        else {
+            lockKey = generateLockKey(target.constructor.name, String(propertyKey));
+            finalOptions = Object.assign({ lockTtl: 3600000, logExecution: true }, lockKeyOrOptions);
+        }
+        return createWorkerDecoratorWithLock((0, schedule_1.Cron)(cronTime, cronOptions), 'WorkerCronAdvanced', lockKey, finalOptions)(target, propertyKey, descriptor);
+    };
+}

package/setup/worker.decorator.d.ts

@@ -0,0 +1,14 @@
+export declare function WorkerProcessor(queueName?: string): ClassDecorator;
+export declare function WorkerProcess(name?: string): MethodDecorator;
+export declare function WorkerOnQueueActive(): MethodDecorator;
+export declare function WorkerOnQueueCompleted(): MethodDecorator;
+export declare function WorkerOnQueueProgress(): MethodDecorator;
+export declare function WorkerOnQueueFailed(): MethodDecorator;
+export declare function WorkerOnQueueError(): MethodDecorator;
+export declare function WorkerOnQueueWaiting(): MethodDecorator;
+export declare function WorkerOnQueueStalled(): MethodDecorator;
+export declare function WorkerOnQueueRemoved(): MethodDecorator;
+export declare function WorkerOnQueueCleaned(): MethodDecorator;
+export declare function WorkerOnQueueDrained(): MethodDecorator;
+export declare function WorkerOnQueuePaused(): MethodDecorator;
+export declare function WorkerOnQueueResumed(): MethodDecorator;

package/setup/worker.decorator.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerProcessor = WorkerProcessor;
+exports.WorkerProcess = WorkerProcess;
+exports.WorkerOnQueueActive = WorkerOnQueueActive;
+exports.WorkerOnQueueCompleted = WorkerOnQueueCompleted;
+exports.WorkerOnQueueProgress = WorkerOnQueueProgress;
+exports.WorkerOnQueueFailed = WorkerOnQueueFailed;
+exports.WorkerOnQueueError = WorkerOnQueueError;
+exports.WorkerOnQueueWaiting = WorkerOnQueueWaiting;
+exports.WorkerOnQueueStalled = WorkerOnQueueStalled;
+exports.WorkerOnQueueRemoved = WorkerOnQueueRemoved;
+exports.WorkerOnQueueCleaned = WorkerOnQueueCleaned;
+exports.WorkerOnQueueDrained = WorkerOnQueueDrained;
+exports.WorkerOnQueuePaused = WorkerOnQueuePaused;
+exports.WorkerOnQueueResumed = WorkerOnQueueResumed;
+const bull_1 = require("@nestjs/bull");
+const mode_setup_1 = require("./mode.setup");
+function WorkerProcessor(queueName) {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.Processor)(queueName);
+    }
+    return function (constructor) {
+        return constructor;
+    };
+}
+function WorkerProcess(name) {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.Process)(name);
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueActive() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueActive)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueCompleted() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueCompleted)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueProgress() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueProgress)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueFailed() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueFailed)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueError() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueError)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueWaiting() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueWaiting)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueStalled() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueStalled)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueRemoved() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueRemoved)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueCleaned() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueCleaned)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueDrained() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueDrained)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueuePaused() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueuePaused)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueResumed() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueResumed)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}

package/shared/serviceRegistryModule.js

@@ -5,34 +5,26 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-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 _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceRegistryModule = void 0;
 const path = require("path");
 const process = require("process");
-const typeorm_1 = require("typeorm");
 const bull_1 = require("@nestjs/bull");
 const nestjs_pino_1 = require("nestjs-pino");
 const config_1 = require("@nestjs/config");
 const common_1 = require("@nestjs/common");
-const typeorm_2 = require("@nestjs/typeorm");
+const typeorm_1 = require("@nestjs/typeorm");
 const schedule_1 = require("@nestjs/schedule");
 const setup_1 = require("@sentry/nestjs/setup");
 const cache_manager_1 = require("@nestjs/cache-manager");
-const typeorm_transactional_1 = require("typeorm-transactional");
+const transactional_1 = require("@nestjs-cls/transactional");
+const transactional_adapter_typeorm_1 = require("@nestjs-cls/transactional-adapter-typeorm");
 const nestjs_i18n_1 = require("nestjs-i18n");
-const health_checker_module_1 = require("../health-checker/health-checker.module");
+const health_checker_1 = require("../health-checker");
 const services_1 = require("./services");
 const nestjs_cls_1 = require("nestjs-cls");
+const typeorm_2 = require("typeorm");
 const providers = [
     services_1.ApiConfigService,
     services_1.ValidatorService,
@@ -40,7 +32,7 @@ const providers = [
     services_1.TranslationService,
 ];
 if (!((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a.ENV_FILE_PATH)) {
-    require('../setup/bootstrap.setup');
+    Promise.resolve().then(() => require('../setup/bootstrap.setup'));
 }
 services_1.ApiConfigService.rootPath = process.env.ROOT_PATH;
 const modules = [
@@ -54,6 +46,15 @@ const modules = [
     nestjs_cls_1.ClsModule.forRoot({
         global: true,
         middleware: { mount: true },
+        plugins: [
+            new transactional_1.ClsPluginTransactional({
+                imports: [typeorm_1.TypeOrmModule],
+                adapter: new transactional_adapter_typeorm_1.TransactionalAdapterTypeOrm({
+                    dataSourceToken: typeorm_2.DataSource,
+                }),
+                enableTransactionProxy: true,
+            }),
+        ],
     }),
     nestjs_pino_1.LoggerModule.forRootAsync({
         inject: [services_1.ApiConfigService],
@@ -71,15 +72,12 @@ const modules = [
         }),
         resolvers: [new nestjs_i18n_1.QueryResolver(['lang']), nestjs_i18n_1.AcceptLanguageResolver],
     }),
-    health_checker_module_1.HealthCheckerModule,
+    health_checker_1.HealthCheckerModule,
 ];
 if (services_1.ApiConfigService.toBoolean(process.env.DB_ENABLED, true)) {
-    modules.push(typeorm_2.TypeOrmModule.forRootAsync({
+    modules.push(typeorm_1.TypeOrmModule.forRootAsync({
         inject: [services_1.ApiConfigService],
         useFactory: (config) => config.typeormConfig,
-        dataSourceFactory: (options) => __awaiter(void 0, void 0, void 0, function* () {
-            return (0, typeorm_transactional_1.addTransactionalDataSource)(new typeorm_1.DataSource(options));
-        }),
     }));
 }
 if (services_1.ApiConfigService.toBoolean(process.env.BULL_ENABLED)) {

package/shared/services/api-config.service.d.ts

@@ -5,21 +5,17 @@ import { Params } from 'nestjs-pino';
 import { BullRootModuleOptions } from '@nestjs/bull/dist/interfaces/bull-module-options.interface';
 import { AxiosProxyConfig } from 'axios';
 import { CorsOptions } from '@nestjs/common/interfaces/external/cors-options.interface';
+import Keyv from 'keyv';
 export declare class ApiConfigService {
     private configService;
     static rootPath: string;
     constructor(configService: ConfigService);
-    static getRootPath(): string;
     get isDev(): boolean;
     get apiVersion(): string;
     get isProd(): boolean;
     get isSit(): boolean;
     get isUat(): boolean;
     get isTest(): boolean;
-    getNumber(key: string, defaultValue?: number): number;
-    getBoolean(key: string, defaultValue?: boolean): boolean;
-    static toBoolean(value: string, defaultValue?: any): boolean;
-    getString(key: string): string;
     get nodeEnv(): string;
     get fallbackLanguage(): string;
     get typeormConfig(): TypeOrmModuleOptions;
@@ -48,11 +44,16 @@ export declare class ApiConfigService {
     };
     get isRedisEnabled(): boolean;
     get bullConfig(): BullRootModuleOptions;
+    get pinoConfig(): Params;
+    get axiosProxyConfig(): AxiosProxyConfig | false;
+    static getRootPath(): string;
+    static toBoolean(value: string, defaultValue?: any): boolean;
+    getNumber(key: string, defaultValue?: number): number;
+    getBoolean(key: string, defaultValue?: boolean): boolean;
+    getString(key: string, defaultValue?: string): string;
     cacheConfig(): Promise<{
         isGlobal: boolean;
-        store: import("cache-manager-ioredis-yet").RedisStore;
+        store: Keyv<any>;
     }>;
-    get pinoConfig(): Params;
-    get axiosProxyConfig(): AxiosProxyConfig | false;
     private get;
 }

package/shared/services/api-config.service.js

@@ -23,20 +23,15 @@ exports.ApiConfigService = void 0;
 const common_1 = require("@nestjs/common");
 const config_1 = require("@nestjs/config");
 const lodash_1 = require("lodash");
-const cache_manager_ioredis_yet_1 = require("cache-manager-ioredis-yet");
 const connect_redis_1 = require("connect-redis");
 const ioredis_1 = require("ioredis");
 const common_2 = require("../../common");
+const keyv_1 = require("keyv");
+const redis_1 = require("@keyv/redis");
 let ApiConfigService = ApiConfigService_1 = class ApiConfigService {
     constructor(configService) {
         this.configService = configService;
     }
-    static getRootPath() {
-        if (!ApiConfigService_1.rootPath) {
-            throw new Error(`rootPath is not set`);
-        }
-        return ApiConfigService_1.rootPath;
-    }
     get isDev() {
         return this.nodeEnv === 'dev';
     }
@@ -55,34 +50,6 @@ let ApiConfigService = ApiConfigService_1 = class ApiConfigService {
     get isTest() {
         return this.nodeEnv === 'test';
     }
-    getNumber(key, defaultValue) {
-        const value = this.get(key, defaultValue);
-        try {
-            return Number(value);
-        }
-        catch (_a) {
-            throw new Error(`key:${key}, value:${value} - is not a number`);
-        }
-    }
-    getBoolean(key, defaultValue) {
-        const value = this.get(key, defaultValue);
-        return ApiConfigService_1.toBoolean(value);
-    }
-    static toBoolean(value, defaultValue = null) {
-        try {
-            return Boolean(JSON.parse(value));
-        }
-        catch (_a) {
-            if (!(0, lodash_1.isNil)(defaultValue)) {
-                return defaultValue;
-            }
-            throw new Error(`value:${value} - is not a boolean`);
-        }
-    }
-    getString(key) {
-        const value = this.get(key);
-        return value.replace(/\\n/g, '\n');
-    }
     get nodeEnv() {
         return this.getString('NODE_ENV');
     }
@@ -92,11 +59,11 @@ let ApiConfigService = ApiConfigService_1 = class ApiConfigService {
     get typeormConfig() {
         return {
             autoLoadEntities: true,
-            keepConnectionAlive: !this.isDev,
             type: 'mysql',
             host: this.getString('DB_HOST'),
             port: this.getNumber('DB_PORT'),
             username: this.getString('DB_USERNAME'),
+            entityPrefix: this.getString('DB_PREFIX', '').toLowerCase(),
             password: this.getString('DB_PASSWORD'),
             database: this.getString('DB_DATABASE'),
             subscribers: [],
@@ -131,6 +98,7 @@ let ApiConfigService = ApiConfigService_1 = class ApiConfigService {
             return this.getBoolean('CORS_ENABLED');
         }
         catch (error) {
+            console.log(error);
             return false;
         }
     }
@@ -170,8 +138,9 @@ let ApiConfigService = ApiConfigService_1 = class ApiConfigService {
             saveUninitialized: false,
         };
         if (this.getBoolean('SESSION_REDIS_ENABLED')) {
-            config.store = new connect_redis_1.default({
-                client: new ioredis_1.default(this.ioRedisConfig),
+            const redisClient = new ioredis_1.default(this.ioRedisConfig);
+            config.store = new connect_redis_1.RedisStore({
+                client: redisClient,
                 prefix: this.getString('SESSION_REDIS_PREFIX'),
             });
         }
@@ -232,14 +201,6 @@ let ApiConfigService = ApiConfigService_1 = class ApiConfigService {
             },
         };
     }
-    cacheConfig() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return {
-                isGlobal: true,
-                store: yield (0, cache_manager_ioredis_yet_1.redisStore)(Object.assign(Object.assign({}, this.ioRedisConfig), { ttl: this.getNumber('CACHE_TTL') })),
-            };
-        });
-    }
     get pinoConfig() {
         const transport = this.isDev
             ? {
@@ -284,6 +245,54 @@ let ApiConfigService = ApiConfigService_1 = class ApiConfigService {
             port: this.getNumber('DIRECT_PROXY_PORT'),
         };
     }
+    static getRootPath() {
+        if (!ApiConfigService_1.rootPath) {
+            throw new Error(`rootPath is not set`);
+        }
+        return ApiConfigService_1.rootPath;
+    }
+    static toBoolean(value, defaultValue = null) {
+        try {
+            return Boolean(JSON.parse(value));
+        }
+        catch (_a) {
+            if (!(0, lodash_1.isNil)(defaultValue)) {
+                return defaultValue;
+            }
+            throw new Error(`value:${value} - is not a boolean`);
+        }
+    }
+    getNumber(key, defaultValue) {
+        const value = this.get(key, defaultValue);
+        try {
+            return Number(value);
+        }
+        catch (_a) {
+            throw new Error(`key:${key}, value:${value} - is not a number`);
+        }
+    }
+    getBoolean(key, defaultValue) {
+        const value = this.get(key, defaultValue);
+        return ApiConfigService_1.toBoolean(value);
+    }
+    getString(key, defaultValue) {
+        const value = this.get(key, defaultValue);
+        return value.replace(/\\n/g, '\n');
+    }
+    cacheConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const uri = `redis://${this.getString('REDIS_USERNAME') ? this.getString('REDIS_USERNAME') + ':' : ''}${this.getString('REDIS_PASSWORD') ? this.getString('REDIS_PASSWORD') + '@' : ''}${this.getString('REDIS_HOST')}:${this.getNumber('REDIS_PORT')}/${this.getNumber('REDIS_DB')}`;
+            const keyvRedis = new redis_1.default(uri);
+            const store = new keyv_1.default({
+                store: keyvRedis,
+                ttl: this.getNumber('CACHE_TTL'),
+            });
+            return {
+                isGlobal: true,
+                store,
+            };
+        });
+    }
     get(key, defaultValue) {
         const value = this.configService.get(key);
         if ((0, lodash_1.isNil)(value)) {

package/validator-json/default.js

@@ -83,7 +83,15 @@ function applyConverters(propertyMetadatas, options, i18n) {
         const converterResult = typeof converter === 'function' ? converter(meta, options) : converter;
         const items = {};
         let message = '';
-        const originMessage = typeof meta.message === 'function' ? meta.message(meta) : meta.message;
+        const originMessage = typeof meta.message === 'function'
+            ? meta.message({
+                value: undefined,
+                constraints: meta.constraints,
+                targetName: meta.target.name || '',
+                object: {},
+                property: meta.propertyName,
+            })
+            : meta.message;
         if ((0, lodash_1.isString)(originMessage)) {
             const [translationKey, argsString] = originMessage.split('|');
             const args = !!argsString ? JSON.parse(argsString) : {};