@abdokouta/react-config 1.0.0 → 1.0.2

package/__tests__/services/config.service.test.ts

@@ -1,328 +0,0 @@
-/**
- * @fileoverview Tests for ConfigService
- * 
- * This test suite verifies the ConfigService functionality including:
- * - Getting configuration values
- * - Type-safe getters (getString, getNumber, getBoolean)
- * - Throwing methods (getOrThrow, getStringOrThrow)
- * - Default value handling
- * - Nested key access
- * 
- * @module @abdokouta/config
- * @category Tests
- */
-
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { ConfigService } from "@/services/config.service";
-import type { ConfigDriver } from "@/interfaces/config-driver.interface";
-
-describe("ConfigService", () => {
-  let mockDriver: ConfigDriver;
-  let configService: ConfigService;
-
-  beforeEach(() => {
-    // Arrange: Create mock driver
-    mockDriver = {
-      load: vi.fn().mockReturnValue({
-        app: {
-          name: "Test App",
-          port: 3000,
-          debug: true,
-        },
-        database: {
-          host: "localhost",
-          port: 5432,
-          name: "testdb",
-        },
-        api: {
-          key: "test-key-123",
-          timeout: 5000,
-        },
-      }),
-      get: vi.fn((key: string, defaultValue?: any) => {
-        const data: any = {
-          "app.name": "Test App",
-          "app.port": 3000,
-          "app.debug": true,
-          "database.host": "localhost",
-          "database.port": 5432,
-          "api.key": "test-key-123",
-        };
-        return data[key] ?? defaultValue;
-      }),
-      has: vi.fn((key: string) => {
-        const keys = ["app.name", "app.port", "app.debug", "database.host", "database.port", "api.key"];
-        return keys.includes(key);
-      }),
-      all: vi.fn().mockReturnValue({
-        app: { name: "Test App", port: 3000, debug: true },
-        database: { host: "localhost", port: 5432, name: "testdb" },
-      }),
-    };
-
-    configService = new ConfigService(mockDriver);
-  });
-
-  describe("get", () => {
-    it("should get existing configuration value", () => {
-      // Act: Get config value
-      const appName = configService.get("app.name");
-
-      // Assert: Value is returned
-      expect(appName).toBe("Test App");
-      expect(mockDriver.get).toHaveBeenCalledWith("app.name", undefined);
-    });
-
-    it("should return default value when key doesn't exist", () => {
-      // Arrange: Mock missing key
-      mockDriver.get = vi.fn((key, defaultValue) => defaultValue);
-
-      // Act: Get with default
-      const value = configService.get("missing.key", "default");
-
-      // Assert: Default is returned
-      expect(value).toBe("default");
-    });
-
-    it("should return undefined when key doesn't exist and no default", () => {
-      // Arrange: Mock missing key
-      mockDriver.get = vi.fn(() => undefined);
-
-      // Act: Get without default
-      const value = configService.get("missing.key");
-
-      // Assert: Undefined is returned
-      expect(value).toBeUndefined();
-    });
-
-    it("should handle nested keys", () => {
-      // Act: Get nested value
-      const dbHost = configService.get("database.host");
-
-      // Assert: Nested value is returned
-      expect(dbHost).toBe("localhost");
-    });
-
-    it("should handle numeric values", () => {
-      // Act: Get numeric value
-      const port = configService.get<number>("app.port");
-
-      // Assert: Number is returned
-      expect(port).toBe(3000);
-      expect(typeof port).toBe("number");
-    });
-
-    it("should handle boolean values", () => {
-      // Act: Get boolean value
-      const debug = configService.get<boolean>("app.debug");
-
-      // Assert: Boolean is returned
-      expect(debug).toBe(true);
-      expect(typeof debug).toBe("boolean");
-    });
-  });
-
-  describe("getOrThrow", () => {
-    it("should return value when key exists", () => {
-      // Act: Get existing key
-      const appName = configService.getOrThrow("app.name");
-
-      // Assert: Value is returned
-      expect(appName).toBe("Test App");
-    });
-
-    it("should throw error when key doesn't exist", () => {
-      // Arrange: Mock missing key
-      mockDriver.get = vi.fn(() => undefined);
-
-      // Act & Assert: Should throw
-      expect(() => {
-        configService.getOrThrow("missing.key");
-      }).toThrow();
-    });
-
-    it("should throw with descriptive error message", () => {
-      // Arrange: Mock missing key
-      mockDriver.get = vi.fn(() => undefined);
-
-      // Act & Assert: Should throw with message
-      expect(() => {
-        configService.getOrThrow("missing.key");
-      }).toThrow(/missing\.key/);
-    });
-  });
-
-  describe("getString", () => {
-    it("should return string value", () => {
-      // Act: Get string
-      const appName = configService.getString("app.name");
-
-      // Assert: String is returned
-      expect(appName).toBe("Test App");
-      expect(typeof appName).toBe("string");
-    });
-
-    it("should return default string when key doesn't exist", () => {
-      // Arrange: Mock missing key
-      mockDriver.get = vi.fn((key, defaultValue) => defaultValue);
-
-      // Act: Get with default
-      const value = configService.getString("missing.key", "default");
-
-      // Assert: Default is returned
-      expect(value).toBe("default");
-    });
-
-    it("should return undefined when no default provided", () => {
-      // Arrange: Mock missing key
-      mockDriver.get = vi.fn(() => undefined);
-
-      // Act: Get without default
-      const value = configService.getString("missing.key");
-
-      // Assert: Undefined is returned
-      expect(value).toBeUndefined();
-    });
-  });
-
-  describe("getStringOrThrow", () => {
-    it("should return string value when key exists", () => {
-      // Act: Get existing string
-      const apiKey = configService.getStringOrThrow("api.key");
-
-      // Assert: String is returned
-      expect(apiKey).toBe("test-key-123");
-      expect(typeof apiKey).toBe("string");
-    });
-
-    it("should throw when key doesn't exist", () => {
-      // Arrange: Mock missing key
-      mockDriver.get = vi.fn(() => undefined);
-
-      // Act & Assert: Should throw
-      expect(() => {
-        configService.getStringOrThrow("missing.key");
-      }).toThrow();
-    });
-  });
-
-  describe("getNumber", () => {
-    it("should return number value", () => {
-      // Act: Get number
-      const port = configService.getNumber("app.port");
-
-      // Assert: Number is returned
-      expect(port).toBe(3000);
-      expect(typeof port).toBe("number");
-    });
-
-    it("should return default number when key doesn't exist", () => {
-      // Arrange: Mock missing key
-      mockDriver.get = vi.fn((key, defaultValue) => defaultValue);
-
-      // Act: Get with default
-      const value = configService.getNumber("missing.key", 8080);
-
-      // Assert: Default is returned
-      expect(value).toBe(8080);
-    });
-
-    it("should parse string numbers", () => {
-      // Arrange: Mock string number
-      mockDriver.get = vi.fn(() => "5432");
-
-      // Act: Get as number
-      const port = configService.getNumber("database.port");
-
-      // Assert: Parsed number is returned
-      expect(port).toBe(5432);
-      expect(typeof port).toBe("number");
-    });
-  });
-
-  describe("getBoolean", () => {
-    it("should return boolean value", () => {
-      // Act: Get boolean
-      const debug = configService.getBoolean("app.debug");
-
-      // Assert: Boolean is returned
-      expect(debug).toBe(true);
-      expect(typeof debug).toBe("boolean");
-    });
-
-    it("should parse string booleans", () => {
-      // Arrange: Mock string boolean
-      mockDriver.get = vi.fn((key) => {
-        if (key === "feature.enabled") return "true";
-        if (key === "feature.disabled") return "false";
-        return undefined;
-      });
-
-      // Act: Get as boolean
-      const enabled = configService.getBoolean("feature.enabled");
-      const disabled = configService.getBoolean("feature.disabled");
-
-      // Assert: Parsed booleans are returned
-      expect(enabled).toBe(true);
-      expect(disabled).toBe(false);
-    });
-
-    it("should handle truthy/falsy values", () => {
-      // Arrange: Mock various values
-      mockDriver.get = vi.fn((key) => {
-        if (key === "one") return 1;
-        if (key === "zero") return 0;
-        if (key === "yes") return "yes";
-        if (key === "no") return "no";
-        return undefined;
-      });
-
-      // Act: Get as booleans
-      const one = configService.getBoolean("one");
-      const zero = configService.getBoolean("zero");
-      const yes = configService.getBoolean("yes");
-      const no = configService.getBoolean("no");
-
-      // Assert: Values are converted to boolean
-      expect(one).toBe(true);
-      expect(zero).toBe(false);
-      expect(yes).toBe(true);
-      expect(no).toBe(false);
-    });
-  });
-
-  describe("Edge Cases", () => {
-    it("should handle null values", () => {
-      // Arrange: Mock null value
-      mockDriver.get = vi.fn(() => null);
-
-      // Act: Get null value
-      const value = configService.get("null.key");
-
-      // Assert: Null is returned
-      expect(value).toBeNull();
-    });
-
-    it("should handle empty string values", () => {
-      // Arrange: Mock empty string
-      mockDriver.get = vi.fn(() => "");
-
-      // Act: Get empty string
-      const value = configService.getString("empty.key");
-
-      // Assert: Empty string is returned
-      expect(value).toBe("");
-    });
-
-    it("should handle zero values", () => {
-      // Arrange: Mock zero
-      mockDriver.get = vi.fn(() => 0);
-
-      // Act: Get zero
-      const value = configService.getNumber("zero.key");
-
-      // Assert: Zero is returned
-      expect(value).toBe(0);
-    });
-  });
-});

package/__tests__/setup.d.ts

@@ -1,11 +0,0 @@
-/**
- * @fileoverview Type declarations for Vitest test environment
- * 
- * This file extends Vitest's type definitions to include custom matchers
- * and global test utilities.
- * 
- * @module @abdokouta/config
- * @category Configuration
- */
-
-import "vitest/globals";

package/__tests__/vitest.setup.ts

@@ -1,30 +0,0 @@
-/**
- * @fileoverview Vitest setup file for @abdokouta/config package
- * 
- * This file configures the testing environment before running tests.
- * It sets up container mocking for dependency injection tests.
- * 
- * Setup Features:
- * - Container mocking for DI tests
- * 
- * @module @abdokouta/config
- * @category Configuration
- */
-
-import { vi } from "vitest";
-
-/**
- * Mock @abdokouta/react-di decorators
- * 
- * This ensures that decorator metadata doesn't interfere with tests
- * and allows us to test module behavior in isolation.
- */
-vi.mock("@abdokouta/react-di", async () => {
-  const actual = await vi.importActual("@abdokouta/react-di");
-  return {
-    ...actual,
-    Injectable: () => (target: any) => target,
-    Inject: () => (target: any, propertyKey: string, parameterIndex: number) => {},
-    Module: (metadata: any) => (target: any) => target,
-  };
-});

package/eslint.config.js

@@ -1,13 +0,0 @@
-import nesvelConfig from '@nesvel/eslint-config';
-
-export default [
-  ...nesvelConfig,
-  {
-    ignores: ['dist/**', 'node_modules/**', '*.config.js', '*.config.ts'],
-  },
-  {
-    rules: {
-      // Add any package-specific rule overrides here
-    },
-  },
-];

package/src/config.module.ts

@@ -1,154 +0,0 @@
-import { Module, DynamicModule } from '@abdokouta/react-di';
-
-import { EnvDriver } from './drivers/env.driver';
-import { FileDriver } from './drivers/file.driver';
-import { ConfigService } from './services/config.service';
-import type { ConfigDriver } from './interfaces/config-driver.interface';
-import type { ConfigModuleOptions } from './interfaces/config-module-options.interface';
-import { CONFIG_DRIVER, CONFIG_OPTIONS, CONFIG_SERVICE } from './constants/tokens.constant';
-
-/**
- * Configuration Module
- * 
- * Provides configuration management with multiple drivers.
- * Similar to NestJS ConfigModule.
- * 
- * @example
- * ```typescript
- * // Using environment variables (default)
- * @Module({
- *   imports: [
- *     ConfigModule.forRoot({
- *       envFilePath: '.env',
- *       isGlobal: true,
- *     }),
- *   ],
- * })
- * export class AppModule {}
- * ```
- * 
- * @example
- * ```typescript
- * // Using file-based configuration
- * @Module({
- *   imports: [
- *     ConfigModule.forRoot({
- *       driver: 'file',
- *       filePattern: 'config/**\/*.config.ts',
- *       isGlobal: true,
- *     }),
- *   ],
- * })
- * export class AppModule {}
- * ```
- */
-@Module({})
-export class ConfigModule {
-  /**
-   * Register configuration module with options
-   * 
-   * @param options - Configuration options
-   * @returns Dynamic module
-   */
-  static forRoot(options: ConfigModuleOptions = {}): DynamicModule {
-    const driver = this.createDriver(options);
-    
-    const isGlobal = options.isGlobal ?? false;
-    
-    const providers = [
-      {
-        provide: CONFIG_OPTIONS,
-        useValue: options,
-        isGlobal,
-      },
-      {
-        provide: CONFIG_DRIVER,
-        useValue: driver,
-        isGlobal,
-      },
-      ConfigService,
-      {
-        provide: CONFIG_SERVICE,
-        useExisting: ConfigService,
-        isGlobal,
-      },
-    ];
-
-    return {
-      module: ConfigModule,
-      providers: providers as any,
-      exports: [ConfigService],
-    };
-  }
-
-  /**
-   * Register configuration module asynchronously
-   * 
-   * @param options - Async configuration options
-   * @returns Dynamic module
-   */
-  static async forRootAsync(
-    options: ConfigModuleOptions & {
-      useFactory?: () => Promise<ConfigModuleOptions> | ConfigModuleOptions;
-    }
-  ): Promise<DynamicModule> {
-    const resolvedOptions = options.useFactory
-      ? await options.useFactory()
-      : options;
-
-    return this.forRoot(resolvedOptions);
-  }
-
-  /**
-   * Create configuration driver based on options
-   */
-  private static createDriver(options: ConfigModuleOptions): ConfigDriver {
-    const driverType = options.driver || 'env';
-
-    switch (driverType) {
-      case 'env':
-        const envDriver = new EnvDriver({
-          envFilePath: options.envFilePath,
-          ignoreEnvFile: options.ignoreEnvFile,
-          expandVariables: options.expandVariables,
-          envPrefix: options.envPrefix,
-          globalName: options.globalName,
-        });
-        envDriver.load();
-        
-        // Merge custom load function if provided
-        if (options.load) {
-          this.mergeCustomConfig(envDriver, options.load);
-        }
-        
-        return envDriver;
-
-      case 'file':
-        const fileDriver = new FileDriver({
-          config: typeof options.load === 'object' ? options.load : undefined,
-        });
-        return fileDriver;
-
-      default:
-        throw new Error(`Unknown configuration driver: ${driverType}`);
-    }
-  }
-
-  /**
-   * Merge custom configuration into driver
-   */
-  private static mergeCustomConfig(
-    driver: ConfigDriver,
-    load: Record<string, any> | (() => Record<string, any> | Promise<Record<string, any>>)
-  ): void {
-    const customConfig = typeof load === 'function' ? load() : load;
-    
-    if (customConfig instanceof Promise) {
-      customConfig.then(config => {
-        Object.assign(driver.all(), config);
-      });
-    } else {
-      Object.assign(driver.all(), customConfig);
-    }
-  }
-}

package/src/constants/index.ts

@@ -1,5 +0,0 @@
-/**
- * Constants
- */
-
-export { CONFIG_TOKENS } from './tokens.constant';

package/src/constants/tokens.constant.ts

@@ -1,38 +0,0 @@
-/**
- * Dependency Injection Tokens
- * 
- * Used for injecting configuration dependencies.
- */
-
-/**
- * Configuration driver token
- * 
- * @example
- * ```typescript
- * @Inject(CONFIG_DRIVER)
- * private driver: ConfigDriver
- * ```
- */
-export const CONFIG_DRIVER = Symbol('CONFIG_DRIVER');
-
-/**
- * Configuration options token
- * 
- * @example
- * ```typescript
- * @Inject(CONFIG_OPTIONS)
- * private options: ConfigModuleOptions
- * ```
- */
-export const CONFIG_OPTIONS = Symbol('CONFIG_OPTIONS');
-
-/**
- * Configuration service token
- * 
- * @example
- * ```typescript
- * @Inject(CONFIG_SERVICE)
- * private config: ConfigService
- * ```
- */
-export const CONFIG_SERVICE = Symbol('CONFIG_SERVICE');