@hazeljs/config 0.2.0-beta.1

package/README.md

@@ -0,0 +1,508 @@
+# @hazeljs/config
+
+**Configuration Module for HazelJS - Environment Variables and Type-Safe Configuration**
+
+Manage application configuration with environment variables, validation, and type safety.
+
+[![npm version](https://img.shields.io/npm/v/@hazeljs/config.svg)](https://www.npmjs.com/package/@hazeljs/config)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- 🔐 **Environment Variables** - Load from .env files
+- ✅ **Validation** - Validate configuration on startup
+- 🎯 **Type Safety** - Full TypeScript support
+- 🏗️ **Schema-Based** - Define configuration schema
+- 🔄 **Hot Reload** - Reload configuration without restart (optional)
+- 📁 **Multiple Environments** - Support for .env.development, .env.production, etc.
+- 🎨 **Decorator Support** - Inject configuration with decorators
+- 🔒 **Secret Management** - Secure handling of sensitive data
+
+## Installation
+
+```bash
+npm install @hazeljs/config
+```
+
+## Quick Start
+
+### 1. Create Configuration Schema
+
+```typescript
+import { IsString, IsNumber, IsEnum } from 'class-validator';
+
+export enum Environment {
+  Development = 'development',
+  Production = 'production',
+  Test = 'test',
+}
+
+export class AppConfig {
+  @IsEnum(Environment)
+  NODE_ENV: Environment;
+
+  @IsNumber()
+  PORT: number;
+
+  @IsString()
+  DATABASE_URL: string;
+
+  @IsString()
+  JWT_SECRET: string;
+
+  @IsString()
+  REDIS_URL: string;
+}
+```
+
+### 2. Configure Module
+
+```typescript
+import { HazelModule } from '@hazeljs/core';
+import { ConfigModule } from '@hazeljs/config';
+import { AppConfig } from './app.config';
+
+@HazelModule({
+  imports: [
+    ConfigModule.forRoot({
+      schema: AppConfig,
+      envFilePath: '.env',
+      validate: true,
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### 3. Use Configuration
+
+```typescript
+import { Injectable } from '@hazeljs/core';
+import { ConfigService } from '@hazeljs/config';
+
+@Injectable()
+export class DatabaseService {
+  constructor(private configService: ConfigService<AppConfig>) {}
+
+  connect() {
+    const dbUrl = this.configService.get('DATABASE_URL');
+    const port = this.configService.get('PORT');
+    
+    console.log(`Connecting to database: ${dbUrl}`);
+    console.log(`Server will run on port: ${port}`);
+  }
+}
+```
+
+## Environment Files
+
+### Multiple Environment Files
+
+```typescript
+ConfigModule.forRoot({
+  schema: AppConfig,
+  envFilePath: [
+    '.env',
+    `.env.${process.env.NODE_ENV}`,
+    '.env.local',
+  ],
+  validate: true,
+})
+```
+
+### File Priority
+
+Files are loaded in order, with later files overriding earlier ones:
+1. `.env` - Base configuration
+2. `.env.${NODE_ENV}` - Environment-specific
+3. `.env.local` - Local overrides (gitignored)
+
+### Example .env File
+
+```env
+NODE_ENV=development
+PORT=3000
+DATABASE_URL=postgresql://user:password@localhost:5432/mydb
+JWT_SECRET=your-super-secret-key
+REDIS_URL=redis://localhost:6379
+
+# API Keys
+OPENAI_API_KEY=sk-...
+STRIPE_API_KEY=sk_test_...
+
+# Feature Flags
+ENABLE_ANALYTICS=true
+ENABLE_CACHING=true
+```
+
+## Configuration Validation
+
+### Basic Validation
+
+```typescript
+import { IsString, IsNumber, IsUrl, IsBoolean } from 'class-validator';
+
+export class AppConfig {
+  @IsString()
+  NODE_ENV: string;
+
+  @IsNumber()
+  PORT: number;
+
+  @IsUrl()
+  DATABASE_URL: string;
+
+  @IsString()
+  JWT_SECRET: string;
+
+  @IsBoolean()
+  ENABLE_CACHING: boolean;
+}
+```
+
+### Custom Validation
+
+```typescript
+import { IsString, ValidateIf, MinLength } from 'class-validator';
+
+export class AppConfig {
+  @IsString()
+  @MinLength(32, { message: 'JWT_SECRET must be at least 32 characters' })
+  JWT_SECRET: string;
+
+  @ValidateIf(o => o.NODE_ENV === 'production')
+  @IsString()
+  SSL_CERT_PATH: string;
+}
+```
+
+### Transform Values
+
+```typescript
+import { Transform } from 'class-transformer';
+
+export class AppConfig {
+  @Transform(({ value }) => parseInt(value, 10))
+  @IsNumber()
+  PORT: number;
+
+  @Transform(({ value }) => value === 'true')
+  @IsBoolean()
+  ENABLE_CACHING: boolean;
+
+  @Transform(({ value }) => value.split(','))
+  ALLOWED_ORIGINS: string[];
+}
+```
+
+## Nested Configuration
+
+```typescript
+export class DatabaseConfig {
+  @IsString()
+  host: string;
+
+  @IsNumber()
+  port: number;
+
+  @IsString()
+  username: string;
+
+  @IsString()
+  password: string;
+
+  @IsString()
+  database: string;
+}
+
+export class AppConfig {
+  @IsString()
+  NODE_ENV: string;
+
+  @ValidateNested()
+  @Type(() => DatabaseConfig)
+  database: DatabaseConfig;
+}
+```
+
+## Dependency Injection
+
+### Inject ConfigService
+
+```typescript
+import { Injectable } from '@hazeljs/core';
+import { ConfigService } from '@hazeljs/config';
+
+@Injectable()
+export class MyService {
+  constructor(private config: ConfigService<AppConfig>) {}
+
+  doSomething() {
+    const apiKey = this.config.get('OPENAI_API_KEY');
+    const port = this.config.get('PORT');
+  }
+}
+```
+
+### Inject Specific Config Values
+
+```typescript
+import { InjectConfig } from '@hazeljs/config';
+
+@Injectable()
+export class MyService {
+  constructor(
+    @InjectConfig('DATABASE_URL') private dbUrl: string,
+    @InjectConfig('PORT') private port: number
+  ) {}
+
+  connect() {
+    console.log(`Connecting to ${this.dbUrl} on port ${this.port}`);
+  }
+}
+```
+
+## Configuration Namespaces
+
+Organize configuration into logical groups:
+
+```typescript
+export class DatabaseConfig {
+  @IsString()
+  url: string;
+
+  @IsNumber()
+  poolSize: number;
+}
+
+export class RedisConfig {
+  @IsString()
+  url: string;
+
+  @IsNumber()
+  ttl: number;
+}
+
+export class AppConfig {
+  @ValidateNested()
+  @Type(() => DatabaseConfig)
+  database: DatabaseConfig;
+
+  @ValidateNested()
+  @Type(() => RedisConfig)
+  redis: RedisConfig;
+}
+
+// Usage
+const dbConfig = this.config.get('database');
+console.log(dbConfig.url);
+console.log(dbConfig.poolSize);
+```
+
+## Default Values
+
+```typescript
+export class AppConfig {
+  @IsNumber()
+  @Default(3000)
+  PORT: number;
+
+  @IsBoolean()
+  @Default(false)
+  ENABLE_DEBUG: boolean;
+
+  @IsString()
+  @Default('info')
+  LOG_LEVEL: string;
+}
+```
+
+## Dynamic Configuration
+
+Load configuration from external sources:
+
+```typescript
+ConfigModule.forRoot({
+  schema: AppConfig,
+  load: [
+    async () => {
+      // Load from database
+      const settings = await database.settings.findMany();
+      return settings.reduce((acc, s) => ({
+        ...acc,
+        [s.key]: s.value,
+      }), {});
+    },
+    async () => {
+      // Load from API
+      const response = await fetch('https://api.example.com/config');
+      return await response.json();
+    },
+  ],
+})
+```
+
+## Configuration Service API
+
+```typescript
+class ConfigService<T = any> {
+  // Get configuration value
+  get<K extends keyof T>(key: K): T[K];
+  get<K extends keyof T>(key: K, defaultValue: T[K]): T[K];
+
+  // Get all configuration
+  getAll(): T;
+
+  // Check if key exists
+  has(key: keyof T): boolean;
+
+  // Get with type casting
+  getOrThrow<K extends keyof T>(key: K): T[K];
+}
+```
+
+## Best Practices
+
+### 1. Never Commit Secrets
+
+```gitignore
+# .gitignore
+.env
+.env.local
+.env.*.local
+```
+
+### 2. Use Environment-Specific Files
+
+```
+.env                 # Base configuration
+.env.development     # Development overrides
+.env.production      # Production overrides
+.env.test            # Test overrides
+.env.local           # Local overrides (gitignored)
+```
+
+### 3. Validate on Startup
+
+```typescript
+ConfigModule.forRoot({
+  schema: AppConfig,
+  validate: true,
+  validationOptions: {
+    allowUnknown: false,
+    abortEarly: false,
+  },
+})
+```
+
+### 4. Use Type-Safe Access
+
+```typescript
+// Good - Type-safe
+const port = this.config.get('PORT'); // number
+
+// Bad - Not type-safe
+const port = process.env.PORT; // string | undefined
+```
+
+### 5. Document Required Variables
+
+```typescript
+/**
+ * Application Configuration
+ * 
+ * Required Environment Variables:
+ * - NODE_ENV: Application environment (development|production|test)
+ * - PORT: Server port number
+ * - DATABASE_URL: PostgreSQL connection string
+ * - JWT_SECRET: Secret key for JWT tokens (min 32 characters)
+ * - REDIS_URL: Redis connection string
+ */
+export class AppConfig {
+  // ...
+}
+```
+
+## Examples
+
+### Complete Example
+
+```typescript
+// config/app.config.ts
+import { IsString, IsNumber, IsEnum, IsUrl } from 'class-validator';
+import { Transform } from 'class-transformer';
+
+export enum Environment {
+  Development = 'development',
+  Production = 'production',
+  Test = 'test',
+}
+
+export class AppConfig {
+  @IsEnum(Environment)
+  NODE_ENV: Environment;
+
+  @Transform(({ value }) => parseInt(value, 10))
+  @IsNumber()
+  PORT: number;
+
+  @IsUrl()
+  DATABASE_URL: string;
+
+  @IsString()
+  JWT_SECRET: string;
+
+  @IsUrl()
+  REDIS_URL: string;
+
+  @IsString()
+  OPENAI_API_KEY: string;
+
+  @Transform(({ value }) => value === 'true')
+  ENABLE_CACHING: boolean;
+}
+
+// app.module.ts
+@HazelModule({
+  imports: [
+    ConfigModule.forRoot({
+      schema: AppConfig,
+      envFilePath: ['.env', `.env.${process.env.NODE_ENV}`],
+      validate: true,
+    }),
+  ],
+})
+export class AppModule {}
+
+// database.service.ts
+@Injectable()
+export class DatabaseService {
+  constructor(private config: ConfigService<AppConfig>) {}
+
+  async connect() {
+    const url = this.config.get('DATABASE_URL');
+    // Connect to database
+  }
+}
+```
+
+## Testing
+
+```bash
+npm test
+```
+
+## Contributing
+
+Contributions are welcome! Please read our [Contributing Guide](../../CONTRIBUTING.md) for details.
+
+## License
+
+MIT © [HazelJS](https://hazeljs.com)
+
+## Links
+
+- [Documentation](https://hazeljs.com/docs/packages/config)
+- [GitHub](https://github.com/hazel-js/hazeljs)
+- [Issues](https://github.com/hazeljs/hazel-js/issues)
+- [Discord](https://discord.gg/hazeljs)

package/dist/config.module.d.ts

@@ -0,0 +1,46 @@
+export declare class ConfigModule {
+    /**
+     * Register ConfigModule with options
+     */
+    static forRoot(options?: ConfigModuleOptions): typeof ConfigModule;
+}
+export interface ConfigModuleOptions {
+    /**
+     * Path to .env file
+     */
+    envFilePath?: string | string[];
+    /**
+     * Whether to ignore .env file
+     */
+    ignoreEnvFile?: boolean;
+    /**
+     * Whether to ignore environment variables
+     */
+    ignoreEnvVars?: boolean;
+    /**
+     * Validation schema for configuration
+     */
+    validationSchema?: ValidationSchema;
+    /**
+     * Validation options
+     */
+    validationOptions?: {
+        allowUnknown?: boolean;
+        abortEarly?: boolean;
+    };
+    /**
+     * Whether configuration is global
+     */
+    isGlobal?: boolean;
+    /**
+     * Custom configuration loader
+     */
+    load?: Array<() => Record<string, unknown>>;
+}
+export interface ValidationSchema {
+    validate(config: Record<string, unknown>): {
+        error?: Error;
+        value: Record<string, unknown>;
+    };
+}
+//# sourceMappingURL=config.module.d.ts.map

package/dist/config.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.module.d.ts","sourceRoot":"","sources":["../src/config.module.ts"],"names":[],"mappings":"AAGA,qBAIa,YAAY;IACvB;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,YAAY;CAMnE;AAED,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAEhC;;OAEG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;OAEG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;OAEG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IAEpC;;OAEG;IACH,iBAAiB,CAAC,EAAE;QAClB,YAAY,CAAC,EAAE,OAAO,CAAC;QACvB,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB,CAAC;IAEF;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,IAAI,CAAC,EAAE,KAAK,CAAC,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC7C;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;QACzC,KAAK,CAAC,EAAE,KAAK,CAAC;QACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAChC,CAAC;CACH"}

package/dist/config.module.js

@@ -0,0 +1,30 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var ConfigModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigModule = void 0;
+const core_1 = require("@hazeljs/core");
+const config_service_1 = require("./config.service");
+let ConfigModule = ConfigModule_1 = class ConfigModule {
+    /**
+     * Register ConfigModule with options
+     */
+    static forRoot(options) {
+        if (options) {
+            config_service_1.ConfigService.setOptions(options);
+        }
+        return ConfigModule_1;
+    }
+};
+exports.ConfigModule = ConfigModule;
+exports.ConfigModule = ConfigModule = ConfigModule_1 = __decorate([
+    (0, core_1.HazelModule)({
+        providers: [config_service_1.ConfigService],
+        exports: [config_service_1.ConfigService],
+    })
+], ConfigModule);

package/dist/config.service.d.ts

@@ -0,0 +1,49 @@
+import { ConfigModuleOptions } from './config.module';
+export declare class ConfigService {
+    private static options;
+    private config;
+    private isLoaded;
+    constructor();
+    /**
+     * Set module options (called by ConfigModule.forRoot)
+     */
+    static setOptions(options: ConfigModuleOptions): void;
+    /**
+     * Load configuration
+     */
+    private load;
+    /**
+     * Load environment files
+     */
+    private loadEnvFiles;
+    /**
+     * Validate configuration against schema
+     */
+    private validate;
+    /**
+     * Get a configuration value
+     */
+    get<T = unknown>(key: string): T | undefined;
+    get<T = unknown>(key: string, defaultValue: T): T;
+    /**
+     * Get nested value using dot notation
+     */
+    private getNestedValue;
+    /**
+     * Get all configuration
+     */
+    getAll(): Record<string, unknown>;
+    /**
+     * Set a configuration value
+     */
+    set(key: string, value: unknown): void;
+    /**
+     * Check if a key exists
+     */
+    has(key: string): boolean;
+    /**
+     * Get configuration as a specific type
+     */
+    getOrThrow<T = unknown>(key: string): T;
+}
+//# sourceMappingURL=config.service.d.ts.map

package/dist/config.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.service.d.ts","sourceRoot":"","sources":["../src/config.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAoB,MAAM,iBAAiB,CAAC;AAMxE,qBACa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAC,OAAO,CAA2B;IACjD,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,QAAQ,CAAS;;IAMzB;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI;IAIrD;;OAEG;IACH,OAAO,CAAC,IAAI;IAgCZ;;OAEG;IACH,OAAO,CAAC,YAAY;IAuBpB;;OAEG;IACH,OAAO,CAAC,QAAQ;IAkBhB;;OAEG;IACH,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAC5C,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC,GAAG,CAAC;IAMjD;;OAEG;IACH,OAAO,CAAC,cAAc;IAetB;;OAEG;IACH,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAIjC;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAItC;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB;;OAEG;IACH,UAAU,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC;CASxC"}

package/dist/config.service.js

@@ -0,0 +1,186 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var ConfigService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigService = void 0;
+const core_1 = require("@hazeljs/core");
+const dotenv = __importStar(require("dotenv"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const core_2 = __importDefault(require("@hazeljs/core"));
+let ConfigService = ConfigService_1 = class ConfigService {
+    constructor() {
+        this.config = {};
+        this.isLoaded = false;
+        this.load();
+    }
+    /**
+     * Set module options (called by ConfigModule.forRoot)
+     */
+    static setOptions(options) {
+        ConfigService_1.options = options;
+    }
+    /**
+     * Load configuration
+     */
+    load() {
+        if (this.isLoaded)
+            return;
+        const options = ConfigService_1.options;
+        // Load from .env files
+        if (!options.ignoreEnvFile) {
+            this.loadEnvFiles(options.envFilePath);
+        }
+        // Load from environment variables
+        if (!options.ignoreEnvVars) {
+            this.config = { ...this.config, ...process.env };
+        }
+        // Load custom configurations
+        if (options.load) {
+            options.load.forEach((loader) => {
+                const customConfig = loader();
+                this.config = { ...this.config, ...customConfig };
+            });
+        }
+        // Validate configuration
+        if (options.validationSchema) {
+            this.validate(options.validationSchema, options.validationOptions);
+        }
+        this.isLoaded = true;
+        core_2.default.info('Configuration loaded successfully');
+    }
+    /**
+     * Load environment files
+     */
+    loadEnvFiles(envFilePath) {
+        const paths = Array.isArray(envFilePath) ? envFilePath : envFilePath ? [envFilePath] : ['.env'];
+        for (const filePath of paths) {
+            const fullPath = path.resolve(process.cwd(), filePath);
+            if (fs.existsSync(fullPath)) {
+                core_2.default.debug(`Loading environment file: ${fullPath}`);
+                const result = dotenv.config({ path: fullPath });
+                if (result.parsed) {
+                    this.config = { ...this.config, ...result.parsed };
+                }
+                if (result.error) {
+                    core_2.default.warn(`Error loading ${fullPath}:`, result.error);
+                }
+            }
+            else {
+                core_2.default.debug(`Environment file not found: ${fullPath}`);
+            }
+        }
+    }
+    /**
+     * Validate configuration against schema
+     */
+    validate(schema, options) {
+        const result = schema.validate(this.config);
+        if (result.error) {
+            const message = `Configuration validation error: ${result.error.message}`;
+            core_2.default.error(message);
+            if (!options?.abortEarly) {
+                throw new Error(message);
+            }
+        }
+        this.config = result.value;
+    }
+    get(key, defaultValue) {
+        const value = this.getNestedValue(key);
+        return value !== undefined ? value : defaultValue;
+    }
+    /**
+     * Get nested value using dot notation
+     */
+    getNestedValue(key) {
+        const keys = key.split('.');
+        let value = this.config;
+        for (const k of keys) {
+            if (value && typeof value === 'object' && value !== null && k in value) {
+                value = value[k];
+            }
+            else {
+                return undefined;
+            }
+        }
+        return value;
+    }
+    /**
+     * Get all configuration
+     */
+    getAll() {
+        return { ...this.config };
+    }
+    /**
+     * Set a configuration value
+     */
+    set(key, value) {
+        this.config[key] = value;
+    }
+    /**
+     * Check if a key exists
+     */
+    has(key) {
+        return this.getNestedValue(key) !== undefined;
+    }
+    /**
+     * Get configuration as a specific type
+     */
+    getOrThrow(key) {
+        const value = this.get(key);
+        if (value === undefined) {
+            throw new Error(`Configuration key "${key}" is required but not found`);
+        }
+        return value;
+    }
+};
+exports.ConfigService = ConfigService;
+ConfigService.options = {};
+exports.ConfigService = ConfigService = ConfigService_1 = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], ConfigService);

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @hazeljs/config - Configuration module for HazelJS
+ */
+export { ConfigModule, type ConfigModuleOptions, type ValidationSchema as ConfigValidationSchema, } from './config.module';
+export { ConfigService } from './config.service';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,YAAY,EACZ,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,IAAI,sBAAsB,GAChD,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * @hazeljs/config - Configuration module for HazelJS
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigService = exports.ConfigModule = void 0;
+var config_module_1 = require("./config.module");
+Object.defineProperty(exports, "ConfigModule", { enumerable: true, get: function () { return config_module_1.ConfigModule; } });
+var config_service_1 = require("./config.service");
+Object.defineProperty(exports, "ConfigService", { enumerable: true, get: function () { return config_service_1.ConfigService; } });

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@hazeljs/config",
+  "version": "0.2.0-beta.1",
+  "description": "Configuration module for HazelJS framework",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --coverage --passWithNoTests",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@hazeljs/core": "file:../core",
+    "dotenv": "^16.5.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.50",
+    "@typescript-eslint/eslint-plugin": "^8.18.2",
+    "@typescript-eslint/parser": "^8.18.2",
+    "eslint": "^8.56.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hazel-js/hazeljs.git",
+    "directory": "packages/config"
+  },
+  "keywords": [
+    "hazeljs",
+    "config",
+    "configuration",
+    "environment"
+  ],
+  "author": "Muhammad Arslan <marslan@hazeljs.com>",
+  "license": "MIT"
+}