ezcfg 0.2.0 → 0.3.0

package/README.md

@@ -9,8 +9,10 @@ Lite and easy configuration management for Node.js with full TypeScript support.
 
 - **Type-safe configuration** - Full TypeScript support with automatic type inference
 - **Automatic .env file loading** - Loads environment files based on `NODE_ENV`
+- **Direct .env file parsing** - Read from a specific `.env` file without modifying `process.env`
 - **Validation with clear error messages** - Collects all validation errors at once
-- **Zero runtime dependencies** - Only uses `dotenv` for .env file parsing
+- **PostgreSQL config support** - Built-in `postgresConfig` spec via `ezcfg/postgres`
+- **Extensible** - Implement `ConfigSpec` to add custom config types
 - **Singleton pattern** - Config is lazily evaluated and cached (except in test environment)
 
 ## Installation
@@ -90,12 +92,40 @@ const config = getConfig(); // Lazily evaluated and cached
 | `schema` | `Record<string, unknown>` | Object defining your configuration shape |
 | `options.loadEnv` | `boolean` | Whether to load .env files automatically (default: `false`) |
 | `options.envLoader` | `() => void` | Custom function to load environment variables |
+| `options.fromEnvFile` | `string` | Path to a `.env` file to parse directly (does not modify `process.env`) |
 
 **Behavior:**
 
 - Returns a factory function that lazily evaluates and caches the config
 - In test environment (`NODE_ENV=test`), config is re-evaluated on each call
 - Throws `ConfigValidationError` if any required values are missing
+- When `fromEnvFile` is set, the file is parsed into a local object and passed to each spec's `resolve()` — `process.env` is never modified
+
+---
+
+### `parseEnvFile(filePath)`
+
+Parses a `.env` file and returns its contents as a `Record<string, string>`. Does not modify `process.env`.
+
+```typescript
+import { parseEnvFile } from 'ezcfg';
+
+const env = parseEnvFile('/path/to/.env');
+// { DATABASE_URL: 'postgres://...', API_KEY: 'secret' }
+```
+
+Useful for injecting env vars into test runners:
+
+```typescript
+// vitest.config.ts
+import { parseEnvFile } from 'ezcfg';
+
+export default defineConfig({
+  test: {
+    env: parseEnvFile(resolve(__dirname, '.env')),
+  },
+});
+```
 
 ---
 
@@ -216,6 +246,90 @@ loadEnvFiles({
 });
 ```
 
+---
+
+## `ezcfg/postgres`
+
+PostgreSQL configuration support, available as a subpath import.
+
+```typescript
+import { postgresConfig, PostgresConfig } from 'ezcfg/postgres';
+```
+
+### `postgresConfig(prefix, mode?)`
+
+A `ConfigSpec` implementation for PostgreSQL database configuration. Use with `defineConfig`.
+
+```typescript
+import { defineConfig } from 'ezcfg';
+import { postgresConfig } from 'ezcfg/postgres';
+
+const getConfig = defineConfig({
+  db: postgresConfig('ORDER_DB'),           // reads ORDER_DB_URL
+  db2: postgresConfig('PG', 'fields'),      // reads PG_HOST, PG_PORT, etc.
+});
+
+getConfig().db.host;        // "localhost"
+getConfig().db.toString();  // "postgres://..."
+```
+
+**Parameters:**
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `prefix` | `string` | — | Environment variable prefix |
+| `mode` | `"url" \| "fields"` | `"url"` | `"url"` reads `{PREFIX}_URL`, `"fields"` reads individual fields |
+
+**Fields mode** reads: `{PREFIX}_HOST`, `{PREFIX}_PORT`, `{PREFIX}_DATABASE`, `{PREFIX}_USER`, `{PREFIX}_PASSWORD`
+
+### `PostgresConfig`
+
+Immutable value object representing a PostgreSQL connection configuration.
+
+```typescript
+import { PostgresConfig } from 'ezcfg/postgres';
+
+// From URL
+const config = PostgresConfig.fromUrl('postgres://user:pass@localhost:5432/mydb');
+
+// From environment variables
+const config = PostgresConfig.fromEnv('DATABASE');       // reads DATABASE_URL
+const config = PostgresConfig.fromEnv('PG', { mode: 'fields' });
+
+// Builder methods (each returns a new instance)
+config.withDatabase('other_db');
+config.withHost('remote-host');
+config.withPort(5433);
+config.withUser('admin');
+config.withPassword('secret');
+config.withPoolSize(10);
+config.withConnectionTimeout(5000);
+config.withIdleTimeout(30000);
+
+// Connection string
+config.toString();  // "postgres://user:pass@localhost:5432/mydb"
+```
+
+### Using with `fromEnvFile`
+
+`postgresConfig` works with `fromEnvFile` — the `.env` file is parsed locally without modifying `process.env`:
+
+```typescript
+import { defineConfig } from 'ezcfg';
+import { postgresConfig } from 'ezcfg/postgres';
+
+const getConfig = defineConfig(
+  { db: postgresConfig('DATABASE') },
+  { fromEnvFile: resolve(__dirname, '.env') }
+);
+
+// .env contains: DATABASE_URL=postgres://user@localhost/mydb
+const config = getConfig();
+config.db.database;  // "mydb"
+```
+
+---
+
 ## .env File Loading
 
 When `loadEnv: true` is set, ezcfg automatically loads environment files in the following order (later files override earlier ones):
@@ -241,7 +355,7 @@ When `loadEnv: true` is set, ezcfg automatically loads environment files in the
 When validation fails, ezcfg throws a `ConfigValidationError` with all errors collected:
 
 ```typescript
-import { defineConfig, env, ConfigValidationError } from 'ezcfg';
+import { defineConfig, env, envNumber, ConfigValidationError } from 'ezcfg';
 
 const getConfig = defineConfig({
   apiKey: env('API_KEY'),
@@ -297,7 +411,7 @@ const config = getConfig();
 You can also extract the config type for use elsewhere:
 
 ```typescript
-import { defineConfig, env, type InferConfigType } from 'ezcfg';
+import { defineConfig, env, envNumber, type InferConfigType } from 'ezcfg';
 
 const schema = {
   apiKey: env('API_KEY'),
@@ -315,75 +429,30 @@ function initializeApp(config: AppConfig) {
 }
 ```
 
-## Examples
-
-### Database Configuration
-
-```typescript
-import { defineConfig, env, envNumber, envOptional } from 'ezcfg';
-
-export const getDbConfig = defineConfig({
-  host: env('DB_HOST'),
-  port: envNumber('DB_PORT'),
-  database: env('DB_NAME'),
-  user: env('DB_USER'),
-  password: envOptional('DB_PASSWORD'),
-}, { loadEnv: true });
-
-// Usage
-const db = getDbConfig();
-const connectionString = `postgres://${db.user}:${db.password}@${db.host}:${db.port}/${db.database}`;
-```
+## Custom ConfigSpec
 
-### API Service Configuration
+Implement the `ConfigSpec` interface to create your own config types:
 
 ```typescript
-import { defineConfig, env, envNumber, envBoolean, envJsonOptional } from 'ezcfg';
-
-export const getConfig = defineConfig({
-  // Server
-  port: envNumber('PORT'),
-  host: envOptional('HOST', '0.0.0.0'),
-
-  // API Keys
-  apiKey: env('API_KEY'),
-  secretKey: env('SECRET_KEY'),
-
-  // Features
-  debug: envBoolean('DEBUG', false),
-  enableMetrics: envBoolean('ENABLE_METRICS', true),
+import type { ConfigSpec } from 'ezcfg';
 
-  // CORS
-  allowedOrigins: envJsonOptional<string[]>('ALLOWED_ORIGINS', ['http://localhost:3000']),
-}, { loadEnv: true });
-```
+class RedisConfigSpec implements ConfigSpec<RedisConfig> {
+  readonly _type = 'redis';
 
-### Multi-environment Setup
+  constructor(private readonly prefix: string) {}
 
-```
-project/
-├── .env                 # Shared defaults
-├── .env.local           # Local secrets (gitignored)
-├── .env.development     # Development settings
-├── .env.production      # Production settings
-└── .env.test            # Test settings
-```
+  resolve(errors: string[], envSource?: Record<string, string>): RedisConfig | undefined {
+    const source = envSource ?? process.env;
+    const url = source[`${this.prefix}_URL`];
 
-```bash
-# .env
-LOG_LEVEL=info
-API_TIMEOUT=5000
+    if (!url) {
+      errors.push(`Missing ${this.prefix}_URL`);
+      return undefined;
+    }
 
-# .env.development
-DEBUG=true
-API_URL=http://localhost:3000
-
-# .env.production
-DEBUG=false
-API_URL=https://api.example.com
-
-# .env.local (gitignored)
-API_KEY=your-secret-key
+    return new RedisConfig(url);
+  }
+}
 ```
 
 ## License

package/dist/database-config-YXQXZ9gp.d.mts

@@ -0,0 +1,20 @@
+interface ConfigSpec<T> {
+    readonly _type: string;
+    resolve(errors: string[], envSource?: Record<string, string>): T | undefined;
+}
+type InferSpecType<S> = S extends ConfigSpec<infer T> ? T : S;
+type InferConfigType<S extends Record<string, unknown>> = {
+    readonly [K in keyof S]: InferSpecType<S[K]>;
+};
+declare function isConfigSpec(value: unknown): value is ConfigSpec<unknown>;
+
+interface DatabaseConfig {
+    readonly host: string;
+    readonly port: number;
+    readonly database: string;
+    readonly user: string;
+    readonly password?: string;
+    toString(): string;
+}
+
+export { type ConfigSpec as C, type DatabaseConfig as D, type InferConfigType as I, type InferSpecType as a, isConfigSpec as i };

package/dist/database-config-YXQXZ9gp.d.ts

@@ -0,0 +1,20 @@
+interface ConfigSpec<T> {
+    readonly _type: string;
+    resolve(errors: string[], envSource?: Record<string, string>): T | undefined;
+}
+type InferSpecType<S> = S extends ConfigSpec<infer T> ? T : S;
+type InferConfigType<S extends Record<string, unknown>> = {
+    readonly [K in keyof S]: InferSpecType<S[K]>;
+};
+declare function isConfigSpec(value: unknown): value is ConfigSpec<unknown>;
+
+interface DatabaseConfig {
+    readonly host: string;
+    readonly port: number;
+    readonly database: string;
+    readonly user: string;
+    readonly password?: string;
+    toString(): string;
+}
+
+export { type ConfigSpec as C, type DatabaseConfig as D, type InferConfigType as I, type InferSpecType as a, isConfigSpec as i };

package/dist/index.d.mts

@@ -0,0 +1,47 @@
+import { I as InferConfigType, C as ConfigSpec } from './database-config-YXQXZ9gp.mjs';
+export { D as DatabaseConfig, a as InferSpecType, i as isConfigSpec } from './database-config-YXQXZ9gp.mjs';
+
+declare class ConfigValidationError extends Error {
+    readonly errors: string[];
+    constructor(errors: string[]);
+}
+
+interface ConfigOptions {
+    loadEnv?: boolean;
+    envLoader?: () => void;
+    fromEnvFile?: string;
+}
+declare function defineConfig<S extends Record<string, unknown>>(schema: S, options?: ConfigOptions): () => InferConfigType<S>;
+declare function parseEnvFile(filePath: string): Record<string, string>;
+
+declare function loadEnvFiles({ basePath, nodeEnv, }?: {
+    basePath?: string;
+    nodeEnv?: string;
+}): void;
+
+declare class EnvSpec<T> implements ConfigSpec<T> {
+    private readonly envKey;
+    private readonly required;
+    private readonly defaultValue?;
+    private readonly transform?;
+    readonly _type = "env";
+    constructor(envKey: string, required: boolean, defaultValue?: T | undefined, transform?: ((value: string) => T) | undefined);
+    resolve(errors: string[], envSource?: Record<string, string>): T | undefined;
+}
+declare function env(key: string): EnvSpec<string>;
+declare function envOptional(key: string, defaultValue?: string): EnvSpec<string | undefined>;
+declare function envNumber(key: string): EnvSpec<number>;
+declare function envNumberOptional(key: string, defaultValue?: number): EnvSpec<number | undefined>;
+declare function envBoolean(key: string, defaultValue?: boolean): EnvSpec<boolean>;
+declare function envJson<T>(key: string): EnvSpec<T>;
+declare function envJsonOptional<T>(key: string, defaultValue?: T): EnvSpec<T | undefined>;
+
+declare class ComputedSpec<T> implements ConfigSpec<T> {
+    private readonly factory;
+    readonly _type = "computed";
+    constructor(factory: () => T);
+    resolve(errors: string[], _envSource?: Record<string, string>): T | undefined;
+}
+declare function computed<T>(factory: () => T): ComputedSpec<T>;
+
+export { ComputedSpec, type ConfigOptions, ConfigSpec, ConfigValidationError, EnvSpec, InferConfigType, computed, defineConfig, env, envBoolean, envJson, envJsonOptional, envNumber, envNumberOptional, envOptional, loadEnvFiles, parseEnvFile };

package/dist/index.d.ts

@@ -0,0 +1,47 @@
+import { I as InferConfigType, C as ConfigSpec } from './database-config-YXQXZ9gp.js';
+export { D as DatabaseConfig, a as InferSpecType, i as isConfigSpec } from './database-config-YXQXZ9gp.js';
+
+declare class ConfigValidationError extends Error {
+    readonly errors: string[];
+    constructor(errors: string[]);
+}
+
+interface ConfigOptions {
+    loadEnv?: boolean;
+    envLoader?: () => void;
+    fromEnvFile?: string;
+}
+declare function defineConfig<S extends Record<string, unknown>>(schema: S, options?: ConfigOptions): () => InferConfigType<S>;
+declare function parseEnvFile(filePath: string): Record<string, string>;
+
+declare function loadEnvFiles({ basePath, nodeEnv, }?: {
+    basePath?: string;
+    nodeEnv?: string;
+}): void;
+
+declare class EnvSpec<T> implements ConfigSpec<T> {
+    private readonly envKey;
+    private readonly required;
+    private readonly defaultValue?;
+    private readonly transform?;
+    readonly _type = "env";
+    constructor(envKey: string, required: boolean, defaultValue?: T | undefined, transform?: ((value: string) => T) | undefined);
+    resolve(errors: string[], envSource?: Record<string, string>): T | undefined;
+}
+declare function env(key: string): EnvSpec<string>;
+declare function envOptional(key: string, defaultValue?: string): EnvSpec<string | undefined>;
+declare function envNumber(key: string): EnvSpec<number>;
+declare function envNumberOptional(key: string, defaultValue?: number): EnvSpec<number | undefined>;
+declare function envBoolean(key: string, defaultValue?: boolean): EnvSpec<boolean>;
+declare function envJson<T>(key: string): EnvSpec<T>;
+declare function envJsonOptional<T>(key: string, defaultValue?: T): EnvSpec<T | undefined>;
+
+declare class ComputedSpec<T> implements ConfigSpec<T> {
+    private readonly factory;
+    readonly _type = "computed";
+    constructor(factory: () => T);
+    resolve(errors: string[], _envSource?: Record<string, string>): T | undefined;
+}
+declare function computed<T>(factory: () => T): ComputedSpec<T>;
+
+export { ComputedSpec, type ConfigOptions, ConfigSpec, ConfigValidationError, EnvSpec, InferConfigType, computed, defineConfig, env, envBoolean, envJson, envJsonOptional, envNumber, envNumberOptional, envOptional, loadEnvFiles, parseEnvFile };

package/dist/index.js

@@ -0,0 +1,219 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ComputedSpec: () => ComputedSpec,
+  ConfigValidationError: () => ConfigValidationError,
+  EnvSpec: () => EnvSpec,
+  computed: () => computed,
+  defineConfig: () => defineConfig,
+  env: () => env,
+  envBoolean: () => envBoolean,
+  envJson: () => envJson,
+  envJsonOptional: () => envJsonOptional,
+  envNumber: () => envNumber,
+  envNumberOptional: () => envNumberOptional,
+  envOptional: () => envOptional,
+  isConfigSpec: () => isConfigSpec,
+  loadEnvFiles: () => loadEnvFiles,
+  parseEnvFile: () => parseEnvFile
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config-spec.ts
+function isConfigSpec(value) {
+  return typeof value === "object" && value !== null && "resolve" in value && typeof value.resolve === "function";
+}
+
+// src/errors.ts
+var ConfigValidationError = class extends Error {
+  constructor(errors) {
+    super(`Config validation failed:
+  - ${errors.join("\n  - ")}`);
+    this.errors = errors;
+    this.name = "ConfigValidationError";
+  }
+};
+
+// src/define-config.ts
+var import_node_fs2 = __toESM(require("fs"));
+var import_dotenv2 = __toESM(require("dotenv"));
+
+// src/load-env-files.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+var import_dotenv = __toESM(require("dotenv"));
+function loadEnvFiles({
+  basePath,
+  nodeEnv
+} = {}) {
+  const basePath_ = basePath ?? process.cwd();
+  const nodeEnv_ = nodeEnv ?? process.env.NODE_ENV ?? "development";
+  const envFiles = [
+    ".env",
+    ".env.local",
+    `.env.${nodeEnv_}`,
+    `.env.${nodeEnv_}.local`
+  ];
+  const loadEnvFile = (filePath) => {
+    if (import_node_fs.default.existsSync(filePath)) {
+      import_dotenv.default.config({ path: filePath });
+    }
+  };
+  envFiles.reverse().forEach((file) => {
+    const filePath = import_node_path.default.resolve(basePath_, file);
+    loadEnvFile(filePath);
+  });
+}
+
+// src/define-config.ts
+function defineConfig(schema, options) {
+  let instance = null;
+  return () => {
+    if (instance && process.env.NODE_ENV !== "test") {
+      return instance;
+    }
+    let envSource;
+    if (options?.fromEnvFile) {
+      envSource = parseEnvFile(options.fromEnvFile);
+    } else if (options?.loadEnv) {
+      if (options.envLoader) {
+        options.envLoader();
+      } else {
+        loadEnvFiles();
+      }
+    }
+    const config = {};
+    const errors = [];
+    for (const [key, value] of Object.entries(schema)) {
+      if (isConfigSpec(value)) {
+        config[key] = value.resolve(errors, envSource);
+      } else {
+        config[key] = value;
+      }
+    }
+    if (errors.length > 0) {
+      throw new ConfigValidationError(errors);
+    }
+    instance = config;
+    return instance;
+  };
+}
+function parseEnvFile(filePath) {
+  const content = import_node_fs2.default.readFileSync(filePath, "utf-8");
+  return import_dotenv2.default.parse(content);
+}
+
+// src/env-spec.ts
+var EnvSpec = class {
+  constructor(envKey, required, defaultValue, transform) {
+    this.envKey = envKey;
+    this.required = required;
+    this.defaultValue = defaultValue;
+    this.transform = transform;
+  }
+  _type = "env";
+  resolve(errors, envSource) {
+    const rawValue = (envSource ?? process.env)[this.envKey];
+    if (!rawValue && this.required) {
+      errors.push(`Missing required env: ${this.envKey}`);
+      return void 0;
+    }
+    if (rawValue !== void 0) {
+      try {
+        return this.transform ? this.transform(rawValue) : rawValue;
+      } catch (e) {
+        errors.push(`Failed to transform ${this.envKey}: ${e.message}`);
+        return void 0;
+      }
+    }
+    return this.defaultValue;
+  }
+};
+function env(key) {
+  return new EnvSpec(key, true);
+}
+function envOptional(key, defaultValue) {
+  return new EnvSpec(key, false, defaultValue);
+}
+function envNumber(key) {
+  return new EnvSpec(key, true, void 0, Number);
+}
+function envNumberOptional(key, defaultValue) {
+  return new EnvSpec(key, false, defaultValue, (v) => v ? Number(v) : void 0);
+}
+function envBoolean(key, defaultValue = false) {
+  return new EnvSpec(key, false, defaultValue, (v) => v === "true" || v === "1");
+}
+function envJson(key) {
+  return new EnvSpec(key, true, void 0, JSON.parse);
+}
+function envJsonOptional(key, defaultValue) {
+  return new EnvSpec(key, false, defaultValue, (v) => v ? JSON.parse(v) : void 0);
+}
+
+// src/computed-spec.ts
+var ComputedSpec = class {
+  constructor(factory) {
+    this.factory = factory;
+  }
+  _type = "computed";
+  resolve(errors, _envSource) {
+    try {
+      return this.factory();
+    } catch (e) {
+      errors.push(`Computed value failed: ${e.message}`);
+      return void 0;
+    }
+  }
+};
+function computed(factory) {
+  return new ComputedSpec(factory);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ComputedSpec,
+  ConfigValidationError,
+  EnvSpec,
+  computed,
+  defineConfig,
+  env,
+  envBoolean,
+  envJson,
+  envJsonOptional,
+  envNumber,
+  envNumberOptional,
+  envOptional,
+  isConfigSpec,
+  loadEnvFiles,
+  parseEnvFile
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/config-spec.ts","../src/errors.ts","../src/define-config.ts","../src/load-env-files.ts","../src/env-spec.ts","../src/computed-spec.ts"],"sourcesContent":["export {\n    type ConfigSpec,\n    type InferSpecType,\n    type InferConfigType,\n    isConfigSpec,\n} from \"./config-spec\";\n\nexport { ConfigValidationError } from \"./errors\";\n\nexport { defineConfig, parseEnvFile, type ConfigOptions } from \"./define-config\";\nexport { loadEnvFiles } from \"./load-env-files\";\n\nexport {\n    EnvSpec,\n    env,\n    envOptional,\n    envNumber,\n    envNumberOptional,\n    envBoolean,\n    envJson,\n    envJsonOptional,\n} from \"./env-spec\";\n\nexport { ComputedSpec, computed } from \"./computed-spec\";\n\nexport type { DatabaseConfig } from \"./database-config\";\n","export interface ConfigSpec<T> {\n    readonly _type: string;\n    resolve(errors: string[], envSource?: Record<string, string>): T | undefined;\n}\n\nexport type InferSpecType<S> = S extends ConfigSpec<infer T> ? T : S;\n\nexport type InferConfigType<S extends Record<string, unknown>> = {\n    readonly [K in keyof S]: InferSpecType<S[K]>;\n};\n\nexport function isConfigSpec(value: unknown): value is ConfigSpec<unknown> {\n    return (\n        typeof value === \"object\" &&\n        value !== null &&\n        \"resolve\" in value &&\n        typeof (value as ConfigSpec<unknown>).resolve === \"function\"\n    );\n}\n","export class ConfigValidationError extends Error {\n    constructor(public readonly errors: string[]) {\n        super(`Config validation failed:\\n  - ${errors.join(\"\\n  - \")}`);\n        this.name = \"ConfigValidationError\";\n    }\n}\n","import fs from \"node:fs\";\n\nimport dotenv from \"dotenv\";\n\nimport { type InferConfigType, isConfigSpec } from \"./config-spec\";\nimport { ConfigValidationError } from \"./errors\";\nimport { loadEnvFiles } from \"./load-env-files\";\n\nexport interface ConfigOptions {\n    loadEnv?: boolean;\n    envLoader?: () => void;\n    fromEnvFile?: string;\n}\n\nexport function defineConfig<S extends Record<string, unknown>>(\n    schema: S,\n    options?: ConfigOptions\n): () => InferConfigType<S> {\n    let instance: InferConfigType<S> | null = null;\n\n    return () => {\n        if (instance && process.env.NODE_ENV !== \"test\") {\n            return instance;\n        }\n\n        let envSource: Record<string, string> | undefined;\n\n        if (options?.fromEnvFile) {\n            envSource = parseEnvFile(options.fromEnvFile);\n        } else if (options?.loadEnv) {\n            if (options.envLoader) {\n                options.envLoader();\n            } else {\n                loadEnvFiles();\n            }\n        }\n\n        const config = {} as Record<string, unknown>;\n        const errors: string[] = [];\n\n        for (const [key, value] of Object.entries(schema)) {\n            if (isConfigSpec(value)) {\n                config[key] = value.resolve(errors, envSource);\n            } else {\n                config[key] = value;\n            }\n        }\n\n        if (errors.length > 0) {\n            throw new ConfigValidationError(errors);\n        }\n\n        instance = config as InferConfigType<S>;\n        return instance;\n    };\n}\n\nexport function parseEnvFile(filePath: string): Record<string, string> {\n    const content = fs.readFileSync(filePath, \"utf-8\");\n    return dotenv.parse(content);\n}\n","import fs from \"node:fs\";\nimport path from \"node:path\";\n\nimport dotenv from \"dotenv\";\n\nexport function loadEnvFiles({\n    basePath,\n    nodeEnv,\n}: {\n    basePath?: string;\n    nodeEnv?: string;\n} = {}): void {\n    const basePath_ = basePath ?? process.cwd();\n    const nodeEnv_ = nodeEnv ?? process.env.NODE_ENV ?? \"development\";\n\n    const envFiles = [\n        \".env\",\n        \".env.local\",\n        `.env.${nodeEnv_}`,\n        `.env.${nodeEnv_}.local`,\n    ];\n\n    const loadEnvFile = (filePath: string) => {\n        if (fs.existsSync(filePath)) {\n            dotenv.config({ path: filePath });\n        }\n    };\n\n    envFiles.reverse().forEach((file) => {\n        const filePath = path.resolve(basePath_, file);\n        loadEnvFile(filePath);\n    });\n}\n","import type { ConfigSpec } from \"./config-spec\";\n\nexport class EnvSpec<T> implements ConfigSpec<T> {\n    readonly _type = \"env\";\n\n    constructor(\n        private readonly envKey: string,\n        private readonly required: boolean,\n        private readonly defaultValue?: T,\n        private readonly transform?: (value: string) => T\n    ) {}\n\n    resolve(errors: string[], envSource?: Record<string, string>): T | undefined {\n        const rawValue = (envSource ?? process.env)[this.envKey];\n\n        if (!rawValue && this.required) {\n            errors.push(`Missing required env: ${this.envKey}`);\n            return undefined;\n        }\n\n        if (rawValue !== undefined) {\n            try {\n                return this.transform ? this.transform(rawValue) : (rawValue as T);\n            } catch (e) {\n                errors.push(`Failed to transform ${this.envKey}: ${(e as Error).message}`);\n                return undefined;\n            }\n        }\n\n        return this.defaultValue;\n    }\n}\n\nexport function env(key: string): EnvSpec<string> {\n    return new EnvSpec(key, true);\n}\n\nexport function envOptional(key: string, defaultValue?: string): EnvSpec<string | undefined> {\n    return new EnvSpec(key, false, defaultValue);\n}\n\nexport function envNumber(key: string): EnvSpec<number> {\n    return new EnvSpec(key, true, undefined, Number);\n}\n\nexport function envNumberOptional(key: string, defaultValue?: number): EnvSpec<number | undefined> {\n    return new EnvSpec(key, false, defaultValue, (v) => (v ? Number(v) : undefined));\n}\n\nexport function envBoolean(key: string, defaultValue = false): EnvSpec<boolean> {\n    return new EnvSpec(key, false, defaultValue, (v) => v === \"true\" || v === \"1\");\n}\n\nexport function envJson<T>(key: string): EnvSpec<T> {\n    return new EnvSpec(key, true, undefined, JSON.parse);\n}\n\nexport function envJsonOptional<T>(key: string, defaultValue?: T): EnvSpec<T | undefined> {\n    return new EnvSpec(key, false, defaultValue, (v) => (v ? JSON.parse(v) : undefined));\n}\n","import type { ConfigSpec } from \"./config-spec\";\n\nexport class ComputedSpec<T> implements ConfigSpec<T> {\n    readonly _type = \"computed\";\n\n    constructor(private readonly factory: () => T) {}\n\n    resolve(errors: string[], _envSource?: Record<string, string>): T | undefined {\n        try {\n            return this.factory();\n        } catch (e) {\n            errors.push(`Computed value failed: ${(e as Error).message}`);\n            return undefined;\n        }\n    }\n}\n\nexport function computed<T>(factory: () => T): ComputedSpec<T> {\n    return new ComputedSpec(factory);\n}\n"],"mappings":"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","names":["import_node_fs","import_dotenv","fs","dotenv","path","fs","dotenv"]}