dotenv-gad 0.1.0 → 1.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kasim Lyee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,12 +1,13 @@
 # dotenv-gad
 
-[![npm version](https://badge.fury.io/js/dotenv-gad.svg)](https://badge.fury.io/js/dotenv-guard)
+[![npm version](https://badge.fury.io/js/dotenv-gad.svg)](https://badge.fury.io/js/dotenv-gad)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 **dotenv-gad** is an environment variable validation tool that brings type safety and schema validation to your Node.js and JavaScript applications. It extends `dotenv` with features like:
 
 - Type-safe environment variables
 - Schema validation
+- Schema composition
 - Automatic documentation generation
 - TypeScript support
 - CLI tooling
@@ -61,6 +62,8 @@ console.log(`Server running on port ${env.PORT}`);
 | `sync`  | Generate/update .env.example       |
 | `types` | Generate env.d.ts TypeScript types |
 | `init`  | Create starter schema              |
+| `fix`   | Fixes environment issues           |
+| `docs`  | Generates .env documentation       |
 
 ```bash
 npx dotenv-gad check
@@ -195,8 +198,8 @@ Environment validation failed:
 }
 ```
 
-## 📜 License
+## License
 
 MIT © [Kasim Lyee]
 
-Contributions are welcome!!
+[![contribution](https://github.com/kasimlyee/dotenv-gad/blob/main/CONTRIBUTING.md)] are welcome!!

package/dist/cli/index.js

@@ -9,6 +9,8 @@ import checkCommand from "./commands/check.js";
 import syncCommand from "./commands/sync.js";
 import typesCommand from "./commands/types.js";
 import initCommand from "./commands/init.js";
+import fixCommand from "./commands/fix.js";
+import docsCommand from "./commands/docs.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, "../../package.json"), "utf-8"));
 export function createCLI() {
@@ -22,7 +24,14 @@ export function createCLI() {
         .option("--debug", "Enable debug output")
         .option("--env <file>", "Specify env file path", ".env")
         .option("--schema <file>", "Specify schema file path", "env.schema.ts");
-    const commands = [checkCommand, syncCommand, typesCommand, initCommand];
+    const commands = [
+        checkCommand,
+        syncCommand,
+        typesCommand,
+        initCommand,
+        fixCommand,
+        docsCommand,
+    ];
     commands.forEach((command) => {
         const cmd = command(program);
         program.addCommand(cmd);

package/dist/index.js

@@ -1,9 +1,12 @@
 import { EnvValidator } from "./validator.js";
 import { defineSchema } from "./schema.js";
-import { AggregateError } from "./errors.js";
+import { AggregateError, EnvValidationError } from "./errors.js";
 import { loadEnv, createEnvProxy } from "./utils.js";
+import { composeSchema } from "./compose.js";
+import loadSchema from "./cli/commands/types.js";
+import { applyFix } from "./cli/commands/utils.js";
 import dotenv from "dotenv";
-export { defineSchema, AggregateError, EnvValidator, loadEnv, createEnvProxy };
+export { defineSchema, AggregateError, EnvValidationError, EnvValidator, loadEnv, createEnvProxy, composeSchema, loadSchema, applyFix, };
 export function validateEnv(schema, options) {
     const env = dotenv.config().parsed || {};
     const validator = new EnvValidator(schema, options);

package/dist/types/cli/commands/check.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export default function (program: Command): Command;

package/dist/types/cli/commands/docs.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export default function (program: Command): Command;

package/dist/types/cli/commands/fix.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export default function (program: Command): Command;

package/dist/types/cli/commands/init.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export default function (program: Command): Command;

package/dist/types/cli/commands/sync.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export default function (program: Command): Command;

package/dist/types/cli/commands/types.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export default function (program: Command): Command;

package/dist/types/cli/commands/utils.d.ts

@@ -0,0 +1,20 @@
+import { SchemaDefinition } from "../../schema.js";
+/**
+ * Loads a schema from a file.
+ * @param schemaPath Path to the schema file.
+ * @returns The loaded schema.
+ * @throws If the schema file is malformed or cannot be loaded.
+ */
+export declare function loadSchema(schemaPath: string): Promise<SchemaDefinition>;
+/**
+ * Applies fixes to the given environment file by prompting the user to input
+ * values for missing variables and variables that do not match the schema.
+ *
+ * @param issues An object where each key is the name of an environment variable
+ * and the value is an object containing the `value` property (which is the
+ * invalid value) and the `key` property (which is the name of the variable).
+ * @param schema The schema definition for the environment variables.
+ * @param envPath The path to the environment file. Defaults to `.env`.
+ * @throws If the schema is malformed or if the user cancels the prompt.
+ */
+export declare function applyFix(issues: Record<string, any>, schema: SchemaDefinition, envPath?: string): Promise<void>;

package/dist/types/cli/index.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+export declare function createCLI(): Command;
+declare const program: Command;
+export default program;

package/dist/types/compose.d.ts

@@ -0,0 +1,22 @@
+import { SchemaDefinition } from "./schema.js";
+/**
+ * Compose multiple schema definitions into a single one.
+ *
+ * @example
+ * const dbSchema = {
+ *   DB_HOST: { type: "string" },
+ *   DB_USER: { type: "string" },
+ *   DB_PASSWORD: { type: "string", sensitive: true },
+ * };
+ *
+ * const appSchema = {
+ *   APP_NAME: { type: "string" },
+ *   APP_PORT: { type: "number" },
+ * };
+ *
+ * const fullSchema = composeSchema(dbSchema, appSchema);
+ *
+ * @param {...SchemaDefinition[]} schemas - schema definitions to compose
+ * @returns {SchemaDefinition} - a single schema definition with all the properties
+ */
+export declare function composeSchema(...schemas: SchemaDefinition[]): SchemaDefinition;

package/dist/types/errors.d.ts

@@ -0,0 +1,22 @@
+import { SchemaRule } from "./schema.js";
+export declare class EnvValidationError extends Error {
+    key: string;
+    message: string;
+    receiveValue?: unknown | undefined;
+    constructor(key: string, message: string, receiveValue?: unknown | undefined);
+}
+export declare class AggregateError extends Error {
+    errors: {
+        key: string;
+        message: string;
+        value?: any;
+        rule?: SchemaRule;
+    }[];
+    constructor(errors: {
+        key: string;
+        message: string;
+        value?: any;
+        rule?: SchemaRule;
+    }[], message: string);
+    toString(): string;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+import { EnvValidator } from "./validator.js";
+import { defineSchema, SchemaDefinition, SchemaRule } from "./schema.js";
+import { AggregateError, EnvValidationError } from "./errors.js";
+import { loadEnv, createEnvProxy } from "./utils.js";
+import { composeSchema } from "./compose.js";
+import loadSchema from "./cli/commands/types.js";
+import { applyFix } from "./cli/commands/utils.js";
+export { defineSchema, AggregateError, EnvValidationError, EnvValidator, loadEnv, createEnvProxy, composeSchema, loadSchema, applyFix, };
+export type { SchemaDefinition, SchemaRule };
+export declare function validateEnv(schema: SchemaDefinition, options?: {
+    strict?: boolean;
+}): Record<string, any>;

package/dist/types/schema.d.ts

@@ -0,0 +1,35 @@
+type PrimitiveType = "string" | "number" | "boolean" | "date";
+type ComplexType = "object" | "array" | "email" | "url" | "ip" | "json" | "port";
+type SchemaType = PrimitiveType | ComplexType;
+export interface SchemaRule {
+    type: SchemaType;
+    required?: boolean;
+    default?: any;
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    validate?: (value: any) => boolean;
+    transform?: (value: any) => any;
+    sensitive?: boolean;
+    docs?: string;
+    enum?: any[];
+    regex?: RegExp;
+    regexError?: string;
+    error?: string;
+    items?: SchemaRule;
+    properties?: Record<string, SchemaRule>;
+    env?: {
+        [envName: string]: Partial<SchemaRule>;
+    };
+}
+export type SchemaDefinition = Record<string, SchemaRule>;
+/**
+ * Define a schema for a set of environment variables.
+ *
+ * @param schema A record where each key is the name of an environment variable
+ * and the value is a `SchemaRule` object that defines the rules for that
+ * variable.
+ */
+export declare function defineSchema(schema: SchemaDefinition): SchemaDefinition;
+export {};

package/dist/{utils.js → types/utils.d.ts}

@@ -1,5 +1,4 @@
-import dotenv from "dotenv";
-import { EnvValidator } from "./validator.js";
+import { SchemaDefinition } from "./schema.js";
 /**
  * Load the environment variables from a .env file, validate them against the schema
  * and return an object with the validated values.
@@ -9,11 +8,9 @@ import { EnvValidator } from "./validator.js";
  *
  * @returns A validated object with the environment variables.
  */
-export function loadEnv(schema, options) {
-    const env = dotenv.config().parsed || {};
-    const validator = new EnvValidator(schema, options);
-    return validator.validate(env);
-}
+export declare function loadEnv(schema: SchemaDefinition, options?: {
+    strict?: boolean;
+}): Record<string, any>;
 /**
  * Create a proxy around the validated environment variables. The proxy will
  * throw an error if you try to access a variable that is not validated.
@@ -23,14 +20,4 @@ export function loadEnv(schema, options) {
  * @returns A proxy object that throws an error if you access an
  * unvalidated variable.
  */
-export function createEnvProxy(validatedEnv) {
-    return new Proxy(validatedEnv, {
-        get(target, prop) {
-            const value = target[prop];
-            if (value === undefined) {
-                throw new Error(`Environment variable ${String(prop)} is not validated`);
-            }
-            return value;
-        },
-    });
-}
+export declare function createEnvProxy<T extends Record<string, any>>(validatedEnv: T): T;

package/dist/types/validator.d.ts

@@ -0,0 +1,12 @@
+import { SchemaDefinition } from "./schema.js";
+export declare class EnvValidator {
+    private schema;
+    private options?;
+    private errors;
+    constructor(schema: SchemaDefinition, options?: {
+        strict?: boolean;
+    } | undefined);
+    validate(env: Record<string, string | undefined>): Record<string, any>;
+    private validateKey;
+    private getEffectiveRule;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotenv-gad",
-  "version": "0.1.0",
+  "version": "1.0.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -13,12 +13,6 @@
     "dev": "tsc --watch",
     "prepublishOnly": "npm run build && npm test"
   },
-  "jest": {
-    "extensionsToTreatAsEsm": [
-      ".ts"
-    ],
-    "transform": {}
-  },
   "keywords": [
     "dotenv",
     "environment",
@@ -35,7 +29,7 @@
     "./package.json": "./package.json"
   },
   "files": [
-    "dist/**/*",
+    "dist/**/*.d.ts",
     "README.md",
     "LICENSE"
   ],
@@ -63,6 +57,7 @@
     "ts-jest": "^29.4.0"
   },
   "dependencies": {
+    "dotenv": "^16.5.0",
     "esbuild": "^0.25.5"
   }
 }

package/dist/cli/commands/check.js

@@ -1,41 +0,0 @@
-import { Command } from "commander";
-import chalk from "chalk";
-import ora from "ora";
-import { validateEnv } from "../../index.js";
-import { AggregateError } from "../../errors.js";
-import { loadSchema } from "./utils.js";
-export default function (program) {
-    return new Command("check")
-        .description("Validate .env against schema")
-        .option("--strict", "Fail on extra env vars not in schema")
-        .option("--fix", "Attempt to fix errors interactively")
-        .action(async (option, command) => {
-        const rootOpts = command.parent.opts();
-        const spinner = ora("Validatng environment.......").start();
-        try {
-            const schema = await loadSchema(rootOpts.schema);
-            const env = validateEnv(schema, {
-                strict: option.strict,
-            });
-            spinner.succeed(chalk.green("Environment validation passed!"));
-            console.log(chalk.dim(`Found ${Object.keys(env).length} valid variables`));
-        }
-        catch (error) {
-            spinner.stop();
-            if (error instanceof AggregateError) {
-                console.error(chalk.red("\nEnvironment validation failed:"));
-                error.errors.forEach((e) => {
-                    console.log(`  ${chalk.yellow(e.key)}: ${e.message}`);
-                    if (e.rule?.docs) {
-                        console.log(chalk.dim(`  ${e.rule.docs}`));
-                    }
-                });
-                process.exit(1);
-            }
-            else {
-                console.error(chalk.red("Unexpected error:"), error);
-                process.exit(2);
-            }
-        }
-    });
-}

package/dist/cli/commands/init.js

@@ -1,61 +0,0 @@
-import { Command } from "commander";
-import chalk from "chalk";
-import ora from "ora";
-import { writeFileSync, existsSync } from "fs";
-import inquirer from "inquirer";
-import { dirname } from "path";
-import { fileURLToPath } from "url";
-const __dirname = dirname(fileURLToPath(import.meta.url));
-export default function (program) {
-    return new Command("init")
-        .description("Initialize new schema file")
-        .option("--force", "Overwrite existing files")
-        .action(async (options, command) => {
-        const rootOpts = command.parent.opts();
-        const schemaPath = rootOpts.schema;
-        if (existsSync(schemaPath)) {
-            if (!options.force) {
-                const { overwrite } = await inquirer.prompt({
-                    type: "confirm",
-                    name: "overwrite",
-                    message: "Schema file already exists. Overwrite?",
-                    default: false,
-                });
-                if (!overwrite)
-                    process.exit(0);
-            }
-        }
-        const spinner = ora("Creating new schema...").start();
-        try {
-            const template = `import { defineSchema } from 'dotenv-gad';
-
-export default defineSchema({
-  // Add your environment variables here
-  PORT: {
-    type: 'number',
-    default: 3000,
-    docs: 'Port to run the server on'
-  },
-  NODE_ENV: {
-    type: 'string',
-    enum: ['development', 'production', 'test'],
-    default: 'development'
-  },
-  DB_URL: {
-    type: 'string',
-    required: true,
-    docs: 'Database connection URL'
-  }
-});
-`;
-            writeFileSync(schemaPath, template);
-            spinner.succeed(chalk.green(`Created ${schemaPath} successfully!`));
-            console.log(chalk.dim("\nEdit this file to define your environment schema"));
-        }
-        catch (error) {
-            spinner.fail(chalk.red("Failed to create schema file"));
-            console.error(error);
-            process.exit(1);
-        }
-    });
-}

package/dist/cli/commands/sync.js

@@ -1,37 +0,0 @@
-import { Command } from "commander";
-import chalk from "chalk";
-import ora from "ora";
-import { writeFileSync } from "fs";
-import { loadSchema } from "./utils.js";
-export default function (program) {
-    return new Command("sync")
-        .description("Genearte/update .env.example file")
-        .option("--output <file>", "Output file path", ".env.example")
-        .action(async (options, command) => {
-        const rootOpts = command.parent.opts();
-        const spinner = ora("Generating .env.example.......").start();
-        try {
-            const schema = await loadSchema(rootOpts.schema);
-            let exampleContent = "# Auto-generated by dotenv-gad\n\n";
-            Object.entries(schema).forEach(([key, rule]) => {
-                if (rule.sensitive)
-                    return;
-                exampleContent += `# ${rule.docs || "No description available"}\n`;
-                exampleContent += `# Type: ${rule.type}\n`;
-                if (rule.default !== undefined) {
-                    exampleContent += `# Default: ${JSON.stringify(rule.default)}\n`;
-                }
-                exampleContent += `${key}=${rule.default
-                    ? JSON.stringify(rule.default)
-                    : ""}\n\n`;
-            });
-            writeFileSync(options.output, exampleContent.trim());
-            spinner.succeed(chalk.green(`Generated ${options.output} successfully!`));
-        }
-        catch (error) {
-            spinner.fail(chalk.red(`Failed to generate .env.example`));
-            console.error(error);
-            process.exit(1);
-        }
-    });
-}

package/dist/cli/commands/types.js

@@ -1,40 +0,0 @@
-import { Command } from "commander";
-import chalk from "chalk";
-import ora from "ora";
-import { writeFileSync } from "fs";
-import { loadSchema } from "./utils.js";
-export default function (program) {
-    return new Command("types")
-        .description("Generate Typescript types")
-        .option("--output <file>", "Output file path", "env.d.ts")
-        .action(async (options, command) => {
-        const rootOpts = command.parent.opts();
-        const spinner = ora("Generating type definitions.......").start();
-        try {
-            const schema = await loadSchema(rootOpts.schema);
-            let typeContent = "// Auto-generated by dotenv-gad\n\ndeclare namespace NodeJS{\n  interface ProcessEnv{\n";
-            Object.entries(schema).forEach(([key, rule]) => {
-                let type;
-                switch (rule.type) {
-                    case "number":
-                        type = "number";
-                        break;
-                    case "boolean":
-                        type = "boolean";
-                        break;
-                    default:
-                        type = "string";
-                }
-                typeContent += `    ${key}${rule.required ? "" : "?"}:${type};\n`;
-            });
-            typeContent += "  }\n}\n";
-            writeFileSync(options.output, typeContent);
-            spinner.succeed(chalk.green(`Generated ${options.output} successfully!`));
-        }
-        catch (error) {
-            spinner.fail(chalk.red("Failed to generate type definitions"));
-            console.error(error);
-            process.exit(1);
-        }
-    });
-}

package/dist/cli/commands/utils.js

@@ -1,40 +0,0 @@
-import { readFileSync, writeFileSync, unlinkSync } from "fs";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-import { transformSync } from "esbuild";
-const __dirname = dirname(fileURLToPath(import.meta.url));
-export async function loadSchema(schemaPath) {
-    try {
-        if (schemaPath.endsWith(".ts")) {
-            const code = readFileSync(schemaPath, "utf-8");
-            const result = transformSync(code, {
-                format: "esm",
-                loader: "ts",
-                target: "esnext",
-            });
-            // Create temporary file
-            const tempFile = join(__dirname, "../../temp-schema.mjs");
-            writeFileSync(tempFile, result.code);
-            try {
-                // Import with query string to bust cache
-                const module = await import(`${tempFile}?t=${Date.now()}`);
-                return module.default;
-            }
-            finally {
-                // Clean up temp file
-                unlinkSync(tempFile);
-            }
-        }
-        else if (schemaPath.endsWith(".js")) {
-            const module = await import(schemaPath);
-            return module.default;
-        }
-        else if (schemaPath.endsWith(".json")) {
-            return JSON.parse(readFileSync(schemaPath, "utf-8"));
-        }
-        throw new Error("Unsupported schema format. Use .ts, .js or .json");
-    }
-    catch (error) {
-        throw new Error(`Failed to load schema: ${error.message}`);
-    }
-}

package/dist/errors.js

@@ -1,22 +0,0 @@
-export class AggregateError extends Error {
-    errors;
-    constructor(errors, message) {
-        super(message);
-        this.errors = errors;
-        this.name = "AggregateError";
-        Object.setPrototypeOf(this, AggregateError.prototype);
-    }
-    toString() {
-        const errorList = this.errors
-            .map((e) => {
-            let msg = `  - ${e.key}:${e.message}`;
-            if (e.value !== undefined)
-                msg += ` (reaceived: ${JSON.stringify(e.value)})`;
-            if (e.rule?.docs)
-                msg += `\n   (${e.rule.docs})`;
-            return msg;
-        })
-            .join("\n");
-        return `${this.message}:\n${errorList}`;
-    }
-}

package/dist/schema.js

@@ -1,10 +0,0 @@
-/**
- * Define a schema for a set of environment variables.
- *
- * @param schema A record where each key is the name of an environment variable
- * and the value is a `SchemaRule` object that defines the rules for that
- * variable.
- */
-export function defineSchema(schema) {
-    return schema;
-}

package/dist/validator.js

@@ -1,180 +0,0 @@
-import { AggregateError } from "./errors.js";
-export class EnvValidator {
-    schema;
-    options;
-    errors = [];
-    constructor(schema, options) {
-        this.schema = schema;
-        this.options = options;
-    }
-    validate(env) {
-        this.errors = [];
-        const result = {};
-        for (const [key, rule] of Object.entries(this.schema)) {
-            try {
-                result[key] = this.validateKey(key, rule, env[key]);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    this.errors.push({
-                        key,
-                        message: error.message,
-                        value: env[key],
-                        rule,
-                    });
-                }
-            }
-        }
-        if (this.errors.length > 0) {
-            const keys = this.errors.map((e) => e.key).join(", ");
-            throw new AggregateError(this.errors, `Environment validation failed: ${keys}`);
-        }
-        if (this.options?.strict) {
-            const extraVars = Object.keys(env).filter((k) => !(k in this.schema));
-            if (extraVars.length > 0) {
-                throw new Error(`Unexpected environment variables: ${extraVars.join(", ")}`);
-            }
-        }
-        return result;
-    }
-    validateKey(key, rule, value) {
-        const effectiveRule = this.getEffectiveRule(key, rule);
-        if (value === undefined) {
-            if (effectiveRule.required)
-                throw new Error(`Missing required environment variable`);
-            return effectiveRule.default;
-        }
-        if (effectiveRule.transform) {
-            value = effectiveRule.transform(value);
-        }
-        switch (effectiveRule.type) {
-            case "string":
-                value = String(value).trim();
-                if (effectiveRule.minLength && value.length < effectiveRule.minLength) {
-                    throw new Error(`Environment variable ${key} must be at least ${effectiveRule.minLength} characters`);
-                }
-                if (effectiveRule.maxLength && value.length > effectiveRule.maxLength) {
-                    throw new Error(`Environment variable ${key} must be at most ${effectiveRule.maxLength} characters`);
-                }
-                break;
-            case "number":
-                value = Number(value);
-                if (isNaN(value)) {
-                    throw new Error(`Environment variable ${key} must be a number`);
-                }
-                if (effectiveRule.min !== undefined && value < effectiveRule.min) {
-                    throw new Error(`Environment variable ${key} must be at least ${effectiveRule.min}`);
-                }
-                if (effectiveRule.max !== undefined && value > effectiveRule.max) {
-                    throw new Error(`Environment variable ${key} must be at most ${effectiveRule.max}`);
-                }
-                break;
-            case "boolean":
-                if (typeof value === "string") {
-                    value = value.toLowerCase();
-                    if (value === "true") {
-                        value = true;
-                    }
-                    else if (value === "false") {
-                        value = false;
-                    }
-                }
-                if (typeof value !== "boolean") {
-                    throw new Error(`Environment variable ${key} must be a boolean (true/false)`);
-                }
-                value = Boolean(value);
-                break;
-            case "url":
-                try {
-                    new URL(String(value));
-                }
-                catch {
-                    throw new Error("Must be a valid URL");
-                }
-                break;
-            case "email":
-                if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(value))) {
-                    throw new Error("Must be a valid email");
-                }
-                break;
-            case "ip":
-                if (!/^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/.test(String(value))) {
-                    throw new Error("Must be a valid IP address");
-                }
-                break;
-            case "port":
-                const port = Number(value);
-                if (isNaN(port))
-                    throw new Error("Must be a number");
-                if (port < 1 || port > 65535) {
-                    throw new Error("Must be between 1 and 65535");
-                }
-                break;
-            case "json":
-                try {
-                    value = JSON.parse(value);
-                }
-                catch {
-                    throw new Error("Must be valid JSON");
-                }
-                break;
-            case "array":
-                if (!Array.isArray(value)) {
-                    try {
-                        value = JSON.parse(value);
-                    }
-                    catch {
-                        throw new Error("Must be a valid array or JSON array string");
-                    }
-                }
-                if (effectiveRule.items) {
-                    value = value.map((item, i) => {
-                        try {
-                            return this.validateKey(`${key}[${i}]`, effectiveRule.items, item);
-                        }
-                        catch (error) {
-                            throw new Error(`Array item '${i}':${error.message}`);
-                        }
-                    });
-                }
-                break;
-            case "object":
-                if (typeof value === "string") {
-                    try {
-                        value = JSON.parse(value);
-                    }
-                    catch {
-                        throw new Error("Must be a valid object or JSON string");
-                    }
-                }
-                if (effectiveRule.properties) {
-                    const obj = {};
-                    for (const [prop, propRule] of Object.entries(effectiveRule.properties)) {
-                        try {
-                            obj[prop] = this.validateKey(`${key}.${prop}`, propRule, value[prop]);
-                        }
-                        catch (error) {
-                            throw new Error(`Property '${prop}':${error.message}`);
-                        }
-                    }
-                    value = obj;
-                }
-                break;
-        }
-        if (effectiveRule.enum && !effectiveRule.enum.includes(value)) {
-            throw new Error(`Environment variable ${key} must be one of ${effectiveRule.enum.join(", ")}`);
-        }
-        if (effectiveRule.regex && !effectiveRule.regex.test(value)) {
-            throw new Error(`Environment variable ${key} must match ${effectiveRule.regex}`);
-        }
-        if (effectiveRule.validate && !effectiveRule.validate(value)) {
-            throw new Error(effectiveRule.error || "Custom validation failed");
-        }
-        return value;
-    }
-    getEffectiveRule(key, rule) {
-        const envName = process.env.NODE_ENV || "development";
-        const envRule = rule.env?.[envName] || {};
-        return { ...rule, ...envRule };
-    }
-}