@onebun/core 0.2.9 → 0.2.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onebun/core",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "Core package for OneBun framework - decorators, DI, modules, controllers",
   "license": "LGPL-3.0",
   "author": "RemRyahirev",
@@ -51,6 +51,14 @@
     "bun-types": "^1.3.8",
     "testcontainers": "^11.7.1"
   },
+  "peerDependencies": {
+    "testcontainers": ">=10.0.0"
+  },
+  "peerDependenciesMeta": {
+    "testcontainers": {
+      "optional": true
+    }
+  },
   "engines": {
     "bun": ">=1.2.12"
   }

package/src/application/application.test.ts

@@ -41,7 +41,14 @@ import { BaseMiddleware } from '../module/middleware';
 import { clearGlobalServicesRegistry } from '../module/module';
 import { Service } from '../module/service';
 import { QueueService, QUEUE_NOT_ENABLED_ERROR_MESSAGE } from '../queue';
-import { Subscribe } from '../queue/decorators';
+import { CronExpression } from '../queue/cron-expression';
+import {
+  Cron,
+  Interval,
+  OnQueueReady,
+  Subscribe,
+  Timeout,
+} from '../queue/decorators';
 import { makeMockLoggerLayer } from '../testing/test-utils';
 
 
@@ -4083,4 +4090,225 @@ describe('OneBunApplication', () => {
       await app.stop();
     });
   });
+
+  describe('queue auto-detection', () => {
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    const noop = () => {};
+
+    afterEach(async () => {
+      clearGlobalServicesRegistry();
+      register.clear();
+    });
+
+    test('auto-enables queue when controller has @Subscribe', async () => {
+      @Controller('/auto-sub')
+      class AutoSubController extends BaseController {
+        @Subscribe('auto.test')
+        async handle(): Promise<void> {}
+      }
+
+      @Module({ controllers: [AutoSubController] })
+      class AutoSubModule {}
+
+      const app = createTestApp(AutoSubModule, { port: 0 });
+      await app.start();
+
+      expect(app.getQueueService()).not.toBeNull();
+
+      await app.stop();
+    });
+
+    test('auto-enables queue when controller has @Cron', async () => {
+      @Controller('/auto-cron')
+      class AutoCronController extends BaseController {
+        @Cron(CronExpression.EVERY_MINUTE, { pattern: 'cron.test' })
+        getData() {
+          return { ts: Date.now() };
+        }
+      }
+
+      @Module({ controllers: [AutoCronController] })
+      class AutoCronModule {}
+
+      const app = createTestApp(AutoCronModule, { port: 0 });
+      await app.start();
+
+      expect(app.getQueueService()).not.toBeNull();
+
+      await app.stop();
+    });
+
+    test('auto-enables queue when controller has @Interval', async () => {
+       
+      const intervalMs = 5000;
+
+      @Controller('/auto-interval')
+      class AutoIntervalController extends BaseController {
+        @Interval(intervalMs, { pattern: 'interval.test' })
+        getData() {
+          return { ts: Date.now() };
+        }
+      }
+
+      @Module({ controllers: [AutoIntervalController] })
+      class AutoIntervalModule {}
+
+      const app = createTestApp(AutoIntervalModule, { port: 0 });
+      await app.start();
+
+      expect(app.getQueueService()).not.toBeNull();
+
+      await app.stop();
+    });
+
+    test('auto-enables queue when controller has @Timeout', async () => {
+       
+      const timeoutMs = 1000;
+
+      @Controller('/auto-timeout')
+      class AutoTimeoutController extends BaseController {
+        @Timeout(timeoutMs, { pattern: 'timeout.test' })
+        getData() {
+          return { ts: Date.now() };
+        }
+      }
+
+      @Module({ controllers: [AutoTimeoutController] })
+      class AutoTimeoutModule {}
+
+      const app = createTestApp(AutoTimeoutModule, { port: 0 });
+      await app.start();
+
+      expect(app.getQueueService()).not.toBeNull();
+
+      await app.stop();
+    });
+
+    test('does not enable queue when no queue decorators present', async () => {
+      @Controller('/plain')
+      class PlainController extends BaseController {
+        @Get('/')
+        async index(): Promise<OneBunResponse> {
+          return this.success({ ok: true });
+        }
+      }
+
+      @Module({ controllers: [PlainController] })
+      class PlainModule {}
+
+      const app = createTestApp(PlainModule, { port: 0 });
+      await app.start();
+
+      expect(app.getQueueService()).toBeNull();
+
+      await app.stop();
+    });
+
+    test('does not enable queue when only lifecycle decorators present', async () => {
+      @Controller('/lifecycle-only')
+      class LifecycleOnlyController extends BaseController {
+        @OnQueueReady()
+        onReady() {
+          noop();
+        }
+      }
+
+      @Module({ controllers: [LifecycleOnlyController] })
+      class LifecycleOnlyModule {}
+
+      const app = createTestApp(LifecycleOnlyModule, { port: 0 });
+      await app.start();
+
+      expect(app.getQueueService()).toBeNull();
+
+      await app.stop();
+    });
+
+    test('enabled: false overrides auto-detection', async () => {
+      @Controller('/force-off')
+      class ForceOffController extends BaseController {
+        @Subscribe('force.off')
+        async handle(): Promise<void> {}
+      }
+
+      @Module({ controllers: [ForceOffController] })
+      class ForceOffModule {}
+
+      const app = createTestApp(ForceOffModule, {
+        port: 0,
+        queue: { enabled: false },
+      });
+      await app.start();
+
+      expect(app.getQueueService()).toBeNull();
+
+      await app.stop();
+    });
+
+    test('auto-detects from nested child module', async () => {
+      @Controller('/child-auto')
+      class ChildAutoController extends BaseController {
+        @Subscribe('child.auto')
+        async handle(): Promise<void> {}
+      }
+
+      @Module({ controllers: [ChildAutoController] })
+      class ChildAutoModule {}
+
+      @Module({ imports: [ChildAutoModule] })
+      class ParentAutoModule {}
+
+      const app = createTestApp(ParentAutoModule, { port: 0 });
+      await app.start();
+
+      expect(app.getQueueService()).not.toBeNull();
+
+      await app.stop();
+    });
+
+    test('auto-detects from deeply nested module (grandchild)', async () => {
+      @Controller('/grandchild')
+      class GrandchildController extends BaseController {
+        @Subscribe('grandchild.event')
+        async handle(): Promise<void> {}
+      }
+
+      @Module({ controllers: [GrandchildController] })
+      class GrandchildModule {}
+
+      @Module({ imports: [GrandchildModule] })
+      class MiddleModule {}
+
+      @Module({ imports: [MiddleModule] })
+      class TopModule {}
+
+      const app = createTestApp(TopModule, { port: 0 });
+      await app.start();
+
+      expect(app.getQueueService()).not.toBeNull();
+
+      await app.stop();
+    });
+
+    test('getQueueService() returns null when queue not enabled', async () => {
+      @Controller('/no-queue')
+      class NoQueueController extends BaseController {
+        @Get('/')
+        async index(): Promise<OneBunResponse> {
+          return this.success({});
+        }
+      }
+
+      @Module({ controllers: [NoQueueController] })
+      class NoQueueModule {}
+
+      const app = createTestApp(NoQueueModule, { port: 0 });
+      await app.start();
+
+      const queueService = app.getQueueService();
+      expect(queueService).toBeNull();
+
+      await app.stop();
+    });
+  });
 });

package/src/decorators/decorators.ts

@@ -15,7 +15,11 @@ import {
   type RouteOptions,
 } from '../types';
 
-import { getConstructorParamTypes as getDesignParamTypes, Reflect } from './metadata';
+import {
+  copyAllMetadata,
+  getConstructorParamTypes as getDesignParamTypes,
+  Reflect,
+} from './metadata';
 
 /**
  * Metadata storage for controllers
@@ -174,6 +178,9 @@ export function controllerDecorator(basePath: string = '') {
       }
     }
 
+    // Copy all method-decorator metadata (queue decorators, etc.) from original to wrapped class
+    copyAllMetadata(target, WrappedController);
+
     // Copy metadata and static properties
     META_CONTROLLERS.set(WrappedController, metadata);
     META_CONTROLLERS.set(target, metadata); // Keep original for compatibility

package/src/decorators/metadata.ts

@@ -43,6 +43,31 @@ export function defineMetadata(
   keyMetadata.set(propertyKey || '', metadataValue);
 }
 
+/**
+ * Copy all metadata from one target to another.
+ * Used by @Controller to preserve method-decorator metadata (e.g. queue decorators)
+ * when wrapping the original class.
+ */
+export function copyAllMetadata(source: object, destination: object): void {
+  const sourceMetadata = metadataStorage.get(source);
+  if (!sourceMetadata) {
+    return;
+  }
+
+  let destMetadata = metadataStorage.get(destination);
+  if (!destMetadata) {
+    destMetadata = new Map<string, Map<string | symbol, any>>();
+    metadataStorage.set(destination, destMetadata);
+  }
+
+  for (const [metadataKey, keyMap] of sourceMetadata) {
+    // Only copy if destination doesn't already have this key
+    if (!destMetadata.has(metadataKey)) {
+      destMetadata.set(metadataKey, new Map(keyMap));
+    }
+  }
+}
+
 /**
  * Get metadata from a target object
  * @param metadataKey - The key for the metadata