@onebun/core 0.2.10 → 0.2.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onebun/core",
-  "version": "0.2.10",
+  "version": "0.2.11",
   "description": "Core package for OneBun framework - decorators, DI, modules, controllers",
   "license": "LGPL-3.0",
   "author": "RemRyahirev",

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

package/src/testing/docs-examples.test.ts

@@ -22,7 +22,11 @@ import { Controller as BaseController } from '../module/controller';
 import { BaseService, Service } from '../module/service';
 
 import { createTestController, createTestService } from './service-helpers';
-import { createMockConfig, useFakeTimers } from './test-utils';
+import {
+  createMockConfig,
+  createMockLogger,
+  useFakeTimers,
+} from './test-utils';
 import { TestingModule } from './testing-module';
 
 // ============================================================================
@@ -161,6 +165,50 @@ describe('docs/testing.md — TestingModule', () => {
       await module?.close();
     }
   });
+
+  /**
+   * @source docs/testing.md#overrideproviderserviceclass
+   */
+  it('overrideProvider — replaces service with mock value', async () => {
+    const mockUser = { id: '1', name: 'MockUser' };
+    let module: CompiledTestingModule | undefined;
+
+    try {
+      module = await TestingModule
+        .create({ controllers: [UserController], providers: [UserService] })
+        .overrideProvider(UserService).useValue({ findById: () => mockUser })
+        .compile();
+
+      const response = await module.inject('GET', '/users/1');
+
+      expect(response.status).toBe(200);
+
+      const body = await response.json() as { result: { id: string; name: string } };
+      expect(body.result.name).toBe('MockUser');
+    } finally {
+      await module?.close();
+    }
+  });
+
+  /**
+   * @source docs/testing.md#setoptionsoptions
+   */
+  it('setOptions — applies basePath to routes', async () => {
+    let module: CompiledTestingModule | undefined;
+
+    try {
+      module = await TestingModule
+        .create({ controllers: [UserController], providers: [UserService] })
+        .setOptions({ basePath: '/api' })
+        .compile();
+
+      const response = await module.inject('GET', '/api/users/1');
+
+      expect(response.status).toBe(200);
+    } finally {
+      await module?.close();
+    }
+  });
 });
 
 // ============================================================================
@@ -191,6 +239,24 @@ describe('docs/testing.md — useFakeTimers', () => {
   });
 });
 
+// ============================================================================
+// createMockLogger — docs/testing.md
+// ============================================================================
+
+describe('docs/testing.md — createMockLogger', () => {
+  /**
+   * @source docs/testing.md#createmocklogger
+   */
+  it('basic usage — creates silent async logger', () => {
+    const logger = createMockLogger();
+
+    expect(logger).toBeDefined();
+    expect(typeof logger.info).toBe('function');
+    expect(typeof logger.child).toBe('function');
+    expect(logger.child({ context: 'test' })).toBe(logger);
+  });
+});
+
 // ============================================================================
 // createMockConfig — docs/testing.md
 // ============================================================================