@onebun/core 0.2.2 → 0.2.4

package/package.json

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

package/src/docs-examples.test.ts

@@ -693,6 +693,27 @@ describe('Controllers API Documentation Examples', () => {
 
       expect(UserController).toBeDefined();
     });
+
+    /**
+     * @source docs/api/controllers.md#constructor-access
+     * Controllers have this.config and this.logger available immediately after super()
+     */
+    it('should have config and logger available in controller constructor after super()', () => {
+      @Service()
+      class UserService extends BaseService {}
+
+      // From docs: Controller with constructor access to config and logger
+      @Controller('/users')
+      class UserController extends BaseController {
+        constructor(private userService: UserService) {
+          super();
+          // config and logger are available immediately after super()
+          // e.g. this.config.get('api.prefix'), this.logger.info('...')
+        }
+      }
+
+      expect(UserController).toBeDefined();
+    });
   });
 
   describe('Response Methods (docs/api/controllers.md)', () => {
@@ -1393,6 +1414,28 @@ describe('Services API Documentation Examples', () => {
 
       expect(UserService).toBeDefined();
     });
+
+    /**
+     * @source docs/api/services.md#constructor-access
+     * Services have this.config and this.logger available immediately after super()
+     */
+    it('should have config and logger available in service constructor after super()', () => {
+      @Service()
+      class ConfiguredService extends BaseService {
+        readonly configAvailable: boolean;
+        readonly loggerAvailable: boolean;
+
+        constructor() {
+          super();
+          // config and logger are available immediately after super()
+          this.configAvailable = this.config !== undefined;
+          this.loggerAvailable = this.logger !== undefined;
+        }
+      }
+
+      // Verify the class is well-formed — actual DI test is in module.test.ts
+      expect(ConfiguredService).toBeDefined();
+    });
   });
 
   describe('getServiceTag (docs/api/services.md)', () => {
@@ -3234,8 +3277,7 @@ describe('WebSocket Gateway API Documentation (docs/api/websocket.md)', () => {
       class TestGateway extends BaseWebSocketGateway {
         @OnConnect()
         handleConnect(@Client() client: WsClientData) {
-          // eslint-disable-next-line no-console
-          console.log(`Client ${client.id} connected`);
+          this.logger.info(`Client ${client.id} connected`);
 
           return { event: 'welcome', data: { message: 'Welcome!' } };
         }
@@ -3252,8 +3294,7 @@ describe('WebSocket Gateway API Documentation (docs/api/websocket.md)', () => {
       class TestGateway extends BaseWebSocketGateway {
         @OnDisconnect()
         handleDisconnect(@Client() client: WsClientData) {
-          // eslint-disable-next-line no-console
-          console.log(`Client ${client.id} disconnected`);
+          this.logger.info(`Client ${client.id} disconnected`);
         }
       }
 
@@ -3682,8 +3723,7 @@ describe('WebSocket Chat Example (docs/examples/websocket-chat.md)', () => {
 
         @OnConnect()
         async handleConnect(@Client() client: WsClientData) {
-          // eslint-disable-next-line no-console
-          console.log(`Client ${client.id} connected`);
+          this.logger.info(`Client ${client.id} connected`);
 
           return {
             event: 'welcome',
@@ -3697,8 +3737,7 @@ describe('WebSocket Chat Example (docs/examples/websocket-chat.md)', () => {
 
         @OnDisconnect()
         async handleDisconnect(@Client() client: WsClientData) {
-          // eslint-disable-next-line no-console
-          console.log(`Client ${client.id} disconnected`);
+          this.logger.info(`Client ${client.id} disconnected`);
 
           for (const room of client.rooms) {
             this.emitToRoom(room, 'user:left', {
@@ -3714,8 +3753,7 @@ describe('WebSocket Chat Example (docs/examples/websocket-chat.md)', () => {
           @RoomName() room: string,
           @PatternParams() params: { roomId: string },
         ) {
-          // eslint-disable-next-line no-console
-          console.log(`Client ${client.id} joining room ${params.roomId}`);
+          this.logger.info(`Client ${client.id} joining room ${params.roomId}`);
 
           await this.joinRoom(client.id, room);
 
@@ -3981,6 +4019,77 @@ describe('WebSocket Chat Example (docs/examples/websocket-chat.md)', () => {
   });
 });
 
+describe('WebSocket Gateway DI (docs/api/websocket.md#basewebsocketgateway)', () => {
+  /**
+   * @source docs/api/websocket.md#basewebsocketgateway
+   * Gateways receive this.logger and this.config just like controllers.
+   */
+  it('should inject logger and config into WebSocket gateway via module DI', async () => {
+    const effectLib = await import('effect');
+    const moduleMod = await import('./module/module');
+    const testUtils = await import('./testing/test-utils');
+
+    @WebSocketGateway({ path: '/ws' })
+    class TestGateway extends BaseWebSocketGateway {
+      @OnConnect()
+      handleConnect(@Client() client: WsClientData) {
+        this.logger.info(`Client ${client.id} connected`);
+
+        return { event: 'welcome', data: { id: client.id } };
+      }
+
+      getLoggerForTest() {
+        return this.logger;
+      }
+
+      getConfigForTest() {
+        return this.config;
+      }
+    }
+
+    @Module({ controllers: [TestGateway] })
+    class TestModule {}
+
+    const mod = new moduleMod.OneBunModule(TestModule, testUtils.makeMockLoggerLayer());
+    mod.getLayer();
+    await effectLib.Effect.runPromise(mod.setup() as import('effect').Effect.Effect<unknown, never, never>);
+
+    const gateway = mod.getControllerInstance(TestGateway) as unknown as TestGateway;
+    expect(gateway).toBeDefined();
+    expect(gateway.getLoggerForTest()).toBeDefined();
+    expect(typeof gateway.getLoggerForTest().info).toBe('function');
+    expect(typeof gateway.getLoggerForTest().warn).toBe('function');
+    expect(typeof gateway.getLoggerForTest().error).toBe('function');
+    expect(gateway.getConfigForTest()).toBeDefined();
+    expect(typeof gateway.getConfigForTest().get).toBe('function');
+  });
+
+  /**
+   * @source docs/api/websocket.md#constructor-access
+   * Gateways have this.config and this.logger available immediately after super()
+   */
+  it('should have config and logger available in WS gateway constructor after super()', () => {
+    // From docs: Gateway with constructor access to config and logger
+    @WebSocketGateway({ path: '/ws' })
+    class ChatGateway extends BaseWebSocketGateway {
+      readonly configAvailable: boolean;
+
+      constructor() {
+        super();
+        // config and logger are available immediately after super()
+        this.configAvailable = this.config !== undefined;
+      }
+
+      @OnMessage('chat:message')
+      handleMessage(@Client() client: WsClientData, @MessageData() data: unknown) {
+        this.broadcast('chat:message', { userId: client.id, data });
+      }
+    }
+
+    expect(ChatGateway).toBeDefined();
+  });
+});
+
 // ============================================================================
 // SSE (Server-Sent Events) Documentation Tests
 // ============================================================================

package/src/module/controller.test.ts

@@ -229,7 +229,7 @@ describe('Controller', () => {
       expect(mockLogger.child).toHaveBeenCalledWith({ className: 'EmptyController' });
     });
 
-    test('should handle re-initialization attempts', () => {
+    test('should handle re-initialization attempts (no-op after first init)', () => {
       class TestController extends Controller {
         testMethod() {
           return 'test';
@@ -242,7 +242,7 @@ describe('Controller', () => {
       controller.initializeController(mockLogger, mockConfig);
       expect(mockLogger.debug).toHaveBeenCalledWith('Controller TestController initialized');
 
-      // Second initialization (should work but replace values)
+      // Second initialization — should be a no-op (already initialized)
       const newMockLogger = {
         ...mockLogger,
         child: mock(() => newMockLogger),
@@ -251,7 +251,11 @@ describe('Controller', () => {
 
       const newConfig = createMockConfig({ 'newConfig': true });
       controller.initializeController(newMockLogger, newConfig);
-      expect(newMockLogger.debug).toHaveBeenCalledWith('Controller TestController initialized');
+
+      // Should NOT have been called — initializeController is a no-op after first init
+      expect(newMockLogger.debug).not.toHaveBeenCalled();
+      // Should still have original config
+      expect((controller as any).config).toBe(mockConfig);
     });
   });
 
@@ -579,4 +583,108 @@ describe('Controller', () => {
       expect(text).toBe('');
     });
   });
+
+  describe('Initialization via static init context (constructor)', () => {
+    test('should initialize controller via static init context in constructor', () => {
+      class TestController extends Controller {
+        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)
+      Controller.setInitContext(mockLogger, mockConfig);
+      let controller: TestController;
+      try {
+        controller = new TestController();
+      } finally {
+        Controller.clearInitContext();
+      }
+
+      expect(controller.configAvailableInConstructor).toBe(true);
+      expect(controller.loggerAvailableInConstructor).toBe(true);
+      expect((controller as any).config).toBe(mockConfig);
+    });
+
+    test('should allow using config.get() in constructor when init context is set', () => {
+      class TestController extends Controller {
+        readonly dbHost: string;
+
+        constructor() {
+          super();
+          this.dbHost = this.config.get('database.host') as string;
+        }
+      }
+
+      Controller.setInitContext(mockLogger, mockConfig);
+      let controller: TestController;
+      try {
+        controller = new TestController();
+      } finally {
+        Controller.clearInitContext();
+      }
+
+      expect(controller.dbHost).toBe('localhost');
+    });
+
+    test('should create child logger with correct className in constructor', () => {
+      class MyCustomController extends Controller {}
+
+      Controller.setInitContext(mockLogger, mockConfig);
+      try {
+        new MyCustomController();
+      } finally {
+        Controller.clearInitContext();
+      }
+
+      expect(mockLogger.child).toHaveBeenCalledWith({ className: 'MyCustomController' });
+    });
+
+    test('should not initialize if no init context is set', () => {
+      // Ensure context is clear
+      Controller.clearInitContext();
+
+      class TestController extends Controller {}
+      const controller = new TestController();
+
+      expect((controller as any)._initialized).toBe(false);
+      expect((controller as any).logger).toBeUndefined();
+      expect((controller as any).config).toBeUndefined();
+    });
+
+    test('initializeController should be a no-op if already initialized via init context', () => {
+      class TestController extends Controller {}
+
+      Controller.setInitContext(mockLogger, mockConfig);
+      let controller: TestController;
+      try {
+        controller = new TestController();
+      } finally {
+        Controller.clearInitContext();
+      }
+
+      // Call initializeController again — should be a no-op
+      const otherLogger = { ...mockLogger, child: mock(() => ({ ...mockLogger })) };
+      const otherConfig = createMockConfig({ other: 'config' });
+      controller.initializeController(otherLogger, otherConfig);
+
+      // Should still have original config (no reinit)
+      expect((controller as any).config).toBe(mockConfig);
+    });
+
+    test('clearInitContext should prevent subsequent constructors from picking up context', () => {
+      Controller.setInitContext(mockLogger, mockConfig);
+      Controller.clearInitContext();
+
+      class TestController extends Controller {}
+      const controller = new TestController();
+
+      expect((controller as any)._initialized).toBe(false);
+    });
+  });
 });

package/src/module/controller.ts

@@ -31,7 +31,26 @@ export const DEFAULT_SSE_HEARTBEAT_MS = 30_000;
 export const DEFAULT_SSE_TIMEOUT = 600;
 
 /**
- * Base controller class that can be extended to add common functionality
+ * Base controller class that can be extended to add common functionality.
+ *
+ * Controllers extending this class 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
+ * the Controller base class reads from it in its constructor.
+ *
+ * @example
+ * ```typescript
+ * @Controller('/users')
+ * class UserController extends BaseController {
+ *   private readonly prefix: string;
+ *
+ *   constructor(private userService: UserService) {
+ *     super();
+ *     // this.config and this.logger are available here!
+ *     this.prefix = this.config.get('api.prefix');
+ *   }
+ * }
+ * ```
  */
 export class Controller {
   // Store service instances
@@ -42,12 +61,61 @@ export class Controller {
   protected logger!: SyncLogger;
   // Configuration instance for accessing environment variables
   protected config!: IConfig<OneBunAppConfig>;
+  // Flag to track initialization status
+  private _initialized = false;
+
+  /**
+   * Ambient init context set by the framework before controller construction.
+   * This allows the Controller 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 controller.
+   * Called by the framework (OneBunModule) before `new ControllerClass(...)`.
+   * @internal
+   */
+  static setInitContext(logger: SyncLogger, config: IConfig<OneBunAppConfig>): void {
+    Controller._initContext = { logger, config };
+  }
 
   /**
-   * Initialize controller with logger and config (called by the framework)
+   * Clear the ambient init context after controller construction.
+   * Called by the framework (OneBunModule) after `new ControllerClass(...)`.
+   * @internal
+   */
+  static clearInitContext(): void {
+    Controller._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 (Controller._initContext) {
+      const { logger, config } = Controller._initContext;
+      const className = this.constructor.name;
+      this.logger = logger.child({ className });
+      this.config = config;
+      this._initialized = true;
+    }
+  }
+
+  /**
+   * Initialize controller with logger and config (called by the framework).
+   * This is a fallback for controllers not constructed through the DI system
+   * (e.g., in tests or when created manually). If the controller was already
+   * initialized via the constructor init context, this is a no-op.
    * @internal
    */
   initializeController(logger: SyncLogger, config: IConfig<OneBunAppConfig>): void {
+    if (this._initialized) {
+      return; // Already initialized (via constructor or previous call)
+    }
+
     const className = this.constructor.name;
 
     if (logger) {
@@ -61,6 +129,7 @@ export class Controller {
 
     // Set configuration instance
     this.config = config;
+    this._initialized = true;
 
     this.logger.debug(`Controller ${className} initialized`);
   }

package/src/module/middleware.ts

@@ -11,6 +11,11 @@ import type { SyncLogger } from '@onebun/logger';
  * Constructor-based DI is fully supported — inject any service from
  * the module's DI scope just like you would in a controller.
  *
+ * Middleware extending this class 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
+ * BaseMiddleware reads from it in its constructor.
+ *
  * Middleware is instantiated **once** at application startup and reused
  * for every matching request.
  *
@@ -24,17 +29,20 @@ import type { SyncLogger } from '@onebun/logger';
  * }
  * ```
  *
- * @example Middleware with DI
+ * @example Middleware with DI and constructor access
  * ```typescript
  * class AuthMiddleware extends BaseMiddleware {
+ *   private readonly jwtSecret: string;
+ *
  *   constructor(private authService: AuthService) {
  *     super();
+ *     // this.config and this.logger are available here!
+ *     this.jwtSecret = this.config.get('auth.jwtSecret');
  *   }
  *
  *   async use(req: OneBunRequest, next: () => Promise<OneBunResponse>) {
- *     const secret = this.config.get('auth.jwtSecret');
  *     const token = req.headers.get('Authorization');
- *     if (!this.authService.verify(token, secret)) {
+ *     if (!this.authService.verify(token, this.jwtSecret)) {
  *       this.logger.warn('Authentication failed');
  *       return new Response('Unauthorized', { status: 401 });
  *     }
@@ -50,15 +58,66 @@ export abstract class BaseMiddleware {
   /** Configuration instance for accessing environment variables */
   protected config!: IConfig<OneBunAppConfig>;
 
+  /** Flag to track initialization status */
+  private _initialized = false;
+
+  /**
+   * Ambient init context set by the framework before middleware construction.
+   * This allows the BaseMiddleware 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 middleware.
+   * Called by the framework (OneBunModule) before `new MiddlewareClass(...)`.
+   * @internal
+   */
+  static setInitContext(logger: SyncLogger, config: IConfig<OneBunAppConfig>): void {
+    BaseMiddleware._initContext = { logger, config };
+  }
+
+  /**
+   * Clear the ambient init context after middleware construction.
+   * Called by the framework (OneBunModule) after `new MiddlewareClass(...)`.
+   * @internal
+   */
+  static clearInitContext(): void {
+    BaseMiddleware._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 (BaseMiddleware._initContext) {
+      const { logger, config } = BaseMiddleware._initContext;
+      const className = this.constructor.name;
+      this.logger = logger.child({ className });
+      this.config = config;
+      this._initialized = true;
+    }
+  }
+
   /**
    * Initialize middleware with logger and config.
+   * This is a fallback for middleware not constructed through the DI system
+   * (e.g., in tests or when created manually). If the middleware was already
+   * initialized via the constructor init context, this is a no-op.
    * Called by the framework after DI construction — do NOT call manually.
    * @internal
    */
   initializeMiddleware(logger: SyncLogger, config: IConfig<OneBunAppConfig>): void {
+    if (this._initialized) {
+      return; // Already initialized (via constructor or previous call)
+    }
+
     const className = this.constructor.name;
     this.logger = logger.child({ className });
     this.config = config;
+    this._initialized = true;
     this.logger.debug(`Middleware ${className} initialized`);
   }
 

package/src/module/module.test.ts

@@ -26,6 +26,8 @@ import type {
 
 import { Controller as CtrlDeco, Module } from '../decorators/decorators';
 import { makeMockLoggerLayer } from '../testing/test-utils';
+import { BaseWebSocketGateway } from '../websocket/ws-base-gateway';
+import { WebSocketGateway } from '../websocket/ws-decorators';
 
 import { Controller as CtrlBase } from './controller';
 import { BaseMiddleware } from './middleware';
@@ -963,6 +965,230 @@ describe('OneBunModule', () => {
     });
   });
 
+  describe('Controller with ambient init context (config/logger in constructor)', () => {
+    const { Module: ModuleDecorator, Controller: ControllerDecorator, clearGlobalModules } = require('../decorators/decorators');
+    const { clearGlobalServicesRegistry: clearRegistry, OneBunModule: ModuleClass } = require('./module');
+    const { Controller: BaseController } = require('./controller');
+
+    beforeEach(() => {
+      clearGlobalModules();
+      clearRegistry();
+    });
+
+    afterEach(() => {
+      clearGlobalModules();
+      clearRegistry();
+    });
+
+    /**
+     * Test that this.config and this.logger are available in the controller constructor
+     * when the controller is created through the DI system (via ambient init context).
+     */
+    test('should have this.config and this.logger available in controller constructor via DI', async () => {
+      let configInConstructor: unknown = undefined;
+      let loggerInConstructor: unknown = undefined;
+
+      @ControllerDecorator('/test')
+      class TestCtrl extends BaseController {
+        constructor() {
+          super();
+          configInConstructor = this.config;
+          loggerInConstructor = this.logger;
+        }
+      }
+
+      @ModuleDecorator({
+        controllers: [TestCtrl],
+      })
+      class TestModule {}
+
+      // Initialize module and run setup — this triggers DI and controller creation
+      const module = new ModuleClass(TestModule, mockLoggerLayer);
+      module.getLayer();
+      await Effect.runPromise(module.setup() as Effect.Effect<unknown, never, never>);
+
+      // config and logger should have been available in the constructor
+      expect(configInConstructor).toBeDefined();
+      expect(loggerInConstructor).toBeDefined();
+    });
+
+    /**
+     * Test that this.config and this.logger are available in the controller constructor
+     * when the controller has injected service dependencies.
+     */
+    test('should have this.config and this.logger in constructor of controller with dependencies', async () => {
+      let configAvailable = false;
+      let loggerAvailable = false;
+
+      @Service()
+      class SomeService {
+        getValue() {
+          return 42;
+        }
+      }
+
+      @ControllerDecorator('/test')
+      class TestCtrl extends BaseController {
+        constructor(private svc: SomeService) {
+          super();
+          configAvailable = this.config !== undefined;
+          loggerAvailable = this.logger !== undefined;
+        }
+      }
+
+      @ModuleDecorator({
+        providers: [SomeService],
+        controllers: [TestCtrl],
+      })
+      class TestModule {}
+
+      const module = new ModuleClass(TestModule, mockLoggerLayer);
+      module.getLayer();
+      await Effect.runPromise(module.setup() as Effect.Effect<unknown, never, never>);
+
+      expect(configAvailable).toBe(true);
+      expect(loggerAvailable).toBe(true);
+    });
+  });
+
+  describe('WebSocket gateway with ambient init context (config/logger in constructor)', () => {
+    const { Module: ModuleDecorator, clearGlobalModules } = require('../decorators/decorators');
+    const { clearGlobalServicesRegistry: clearRegistry, OneBunModule: ModuleClass } = require('./module');
+
+    beforeEach(() => {
+      clearGlobalModules();
+      clearRegistry();
+    });
+
+    afterEach(() => {
+      clearGlobalModules();
+      clearRegistry();
+    });
+
+    /**
+     * Test that this.config and this.logger are available in the WS gateway constructor
+     * when the gateway is created through the DI system (via ambient init context).
+     */
+    test('should have this.config and this.logger available in WS gateway constructor via DI', async () => {
+      let configInConstructor: unknown = undefined;
+      let loggerInConstructor: unknown = undefined;
+
+      @WebSocketGateway({ path: '/ws' })
+      class TestGateway extends BaseWebSocketGateway {
+        constructor() {
+          super();
+          configInConstructor = this.config;
+          loggerInConstructor = this.logger;
+        }
+      }
+
+      @ModuleDecorator({
+        controllers: [TestGateway],
+      })
+      class TestModule {}
+
+      // Initialize module and run setup — this triggers DI and gateway creation
+      const module = new ModuleClass(TestModule, mockLoggerLayer);
+      module.getLayer();
+      await Effect.runPromise(module.setup() as Effect.Effect<unknown, never, never>);
+
+      // config and logger should have been available in the constructor
+      expect(configInConstructor).toBeDefined();
+      expect(loggerInConstructor).toBeDefined();
+    });
+
+    /**
+     * Test that this.config and this.logger are available in the WS gateway constructor
+     * when the gateway has injected service dependencies.
+     */
+    test('should have this.config and this.logger in constructor of WS gateway with dependencies', async () => {
+      let configAvailable = false;
+      let loggerAvailable = false;
+
+      @Service()
+      class WsAuthService {
+        verify() {
+          return true;
+        }
+      }
+
+      @WebSocketGateway({ path: '/ws' })
+      class TestGateway extends BaseWebSocketGateway {
+        constructor(private auth: WsAuthService) {
+          super();
+          configAvailable = this.config !== undefined;
+          loggerAvailable = this.logger !== undefined;
+        }
+      }
+
+      @ModuleDecorator({
+        providers: [WsAuthService],
+        controllers: [TestGateway],
+      })
+      class TestModule {}
+
+      const module = new ModuleClass(TestModule, mockLoggerLayer);
+      module.getLayer();
+      await Effect.runPromise(module.setup() as Effect.Effect<unknown, never, never>);
+
+      expect(configAvailable).toBe(true);
+      expect(loggerAvailable).toBe(true);
+    });
+  });
+
+  describe('Middleware with ambient init context (config/logger in constructor)', () => {
+    const { Module: ModuleDecorator, Controller: ControllerDecorator, clearGlobalModules } = require('../decorators/decorators');
+    const { clearGlobalServicesRegistry: clearRegistry, OneBunModule: ModuleInstance } = require('./module');
+    const { Controller: BaseController } = require('./controller');
+
+    beforeEach(() => {
+      clearGlobalModules();
+      clearRegistry();
+    });
+
+    afterEach(() => {
+      clearGlobalModules();
+      clearRegistry();
+    });
+
+    /**
+     * Test that this.config and this.logger are available in the middleware constructor
+     * when the middleware is created through the DI system (via ambient init context).
+     */
+    test('should have this.config and this.logger available in middleware constructor via DI', () => {
+      let configInConstructor: unknown = undefined;
+      let loggerInConstructor: unknown = undefined;
+
+      class TestMiddleware extends BaseMiddleware {
+        constructor() {
+          super();
+          configInConstructor = this.config;
+          loggerInConstructor = this.logger;
+        }
+
+        async use(req: OneBunRequest, next: () => Promise<OneBunResponse>): Promise<OneBunResponse> {
+          return await next();
+        }
+      }
+
+      @ControllerDecorator('/test')
+      class TestCtrl extends BaseController {}
+
+      @ModuleDecorator({
+        controllers: [TestCtrl],
+      })
+      class TestModule {}
+
+      // Initialize module and resolve middleware (as the framework does)
+      const module = new ModuleInstance(TestModule, mockLoggerLayer);
+      module.resolveMiddleware([TestMiddleware]);
+
+      // config and logger should have been available in the constructor
+      expect(configInConstructor).toBeDefined();
+      expect(loggerInConstructor).toBeDefined();
+    });
+  });
+
   describe('Lifecycle hooks', () => {
     const { clearGlobalModules } = require('../decorators/decorators');
     const { clearGlobalServicesRegistry: clearRegistry, OneBunModule: ModuleClass } = require('./module');

package/src/module/module.ts

@@ -4,9 +4,9 @@ import {
   Layer,
 } from 'effect';
 
-import type { Controller } from './controller';
 import type { ModuleInstance } from '../types';
 
+
 import {
   createSyncLogger,
   type Logger,
@@ -22,6 +22,7 @@ import {
   isGlobalModule,
   registerControllerDependencies,
 } from '../decorators/decorators';
+import { BaseWebSocketGateway } from '../websocket/ws-base-gateway';
 import { isWebSocketGateway } from '../websocket/ws-decorators';
 
 import {
@@ -29,6 +30,7 @@ import {
   type IConfig,
   type OneBunAppConfig,
 } from './config.interface';
+import { Controller } from './controller';
 import {
   hasOnModuleInit,
   hasOnApplicationInit,
@@ -461,7 +463,19 @@ export class OneBunModule implements ModuleInstance {
       }
 
       const middlewareConstructor = cls as new (...args: unknown[]) => BaseMiddleware;
-      const instance = new middlewareConstructor(...deps);
+
+      // Set ambient init context so BaseMiddleware constructor can pick up logger/config,
+      // making them available immediately after super() in subclass constructors.
+      BaseMiddleware.setInitContext(this.logger, this.config);
+      let instance: BaseMiddleware;
+      try {
+        instance = new middlewareConstructor(...deps);
+      } finally {
+        BaseMiddleware.clearInitContext();
+      }
+
+      // Fallback: call initializeMiddleware for middleware not initialized via
+      // the constructor (e.g., not extending BaseMiddleware, or for backwards compatibility).
       instance.initializeMiddleware(this.logger, this.config);
 
       return instance.use.bind(instance);
@@ -533,15 +547,38 @@ export class OneBunModule implements ModuleInstance {
         }
       }
 
-      // Logger and config are now injected separately via initializeController
-      // No need to add them to constructor dependencies
-
-      // Create controller with resolved dependencies
+      // Create controller with resolved dependencies.
+      // Set ambient init context so the base class constructor can pick up logger/config,
+      // making them available immediately after super() in subclass constructors.
       const controllerConstructor = controllerClass as new (...args: unknown[]) => Controller;
-      const controller = new controllerConstructor(...dependencies);
+      const isGateway = isWebSocketGateway(controllerClass);
+      let controller: Controller;
 
-      // Initialize controller with logger and config (skip for WebSocket gateways)
-      if (!isWebSocketGateway(controllerClass) && typeof controller.initializeController === 'function') {
+      if (isGateway) {
+        BaseWebSocketGateway.setInitContext(this.logger, this.config);
+      } else {
+        Controller.setInitContext(this.logger, this.config);
+      }
+
+      try {
+        controller = new controllerConstructor(...dependencies);
+      } finally {
+        if (isGateway) {
+          BaseWebSocketGateway.clearInitContext();
+        } else {
+          Controller.clearInitContext();
+        }
+      }
+
+      // Fallback: call initializeController / _initializeBase for controllers/gateways
+      // that were not initialized via the constructor (e.g., not extending the base class,
+      // or for backwards compatibility).
+      if (isGateway) {
+        const gateway = controller as unknown as BaseWebSocketGateway;
+        if (typeof gateway._initializeBase === 'function') {
+          gateway._initializeBase(this.logger, this.config);
+        }
+      } else if (typeof controller.initializeController === 'function') {
         controller.initializeController(this.logger, this.config);
       }
 

package/src/websocket/ws-base-gateway.test.ts

@@ -1,3 +1,7 @@
+/* eslint-disable
+   @typescript-eslint/no-explicit-any,
+   @typescript-eslint/naming-convention,
+   @typescript-eslint/no-empty-function */
 /**
  * Unit tests for ws-base-gateway.ts
  */
@@ -49,22 +53,22 @@ function createClientData(id: string, rooms: string[] = []): WsClientData {
 class TestGateway extends BaseWebSocketGateway {
   // Expose internal methods for testing
   public exposeRegisterSocket(clientId: string, socket: MockWebSocket): void {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+     
     (this as any)._registerSocket(clientId, socket);
   }
 
   public exposeUnregisterSocket(clientId: string): void {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+     
     (this as any)._unregisterSocket(clientId);
   }
 
   public exposeInitialize(storage: InMemoryWsStorage, server: unknown): void {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+     
     (this as any)._initialize(storage, server);
   }
 
   public exposeGetSocket(clientId: string): MockWebSocket | undefined {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+     
     return (this as any).getSocket(clientId);
   }
 }
@@ -477,4 +481,146 @@ describe('BaseWebSocketGateway', () => {
       expect(typeof wsServer?.publish).toBe('function');
     });
   });
+
+  describe('Initialization via static init context (constructor)', () => {
+    let mockLogger: ReturnType<typeof createMockLogger>;
+    let mockConfig: ReturnType<typeof createMockConfig>;
+
+    function createMockLogger() {
+      const logger = {
+        debug: mock(() => {}),
+        info: mock(() => {}),
+        warn: mock(() => {}),
+        error: mock(() => {}),
+        fatal: mock(() => {}),
+        trace: mock(() => {}),
+        child: mock(() => logger),
+      };
+
+      return logger;
+    }
+
+    function createMockConfig(data: Record<string, unknown> = {}) {
+      return {
+        get: mock((key: string) => data[key]),
+        getOrThrow: mock((key: string) => {
+          if (key in data) {
+            return data[key];
+          }
+          throw new Error(`Missing config: ${key}`);
+        }),
+        has: mock((key: string) => key in data),
+        set: mock(() => {}),
+        entries: mock(() => Object.entries(data)),
+      } as any;
+    }
+
+    beforeEach(() => {
+      mockLogger = createMockLogger();
+      mockConfig = createMockConfig({
+        'ws.port': 8080,
+        'ws.path': '/ws',
+      });
+    });
+
+    it('should initialize gateway via static init context in constructor', () => {
+      class ContextTestGateway extends BaseWebSocketGateway {
+        configAvailableInConstructor = false;
+        loggerAvailableInConstructor = false;
+
+        constructor() {
+          super();
+          this.configAvailableInConstructor = this.config !== undefined;
+          this.loggerAvailableInConstructor = this.logger !== undefined;
+        }
+      }
+
+      BaseWebSocketGateway.setInitContext(mockLogger as any, mockConfig);
+      let gw: ContextTestGateway;
+      try {
+        gw = new ContextTestGateway();
+      } finally {
+        BaseWebSocketGateway.clearInitContext();
+      }
+
+      expect(gw.configAvailableInConstructor).toBe(true);
+      expect(gw.loggerAvailableInConstructor).toBe(true);
+      expect((gw as any).config).toBe(mockConfig);
+    });
+
+    it('should allow using config.get() in constructor when init context is set', () => {
+      class ContextTestGateway extends BaseWebSocketGateway {
+        readonly wsPort: number;
+
+        constructor() {
+          super();
+          this.wsPort = this.config.get('ws.port') as number;
+        }
+      }
+
+      BaseWebSocketGateway.setInitContext(mockLogger as any, mockConfig);
+      let gw: ContextTestGateway;
+      try {
+        gw = new ContextTestGateway();
+      } finally {
+        BaseWebSocketGateway.clearInitContext();
+      }
+
+      expect(gw.wsPort).toBe(8080);
+    });
+
+    it('should create child logger with correct className in constructor', () => {
+      class MyCustomGateway extends BaseWebSocketGateway {}
+
+      BaseWebSocketGateway.setInitContext(mockLogger as any, mockConfig);
+      try {
+        new MyCustomGateway();
+      } finally {
+        BaseWebSocketGateway.clearInitContext();
+      }
+
+      expect(mockLogger.child).toHaveBeenCalledWith({ className: 'MyCustomGateway' });
+    });
+
+    it('should not initialize if no init context is set', () => {
+      BaseWebSocketGateway.clearInitContext();
+
+      class ContextTestGateway extends BaseWebSocketGateway {}
+      const gw = new ContextTestGateway();
+
+      expect((gw as any)._initialized).toBe(false);
+      expect((gw as any).logger).toBeUndefined();
+      expect((gw as any).config).toBeUndefined();
+    });
+
+    it('_initializeBase should be a no-op if already initialized via init context', () => {
+      class ContextTestGateway extends BaseWebSocketGateway {}
+
+      BaseWebSocketGateway.setInitContext(mockLogger as any, mockConfig);
+      let gw: ContextTestGateway;
+      try {
+        gw = new ContextTestGateway();
+      } finally {
+        BaseWebSocketGateway.clearInitContext();
+      }
+
+      // Call _initializeBase again — should be a no-op
+      const otherLogger = createMockLogger();
+      const otherConfig = createMockConfig({ other: 'config' });
+      (gw as any)._initializeBase(otherLogger, otherConfig);
+
+      // Should still have original config (no reinit)
+      expect((gw as any).config).toBe(mockConfig);
+    });
+
+    it('clearInitContext should prevent subsequent constructors from picking up context', () => {
+      BaseWebSocketGateway.setInitContext(mockLogger as any, mockConfig);
+      BaseWebSocketGateway.clearInitContext();
+
+      class ContextTestGateway extends BaseWebSocketGateway {}
+      const gw = new ContextTestGateway();
+
+      expect((gw as any)._initialized).toBe(false);
+    });
+  });
 });

package/src/websocket/ws-base-gateway.ts

@@ -11,8 +11,11 @@ import type {
   WsRoom,
   WsServer,
 } from './ws.types';
+import type { IConfig, OneBunAppConfig } from '../module/config.interface';
 import type { Server, ServerWebSocket } from 'bun';
 
+import type { SyncLogger } from '@onebun/logger';
+
 import { createFullEventMessage, createNativeMessage } from './ws-socketio-protocol';
 import { WsStorageEvent, isPubSubAdapter } from './ws-storage';
 
@@ -31,12 +34,22 @@ export function _resetClientSocketsForTesting(): void {
 }
 
 /**
- * Base class for WebSocket gateways
+ * Base class for WebSocket gateways.
+ *
+ * Gateways extending this class 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
+ * BaseWebSocketGateway reads from it in its constructor.
  *
  * @example
  * ```typescript
  * @WebSocketGateway({ path: '/ws' })
  * export class ChatGateway extends BaseWebSocketGateway {
+ *   constructor() {
+ *     super();
+ *     // this.config and this.logger are available here!
+ *   }
+ *
  *   @OnMessage('chat:message')
  *   handleMessage(@Client() client: WsClientData, @MessageData() data: any) {
  *     this.broadcast('chat:message', { userId: client.id, ...data });
@@ -45,6 +58,12 @@ export function _resetClientSocketsForTesting(): void {
  * ```
  */
 export abstract class BaseWebSocketGateway {
+  /** Logger instance with gateway class name as context */
+  protected logger!: SyncLogger;
+
+  /** Configuration instance for accessing environment variables */
+  protected config!: IConfig<OneBunAppConfig>;
+
   /** Storage adapter for persisting client/room data */
   protected storage: WsStorageAdapter | null = null;
 
@@ -54,10 +73,72 @@ export abstract class BaseWebSocketGateway {
   /** Unique instance ID (for multi-instance setups) */
   protected instanceId: string = crypto.randomUUID();
 
+  /** Flag to track initialization status */
+  private _initialized = false;
+
+  /**
+   * Ambient init context set by the framework before gateway construction.
+   * This allows the BaseWebSocketGateway 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 gateway.
+   * Called by the framework (OneBunModule) before `new GatewayClass(...)`.
+   * @internal
+   */
+  static setInitContext(logger: SyncLogger, config: IConfig<OneBunAppConfig>): void {
+    BaseWebSocketGateway._initContext = { logger, config };
+  }
+
+  /**
+   * Clear the ambient init context after gateway construction.
+   * Called by the framework (OneBunModule) after `new GatewayClass(...)`.
+   * @internal
+   */
+  static clearInitContext(): void {
+    BaseWebSocketGateway._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 (BaseWebSocketGateway._initContext) {
+      const { logger, config } = BaseWebSocketGateway._initContext;
+      const className = this.constructor.name;
+      this.logger = logger.child({ className });
+      this.config = config;
+      this._initialized = true;
+    }
+  }
+
   // ============================================================================
   // Initialization
   // ============================================================================
 
+  /**
+   * Initialize the gateway with logger and config.
+   * This is a fallback for gateways not constructed through the DI system
+   * (e.g., in tests or when created manually). If the gateway was already
+   * initialized via the constructor init context, this is a no-op.
+   * Called internally by the framework during DI.
+   * @internal
+   */
+  _initializeBase(logger: SyncLogger, config: IConfig<OneBunAppConfig>): void {
+    if (this._initialized) {
+      return; // Already initialized (via constructor or previous call)
+    }
+
+    const className = this.constructor.name;
+    this.logger = logger.child({ className });
+    this.config = config;
+    this._initialized = true;
+  }
+
   /**
    * Initialize the gateway with storage and server
    * Called internally by the framework