@onebun/core 0.1.10 → 0.1.12

package/src/module/config.service.ts

@@ -1,5 +1,8 @@
 import { Context } from 'effect';
 
+import type { IConfig, OneBunAppConfig } from './config.interface';
+
+import type { DeepPaths, DeepValue } from '@onebun/envs';
 import type { SyncLogger } from '@onebun/logger';
 
 import { BaseService, Service } from './service';
@@ -15,17 +18,16 @@ export const ConfigServiceTag = Context.GenericTag<ConfigServiceImpl>('ConfigSer
  */
 @Service(ConfigServiceTag)
 export class ConfigServiceImpl extends BaseService {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private configInstance: any = null;
+  private configInstance: IConfig<OneBunAppConfig> | null = null;
 
-  constructor(logger?: SyncLogger, config?: unknown) {
+  constructor(logger?: SyncLogger, config?: IConfig<OneBunAppConfig>) {
     super();
     // If logger is provided directly (for backwards compatibility in tests),
     // initialize the service immediately
-    if (logger) {
+    if (logger && config) {
       this.initializeService(logger, config);
     }
-    this.configInstance = config;
+    this.configInstance = config ?? null;
   }
 
   /**
@@ -39,9 +41,24 @@ export class ConfigServiceImpl extends BaseService {
   }
 
   /**
-   * Get configuration value by path
+   * Get configuration value by path with full type inference.
+   * Uses module augmentation of OneBunAppConfig for type-safe access.
+   * 
+   * @example
+   * // With module augmentation:
+   * declare module '@onebun/core' {
+   *   interface OneBunAppConfig {
+   *     server: { port: number; host: string };
+   *   }
+   * }
+   * 
+   * const port = configService.get('server.port'); // number
+   * const host = configService.get('server.host'); // string
    */
-  get<T = unknown>(path: string): T {
+  get<P extends DeepPaths<OneBunAppConfig>>(path: P): DeepValue<OneBunAppConfig, P>;
+  /** Fallback for dynamic paths */
+  get<T = unknown>(path: string): T;
+  get(path: string): unknown {
     if (!this.configInstance) {
       throw new Error('Configuration not initialized. Provide envSchema in ApplicationOptions.');
     }
@@ -52,7 +69,7 @@ export class ConfigServiceImpl extends BaseService {
   /**
    * Get all configuration values
    */
-  get values(): unknown {
+  get values(): OneBunAppConfig {
     if (!this.configInstance) {
       throw new Error('Configuration not initialized. Provide envSchema in ApplicationOptions.');
     }
@@ -63,7 +80,7 @@ export class ConfigServiceImpl extends BaseService {
   /**
    * Get safe configuration for logging (sensitive data masked)
    */
-  getSafeConfig(): unknown {
+  getSafeConfig(): OneBunAppConfig {
     if (!this.configInstance) {
       throw new Error('Configuration not initialized. Provide envSchema in ApplicationOptions.');
     }

package/src/module/controller.test.ts

@@ -12,13 +12,17 @@ import {
 } from 'bun:test';
 import { Context } from 'effect';
 
+import type { IConfig, OneBunAppConfig } from './config.interface';
+
 import type { SyncLogger } from '@onebun/logger';
 
+import { createMockConfig } from '../testing/test-utils';
+
 import { Controller } from './controller';
 
 describe('Controller', () => {
   let mockLogger: SyncLogger;
-  let mockConfig: unknown;
+  let mockConfig: IConfig<OneBunAppConfig>;
 
   beforeEach(() => {
     mockLogger = {
@@ -31,13 +35,11 @@ describe('Controller', () => {
       child: mock(() => mockLogger),
     };
 
-    mockConfig = {
-      test: 'value',
-      database: {
-        host: 'localhost',
-        port: 5432,
-      },
-    };
+    mockConfig = createMockConfig({
+      'test': 'value',
+      'database.host': 'localhost',
+      'database.port': 5432,
+    });
   });
 
   describe('Controller initialization', () => {
@@ -139,33 +141,28 @@ describe('Controller', () => {
       expect(mockLogger.debug).toHaveBeenCalledWith('Controller CustomNamedController initialized');
     });
 
-    test('should work with different config types', () => {
+    test('should provide typed config access', () => {
       class TestController extends Controller {
-        getConfigType() {
-          return typeof this.config;
+        getConfigValue(path: string) {
+          return this.config.get(path);
+        }
+        
+        checkConfigInitialized() {
+          return this.config.isInitialized;
         }
       }
 
       const controller = new TestController();
+      const typedConfig = createMockConfig({
+        'server.port': 3000,
+        'server.host': '0.0.0.0',
+      });
       
-      // Test with object config
-      controller.initializeController(mockLogger, { test: 'value' });
-      expect(controller.getConfigType()).toBe('object');
+      controller.initializeController(mockLogger, typedConfig);
       
-      // Test with string config
-      const controller2 = new TestController();
-      controller2.initializeController(mockLogger, 'string-config');
-      expect(controller2.getConfigType()).toBe('string');
-
-      // Test with null config
-      const controller3 = new TestController();
-      controller3.initializeController(mockLogger, null);
-      expect(controller3.getConfigType()).toBe('object'); // null is typeof 'object'
-
-      // Test with undefined config
-      const controller4 = new TestController();
-      controller4.initializeController(mockLogger, undefined);
-      expect(controller4.getConfigType()).toBe('undefined');
+      expect(controller.getConfigValue('server.port')).toBe(3000);
+      expect(controller.getConfigValue('server.host')).toBe('0.0.0.0');
+      expect(controller.checkConfigInitialized()).toBe(true);
     });
   });
 
@@ -252,7 +249,8 @@ describe('Controller', () => {
         debug: mock(() => {}),
       };
 
-      controller.initializeController(newMockLogger, { newConfig: true });
+      const newConfig = createMockConfig({ 'newConfig': true });
+      controller.initializeController(newMockLogger, newConfig);
       expect(newMockLogger.debug).toHaveBeenCalledWith('Controller TestController initialized');
     });
   });

package/src/module/controller.ts

@@ -1,3 +1,4 @@
+import type { IConfig, OneBunAppConfig } from './config.interface';
 import type { Context } from 'effect';
 
 import type { SyncLogger } from '@onebun/logger';
@@ -14,13 +15,13 @@ export class Controller {
   // Logger instance with controller class name as context
   protected logger!: SyncLogger;
   // Configuration instance for accessing environment variables
-  protected config!: unknown;
+  protected config!: IConfig<OneBunAppConfig>;
 
   /**
    * Initialize controller with logger and config (called by the framework)
    * @internal
    */
-  initializeController(logger: SyncLogger, config: unknown): void {
+  initializeController(logger: SyncLogger, config: IConfig<OneBunAppConfig>): void {
     const className = this.constructor.name;
 
     if (logger) {

package/src/module/index.ts

@@ -10,3 +10,4 @@ export * from './controller';
 export { Controller as BaseController } from './controller';
 export * from './service';
 export * from './config.service';
+export * from './config.interface';

package/src/module/module.test.ts

@@ -12,18 +12,17 @@ import {
 } from 'bun:test';
 import { Context } from 'effect';
 
-import { makeDevLogger } from '@onebun/logger';
-
 import { Module } from '../decorators/decorators';
+import { makeMockLoggerLayer } from '../testing/test-utils';
 
 import { OneBunModule } from './module';
 import { Service } from './service';
 
 describe('OneBunModule', () => {
-  let mockLogger: any;
+  let mockLoggerLayer: any;
 
   beforeEach(() => {
-    mockLogger = makeDevLogger();
+    mockLoggerLayer = makeMockLoggerLayer();
   });
 
   describe('Module initialization', () => {
@@ -31,7 +30,7 @@ describe('OneBunModule', () => {
       @Module({})
       class TestModule {}
 
-      const module = new OneBunModule(TestModule, mockLogger);
+      const module = new OneBunModule(TestModule, mockLoggerLayer);
       expect(module).toBeInstanceOf(OneBunModule);
       expect((module as any).logger).toBeDefined(); // Logger wrapper is created
       expect((module as any).moduleClass).toBe(TestModule);
@@ -49,7 +48,7 @@ describe('OneBunModule', () => {
     test('should handle module without metadata', () => {
       class TestModuleWithoutDecorator {}
 
-      expect(() => new OneBunModule(TestModuleWithoutDecorator, mockLogger)).toThrow();
+      expect(() => new OneBunModule(TestModuleWithoutDecorator, mockLoggerLayer)).toThrow();
     });
   });
 
@@ -58,7 +57,7 @@ describe('OneBunModule', () => {
       @Module({})
       class EmptyModule {}
 
-      const module = new OneBunModule(EmptyModule, mockLogger);
+      const module = new OneBunModule(EmptyModule, mockLoggerLayer);
       const layer = module.getLayer();
       expect(layer).toBeDefined();
     });
@@ -72,7 +71,7 @@ describe('OneBunModule', () => {
       })
       class ModuleWithProviders {}
 
-      const module = new OneBunModule(ModuleWithProviders, mockLogger);
+      const module = new OneBunModule(ModuleWithProviders, mockLoggerLayer);
       const layer = module.getLayer();
       expect(layer).toBeDefined();
     });
@@ -85,7 +84,7 @@ describe('OneBunModule', () => {
       })
       class ModuleWithControllers {}
 
-      const module = new OneBunModule(ModuleWithControllers, mockLogger);
+      const module = new OneBunModule(ModuleWithControllers, mockLoggerLayer);
       const layer = module.getLayer();
       expect(layer).toBeDefined();
     });
@@ -99,7 +98,7 @@ describe('OneBunModule', () => {
       })
       class ModuleWithImports {}
 
-      const module = new OneBunModule(ModuleWithImports, mockLogger);
+      const module = new OneBunModule(ModuleWithImports, mockLoggerLayer);
       const layer = module.getLayer();
       expect(layer).toBeDefined();
     });
@@ -110,7 +109,7 @@ describe('OneBunModule', () => {
       @Module({})
       class TestModule {}
 
-      const module = new OneBunModule(TestModule, mockLogger);
+      const module = new OneBunModule(TestModule, mockLoggerLayer);
       const layer = module.getLayer();
       expect(layer).toBeDefined();
     });
@@ -136,7 +135,7 @@ describe('OneBunModule', () => {
       })
       class ComplexModule {}
 
-      const module = new OneBunModule(ComplexModule, mockLogger);
+      const module = new OneBunModule(ComplexModule, mockLoggerLayer);
       const layer = module.getLayer();
       expect(layer).toBeDefined();
     });
@@ -144,8 +143,8 @@ describe('OneBunModule', () => {
 
   describe('Error handling', () => {
     test('should handle invalid module class', () => {
-      expect(() => new OneBunModule(null as any, mockLogger)).toThrow();
-      expect(() => new OneBunModule(undefined as any, mockLogger)).toThrow();
+      expect(() => new OneBunModule(null as any, mockLoggerLayer)).toThrow();
+      expect(() => new OneBunModule(undefined as any, mockLoggerLayer)).toThrow();
     });
 
     test('should handle malformed metadata', () => {
@@ -153,7 +152,7 @@ describe('OneBunModule', () => {
       const TestClass = class {};
       (TestClass as any)[Symbol.for('module:metadata')] = 'invalid';
 
-      expect(() => new OneBunModule(TestClass, mockLogger)).toThrow();
+      expect(() => new OneBunModule(TestClass, mockLoggerLayer)).toThrow();
     });
   });
 
@@ -162,7 +161,7 @@ describe('OneBunModule', () => {
       @Module({})
       class NamedModule {}
 
-      const module = new OneBunModule(NamedModule, mockLogger);
+      const module = new OneBunModule(NamedModule, mockLoggerLayer);
       expect((module as any).moduleClass.name).toBe('NamedModule');
     });
 
@@ -170,7 +169,7 @@ describe('OneBunModule', () => {
       @Module({})
       class InitModule {}
 
-      const module = new OneBunModule(InitModule, mockLogger);
+      const module = new OneBunModule(InitModule, mockLoggerLayer);
 
       // Test that initialization completes without error
       expect(() => module.getLayer()).not.toThrow();
@@ -191,7 +190,7 @@ describe('OneBunModule', () => {
       })
       class ServiceModule {}
 
-      const module = new OneBunModule(ServiceModule, mockLogger);
+      const module = new OneBunModule(ServiceModule, mockLoggerLayer);
       const layer = module.getLayer();
       expect(layer).toBeDefined();
     });
@@ -208,7 +207,7 @@ describe('OneBunModule', () => {
       })
       class ControllerModule {}
 
-      const module = new OneBunModule(ControllerModule, mockLogger);
+      const module = new OneBunModule(ControllerModule, mockLoggerLayer);
       const layer = module.getLayer();
       expect(layer).toBeDefined();
     });
@@ -227,7 +226,7 @@ describe('OneBunModule', () => {
       })
       class TestModule {}
 
-      const module = new OneBunModule(TestModule, mockLogger);
+      const module = new OneBunModule(TestModule, mockLoggerLayer);
 
       // Access private method via type assertion
       const instances = (module as any).getControllerInstances();
@@ -248,7 +247,7 @@ describe('OneBunModule', () => {
       })
       class TestModule {}
 
-      const module = new OneBunModule(TestModule, mockLogger);
+      const module = new OneBunModule(TestModule, mockLoggerLayer);
       module.getLayer(); // Initialize the module
 
       // Access private method via type assertion
@@ -262,7 +261,7 @@ describe('OneBunModule', () => {
       @Module({})
       class TestModule {}
 
-      const module = new OneBunModule(TestModule, mockLogger);
+      const module = new OneBunModule(TestModule, mockLoggerLayer);
 
       // Access private deprecated method via type assertion
       const resolved = (module as any).resolveDependencyByName('SomeService');
@@ -295,7 +294,7 @@ describe('OneBunModule', () => {
       })
       class TagModule {}
 
-      const module = new OneBunModule(TagModule, mockLogger);
+      const module = new OneBunModule(TagModule, mockLoggerLayer);
       const layer = module.getLayer();
 
       expect(layer).toBeDefined();
@@ -321,7 +320,7 @@ describe('OneBunModule', () => {
       })
       class TestModule {}
 
-      const module = new OneBunModule(TestModule, mockLogger);
+      const module = new OneBunModule(TestModule, mockLoggerLayer);
       module.getLayer(); // Initialize the module
 
       // Try to resolve ServiceB which is not in the module
@@ -350,7 +349,7 @@ describe('OneBunModule', () => {
       })
       class TestModule {}
 
-      const module = new OneBunModule(TestModule, mockLogger);
+      const module = new OneBunModule(TestModule, mockLoggerLayer);
       module.getLayer(); // Initialize the module
 
       // Try to resolve by base type
@@ -400,7 +399,7 @@ describe('OneBunModule', () => {
       })
       class RootModule {}
 
-      const module = new OneBunModule(RootModule, mockLogger);
+      const module = new OneBunModule(RootModule, mockLoggerLayer);
       module.getLayer();
 
       // Check that global service is registered
@@ -452,7 +451,7 @@ describe('OneBunModule', () => {
       })
       class RootModule {}
 
-      const module = new OneBunModule(RootModule, mockLogger);
+      const module = new OneBunModule(RootModule, mockLoggerLayer);
       module.getLayer();
 
       // GlobalDbService should be in the global registry
@@ -498,7 +497,7 @@ describe('OneBunModule', () => {
       })
       class RootModule {}
 
-      const module = new OneBunModule(RootModule, mockLogger);
+      const module = new OneBunModule(RootModule, mockLoggerLayer);
       module.getLayer();
 
       // Should have only one SingletonService instance in global registry
@@ -532,7 +531,7 @@ describe('OneBunModule', () => {
       })
       class RootModule {}
 
-      const module = new OneBunModule(RootModule, mockLogger);
+      const module = new OneBunModule(RootModule, mockLoggerLayer);
       module.getLayer();
 
       // LocalService should NOT be in the global registry
@@ -567,7 +566,7 @@ describe('OneBunModule', () => {
       })
       class RootModule {}
 
-      const module = new OneBunModule(RootModule, mockLogger);
+      const module = new OneBunModule(RootModule, mockLoggerLayer);
       module.getLayer();
 
       // Should have service in registry
@@ -693,7 +692,7 @@ describe('OneBunModule', () => {
       class TestModule {}
 
       // Initialize module
-      const module = new ModuleInstance(TestModule);
+      const module = new ModuleInstance(TestModule, mockLoggerLayer);
 
       // Verify services are created correctly
       const { getServiceTag } = require('./service');
@@ -752,7 +751,7 @@ describe('OneBunModule', () => {
       class ChainModule {}
 
       // Should not throw
-      const module = new ModuleInstance(ChainModule);
+      const module = new ModuleInstance(ChainModule, mockLoggerLayer);
 
       const { getServiceTag } = require('./service');
       const apiServiceTag = getServiceTag(ApiService);

package/src/module/module.ts

@@ -15,7 +15,6 @@ import {
   type SyncLogger,
 } from '@onebun/logger';
 
-
 import {
   autoDetectDependencies,
   getConstructorParamTypes,
@@ -25,6 +24,11 @@ import {
 } from '../decorators/decorators';
 import { isWebSocketGateway } from '../websocket/ws-decorators';
 
+import {
+  NotInitializedConfig,
+  type IConfig,
+  type OneBunAppConfig,
+} from './config.interface';
 import { getServiceMetadata, getServiceTag } from './service';
 
 /**
@@ -65,12 +69,12 @@ export class OneBunModule implements ModuleInstance {
   private controllerInstances: Map<Function, Controller> = new Map();
   private serviceInstances: Map<Context.Tag<unknown, unknown>, unknown> = new Map();
   private logger: SyncLogger;
-  private config: unknown;
+  private config: IConfig<OneBunAppConfig>;
 
   constructor(
     private moduleClass: Function,
     private loggerLayer?: Layer.Layer<never, never, unknown>,
-    config?: unknown,
+    config?: IConfig<OneBunAppConfig>,
   ) {
     // Initialize logger with module class name as context
     const effectLogger = Effect.runSync(
@@ -82,7 +86,7 @@ export class OneBunModule implements ModuleInstance {
       ) as Effect.Effect<Logger, never, never>,
     ) as Logger;
     this.logger = createSyncLogger(effectLogger);
-    this.config = config;
+    this.config = config ?? new NotInitializedConfig();
 
     this.logger.debug(`Initializing OneBunModule for ${moduleClass.name}`);
     const { layer, controllers } = this.initModule();
@@ -520,7 +524,7 @@ export class OneBunModule implements ModuleInstance {
   static create(
     moduleClass: Function,
     loggerLayer?: Layer.Layer<never, never, unknown>,
-    config?: unknown,
+    config?: IConfig<OneBunAppConfig>,
   ): ModuleInstance {
     // Using console.log here because we don't have access to the logger instance yet
     // The instance will create its own logger in the constructor

package/src/module/service.test.ts

@@ -10,11 +10,18 @@ import {
 } from 'bun:test';
 import { Effect } from 'effect';
 
+import { createMockConfig } from '../testing/test-utils';
+
+import {
+  NotInitializedConfig,
+  type IConfig,
+  type OneBunAppConfig,
+} from './config.interface';
 import { BaseService } from './service';
 
 describe('BaseService', () => {
   let mockLogger: any;
-  let mockConfig: any;
+  let mockConfig: IConfig<OneBunAppConfig>;
 
   beforeEach(() => {
     mockLogger = {
@@ -25,19 +32,12 @@ describe('BaseService', () => {
       error: mock(),
     };
     
-    mockConfig = {
-      get: mock((path: string) => {
-        if (path === 'database.host') {
-          return 'localhost';
-        }
-        if (path === 'app.name') {
-          return 'test-app';
-        }
-
-        return undefined;
-      }),
-      getSafeConfig: mock(() => ({ app: { name: 'test-app' } })),
-    };
+    mockConfig = createMockConfig({
+      /* eslint-disable @typescript-eslint/naming-convention */
+      'database.host': 'localhost',
+      'app.name': 'test-app',
+      /* eslint-enable @typescript-eslint/naming-convention */
+    });
   });
 
   describe('Initialization via initializeService', () => {
@@ -56,15 +56,16 @@ describe('BaseService', () => {
       expect((service as any).config).toBe(mockConfig);
     });
 
-    test('should initialize service with logger and undefined config', () => {
+    test('should initialize service with logger and NotInitializedConfig', () => {
       class TestService extends BaseService {}
 
       const service = new TestService();
-      service.initializeService(mockLogger, undefined);
+      const notInitConfig = new NotInitializedConfig();
+      service.initializeService(mockLogger, notInitConfig);
       
       expect(service.isInitialized).toBe(true);
       expect((service as any).logger).toBeDefined();
-      expect((service as any).config).toBeUndefined();
+      expect((service as any).config).toBeInstanceOf(NotInitializedConfig);
     });
 
     test('should throw error when logger is not provided to initializeService', () => {
@@ -90,7 +91,8 @@ describe('BaseService', () => {
       service.initializeService(mockLogger, mockConfig);
       
       const otherLogger = { ...mockLogger, child: mock(() => ({ ...mockLogger })) };
-      service.initializeService(otherLogger, { other: 'config' });
+      const otherConfig = createMockConfig({ 'other': 'config' });
+      service.initializeService(otherLogger, otherConfig);
       
       // Should still have original logger (no reinit)
       expect((service as any).config).toBe(mockConfig);
@@ -174,7 +176,7 @@ describe('BaseService', () => {
       }
 
       const service = new TestService();
-      service.initializeService(mockLogger, undefined);
+      service.initializeService(mockLogger, mockConfig);
       const result = await service.testComplexEffect();
       expect(result).toBe(84);
     });
@@ -190,7 +192,7 @@ describe('BaseService', () => {
       }
 
       const service = new TestService();
-      service.initializeService(mockLogger, undefined);
+      service.initializeService(mockLogger, mockConfig);
       service.testStackTrace();
     });
   });

package/src/module/service.ts

@@ -4,6 +4,8 @@ import {
   Layer,
 } from 'effect';
 
+import type { IConfig, OneBunAppConfig } from './config.interface';
+
 import type { SyncLogger } from '@onebun/logger';
 
 /**
@@ -66,7 +68,7 @@ export class BaseService {
   // Logger instance with service class name as context
   protected logger!: SyncLogger;
   // Configuration instance for accessing environment variables
-  protected config!: unknown;
+  protected config!: IConfig<OneBunAppConfig>;
   // Flag to track initialization status
   private _initialized = false;
 
@@ -74,7 +76,7 @@ export class BaseService {
    * Initialize service with logger and config (called by the framework)
    * @internal
    */
-  initializeService(logger: SyncLogger, config: unknown): void {
+  initializeService(logger: SyncLogger, config: IConfig<OneBunAppConfig>): void {
     if (this._initialized) {
       return; // Already initialized
     }
@@ -143,7 +145,7 @@ export class BaseService {
 export function createServiceLayer<T>(
   serviceClass: new (...args: unknown[]) => T,
   logger?: SyncLogger,
-  config?: unknown,
+  config?: IConfig<OneBunAppConfig>,
 ): Layer.Layer<never, never, unknown> {
   const metadata = getServiceMetadata(serviceClass);
   if (!metadata) {