@onebun/core 0.1.9 → 0.1.10

package/package.json

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

package/src/decorators/decorators.test.ts

@@ -13,7 +13,13 @@ import {
   afterEach,
 } from 'bun:test';
 
-import { Service } from '../module';
+import { OneBunApplication } from '../application';
+import {
+  BaseController,
+  BaseService,
+  Service,
+} from '../module';
+import { makeMockLoggerLayer } from '../testing';
 import { HttpMethod, ParamType } from '../types';
 
 import {
@@ -809,6 +815,53 @@ describe('decorators', () => {
       const deps = getConstructorParamTypes(malformedClass);
       expect(deps).toBeUndefined();
     });
+
+    test('should properly inject module service into controller without @Inject', async () => {
+      @Service()
+      class TestService extends BaseService {
+        getValue() {
+          return 'injected-value';
+        }
+      }
+
+      // No @Inject needed - automatic DI via emitDecoratorMetadata
+      @Controller('')
+      class TestController extends BaseController {
+        constructor(private service: TestService) {
+          super();
+        }
+
+        getServiceValue() {
+          return this.service.getValue();
+        }
+      }
+
+      @Module({
+        controllers: [TestController],
+        providers: [TestService],
+      })
+      class TestModule {}
+
+      const app = new OneBunApplication(TestModule, {
+        loggerLayer: makeMockLoggerLayer(),
+      });
+
+      // Access rootModule to setup and verify DI
+      const rootModule = (app as any).rootModule;
+
+      // Setup module to trigger dependency injection
+      const { Effect } = await import('effect');
+      await Effect.runPromise(rootModule.setup());
+
+      // Get controller instance and verify service was injected
+      const controllerInstance = rootModule.getControllerInstance(TestController) as TestController;
+
+      expect(controllerInstance).toBeDefined();
+      expect(controllerInstance).toBeInstanceOf(TestController);
+
+      // Verify the injected service works correctly
+      expect(controllerInstance.getServiceValue()).toBe('injected-value');
+    });
   });
 
   describe('ApiResponse decorator', () => {

package/src/decorators/decorators.ts

@@ -111,9 +111,17 @@ export function registerControllerDependencies(
 
 /**
  * Get constructor parameter types (automatically detected or explicitly set)
+ * Priority: 1) Explicit @Inject registrations, 2) TypeScript's design:paramtypes
  */
 export function getConstructorParamTypes(target: Function): Function[] | undefined {
-  return META_CONSTRUCTOR_PARAMS.get(target);
+  // First check explicit @Inject registrations
+  const explicitDeps = META_CONSTRUCTOR_PARAMS.get(target);
+  if (explicitDeps && explicitDeps.length > 0) {
+    return explicitDeps;
+  }
+
+  // Fallback to TypeScript's design:paramtypes (automatic DI)
+  return getDesignParamTypes(target);
 }
 
 /**
@@ -174,6 +182,15 @@ export function controllerDecorator(basePath: string = '') {
     // Mark controller as injectable automatically
     injectable()(WrappedController);
 
+    // Copy design:paramtypes from original class to wrapped class
+    // This enables automatic DI without @Inject when emitDecoratorMetadata is enabled
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const designParamTypes = (globalThis as any).Reflect?.getMetadata?.('design:paramtypes', target);
+    if (designParamTypes) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (globalThis as any).Reflect?.defineMetadata?.('design:paramtypes', designParamTypes, WrappedController);
+    }
+
     // Copy constructor params metadata from original class to wrapped class
     // This is needed for @Inject decorator to work correctly with @Controller wrapping
     const existingDeps = META_CONSTRUCTOR_PARAMS.get(target);

package/src/docs-examples.test.ts

@@ -1974,17 +1974,19 @@ describe('Architecture Documentation (docs/architecture.md)', () => {
     });
 
     /**
-     * @source docs/architecture.md#explicit-injection
+     * @source docs/architecture.md#automatic-injection
      */
-    it('should demonstrate explicit injection pattern', () => {
-      // From docs: Explicit Injection example
+    it('should demonstrate automatic DI without @Inject', () => {
+      // From docs: Automatic DI example
+      // TypeScript's emitDecoratorMetadata provides type info automatically
       @Service()
       class UserService extends BaseService {}
 
       @Service()
       class CacheService extends BaseService {}
 
-      // For complex cases, use @Inject() - here we just verify pattern works
+      // No @Inject needed - automatic DI works via emitDecoratorMetadata
+      // @Inject is only needed for: interfaces, abstract classes, token-based injection
       @Controller('/users')
       class UserController extends BaseController {
         constructor(