@nest-omni/core 4.1.3-17 → 4.1.3-19

package/cache/dependencies/db.dependency.d.ts

@@ -89,11 +89,6 @@ export declare class DbDependency implements CacheDependency {
      * @param name The data source name (default: 'default')
      */
     static setDefaultDataSourceName(name: string): void;
-    /**
-     * Get the current fallback DataSource
-     * @deprecated Use DataSourceUtil.getDataSource() instead
-     */
-    static getDataSource(): DataSource | null;
     /**
      * Get DataSource for executing queries
      * Priority: 1. Specific dataSourceName from options, 2. Default from getDataSourceByName, 3. Fallback

package/cache/dependencies/db.dependency.js

@@ -91,13 +91,6 @@ class DbDependency {
     static setDefaultDataSourceName(name) {
         this.defaultDataSourceName = name;
     }
-    /**
-     * Get the current fallback DataSource
-     * @deprecated Use DataSourceUtil.getDataSource() instead
-     */
-    static getDataSource() {
-        return this.fallbackDataSource;
-    }
     /**
      * Get DataSource for executing queries
      * Priority: 1. Specific dataSourceName from options, 2. Default from getDataSourceByName, 3. Fallback

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-omni/core",
-  "version": "4.1.3-17",
+  "version": "4.1.3-19",
   "description": "A comprehensive NestJS framework for building enterprise-grade applications with best practices",
   "main": "index.js",
   "types": "index.d.ts",
@@ -54,7 +54,7 @@
   "dependencies": {
     "@dataui/crud": "^5.3.4",
     "@dataui/crud-typeorm": "^5.3.4",
-    "@nest-omni/transaction": "^1.0.0",
+    "@nest-omni/transaction": "*",
     "@nestjs/bull": "^11.0.4",
     "@nestjs/common": "^11.1.7",
     "@nestjs/config": "^4.0.2",

package/setup/index.d.ts

@@ -2,3 +2,4 @@ export * from './bootstrap.setup';
 export * from './mode.setup';
 export * from './worker.decorator';
 export * from './schedule.decorator';
+export * from './run-in-mode.decorator';

package/setup/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./bootstrap.setup"), exports);
 __exportStar(require("./mode.setup"), exports);
 __exportStar(require("./worker.decorator"), exports);
 __exportStar(require("./schedule.decorator"), exports);
+__exportStar(require("./run-in-mode.decorator"), exports);

package/setup/run-in-mode.decorator.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Mode-Aware Method Decorators
+ *
+ * Conditional method execution based on application mode:
+ * - HTTP: Only HTTP server (no workers/schedulers)
+ * - WORKER: Only background workers and schedulers (no HTTP server)
+ * - HYBRID: Both HTTP server and workers (default)
+ */
+/**
+ * Method only executes in HTTP mode (skipped in WORKER and HYBRID)
+ *
+ * @example
+ * ```typescript
+ * @RunOnlyInHttp()
+ * async handleApiRequest() {
+ *   // Only runs when APP_MODE=http
+ * }
+ * ```
+ */
+export declare function RunOnlyInHttp(): MethodDecorator;
+/**
+ * Method only executes in WORKER mode (skipped in HTTP and HYBRID)
+ *
+ * @example
+ * ```typescript
+ * @RunOnlyInWorker()
+ * async processBackgroundJob() {
+ *   // Only runs when APP_MODE=worker
+ * }
+ * ```
+ */
+export declare function RunOnlyInWorker(): MethodDecorator;
+/**
+ * Method executes in HTTP or HYBRID mode (skipped in WORKER-only mode)
+ *
+ * @example
+ * ```typescript
+ * @RunInHttpOrHybrid()
+ * async handleWebRequest() {
+ *   // Runs in HTTP or HYBRID mode
+ * }
+ * ```
+ */
+export declare function RunInHttpOrHybrid(): MethodDecorator;
+/**
+ * Method executes in WORKER or HYBRID mode (skipped in HTTP-only mode)
+ *
+ * @example
+ * ```typescript
+ * @RunInWorkerOrHybrid()
+ * async processScheduledTask() {
+ *   // Runs in WORKER or HYBRID mode
+ * }
+ * ```
+ */
+export declare function RunInWorkerOrHybrid(): MethodDecorator;

package/setup/run-in-mode.decorator.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * Mode-Aware Method Decorators
+ *
+ * Conditional method execution based on application mode:
+ * - HTTP: Only HTTP server (no workers/schedulers)
+ * - WORKER: Only background workers and schedulers (no HTTP server)
+ * - HYBRID: Both HTTP server and workers (default)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunOnlyInHttp = RunOnlyInHttp;
+exports.RunOnlyInWorker = RunOnlyInWorker;
+exports.RunInHttpOrHybrid = RunInHttpOrHybrid;
+exports.RunInWorkerOrHybrid = RunInWorkerOrHybrid;
+const common_1 = require("@nestjs/common");
+const mode_setup_1 = require("./mode.setup");
+/**
+ * Create mode-restricted decorator
+ */
+function createModeDecorator(allowedModes) {
+    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}`);
+        descriptor.value = function (...args) {
+            const currentMode = (0, mode_setup_1.getApplicationMode)();
+            if (!allowedModes.includes(currentMode)) {
+                logger.log(`Skipped (current: ${currentMode}, allowed: ${allowedModes.join(', ')})`);
+                return undefined;
+            }
+            return originalMethod.apply(this, args);
+        };
+        return descriptor;
+    };
+}
+/**
+ * Method only executes in HTTP mode (skipped in WORKER and HYBRID)
+ *
+ * @example
+ * ```typescript
+ * @RunOnlyInHttp()
+ * async handleApiRequest() {
+ *   // Only runs when APP_MODE=http
+ * }
+ * ```
+ */
+function RunOnlyInHttp() {
+    return createModeDecorator([mode_setup_1.ApplicationMode.HTTP]);
+}
+/**
+ * Method only executes in WORKER mode (skipped in HTTP and HYBRID)
+ *
+ * @example
+ * ```typescript
+ * @RunOnlyInWorker()
+ * async processBackgroundJob() {
+ *   // Only runs when APP_MODE=worker
+ * }
+ * ```
+ */
+function RunOnlyInWorker() {
+    return createModeDecorator([mode_setup_1.ApplicationMode.WORKER]);
+}
+/**
+ * Method executes in HTTP or HYBRID mode (skipped in WORKER-only mode)
+ *
+ * @example
+ * ```typescript
+ * @RunInHttpOrHybrid()
+ * async handleWebRequest() {
+ *   // Runs in HTTP or HYBRID mode
+ * }
+ * ```
+ */
+function RunInHttpOrHybrid() {
+    return createModeDecorator([mode_setup_1.ApplicationMode.HTTP, mode_setup_1.ApplicationMode.HYBRID]);
+}
+/**
+ * Method executes in WORKER or HYBRID mode (skipped in HTTP-only mode)
+ *
+ * @example
+ * ```typescript
+ * @RunInWorkerOrHybrid()
+ * async processScheduledTask() {
+ *   // Runs in WORKER or HYBRID mode
+ * }
+ * ```
+ */
+function RunInWorkerOrHybrid() {
+    return createModeDecorator([mode_setup_1.ApplicationMode.WORKER, mode_setup_1.ApplicationMode.HYBRID]);
+}

package/setup/schedule.decorator.js

@@ -73,10 +73,14 @@ function executeWithRetry(fn, options) {
 function createWorkerDecorator(baseDecorator, decoratorName) {
     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}`);
         descriptor.value = function (...args) {
             return __awaiter(this, void 0, void 0, function* () {
                 // Only execute in worker or hybrid mode
                 if (!(0, mode_setup_1.shouldProcessQueues)()) {
+                    logger.log('Skipped (scheduled tasks require WORKER or HYBRID mode)');
                     return;
                 }
                 return originalMethod.apply(this, args);
@@ -102,6 +106,7 @@ function createWorkerDecoratorWithLock(baseDecorator, decoratorName, lockKey, op
             return __awaiter(this, void 0, void 0, function* () {
                 // Only execute in worker or hybrid mode
                 if (!(0, mode_setup_1.shouldProcessQueues)()) {
+                    logger.log('Skipped (scheduled tasks require WORKER or HYBRID mode)');
                     return;
                 }
                 // Get or create global instance - auto-configures from environment variables

package/setup/worker.decorator.js

@@ -20,6 +20,7 @@ exports.WorkerOnQueueCleaned = WorkerOnQueueCleaned;
 exports.WorkerOnQueueDrained = WorkerOnQueueDrained;
 exports.WorkerOnQueuePaused = WorkerOnQueuePaused;
 exports.WorkerOnQueueResumed = WorkerOnQueueResumed;
+const common_1 = require("@nestjs/common");
 const bull_1 = require("@nestjs/bull");
 const mode_setup_1 = require("./mode.setup");
 /**
@@ -67,8 +68,16 @@ function WorkerProcess(name) {
     if ((0, mode_setup_1.shouldProcessQueues)()) {
         return (0, bull_1.Process)(name);
     }
-    // In HTTP-only mode, return a no-op decorator
+    // In HTTP-only mode, return a decorator that logs and skips
     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}`);
+        descriptor.value = function (...args) {
+            logger.log('Skipped (queue processors require WORKER or HYBRID mode)');
+            return undefined;
+        };
         return descriptor;
     };
 }