@onebun/core 0.2.8 → 0.2.9

package/package.json

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

package/src/application/application.test.ts

@@ -38,6 +38,7 @@ import {
 } from '../decorators/decorators';
 import { Controller as BaseController } from '../module/controller';
 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';
@@ -157,6 +158,7 @@ describe('OneBunApplication', () => {
 
   afterEach(() => {
     register.clear();
+    clearGlobalServicesRegistry();
   });
 
   describe('Constructor and basic initialization', () => {
@@ -4036,5 +4038,49 @@ describe('OneBunApplication', () => {
 
       await app.stop();
     });
+
+    test('QueueService is injectable in controllers of child modules', async () => {
+      @Controller('/child-queue')
+      class ChildQueueController extends BaseController {
+        constructor(private queueService: QueueService) {
+          super();
+        }
+
+        publishTest(pattern: string, data: unknown) {
+          return this.queueService.publish(pattern, data);
+        }
+      }
+
+      @Controller('/child-sub')
+      class ChildSubscribeController extends BaseController {
+        @Subscribe('child.test')
+        async handle(): Promise<void> {}
+      }
+
+      @Module({
+        controllers: [ChildQueueController, ChildSubscribeController],
+      })
+      class ChildQueueModule {}
+
+      @Module({
+        imports: [ChildQueueModule],
+      })
+      class ParentQueueModule {}
+
+      const app = createTestApp(ParentQueueModule, {
+        port: 0,
+        queue: { enabled: true, adapter: 'memory' },
+      });
+      await app.start();
+
+      const rootModule = (app as unknown as { rootModule: ModuleInstance }).rootModule;
+      const controller = rootModule.getControllerInstance?.(ChildQueueController) as
+        | ChildQueueController
+        | undefined;
+      expect(controller).toBeDefined();
+      await expect(controller!.publishTest('child.test', { ok: true })).resolves.toBeDefined();
+
+      await app.stop();
+    });
   });
 });

package/src/application/application.ts

@@ -53,7 +53,7 @@ import {
   DEFAULT_SSE_HEARTBEAT_MS,
   DEFAULT_SSE_TIMEOUT,
 } from '../module/controller';
-import { OneBunModule } from '../module/module';
+import { OneBunModule, registerGlobalService } from '../module/module';
 import {
   QueueService,
   QueueServiceProxy,
@@ -490,19 +490,19 @@ export class OneBunApplication {
         this.logger.info('Application configuration initialized');
       }
 
-      // Create the root module AFTER config is initialized,
-      // so services can safely use this.config.get() in their constructors
-      this.rootModule = OneBunModule.create(this.moduleClass, this.loggerLayer, this.config);
-
-      // Register QueueService proxy in DI so controllers/providers/middleware can inject QueueService.
+      // Register QueueService proxy in global registry BEFORE creating the root module,
+      // so all modules (including child modules) pick it up via PHASE 0 of initModule().
       // After initializeQueue(), setDelegate(real) is called when queue is enabled.
       this.queueServiceProxy = new QueueServiceProxy();
-      if (this.ensureModule().registerService) {
-        this.ensureModule().registerService!(
-          QueueServiceTag as Context.Tag<unknown, QueueService>,
-          this.queueServiceProxy as unknown as QueueService,
-        );
-      }
+      registerGlobalService(
+        QueueServiceTag as Context.Tag<unknown, QueueService>,
+        this.queueServiceProxy as unknown as QueueService,
+      );
+
+      // Create the root module AFTER config is initialized and QueueService proxy is registered,
+      // so services can safely use this.config.get() in their constructors
+      // and inject QueueService in any module depth.
+      this.rootModule = OneBunModule.create(this.moduleClass, this.loggerLayer, this.config);
 
       // Register test provider overrides (must happen before setup() so controllers receive mocks)
       if (this.options._testProviders) {

package/src/module/module.ts

@@ -72,6 +72,16 @@ export function clearGlobalServicesRegistry(): void {
   processedGlobalModules.clear();
 }
 
+/**
+ * Register a service instance in the global services registry so it is available
+ * in all modules (including child modules) via PHASE 0 of module initialization.
+ * Must be called BEFORE creating the root module.
+ * @internal
+ */
+export function registerGlobalService<T>(tag: Context.Tag<unknown, T>, instance: T): void {
+  globalServicesRegistry.set(tag as Context.Tag<unknown, unknown>, instance);
+}
+
 /**
  * Get all global services (useful for debugging)
  * @internal

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

@@ -435,7 +435,7 @@ describe('Custom adapter NATS JetStream (docs/api/queue.md)', () => {
     class NatsJetStreamAdapter implements QueueAdapter {
       readonly name = 'nats-jetstream';
       readonly type = 'jetstream';
-      constructor(private opts: { servers: string; stream?: string }) {}
+      constructor(private opts: { servers: string; streams?: Array<{ name: string; subjects: string[] }> }) {}
       async connect(): Promise<void> {}
       async disconnect(): Promise<void> {}
       isConnected(): boolean {
@@ -473,7 +473,7 @@ describe('Custom adapter NATS JetStream (docs/api/queue.md)', () => {
 
     const adapter = new NatsJetStreamAdapter({
       servers: 'nats://localhost:4222',
-      stream: 'EVENTS',
+      streams: [{ name: 'EVENTS', subjects: ['events.>'] }],
     });
     await adapter.connect();
     expect(adapter.name).toBe('nats-jetstream');