@onebun/core 0.1.11 → 0.1.12

package/package.json

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

package/src/application/application.test.ts

@@ -164,6 +164,98 @@ describe('OneBunApplication', () => {
       // 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()', () => {
+      @Module({})
+      class TestModule {}
+
+      // Mock config that simulates typed IConfig<OneBunAppConfig>
+      const mockConfigValues = {
+        server: { port: 9991, host: 'localhost' },
+      };
+      const mockConfig = {
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        initialize: mock(async () => {}),
+        get: mock((path: string) => {
+          const parts = path.split('.');
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          let value: any = mockConfigValues;
+          for (const part of parts) {
+            value = value?.[part];
+          }
+
+          return value;
+        }),
+        values: mockConfigValues,
+        getSafeConfig: mock(() => mockConfigValues),
+        isInitialized: true,
+      };
+
+      const app = createTestApp(TestModule);
+      // Inject mock config
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (app as any).config = mockConfig;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (app as any).configService = {
+        get: mockConfig.get, values: mockConfig.values, getSafeConfig: mockConfig.getSafeConfig, isInitialized: true, 
+      };
+
+      // getConfig() returns IConfig<OneBunAppConfig> which provides typed .get() method
+      const config = app.getConfig();
+      expect(config).toBeDefined();
+      
+      // Access values through the typed interface
+      // TypeScript will infer the correct types based on module augmentation
+      const port = config.get('server.port');
+      const host = config.get('server.host');
+      
+      expect(port).toBe(9991);
+      expect(host).toBe('localhost');
+    });
+
+    test('should provide typed access via getConfigValue() convenience method', () => {
+      @Module({})
+      class TestModule {}
+
+      // Mock config that simulates typed IConfig<OneBunAppConfig>
+      const mockConfigValues = {
+        app: { name: 'test-app', debug: true },
+      };
+      const mockConfig = {
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        initialize: mock(async () => {}),
+        get: mock((path: string) => {
+          const parts = path.split('.');
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          let value: any = mockConfigValues;
+          for (const part of parts) {
+            value = value?.[part];
+          }
+
+          return value;
+        }),
+        values: mockConfigValues,
+        getSafeConfig: mock(() => mockConfigValues),
+        isInitialized: true,
+      };
+
+      const app = createTestApp(TestModule);
+      // Inject mock config
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (app as any).config = mockConfig;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (app as any).configService = {
+        get: mockConfig.get, values: mockConfig.values, getSafeConfig: mockConfig.getSafeConfig, isInitialized: true, 
+      };
+
+      // getConfigValue() is a convenience method that delegates to getConfig().get()
+      // It also provides typed access based on OneBunAppConfig module augmentation
+      const appName = app.getConfigValue('app.name');
+      const debug = app.getConfigValue('app.debug');
+      
+      expect(appName).toBe('test-app');
+      expect(debug).toBe(true);
+    });
   });
 
   describe('Layer methods', () => {

package/src/application/application.ts

@@ -3,7 +3,11 @@ import { Effect, type Layer } from 'effect';
 import type { Controller } from '../module/controller';
 import type { WsClientData } from '../websocket/ws.types';
 
-import { TypedEnv } from '@onebun/envs';
+import {
+  type DeepPaths,
+  type DeepValue,
+  TypedEnv,
+} from '@onebun/envs';
 import {
   createSyncLogger,
   type Logger,
@@ -230,9 +234,21 @@ export class OneBunApplication {
   }
 
   /**
-   * Get configuration service
+   * Get configuration service 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 config = app.getConfig();
+   * const port = config.get('server.port'); // number
    */
-  getConfig(): ConfigServiceImpl {
+  getConfig(): IConfig<OneBunAppConfig> {
     if (!this.configService) {
       throw new Error('Configuration not initialized. Provide envSchema in ApplicationOptions.');
     }
@@ -241,10 +257,25 @@ export class OneBunApplication {
   }
 
   /**
-   * Get configuration value by path (convenience method)
+   * Get configuration value by path (convenience method) 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 = app.getConfigValue('server.port'); // number
+   * const host = app.getConfigValue('server.host'); // string
    */
-  getConfigValue<T = unknown>(path: string): T {
-    return this.getConfig().get<T>(path);
+  getConfigValue<P extends DeepPaths<OneBunAppConfig>>(path: P): DeepValue<OneBunAppConfig, P>;
+  /** Fallback for dynamic paths */
+  getConfigValue<T = unknown>(path: string): T;
+  getConfigValue(path: string): unknown {
+    return this.getConfig().get(path);
   }
 
   /**

package/src/module/config.service.test.ts

@@ -141,7 +141,8 @@ describe('ConfigService', () => {
         
         const result = service.values;
         
-        expect(result).toEqual({ test: 'value' });
+        // Use unknown cast because tests use mock data that doesn't match OneBunAppConfig augmentation
+        expect(result as unknown).toEqual({ test: 'value' });
       });
 
       test('should throw error when config not initialized', () => {
@@ -159,7 +160,8 @@ describe('ConfigService', () => {
         
         const result = service.getSafeConfig();
         
-        expect(result).toEqual({ test: '***' });
+        // Use unknown cast because tests use mock data that doesn't match OneBunAppConfig augmentation
+        expect(result as unknown).toEqual({ test: '***' });
         expect(mockConfig.getSafeConfig).toHaveBeenCalled();
       });
 
@@ -344,13 +346,15 @@ describe('ConfigService', () => {
 
       expect((service as any).get('database.host')).toBe('localhost');
       expect((service as any).get('database.port')).toBe(5432);
-      expect(service.values).toEqual({
+      // Use unknown cast because tests use mock data that doesn't match OneBunAppConfig augmentation
+      expect(service.values as unknown).toEqual({
         database: { host: 'localhost', port: 5432 },
         api: { key: 'secret', timeout: 30000 },
       });
       
       const safeConfig = service.getSafeConfig();
-      expect(safeConfig).toEqual({
+      // Use unknown cast because tests use mock data that doesn't match OneBunAppConfig augmentation
+      expect(safeConfig as unknown).toEqual({
         database: { host: 'localhost', port: 5432 },
         api: { key: '***', timeout: 30000 },
       });

package/src/module/config.service.ts

@@ -2,6 +2,7 @@ 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';
@@ -40,20 +41,35 @@ 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.');
     }
 
-    return this.configInstance.get(path) as T;
+    return this.configInstance.get(path);
   }
 
   /**
    * Get all configuration values
    */
-  get values(): unknown {
+  get values(): OneBunAppConfig {
     if (!this.configInstance) {
       throw new Error('Configuration not initialized. Provide envSchema in ApplicationOptions.');
     }
@@ -64,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.');
     }