@onebun/core 0.1.22 → 0.1.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onebun/core",
-  "version": "0.1.22",
+  "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;
+      }
     });
   });
 

package/src/docs-examples.test.ts

@@ -816,7 +816,7 @@ describe('Services API Documentation Examples', () => {
       @Service()
       class UserService extends BaseService {
         // Dependencies are auto-injected via constructor
-        // Logger and config are auto-injected via initializeService()
+        // Logger and config are available immediately after super()
         constructor(private repository: UserRepository) {
           super();
         }

package/src/module/module.test.ts

@@ -851,6 +851,106 @@ describe('OneBunModule', () => {
       expect(apiService).toBeDefined();
       expect((apiService as ApiService).getConnectionTimeout()).toBe(5000);
     });
+
+    /**
+     * Test that this.config and this.logger are available in the service constructor
+     * when the service is created through the DI system (via ambient init context).
+     */
+    test('should have this.config and this.logger available in constructor via DI', () => {
+      let configInConstructor: unknown = undefined;
+      let loggerInConstructor: unknown = undefined;
+
+      @Service()
+      class ConfigAwareService extends BaseServiceClass {
+        constructor() {
+          super();
+          configInConstructor = this.config;
+          loggerInConstructor = this.logger;
+        }
+      }
+
+      @ModuleDecorator({
+        providers: [ConfigAwareService],
+      })
+      class TestModule {}
+
+      // Initialize module — this triggers DI and service creation
+      new ModuleInstance(TestModule, mockLoggerLayer);
+
+      // config and logger should have been available in the constructor
+      expect(configInConstructor).toBeDefined();
+      expect(loggerInConstructor).toBeDefined();
+    });
+
+    /**
+     * Test that this.config.get() works in the constructor for services created via DI
+     */
+    test('should allow config.get() in service constructor via DI', () => {
+      @Service()
+      class ServiceWithConfigInConstructor extends BaseServiceClass {
+        readonly configValue: unknown;
+
+        constructor() {
+          super();
+          // Config should be available here via init context
+          this.configValue = this.config;
+        }
+
+        getConfigValue() {
+          return this.configValue;
+        }
+      }
+
+      @ModuleDecorator({
+        providers: [ServiceWithConfigInConstructor],
+      })
+      class TestModule {}
+
+      const module = new ModuleInstance(TestModule, mockLoggerLayer);
+
+      const { getServiceTag } = require('./service');
+      const tag = getServiceTag(ServiceWithConfigInConstructor);
+      const service = module.getServiceInstance(tag) as ServiceWithConfigInConstructor;
+
+      expect(service).toBeDefined();
+      // configValue was captured in constructor — should not be undefined
+      expect(service.getConfigValue()).toBeDefined();
+    });
+
+    /**
+     * Test that this.config is available in constructor of a service with dependencies
+     */
+    test('should have this.config in constructor of service with dependencies', () => {
+      let configAvailable = false;
+
+      @Service()
+      class DependencyService {
+        getValue() {
+          return 42;
+        }
+      }
+
+      @Service()
+      class MainService extends BaseServiceClass {
+        constructor(private dep: DependencyService) {
+          super();
+          configAvailable = this.config !== undefined;
+        }
+
+        getDep() {
+          return this.dep.getValue();
+        }
+      }
+
+      @ModuleDecorator({
+        providers: [DependencyService, MainService],
+      })
+      class TestModule {}
+
+      new ModuleInstance(TestModule, mockLoggerLayer);
+
+      expect(configAvailable).toBe(true);
+    });
   });
 
   describe('Lifecycle hooks', () => {

package/src/module/module.ts

@@ -36,7 +36,11 @@ import {
   hasBeforeApplicationDestroy,
   hasOnApplicationDestroy,
 } from './lifecycle';
-import { getServiceMetadata, getServiceTag } from './service';
+import {
+  BaseService,
+  getServiceMetadata,
+  getServiceTag,
+} from './service';
 
 /**
  * Global services registry
@@ -290,13 +294,23 @@ export class OneBunModule implements ModuleInstance {
         continue;
       }
 
-      // Create service instance with resolved dependencies (without logger/config in constructor)
+      // Create service instance with resolved dependencies.
+      // Set ambient init context so BaseService constructor can pick up logger/config,
+      // making them available immediately after super() in subclass constructors.
       try {
         const serviceConstructor = provider as new (...args: unknown[]) => unknown;
-        const serviceInstance = new serviceConstructor(...dependencies);
 
-        // Initialize service with logger and config if it has initializeService method
-        // This is the pattern used by BaseService
+        BaseService.setInitContext(this.logger, this.config);
+        let serviceInstance: unknown;
+        try {
+          serviceInstance = new serviceConstructor(...dependencies);
+        } finally {
+          BaseService.clearInitContext();
+        }
+
+        // Fallback: call initializeService for services that have it but were not
+        // initialized via the constructor (e.g., services not extending BaseService
+        // but implementing initializeService manually, or for backwards compatibility).
         if (
           serviceInstance &&
           typeof serviceInstance === 'object' &&

package/src/module/service.test.ts

@@ -165,6 +165,111 @@ describe('BaseService', () => {
     });
   });
 
+  describe('Initialization via static init context (constructor)', () => {
+    test('should initialize service via static init context in constructor', () => {
+      class TestService extends BaseService {
+        configAvailableInConstructor = false;
+        loggerAvailableInConstructor = false;
+
+        constructor() {
+          super();
+          this.configAvailableInConstructor = this.config !== undefined;
+          this.loggerAvailableInConstructor = this.logger !== undefined;
+        }
+      }
+
+      // Set init context before construction (as the framework does)
+      BaseService.setInitContext(mockLogger, mockConfig);
+      let service: TestService;
+      try {
+        service = new TestService();
+      } finally {
+        BaseService.clearInitContext();
+      }
+
+      expect(service.isInitialized).toBe(true);
+      expect(service.configAvailableInConstructor).toBe(true);
+      expect(service.loggerAvailableInConstructor).toBe(true);
+      expect((service as any).config).toBe(mockConfig);
+    });
+
+    test('should allow using config.get() in constructor when init context is set', () => {
+      class TestService extends BaseService {
+        readonly dbHost: string;
+
+        constructor() {
+          super();
+          this.dbHost = this.config.get('database.host') as string;
+        }
+      }
+
+      BaseService.setInitContext(mockLogger, mockConfig);
+      let service: TestService;
+      try {
+        service = new TestService();
+      } finally {
+        BaseService.clearInitContext();
+      }
+
+      expect(service.dbHost).toBe('localhost');
+    });
+
+    test('should create child logger with correct className in constructor', () => {
+      class MyCustomService extends BaseService {}
+
+      BaseService.setInitContext(mockLogger, mockConfig);
+      try {
+        new MyCustomService();
+      } finally {
+        BaseService.clearInitContext();
+      }
+
+      expect(mockLogger.child).toHaveBeenCalledWith({ className: 'MyCustomService' });
+    });
+
+    test('should not initialize if no init context is set', () => {
+      // Ensure context is clear
+      BaseService.clearInitContext();
+
+      class TestService extends BaseService {}
+      const service = new TestService();
+
+      expect(service.isInitialized).toBe(false);
+    });
+
+    test('initializeService should be a no-op if already initialized via init context', () => {
+      class TestService extends BaseService {}
+
+      BaseService.setInitContext(mockLogger, mockConfig);
+      let service: TestService;
+      try {
+        service = new TestService();
+      } finally {
+        BaseService.clearInitContext();
+      }
+
+      expect(service.isInitialized).toBe(true);
+
+      // Call initializeService again — should be a no-op
+      const otherLogger = { ...mockLogger, child: mock(() => ({ ...mockLogger })) };
+      const otherConfig = createMockConfig({ other: 'config' });
+      service.initializeService(otherLogger, otherConfig);
+
+      // Should still have original config (no reinit)
+      expect((service as any).config).toBe(mockConfig);
+    });
+
+    test('clearInitContext should prevent subsequent constructors from picking up context', () => {
+      BaseService.setInitContext(mockLogger, mockConfig);
+      BaseService.clearInitContext();
+
+      class TestService extends BaseService {}
+      const service = new TestService();
+
+      expect(service.isInitialized).toBe(false);
+    });
+  });
+
   describe('Error handling edge cases', () => {
     test('should handle complex effect scenarios', async () => {
       class TestService extends BaseService {

package/src/module/service.ts

@@ -19,8 +19,9 @@ const META_SERVICES = new Map<
 /**
  * Service decorator
  * Registers the class as a service with an optional Effect Context tag.
- * Services extending BaseService will have logger and config injected
- * via the initializeService method called by the module after instantiation.
+ * Services extending BaseService will have logger and config available
+ * immediately after super() in the constructor (via ambient init context),
+ * as well as through the initializeService fallback method.
  * 
  * @param tag - Optional Effect Context tag for the service
  */
@@ -62,7 +63,26 @@ export function getServiceTag<T>(serviceClass: new (...args: unknown[]) => T): C
 }
 
 /**
- * Base service class that provides utility methods for working with Effect
+ * Base service class that provides utility methods for working with Effect.
+ *
+ * Services extending BaseService have `this.config` and `this.logger` available
+ * immediately after `super()` in the constructor when created through the framework DI.
+ * The framework sets an ambient init context before calling the constructor, and
+ * BaseService reads from it in `super()`.
+ *
+ * @example
+ * ```typescript
+ * @Service()
+ * class MyService extends BaseService {
+ *   private readonly baseUrl: string;
+ *
+ *   constructor(private dep: SomeDep) {
+ *     super();
+ *     // this.config and this.logger are available here!
+ *     this.baseUrl = this.config.get('api.baseUrl');
+ *   }
+ * }
+ * ```
  */
 export class BaseService {
   // Logger instance with service class name as context
@@ -73,12 +93,55 @@ export class BaseService {
   private _initialized = false;
 
   /**
-   * Initialize service with logger and config (called by the framework)
+   * Ambient init context set by the framework before service construction.
+   * This allows BaseService constructor to pick up logger and config
+   * so they are available immediately after super() in subclass constructors.
+   * @internal
+   */
+  private static _initContext: { logger: SyncLogger; config: IConfig<OneBunAppConfig> } | null =
+    null;
+
+  /**
+   * Set the ambient init context before constructing a service.
+   * Called by the framework (OneBunModule) before `new ServiceClass(...)`.
+   * @internal
+   */
+  static setInitContext(logger: SyncLogger, config: IConfig<OneBunAppConfig>): void {
+    BaseService._initContext = { logger, config };
+  }
+
+  /**
+   * Clear the ambient init context after service construction.
+   * Called by the framework (OneBunModule) after `new ServiceClass(...)`.
+   * @internal
+   */
+  static clearInitContext(): void {
+    BaseService._initContext = null;
+  }
+
+  constructor() {
+    // Pick up logger and config from ambient init context if available.
+    // This makes this.config and this.logger available immediately after super()
+    // in subclass constructors.
+    if (BaseService._initContext) {
+      const { logger, config } = BaseService._initContext;
+      const className = this.constructor.name;
+      this.logger = logger.child({ className });
+      this.config = config;
+      this._initialized = true;
+    }
+  }
+
+  /**
+   * Initialize service with logger and config (called by the framework).
+   * This is a fallback for services not constructed through the DI system
+   * (e.g., in tests or when created manually). If the service was already
+   * initialized via the constructor init context, this is a no-op.
    * @internal
    */
   initializeService(logger: SyncLogger, config: IConfig<OneBunAppConfig>): void {
     if (this._initialized) {
-      return; // Already initialized
+      return; // Already initialized (via constructor or previous call)
     }
 
     const className = this.constructor.name;