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

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) {
@@ -69,24 +70,24 @@ Sentry.init({
     dsn: process.env.SENTRY_DSN || '',
     release: process.env.API_VERSION || '',
     environment: process.env.NODE_ENV || 'unkown',
-    debug: process.env.NODE_ENV === 'dev',
-    tracesSampleRate: 1.0,
-    profileSessionSampleRate: 1.0,
+    debug: false,
+    sampleRate: 1.0,
+    tracesSampleRate: 0.01,
+    profileSessionSampleRate: 0.01,
     profileLifecycle: 'trace',
     sendDefaultPii: true,
     integrations: [profiling_node_1.nodeProfilingIntegration],
 });
 const crud_1 = require("@dataui/crud");
 const core_1 = require("@nestjs/core");
-const typeorm_transactional_1 = require("typeorm-transactional");
 const nestjs_pino_1 = require("nestjs-pino");
 const session = require("express-session");
 const bodyParse = require("body-parser");
+const compression = require("compression");
 const __1 = require("../");
 const common_1 = require("@nestjs/common");
 const nestjs_i18n_1 = require("nestjs-i18n");
 const nestjs_cls_1 = require("nestjs-cls");
-const compression = require("compression");
 const class_validator_1 = require("class-validator");
 const setup_1 = require("@sentry/nestjs/setup");
 crud_1.CrudConfigService.load({
@@ -116,79 +117,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,
+            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);
+        app.useLogger(logger);
+        app.flushLogs();
+        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 +145,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,78 @@
+"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 { RedisLockService } = yield Promise.resolve().then(() => require('./redis-lock.service'));
+                let lockService = RedisLockService.getGlobalInstance();
+                if (!lockService) {
+                    try {
+                        lockService = RedisLockService.getOrCreateGlobalInstance();
+                        logger.debug('RedisLockService auto-initialized for decorator');
+                    }
+                    catch (error) {
+                        logger.error(`Failed to auto-initialize RedisLockService: ${error.message}. ` +
+                            `Please ensure Redis is accessible or call configureRedisLock() in your application setup.`);
+                        throw new Error(`RedisLockService initialization failed. Please check Redis connection or call configureRedisLock() in your application setup.`);
+                    }
+                }
+                const skipReturnValue = (_a = options.skipReturnValue) !== null && _a !== void 0 ? _a : null;
+                try {
+                    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 {
+                        if (lockResult.autoExtendTimer) {
+                            clearInterval(lockResult.autoExtendTimer);
+                        }
+                        yield lockService.releaseLock(lockKey, lockResult.lockValue, options.keyPrefix);
+                        logger.debug(`Lock '${lockKey}' released`);
+                    }
+                }
+                catch (error) {
+                    if (error.message.includes('ECONNREFUSED') ||
+                        error.message.includes('Redis connection') ||
+                        error.message.includes('RedisLockService initialization failed')) {
+                        logger.error(`Redis connection error in ${String(propertyKey)}: ${error.message}. ` +
+                            `Skipping execution to prevent issues.`);
+                        return skipReturnValue;
+                    }
+                    throw error;
+                }
+            });
+        };
+        return descriptor;
+    };
+}
+function UseRedisLockOrSkip(lockKey, ttl = 300000) {
+    return UseRedisLock(lockKey, {
+        ttl,
+        skipReturnValue: false,
+    });
+}

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

@@ -0,0 +1,59 @@
+import { OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+export interface LockOptions {
+    ttl?: number;
+    retryCount?: number;
+    retryDelay?: number;
+    keyPrefix?: string;
+    throwOnFailure?: boolean;
+    autoExtend?: number;
+}
+export interface LockResult {
+    acquired: boolean;
+    lockValue?: string;
+    error?: string;
+    autoExtendTimer?: NodeJS.Timeout;
+}
+export interface RedisOptions {
+    host?: string;
+    port?: number;
+    password?: string;
+    db?: number;
+    retryDelay?: number;
+    maxRetries?: number;
+    reconnectOnError?: (err: Error) => boolean;
+}
+export declare class RedisLockService implements OnModuleInit, OnModuleDestroy {
+    private static globalInstance;
+    private static globalConfig;
+    private readonly logger;
+    private redis;
+    private redisOptions;
+    private isConnected;
+    private isConnecting;
+    private connectionPromise;
+    private readonly defaultOptions;
+    private readonly defaultRedisOptions;
+    constructor(redisOptions?: RedisOptions);
+    static initializeGlobalInstance(config?: RedisOptions): RedisLockService;
+    static getGlobalInstance(): RedisLockService | null;
+    static getOrCreateGlobalInstance(): RedisLockService;
+    static setGlobalInstance(instance: RedisLockService): void;
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    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>;
+    getLockInfo(key: string, keyPrefix?: string): Promise<{
+        value: string | null;
+        ttl: number | null;
+    }>;
+    forceRelease(key: string, keyPrefix?: string): Promise<boolean>;
+    getRedisOptions(): RedisOptions;
+    private getRedis;
+    private createRedisConnection;
+    private generateLockValue;
+    private buildLockKey;
+    private sleep;
+}