@onebun/core 0.1.19 → 0.1.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onebun/core",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "description": "Core package for OneBun framework - decorators, DI, modules, controllers",
   "license": "LGPL-3.0",
   "author": "RemRyahirev",
@@ -41,7 +41,7 @@
   "dependencies": {
     "effect": "^3.13.10",
     "arktype": "^2.0.0",
-    "@onebun/logger": "^0.1.6",
+    "@onebun/logger": "^0.1.7",
     "@onebun/envs": "^0.1.4",
     "@onebun/metrics": "^0.1.6",
     "@onebun/requests": "^0.1.3",

package/src/docs-examples.test.ts

@@ -2327,6 +2327,49 @@ describe('Architecture Documentation (docs/architecture.md)', () => {
       expect(SharedModule).toBeDefined();
       expect(ApiModule).toBeDefined();
     });
+
+    /**
+     * Exports are only required for cross-module injection.
+     * Within a module, any provider can be injected into controllers without being in exports.
+     */
+    it('should allow controller to inject same-module provider without exports', async () => {
+      const effectLib = await import('effect');
+      const moduleMod = await import('./module/module');
+      const testUtils = await import('./testing/test-utils');
+      const decorators = await import('./decorators/decorators');
+
+      @Service()
+      class InternalService extends BaseService {
+        getData(): string {
+          return 'internal';
+        }
+      }
+
+      @Controller('/local')
+      class LocalController extends BaseController {
+        constructor(@decorators.Inject(InternalService) private readonly internal: InternalService) {
+          super();
+        }
+        getData(): string {
+          return this.internal.getData();
+        }
+      }
+
+      @Module({
+        providers: [InternalService],
+        controllers: [LocalController],
+        // No exports - InternalService is only used inside this module
+      })
+      class LocalModule {}
+
+      const mod = new moduleMod.OneBunModule(LocalModule, testUtils.makeMockLoggerLayer());
+      mod.getLayer();
+      await effectLib.Effect.runPromise(mod.setup() as import('effect').Effect.Effect<unknown, never, never>);
+
+      const controller = mod.getControllerInstance(LocalController) as LocalController;
+      expect(controller).toBeDefined();
+      expect(controller.getData()).toBe('internal');
+    });
   });
 });
 

package/src/module/module.test.ts

@@ -10,7 +10,11 @@ import {
   afterEach,
   mock,
 } from 'bun:test';
-import { Context } from 'effect';
+import {
+  Context,
+  Effect,
+  Layer,
+} from 'effect';
 
 import { Module } from '../decorators/decorators';
 import { makeMockLoggerLayer } from '../testing/test-utils';
@@ -157,7 +161,6 @@ describe('OneBunModule', () => {
 
     test('should detect circular dependencies and provide detailed error message', () => {
       const { registerDependencies } = require('../decorators/decorators');
-      const { Effect, Layer } = require('effect');
       const { LoggerService } = require('@onebun/logger');
 
       // Collect error messages
@@ -849,4 +852,145 @@ describe('OneBunModule', () => {
       expect((apiService as ApiService).getConnectionTimeout()).toBe(5000);
     });
   });
+
+  describe('Module DI scoping (exports only for cross-module)', () => {
+    const {
+      Controller: ControllerDecorator,
+      Get,
+      Inject,
+      clearGlobalModules,
+    } = require('../decorators/decorators');
+    const { Controller: BaseController } = require('./controller');
+    const { clearGlobalServicesRegistry: clearRegistry, OneBunModule: ModuleClass } = require('./module');
+
+    beforeEach(() => {
+      clearGlobalModules();
+      clearRegistry();
+    });
+
+    afterEach(() => {
+      clearGlobalModules();
+      clearRegistry();
+    });
+
+    test('controller can inject provider from same module without exports', async () => {
+      @Service()
+      class CounterService {
+        private count = 0;
+        getCount() {
+          return this.count;
+        }
+        increment() {
+          this.count += 1;
+        }
+      }
+
+      class CounterController extends BaseController {
+        constructor(@Inject(CounterService) private readonly counterService: CounterService) {
+          super();
+        }
+        getCount() {
+          return this.counterService.getCount();
+        }
+      }
+      const CounterControllerDecorated = ControllerDecorator('/counter')(CounterController);
+      Get('/')(CounterControllerDecorated.prototype, 'getCount', Object.getOwnPropertyDescriptor(CounterControllerDecorated.prototype, 'getCount')!);
+
+      @Module({
+        providers: [CounterService],
+        controllers: [CounterControllerDecorated],
+        // No exports - CounterService is only used inside this module
+      })
+      class FeatureModule {}
+
+      const module = new ModuleClass(FeatureModule, mockLoggerLayer);
+      module.getLayer();
+      await Effect.runPromise(module.setup() as Effect.Effect<unknown, never, never>);
+
+      const controller = module.getControllerInstance(CounterControllerDecorated) as CounterController;
+      expect(controller).toBeDefined();
+      expect(controller.getCount()).toBe(0);
+    });
+
+    test('child module controller injects own provider; root can resolve controller', async () => {
+      @Service()
+      class ChildService {
+        getValue() {
+          return 'child';
+        }
+      }
+
+      class ChildController extends BaseController {
+        constructor(@Inject(ChildService) private readonly childService: ChildService) {
+          super();
+        }
+        getValue() {
+          return this.childService.getValue();
+        }
+      }
+      const ChildControllerDecorated = ControllerDecorator('/child')(ChildController);
+      Get('/')(ChildControllerDecorated.prototype, 'getValue', Object.getOwnPropertyDescriptor(ChildControllerDecorated.prototype, 'getValue')!);
+
+      @Module({
+        providers: [ChildService],
+        controllers: [ChildControllerDecorated],
+      })
+      class ChildModule {}
+
+      @Module({
+        imports: [ChildModule],
+      })
+      class RootModule {}
+
+      const rootModule = new ModuleClass(RootModule, mockLoggerLayer);
+      rootModule.getLayer();
+      await Effect.runPromise(rootModule.setup() as Effect.Effect<unknown, never, never>);
+
+      const allControllers = rootModule.getControllers();
+      expect(allControllers).toContain(ChildControllerDecorated);
+      const controller = rootModule.getControllerInstance(ChildControllerDecorated) as ChildController;
+      expect(controller).toBeDefined();
+      expect(controller.getValue()).toBe('child');
+    });
+
+    test('exported service from imported module is injectable in importing module', async () => {
+      @Service()
+      class SharedService {
+        getLabel() {
+          return 'shared';
+        }
+      }
+
+      @Module({
+        providers: [SharedService],
+        exports: [SharedService],
+      })
+      class SharedModule {}
+
+      class AppController extends BaseController {
+        constructor(@Inject(SharedService) private readonly sharedService: SharedService) {
+          super();
+        }
+        getLabel() {
+          return this.sharedService.getLabel();
+        }
+      }
+      const AppControllerDecorated = ControllerDecorator('/app')(AppController);
+      Get('/')(AppControllerDecorated.prototype, 'getLabel', Object.getOwnPropertyDescriptor(AppControllerDecorated.prototype, 'getLabel')!);
+
+      @Module({
+        imports: [SharedModule],
+        controllers: [AppControllerDecorated],
+      })
+      class AppModule {}
+
+      const module = new ModuleClass(AppModule, mockLoggerLayer);
+      module.getLayer();
+      await Effect.runPromise(module.setup() as Effect.Effect<unknown, never, never>);
+
+      const controller = module.getControllerInstance(AppControllerDecorated) as AppController;
+      expect(controller).toBeDefined();
+      expect(controller.getLabel()).toBe('shared');
+    });
+  });
 });

package/src/module/module.ts

@@ -169,9 +169,6 @@ export class OneBunModule implements ModuleInstance {
         // Merge layers
         layer = Layer.merge(layer, childModule.getLayer());
 
-        // Add controllers from child module
-        controllers.push(...childModule.getControllers());
-
         // Get exported services from child module and register them for DI
         const exportedServices = childModule.getExportedServices();
         for (const [tag, instance] of exportedServices) {
@@ -386,48 +383,20 @@ export class OneBunModule implements ModuleInstance {
    */
   createControllerInstances(): Effect.Effect<unknown, never, void> {
     return Effect.sync(() => {
-      // Services are already created in initModule via createServicesWithDI
-      // Just need to set up controllers with DI
-
-      // Get module metadata to access providers for controller dependency registration
-      const moduleMetadata = getModuleMetadata(this.moduleClass);
-      if (moduleMetadata && moduleMetadata.providers) {
-        // Create map of available services for dependency resolution
-        const availableServices = new Map<string, Function>();
-
-        // For each provider that is a class constructor, add to available services map
-        for (const provider of moduleMetadata.providers) {
-          if (typeof provider === 'function') {
-            availableServices.set(provider.name, provider);
-          }
-        }
-
-        // Also add services from imported modules
-        for (const childModule of this.childModules) {
-          const childMetadata = getModuleMetadata(childModule.moduleClass);
-          if (childMetadata?.exports) {
-            for (const exported of childMetadata.exports) {
-              if (typeof exported === 'function') {
-                availableServices.set(exported.name, exported);
-              }
-            }
-          }
-        }
-
-        // Add global services to available services for dependency resolution
-        for (const [, instance] of globalServicesRegistry) {
-          if (instance && typeof instance === 'object') {
-            availableServices.set(instance.constructor.name, instance.constructor);
-          }
+      // Build map of available services from this module's DI scope (own providers + imported exports + global)
+      const availableServices = new Map<string, Function>();
+      for (const [, instance] of this.serviceInstances) {
+        if (instance && typeof instance === 'object') {
+          availableServices.set(instance.constructor.name, instance.constructor);
         }
+      }
 
-        // Automatically analyze and register dependencies for all controllers
-        for (const controllerClass of this.controllers) {
-          registerControllerDependencies(controllerClass, availableServices);
-        }
+      // Automatically analyze and register dependencies for all controllers of this module
+      for (const controllerClass of this.controllers) {
+        registerControllerDependencies(controllerClass, availableServices);
       }
 
-      // Now create controller instances with automatic dependency injection
+      // Create controller instances with automatic dependency injection
       this.createControllersWithDI();
     }).pipe(Effect.provide(this.rootLayer));
   }
@@ -567,7 +536,12 @@ export class OneBunModule implements ModuleInstance {
           discard: true,
         }),
       ),
-      // Then create controller instances
+      // Create controller instances in child modules first, then this module (each uses its own DI scope)
+      Effect.flatMap(() =>
+        Effect.forEach(this.childModules, (childModule) => childModule.createControllerInstances(), {
+          discard: true,
+        }),
+      ),
       Effect.flatMap(() => this.createControllerInstances()),
       // Then call onModuleInit for controllers
       Effect.flatMap(() => this.callControllersOnModuleInit()),
@@ -780,30 +754,46 @@ export class OneBunModule implements ModuleInstance {
   }
 
   /**
-   * Get all controllers from this module
+   * Get all controllers from this module and child modules (recursive).
+   * Used by the application layer for routing and lifecycle.
    */
   getControllers(): Function[] {
-    return this.controllers;
+    const fromChildren = this.childModules.flatMap((child) => child.getControllers());
+
+    return [...this.controllers, ...fromChildren];
   }
 
   /**
-   * Get controller instance
+   * Get controller instance (searches this module then child modules recursively).
    */
   getControllerInstance(controllerClass: Function): Controller | undefined {
     const instance = this.controllerInstances.get(controllerClass);
-
-    if (!instance) {
-      this.logger.warn(`No instance found for controller ${controllerClass.name}`);
+    if (instance) {
+      return instance;
+    }
+    for (const childModule of this.childModules) {
+      const childInstance = childModule.getControllerInstance(controllerClass);
+      if (childInstance) {
+        return childInstance;
+      }
     }
+    this.logger.warn(`No instance found for controller ${controllerClass.name}`);
 
-    return instance;
+    return undefined;
   }
 
   /**
-   * Get all controller instances
+   * Get all controller instances from this module and child modules (recursive).
    */
   getControllerInstances(): Map<Function, Controller> {
-    return this.controllerInstances;
+    const merged = new Map<Function, Controller>(this.controllerInstances);
+    for (const childModule of this.childModules) {
+      for (const [cls, instance] of childModule.getControllerInstances()) {
+        merged.set(cls, instance);
+      }
+    }
+
+    return merged;
   }
 
   /**