@nest-omni/core 2.0.1-10 → 2.0.1-12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-omni/core",
-  "version": "2.0.1-10",
+  "version": "2.0.1-12",
   "description": "framework",
   "main": "index.js",
   "types": "index.d.ts",

package/setup/bootstrap.setup.js

@@ -16,6 +16,7 @@ const dotenv = require("dotenv");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const process = require("process");
+const mode_setup_1 = require("./mode.setup");
 function findValidRootPath() {
     const getAppRootPath = () => {
         if (require.main && require.main.filename) {
@@ -70,8 +71,9 @@ Sentry.init({
     release: process.env.API_VERSION || '',
     environment: process.env.NODE_ENV || 'unkown',
     debug: process.env.NODE_ENV === 'dev',
-    tracesSampleRate: 1.0,
-    profileSessionSampleRate: 1.0,
+    sampleRate: 1.0,
+    tracesSampleRate: 0.01,
+    profileSessionSampleRate: 0.01,
     profileLifecycle: 'trace',
     sendDefaultPii: true,
     integrations: [profiling_node_1.nodeProfilingIntegration],
@@ -116,79 +118,21 @@ crud_1.CrudConfigService.load({
         },
     },
 });
-const setupProcessHandlers = (app) => {
-    const logger = app.get(nestjs_pino_1.Logger);
-    process.on('uncaughtException', (error) => {
-        logger.fatal({ error, stack: error.stack, pid: process.pid }, 'Uncaught Exception');
-        process.exit(1);
-    });
-    process.on('unhandledRejection', (reason, promise) => {
-        logger.error({
-            reason: {
-                message: reason.message,
-                stack: reason.stack,
-                name: reason.name,
-            },
-            promise,
-            pid: process.pid,
-        }, 'Unhandled Rejection');
-    });
-    process.on('exit', (code) => {
-        logger.warn(`Process exiting with code ${code}`, {
-            uptime: process.uptime(),
-            memoryUsage: process.memoryUsage(),
-        });
-    });
-};
-const setupGracefulShutdown = (app) => {
-    const logger = app.get(nestjs_pino_1.Logger);
-    const shutdown = (signal) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a;
-        try {
-            logger.warn(`Received ${signal}, starting graceful shutdown...`, {
-                uptime: process.uptime(),
-                connections: (_a = app.getHttpServer()) === null || _a === void 0 ? void 0 : _a.address(),
-            });
-            yield Promise.race([
-                app.close(),
-                new Promise((_, reject) => setTimeout(() => reject(new Error('Shutdown timeout exceeded')), 15000)),
-            ]);
-            logger.log('Application successfully closed', {
-                resourcesReleased: true,
-                pid: process.pid,
-            });
-            process.exit(0);
-        }
-        catch (err) {
-            logger.error('Graceful shutdown failed', {
-                error: {
-                    message: err.message,
-                    stack: err.stack,
-                    name: err.name,
-                },
-                critical: true,
-                pid: process.pid,
-            });
-            process.exit(1);
-        }
-    });
-    process.on('SIGQUIT', () => shutdown('SIGQUIT'));
-    process.on('SIGHUP', () => shutdown('SIGHUP'));
-    process.on('SIGTERM', () => shutdown('SIGTERM'));
-    process.on('SIGINT', () => shutdown('SIGINT'));
-};
 function bootstrapSetup(AppModule, SetupSwagger) {
     return __awaiter(this, void 0, void 0, function* () {
         (0, typeorm_transactional_1.initializeTransactionalContext)();
+        const shouldStartHttp = (0, mode_setup_1.shouldStartHttpServer)();
         const app = yield core_1.NestFactory.create(AppModule, {
             bufferLogs: true,
+            abortOnError: false,
+            autoFlushLogs: true,
         });
         (0, class_validator_1.useContainer)(app.select(AppModule), { fallbackOnErrors: true });
         const configService = app.select(__1.ServiceRegistryModule).get(__1.ApiConfigService);
         const logger = app.get(nestjs_pino_1.Logger);
-        setupProcessHandlers(app);
+        logger.log(`Application Mode: ${(0, mode_setup_1.getModeDescription)()}`);
+        logger.log(`Environment: ${process.env.NODE_ENV || 'unknown'}`);
         app.enableShutdownHooks();
-        setupGracefulShutdown(app);
         app.enableVersioning();
         app.enable('trust proxy');
         app.use(bodyParse.json({ limit: '50mb' }), new nestjs_cls_1.ClsMiddleware({}).use, (0, __1.RequestIdMiddleware)(), (0, __1.PowerByMiddleware)(), (0, __1.OmniAuthMiddleware)(), compression());
@@ -202,26 +146,33 @@ function bootstrapSetup(AppModule, SetupSwagger) {
             stopAtFirstError: true,
             validationError: { target: false, value: false },
         }));
-        if (configService.documentationEnabled && SetupSwagger) {
-            SetupSwagger(app, configService.documentationPath);
-            logger.log(`Swagger docs available at ${configService.documentationPath}`);
-        }
-        if (configService.viewsEnabled) {
-            app.setBaseViewsDir((0, path_1.join)(__1.ApiConfigService.rootPath, 'views'));
-            app.setViewEngine('ejs');
-            logger.log('View engine initialized');
-        }
-        if (configService.sessionEnabled) {
-            app.use(session(configService.sessionConfig));
-            logger.log('Session middleware enabled');
+        if (shouldStartHttp) {
+            if (configService.documentationEnabled && SetupSwagger) {
+                SetupSwagger(app, configService.documentationPath);
+                logger.log(`Swagger docs available at ${configService.documentationPath}`);
+            }
+            if (configService.viewsEnabled) {
+                app.setBaseViewsDir((0, path_1.join)(__1.ApiConfigService.rootPath, 'views'));
+                app.setViewEngine('ejs');
+                logger.log('View engine initialized');
+            }
+            if (configService.sessionEnabled) {
+                app.use(session(configService.sessionConfig));
+                logger.log('Session middleware enabled');
+            }
+            if (configService.corsEnabled) {
+                app.enableCors(configService.corsConfig);
+                logger.log('CORS configuration applied');
+            }
+            const port = configService.appConfig.port;
+            yield app.listen(port);
+            logger.log(`HTTP Server running on ${yield app.getUrl()}`);
         }
-        if (configService.corsEnabled) {
-            app.enableCors(configService.corsConfig);
-            logger.log('CORS configuration applied');
+        else {
+            logger.log('Running in Worker-only mode - HTTP server not started');
+            logger.log('Application is ready to process background tasks');
+            yield app.init();
         }
-        const port = configService.appConfig.port;
-        yield app.listen(port);
-        logger.log(`Server running on ${yield app.getUrl()}`);
         return app;
     });
 }

package/setup/index.d.ts

@@ -1 +1,6 @@
 export * from './bootstrap.setup';
+export * from './mode.setup';
+export * from './worker.decorator';
+export * from './schedule.decorator';
+export * from './redis.lock.service';
+export * from './redis.lock.decorator';

package/setup/index.js

@@ -15,3 +15,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./bootstrap.setup"), exports);
+__exportStar(require("./mode.setup"), exports);
+__exportStar(require("./worker.decorator"), exports);
+__exportStar(require("./schedule.decorator"), exports);
+__exportStar(require("./redis.lock.service"), exports);
+__exportStar(require("./redis.lock.decorator"), exports);

package/setup/mode.setup.d.ts

@@ -0,0 +1,12 @@
+export declare enum ApplicationMode {
+    HTTP = "http",
+    WORKER = "worker",
+    HYBRID = "hybrid"
+}
+export declare function getApplicationMode(): ApplicationMode;
+export declare function shouldProcessQueues(): boolean;
+export declare function shouldStartHttpServer(): boolean;
+export declare function isHttpMode(): boolean;
+export declare function isWorkerMode(): boolean;
+export declare function isHybridMode(): boolean;
+export declare function getModeDescription(): string;

package/setup/mode.setup.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationMode = void 0;
+exports.getApplicationMode = getApplicationMode;
+exports.shouldProcessQueues = shouldProcessQueues;
+exports.shouldStartHttpServer = shouldStartHttpServer;
+exports.isHttpMode = isHttpMode;
+exports.isWorkerMode = isWorkerMode;
+exports.isHybridMode = isHybridMode;
+exports.getModeDescription = getModeDescription;
+var ApplicationMode;
+(function (ApplicationMode) {
+    ApplicationMode["HTTP"] = "http";
+    ApplicationMode["WORKER"] = "worker";
+    ApplicationMode["HYBRID"] = "hybrid";
+})(ApplicationMode || (exports.ApplicationMode = ApplicationMode = {}));
+function getApplicationMode() {
+    const mode = (process.env.APP_MODE || process.env.MODE || 'hybrid')
+        .toLowerCase()
+        .trim();
+    switch (mode) {
+        case 'http':
+            return ApplicationMode.HTTP;
+        case 'worker':
+            return ApplicationMode.WORKER;
+        case 'hybrid':
+        default:
+            return ApplicationMode.HYBRID;
+    }
+}
+function shouldProcessQueues() {
+    const mode = getApplicationMode();
+    return mode === ApplicationMode.WORKER || mode === ApplicationMode.HYBRID;
+}
+function shouldStartHttpServer() {
+    const mode = getApplicationMode();
+    return mode === ApplicationMode.HTTP || mode === ApplicationMode.HYBRID;
+}
+function isHttpMode() {
+    return getApplicationMode() === ApplicationMode.HTTP;
+}
+function isWorkerMode() {
+    return getApplicationMode() === ApplicationMode.WORKER;
+}
+function isHybridMode() {
+    return getApplicationMode() === ApplicationMode.HYBRID;
+}
+function getModeDescription() {
+    const mode = getApplicationMode();
+    switch (mode) {
+        case ApplicationMode.HTTP:
+            return 'HTTP-only mode (no background workers)';
+        case ApplicationMode.WORKER:
+            return 'Worker-only mode (no HTTP server)';
+        case ApplicationMode.HYBRID:
+            return 'Hybrid mode (HTTP server + background workers)';
+        default:
+            return 'Unknown mode';
+    }
+}

package/setup/redis.lock.decorator.d.ts

@@ -0,0 +1,5 @@
+import type { LockOptions } from './redis.lock.service';
+export declare function UseRedisLock(lockKey: string, options?: LockOptions & {
+    skipReturnValue?: any;
+}): MethodDecorator;
+export declare function UseRedisLockOrSkip(lockKey: string, ttl?: number): MethodDecorator;

package/setup/redis.lock.decorator.js

@@ -0,0 +1,56 @@
+"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.UseRedisLock = UseRedisLock;
+exports.UseRedisLockOrSkip = UseRedisLockOrSkip;
+const common_1 = require("@nestjs/common");
+function UseRedisLock(lockKey, options = {}) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const logger = new common_1.Logger(`RedisLock:${String(propertyKey)}`);
+        descriptor.value = function (...args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const lockService = this.lockService;
+                if (!lockService) {
+                    logger.error(`RedisLockService not found on ${target.constructor.name}. ` +
+                        `Please inject RedisLockService as 'lockService' in the constructor.`);
+                    throw new Error(`RedisLockService not found. Please inject it as 'lockService'.`);
+                }
+                const skipReturnValue = (_a = options.skipReturnValue) !== null && _a !== void 0 ? _a : null;
+                const lockResult = yield lockService.acquireLock(lockKey, options);
+                if (!lockResult.acquired) {
+                    logger.log(`Lock '${lockKey}' is already held, skipping execution of ${String(propertyKey)}`);
+                    return skipReturnValue;
+                }
+                logger.debug(`Lock '${lockKey}' acquired, executing ${String(propertyKey)}`);
+                try {
+                    return yield originalMethod.apply(this, args);
+                }
+                catch (error) {
+                    logger.error(`Error executing ${String(propertyKey)} with lock '${lockKey}':`, error);
+                    throw error;
+                }
+                finally {
+                    yield lockService.releaseLock(lockKey, lockResult.lockValue, options.keyPrefix);
+                    logger.debug(`Lock '${lockKey}' released`);
+                }
+            });
+        };
+        return descriptor;
+    };
+}
+function UseRedisLockOrSkip(lockKey, ttl = 300000) {
+    return UseRedisLock(lockKey, {
+        ttl,
+        skipReturnValue: false,
+    });
+}

package/setup/redis.lock.service.d.ts

@@ -0,0 +1,30 @@
+import { OnModuleInit } from '@nestjs/common';
+import { RedisService } from '@liaoliaots/nestjs-redis';
+export interface LockOptions {
+    ttl?: number;
+    retryCount?: number;
+    retryDelay?: number;
+    keyPrefix?: string;
+    throwOnFailure?: boolean;
+}
+export interface LockResult {
+    acquired: boolean;
+    lockValue?: string;
+    error?: string;
+}
+export declare class RedisLockService implements OnModuleInit {
+    private readonly redisService;
+    private readonly logger;
+    private redis;
+    private readonly defaultOptions;
+    constructor(redisService: RedisService);
+    onModuleInit(): void;
+    private generateLockValue;
+    private buildLockKey;
+    private sleep;
+    acquireLock(key: string, options?: LockOptions): Promise<LockResult>;
+    releaseLock(key: string, lockValue: string, keyPrefix?: string): Promise<boolean>;
+    extendLock(key: string, lockValue: string, ttl: number, keyPrefix?: string): Promise<boolean>;
+    isLocked(key: string, keyPrefix?: string): Promise<boolean>;
+    withLock<T>(key: string, fn: () => Promise<T>, options?: LockOptions): Promise<T | null>;
+}

package/setup/redis.lock.service.js

@@ -0,0 +1,185 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+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 RedisLockService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisLockService = void 0;
+const common_1 = require("@nestjs/common");
+const nestjs_redis_1 = require("@liaoliaots/nestjs-redis");
+let RedisLockService = RedisLockService_1 = class RedisLockService {
+    constructor(redisService) {
+        this.redisService = redisService;
+        this.logger = new common_1.Logger(RedisLockService_1.name);
+        this.defaultOptions = {
+            ttl: 300000,
+            retryCount: 0,
+            retryDelay: 100,
+            keyPrefix: 'lock',
+            throwOnFailure: false,
+        };
+    }
+    onModuleInit() {
+        try {
+            this.redis = this.redisService.getOrThrow();
+            this.logger.log('RedisLockService initialized successfully');
+        }
+        catch (error) {
+            this.logger.error('Failed to initialize RedisLockService', error);
+            throw error;
+        }
+    }
+    generateLockValue() {
+        return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+    }
+    buildLockKey(key, prefix = 'lock') {
+        return `${prefix}:${key}`;
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    acquireLock(key_1) {
+        return __awaiter(this, arguments, void 0, function* (key, options = {}) {
+            const opts = Object.assign(Object.assign({}, this.defaultOptions), options);
+            const lockKey = this.buildLockKey(key, opts.keyPrefix);
+            const lockValue = this.generateLockValue();
+            let attempts = 0;
+            const maxAttempts = opts.retryCount + 1;
+            while (attempts < maxAttempts) {
+                try {
+                    const result = yield this.redis.set(lockKey, lockValue, 'PX', opts.ttl, 'NX');
+                    if (result === 'OK') {
+                        this.logger.debug(`Lock acquired: ${lockKey} (value: ${lockValue}, ttl: ${opts.ttl}ms)`);
+                        return { acquired: true, lockValue };
+                    }
+                    attempts++;
+                    if (attempts < maxAttempts) {
+                        this.logger.debug(`Lock acquisition failed for ${lockKey}, retrying... (${attempts}/${opts.retryCount})`);
+                        yield this.sleep(opts.retryDelay);
+                    }
+                }
+                catch (error) {
+                    const errorMessage = `Error acquiring lock for ${lockKey}: ${error.message}`;
+                    this.logger.error(errorMessage, error.stack);
+                    if (opts.throwOnFailure) {
+                        throw new Error(errorMessage);
+                    }
+                    return { acquired: false, error: errorMessage };
+                }
+            }
+            const failureMessage = `Failed to acquire lock for ${lockKey} after ${attempts} attempts`;
+            this.logger.warn(failureMessage);
+            if (opts.throwOnFailure) {
+                throw new Error(failureMessage);
+            }
+            return { acquired: false, error: failureMessage };
+        });
+    }
+    releaseLock(key_1, lockValue_1) {
+        return __awaiter(this, arguments, void 0, function* (key, lockValue, keyPrefix = 'lock') {
+            const lockKey = this.buildLockKey(key, keyPrefix);
+            try {
+                const script = `
+        if redis.call("get", KEYS[1]) == ARGV[1] then
+          return redis.call("del", KEYS[1])
+        else
+          return 0
+        end
+      `;
+                const result = yield this.redis.eval(script, 1, lockKey, lockValue);
+                if (result === 1) {
+                    this.logger.debug(`Lock released: ${lockKey}`);
+                    return true;
+                }
+                else {
+                    this.logger.warn(`Lock release failed: ${lockKey} (lock value mismatch or already expired)`);
+                    return false;
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error releasing lock for ${lockKey}: ${error.message}`, error.stack);
+                return false;
+            }
+        });
+    }
+    extendLock(key_1, lockValue_1, ttl_1) {
+        return __awaiter(this, arguments, void 0, function* (key, lockValue, ttl, keyPrefix = 'lock') {
+            const lockKey = this.buildLockKey(key, keyPrefix);
+            try {
+                const script = `
+        if redis.call("get", KEYS[1]) == ARGV[1] then
+          return redis.call("pexpire", KEYS[1], ARGV[2])
+        else
+          return 0
+        end
+      `;
+                const result = yield this.redis.eval(script, 1, lockKey, lockValue, ttl);
+                if (result === 1) {
+                    this.logger.debug(`Lock extended: ${lockKey} (new ttl: ${ttl}ms)`);
+                    return true;
+                }
+                else {
+                    this.logger.warn(`Lock extension failed: ${lockKey} (lock value mismatch or doesn't exist)`);
+                    return false;
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error extending lock for ${lockKey}: ${error.message}`, error.stack);
+                return false;
+            }
+        });
+    }
+    isLocked(key_1) {
+        return __awaiter(this, arguments, void 0, function* (key, keyPrefix = 'lock') {
+            const lockKey = this.buildLockKey(key, keyPrefix);
+            try {
+                const exists = yield this.redis.exists(lockKey);
+                return exists === 1;
+            }
+            catch (error) {
+                this.logger.error(`Error checking lock existence for ${lockKey}: ${error.message}`, error.stack);
+                return false;
+            }
+        });
+    }
+    withLock(key_1, fn_1) {
+        return __awaiter(this, arguments, void 0, function* (key, fn, options = {}) {
+            const lockResult = yield this.acquireLock(key, options);
+            if (!lockResult.acquired) {
+                this.logger.warn(`Could not acquire lock for ${key}, skipping execution`);
+                return null;
+            }
+            try {
+                const result = yield fn();
+                return result;
+            }
+            catch (error) {
+                this.logger.error(`Error executing function with lock ${key}:`, error);
+                throw error;
+            }
+            finally {
+                yield this.releaseLock(key, lockResult.lockValue, options.keyPrefix);
+            }
+        });
+    }
+};
+exports.RedisLockService = RedisLockService;
+exports.RedisLockService = RedisLockService = RedisLockService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [nestjs_redis_1.RedisService])
+], RedisLockService);

package/setup/schedule.decorator.d.ts

@@ -0,0 +1,21 @@
+import type { CronOptions } from '@nestjs/schedule';
+export declare function WorkerCron(cronTime: string | Date, options?: CronOptions): MethodDecorator;
+export declare function WorkerInterval(timeout: number, options?: {
+    name?: string;
+}): MethodDecorator;
+export declare function WorkerTimeout(timeout: number, options?: {
+    name?: string;
+}): MethodDecorator;
+export declare function WorkerCronWithLock(cronTime: string | Date, lockKey: string, lockTtl?: number, cronOptions?: CronOptions): MethodDecorator;
+export declare function WorkerIntervalWithLock(timeout: number, lockKey: string, lockTtl?: number, intervalOptions?: {
+    name?: string;
+}): MethodDecorator;
+export declare function WorkerTimeoutWithLock(timeout: number, lockKey: string, lockTtl?: number, timeoutOptions?: {
+    name?: string;
+}): MethodDecorator;
+export declare function WorkerCronAdvanced(cronTime: string | Date, lockKey: string, options?: {
+    lockTtl?: number;
+    cronOptions?: CronOptions;
+    logExecution?: boolean;
+    onError?: (error: Error) => void;
+}): MethodDecorator;