@onebun/core 0.1.23 → 0.1.24

package/package.json

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

package/src/application/application.test.ts

@@ -145,7 +145,7 @@ describe('OneBunApplication', () => {
       expect(config).toBeDefined();
     });
 
-    test('should create config service when envSchema provided', () => {
+    test('should create config service when envSchema provided (duplicate check)', () => {
       @Module({})
       class TestModule {}
 
@@ -159,12 +159,9 @@ describe('OneBunApplication', () => {
 
       const app = createTestApp(TestModule, { envSchema });
 
-      // Just check that config service was created
+      // Config service is created eagerly in the constructor
       const config = app.getConfig();
       expect(config).toBeDefined();
-
-      // The actual value access might need the config to be fully initialized
-      // which happens during runtime, not during construction
     });
 
     test('should provide typed access to config values via getConfig()', () => {
@@ -261,17 +258,34 @@ describe('OneBunApplication', () => {
   });
 
   describe('Layer methods', () => {
-    test('should return layer from root module', () => {
+    let originalServe: typeof Bun.serve;
+
+    beforeEach(() => {
+      originalServe = Bun.serve;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (Bun as any).serve = mock(() => ({
+        stop: mock(),
+        port: 3000,
+      }));
+    });
+
+    afterEach(() => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (Bun as any).serve = originalServe;
+    });
+
+    test('should return layer from root module', async () => {
       @Module({})
       class TestModule {}
 
       const app = createTestApp(TestModule);
+      await app.start();
 
       const layer = app.getLayer();
       expect(layer).toBeDefined();
     });
 
-    test('should return layer for complex module structure', () => {
+    test('should return layer for complex module structure', async () => {
       class TestController {}
       class TestService {}
 
@@ -282,6 +296,7 @@ describe('OneBunApplication', () => {
       class TestModule {}
 
       const app = createTestApp(TestModule);
+      await app.start();
 
       const layer = app.getLayer();
       expect(layer).toBeDefined();
@@ -394,14 +409,13 @@ describe('OneBunApplication', () => {
   });
 
   describe('Module class handling', () => {
-    test('should throw error for plain class without decorator', () => {
+    test('should throw error for plain class without decorator', async () => {
       class PlainModule {}
 
-      // This should throw error without @Module decorator
-      expect(() => {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        createTestApp(PlainModule as any);
-      }).toThrow('Module PlainModule does not have @Module decorator');
+      // Module creation now happens in start(), so the error is thrown there
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const app = createTestApp(PlainModule as any);
+      await expect(app.start()).rejects.toThrow('Module PlainModule does not have @Module decorator');
     });
 
     test('should handle class with constructor parameters', () => {

package/src/application/application.ts

@@ -152,12 +152,14 @@ function resolveHost(explicitHost: string | undefined): string {
  * OneBun Application
  */
 export class OneBunApplication {
-  private rootModule: ModuleInstance;
+  private rootModule: ModuleInstance | null = null;
   private server: ReturnType<typeof Bun.serve> | null = null;
   private options: ApplicationOptions;
   private logger: SyncLogger;
   private config: IConfig<OneBunAppConfig>;
   private configService: ConfigServiceImpl | null = null;
+  private moduleClass: new (...args: unknown[]) => object;
+  private loggerLayer: Layer.Layer<never, never, unknown>;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   private metricsService: any = null;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -176,6 +178,8 @@ export class OneBunApplication {
     moduleClass: new (...args: unknown[]) => object,
     options?: Partial<ApplicationOptions>,
   ) {
+    this.moduleClass = moduleClass;
+
     // Resolve port and host with priority: explicit > env > default
     this.options = {
       port: resolvePort(options?.port),
@@ -194,7 +198,7 @@ export class OneBunApplication {
 
     // Use provided logger layer, or create from options, or use default
     // Priority: loggerLayer > loggerOptions > env variables > NODE_ENV defaults
-    const loggerLayer = this.options.loggerLayer
+    this.loggerLayer = this.options.loggerLayer
       ?? (this.options.loggerOptions
         ? makeLoggerFromOptions(this.options.loggerOptions)
         : makeLogger());
@@ -205,13 +209,14 @@ export class OneBunApplication {
         Effect.map(LoggerService, (logger: Logger) =>
           logger.child({ className: 'OneBunApplication' }),
         ),
-        loggerLayer,
-      ),
+        this.loggerLayer,
+      ) as Effect.Effect<Logger, never, never>,
     ) as Logger;
     this.logger = createSyncLogger(effectLogger);
 
-    // Create configuration service if config is initialized
-    if (this.config.isInitialized || !(this.config instanceof NotInitializedConfig)) {
+    // Create configuration service eagerly if config exists (it stores a reference,
+    // doesn't call config.get(), so safe before initialization)
+    if (!(this.config instanceof NotInitializedConfig)) {
       this.configService = new ConfigServiceImpl(this.logger, this.config);
     }
 
@@ -274,8 +279,8 @@ export class OneBunApplication {
       }
     }
 
-    // Create the root module with logger layer and config
-    this.rootModule = OneBunModule.create(moduleClass, loggerLayer, this.config);
+    // Note: root module creation is deferred to start() to ensure
+    // config is fully initialized before services are created.
   }
 
   /**
@@ -323,11 +328,23 @@ export class OneBunApplication {
     return this.getConfig().get(path);
   }
 
+  /**
+   * Ensure root module is created (i.e., start() has been called).
+   * Throws if called before start().
+   */
+  private ensureModule(): ModuleInstance {
+    if (!this.rootModule) {
+      throw new Error('Application not started. Call start() before accessing the module.');
+    }
+
+    return this.rootModule;
+  }
+
   /**
    * Get root module layer
    */
   getLayer(): Layer.Layer<never, never, unknown> {
-    return this.rootModule.getLayer();
+    return this.ensureModule().getLayer();
   }
 
   /**
@@ -377,6 +394,10 @@ 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);
+
       // Start metrics collection if enabled
       if (this.metricsService && this.metricsService.startSystemMetricsCollection) {
         this.metricsService.startSystemMetricsCollection();
@@ -384,10 +405,10 @@ export class OneBunApplication {
       }
 
       // Setup the module and create controller instances
-      await Effect.runPromise(this.rootModule.setup() as Effect.Effect<unknown, never, never>);
+      await Effect.runPromise(this.ensureModule().setup() as Effect.Effect<unknown, never, never>);
 
       // Get all controllers from the root module
-      const controllers = this.rootModule.getControllers();
+      const controllers = this.ensureModule().getControllers();
       this.logger.debug(`Loaded ${controllers.length} controllers`);
 
       // Initialize WebSocket handler and detect gateways
@@ -396,7 +417,7 @@ export class OneBunApplication {
       // Register WebSocket gateways (they are in controllers array but decorated with @WebSocketGateway)
       for (const controllerClass of controllers) {
         if (isWebSocketGateway(controllerClass)) {
-          const instance = this.rootModule.getControllerInstance?.(controllerClass);
+          const instance = this.ensureModule().getControllerInstance?.(controllerClass);
           if (instance) {
             this.wsHandler.registerGateway(controllerClass, instance as import('../websocket/ws-base-gateway').BaseWebSocketGateway);
             this.logger.info(`Registered WebSocket gateway: ${controllerClass.name}`);
@@ -438,14 +459,14 @@ export class OneBunApplication {
         }
 
         // Get controller instance from module
-        if (!this.rootModule.getControllerInstance) {
+        if (!this.ensureModule().getControllerInstance) {
           this.logger.warn(
             `Module does not support getControllerInstance for ${controllerClass.name}`,
           );
           continue;
         }
 
-        const controller = this.rootModule.getControllerInstance(controllerClass) as Controller;
+        const controller = this.ensureModule().getControllerInstance!(controllerClass) as Controller;
         if (!controller) {
           this.logger.warn(`Controller instance not found for ${controllerClass.name}`);
           continue;
@@ -508,8 +529,8 @@ export class OneBunApplication {
       }
 
       // Call onApplicationInit lifecycle hook for all services and controllers
-      if (this.rootModule.callOnApplicationInit) {
-        await this.rootModule.callOnApplicationInit();
+      if (this.ensureModule().callOnApplicationInit) {
+        await this.ensureModule().callOnApplicationInit!();
         this.logger.debug('Application initialization hooks completed');
       }
 
@@ -1242,7 +1263,7 @@ export class OneBunApplication {
     this.logger.info('Stopping OneBun application...');
 
     // Call beforeApplicationDestroy lifecycle hook
-    if (this.rootModule.callBeforeApplicationDestroy) {
+    if (this.rootModule?.callBeforeApplicationDestroy) {
       this.logger.debug('Calling beforeApplicationDestroy hooks');
       await this.rootModule.callBeforeApplicationDestroy(signal);
     }
@@ -1276,7 +1297,7 @@ export class OneBunApplication {
     }
 
     // Call onModuleDestroy lifecycle hook
-    if (this.rootModule.callOnModuleDestroy) {
+    if (this.rootModule?.callOnModuleDestroy) {
       this.logger.debug('Calling onModuleDestroy hooks');
       await this.rootModule.callOnModuleDestroy();
     }
@@ -1288,7 +1309,7 @@ export class OneBunApplication {
     }
 
     // Call onApplicationDestroy lifecycle hook
-    if (this.rootModule.callOnApplicationDestroy) {
+    if (this.rootModule?.callOnApplicationDestroy) {
       this.logger.debug('Calling onApplicationDestroy hooks');
       await this.rootModule.callOnApplicationDestroy(signal);
     }
@@ -1304,7 +1325,7 @@ export class OneBunApplication {
     
     // Check if any controller has queue-related decorators
     const hasQueueHandlers = controllers.some(controller => {
-      const instance = this.rootModule.getControllerInstance?.(controller);
+      const instance = this.ensureModule().getControllerInstance?.(controller);
       if (!instance) {
         return false;
       }
@@ -1364,7 +1385,7 @@ export class OneBunApplication {
 
     // Register handlers from controllers using registerService
     for (const controllerClass of controllers) {
-      const instance = this.rootModule.getControllerInstance?.(controllerClass);
+      const instance = this.ensureModule().getControllerInstance?.(controllerClass);
       if (!instance) {
         continue;
       }
@@ -1528,11 +1549,11 @@ export class OneBunApplication {
    * ```
    */
   getService<T>(serviceClass: new (...args: unknown[]) => T): T {
-    if (!this.rootModule.getServiceByClass) {
+    if (!this.ensureModule().getServiceByClass) {
       throw new Error('Module does not support getServiceByClass');
     }
 
-    const service = this.rootModule.getServiceByClass(serviceClass);
+    const service = this.ensureModule().getServiceByClass!(serviceClass);
     if (!service) {
       throw new Error(
         `Service ${serviceClass.name} not found. Make sure it's registered in the module's providers.`,

package/src/decorators/decorators.test.ts

@@ -11,6 +11,7 @@ import {
   expect,
   beforeEach,
   afterEach,
+  mock,
 } from 'bun:test';
 
 import { OneBunApplication } from '../application';
@@ -817,50 +818,63 @@ describe('decorators', () => {
     });
 
     test('should properly inject module service into controller without @Inject', async () => {
-      @Service()
-      class TestService extends BaseService {
-        getValue() {
-          return 'injected-value';
+      // Mock Bun.serve to avoid starting a real server
+      const originalServe = Bun.serve;
+       
+      (Bun as any).serve = mock(() => ({
+        stop: mock(),
+        port: 3000,
+      }));
+
+      try {
+        @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();
-        }
+        // No @Inject needed - automatic DI via emitDecoratorMetadata
+        @Controller('')
+        class TestController extends BaseController {
+          constructor(private service: TestService) {
+            super();
+          }
 
-        getServiceValue() {
-          return this.service.getValue();
+          getServiceValue() {
+            return this.service.getValue();
+          }
         }
-      }
 
-      @Module({
-        controllers: [TestController],
-        providers: [TestService],
-      })
-      class TestModule {}
+        @Module({
+          controllers: [TestController],
+          providers: [TestService],
+        })
+        class TestModule {}
 
-      const app = new OneBunApplication(TestModule, {
-        loggerLayer: makeMockLoggerLayer(),
-      });
+        const app = new OneBunApplication(TestModule, {
+          loggerLayer: makeMockLoggerLayer(),
+        });
 
-      // Access rootModule to setup and verify DI
-      const rootModule = (app as any).rootModule;
+        // start() creates rootModule and calls setup, triggering dependency injection
+        await app.start();
 
-      // Setup module to trigger dependency injection
-      const { Effect } = await import('effect');
-      await Effect.runPromise(rootModule.setup());
+        // Access rootModule after start to verify DI
+         
+        const rootModule = (app as any).rootModule;
 
-      // Get controller instance and verify service was injected
-      const controllerInstance = rootModule.getControllerInstance(TestController) as TestController;
+        // Get controller instance and verify service was injected
+        const controllerInstance = rootModule.getControllerInstance(TestController) as TestController;
 
-      expect(controllerInstance).toBeDefined();
-      expect(controllerInstance).toBeInstanceOf(TestController);
+        expect(controllerInstance).toBeDefined();
+        expect(controllerInstance).toBeInstanceOf(TestController);
 
-      // Verify the injected service works correctly
-      expect(controllerInstance.getServiceValue()).toBe('injected-value');
+        // Verify the injected service works correctly
+        expect(controllerInstance.getServiceValue()).toBe('injected-value');
+      } finally {
+         
+        (Bun as any).serve = originalServe;
+      }
     });
   });