zod-conf 1.0.2 → 1.1.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Simon Bobrov
+Copyright (c) 2025-2026 Simon Bobrov
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -7,6 +7,7 @@ Not affiliated with the official Zod library.
 ## Features
 
 - **Type-safe** - Full TypeScript support with Zod schema validation
+- **Multi-source** - Load from env vars, config files (e.g. YAML), or any plain object
 - **Env-first** - Bind schema fields directly to environment variables
 - **Simple API** - Intuitive, Zod-native API that feels familiar
 - **Zero compromise** - All Zod features work - transformations, refinements, and more
@@ -52,13 +53,13 @@ console.log(config);
 const schema = zc.define({
   // string
   apiUrl: zc.env('API_URL').string(),
-  
-  // number  
+
+  // number
   port: zc.env('PORT').number(),
-  
+
   // boolean
   isProduction: zc.env('NODE_ENV').boolean(),
-  
+
   // enum
   logLevel: zc.env('LOG_LEVEL').enum(['debug', 'info', 'warn', 'error']),
 });
@@ -70,10 +71,10 @@ const schema = zc.define({
 const schema = zc.define({
   // with default value
   port: zc.env('PORT').number().default(3000),
-  
+
   // optional field
   apiKey: zc.env('API_KEY').string().optional(),
-  
+
   // nullable field
   proxyUrl: zc.env('PROXY_URL').string().nullable(),
 });
@@ -133,6 +134,45 @@ const config = schema.load({
 });
 ```
 
+### Multiple Configuration Sources
+
+You can load from multiple sources. Loaders are processed left-to-right; later loaders override earlier ones.
+
+```typescript
+import { parse } from 'yaml';
+import { readFileSync } from 'fs';
+
+const yamlConfig = parse(readFileSync('config.yml', 'utf8'));
+
+// yaml values are used as base, env vars override
+const config = schema.load({ values: yamlConfig }, { env: process.env });
+```
+
+You can also layer multiple objects for defaults:
+
+```typescript
+const defaults = { port: 3000, host: 'localhost' };
+const yamlConfig = parse(readFileSync('config.yml', 'utf8'));
+
+const config = schema.load({ values: defaults }, { values: yamlConfig }, { env: process.env });
+```
+
+The `values` loader maps values by property name and passes them directly to Zod — no string coercion is needed since YAML/JSON already preserves types. This also means you can use types that env vars can't represent, like arrays:
+
+```typescript
+import { z } from 'zod';
+
+const schema = zc.define({
+  host: zc.env('HOST').string().default('localhost'),
+  port: zc.env('PORT').number().default(3000),
+  allowedOrigins: z.array(z.string()),
+  servers: z.array(z.object({ host: z.string(), port: z.number() })),
+});
+
+// arrays come from yaml, scalar fields can be overridden by env
+const config = schema.load({ values: yamlConfig }, { env: process.env });
+```
+
 ### Error Handling
 
 The error-handling is similar to Zod's standard behavior:
@@ -160,14 +200,16 @@ All Zod transformations work seamlessly:
 
 ```typescript
 const schema = zc.define({
-  port: zc.env('PORT')
+  port: zc
+    .env('PORT')
     .number()
     .default(3000)
-    .transform(p => Math.max(1024, p)), // Ensure port is at least 1024
-    
-  apiUrl: zc.env('API_URL')
+    .transform((p) => Math.max(1024, p)), // Ensure port is at least 1024
+
+  apiUrl: zc
+    .env('API_URL')
     .string()
-    .transform(url => url.replace(/\/$/, '')), // Remove trailing slash
+    .transform((url) => url.replace(/\/$/, '')), // Remove trailing slash
 });
 ```
 
@@ -198,22 +240,22 @@ Creates a nested object schema.
 - **shape**: An object where values are `zc.env()` or nested `zc.object()` calls
 - **returns**: A Zod object schema
 
-### `schema.load(params)`
+### `schema.load(...loaders)`
 
-Loads and validates configuration.
+Loads and validates configuration from one or more loaders.
 
-- **params.env**: Environment variables object
+- **loaders**: One or more loader objects, processed left-to-right (later overrides earlier)
+  - `{ env: Record<string, string | undefined> }` - Load from environment variables
+  - `{ values: Record<string, unknown> }` - Load from a plain object (e.g. parsed YAML/JSON)
 - **returns**: Validated configuration object
 - **throws**: ZodError if validation fails
 
-### `schema.safeLoad(params)`
+### `schema.safeLoad(...loaders)`
 
-Safely loads configuration without throwing.
+Safely loads configuration without throwing. Same loader arguments as `load()`.
 
-- **params.env**: Environment variables object  
 - **returns**: `{ success: true, data: T }` or `{ success: false, error: ZodError }`
 
 ## License
 
 MIT
-

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { boolean, number, string, enum as zenum } from 'zod';
-export { ZodConfSchema } from './values/define.js';
+export { ZodConfSchema, type Loader, type EnvLoader, type ValuesLoader } from './values/define.js';
 export declare const zc: {
     define: <T extends import("zod").ZodRawShape>(shape: T) => import("./values/define.js").ZodConfSchema<T>;
     env: (key: string) => {

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,IAAI,KAAK,EAAE,MAAM,KAAK,CAAC;AAK7D,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;CAWd,CAAC;AAEF,eAAe,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,IAAI,KAAK,EAAE,MAAM,KAAK,CAAC;AAK7D,OAAO,EAAE,aAAa,EAAE,KAAK,MAAM,EAAE,KAAK,SAAS,EAAE,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEnG,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;CAWd,CAAC;AAEF,eAAe,EAAE,CAAC"}

package/dist/index.js

@@ -4,14 +4,13 @@ import { env } from './values/env.js';
 import { object } from './values/object.js';
 export { ZodConfSchema } from './values/define.js';
 export const zc = {
-    // core values
     define,
     env,
     object,
-    // re-export common zod values for convenience
     string,
     boolean,
     number,
     enum: zenum,
 };
 export default zc;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,IAAI,KAAK,EAAE,MAAM,KAAK,CAAC;AAC7D,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,MAAM,CAAC,MAAM,EAAE,GAAG;IAEhB,MAAM;IACN,GAAG;IACH,MAAM;IAGN,MAAM;IACN,OAAO;IACP,MAAM;IACN,IAAI,EAAE,KAAK;CACZ,CAAC;AAEF,eAAe,EAAE,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,IAAI,KAAK,EAAE,MAAM,KAAK,CAAC;AAC7D,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,OAAO,EAAE,aAAa,EAAkD,MAAM,oBAAoB,CAAC;AAEnG,MAAM,CAAC,MAAM,EAAE,GAAG;IAEhB,MAAM;IACN,GAAG;IACH,MAAM;IAGN,MAAM;IACN,OAAO;IACP,MAAM;IACN,IAAI,EAAE,KAAK;CACZ,CAAC;AAEF,eAAe,EAAE,CAAC"}

package/dist/values/define.d.ts

@@ -1,78 +1,23 @@
 import { ZodObject, type ZodRawShape, type infer as ZodInfer } from 'zod';
 type Env = Record<string, string | undefined>;
-export type LoadParams = {
+export type EnvLoader = {
     env: Env;
+    values?: never | undefined;
 };
+export type ValuesLoader = {
+    values: Record<string, unknown>;
+    env?: never | undefined;
+};
+export type Loader = EnvLoader | ValuesLoader;
 export declare class ZodConfSchema<T extends ZodRawShape> {
     private shape;
     private schema;
     constructor(shape: T, schema: ZodObject<T>);
+    private resolveEnvValue;
     private loadValue;
-    /**
-     * Loads and validates configuration from environment variables.
-     * Throws a ZodError if validation fails.
-     *
-     * @param input - Object containing environment variables
-     * @param input.env - Environment variables as key-value pairs
-     * @returns Validated configuration object
-     * @throws {ZodError} If validation fails
-     *
-     * @example
-     * ```typescript
-     * const config = schema.load({ env: process.env });
-     * ```
-     */
-    load(input: LoadParams): ZodInfer<ZodObject<T>>;
-    /**
-     * Safely loads and validates configuration without throwing.
-     * Returns a result object with either success or error.
-     *
-     * @param input - Object containing environment variables
-     * @param input.env - Environment variables as key-value pairs
-     * @returns SafeParseReturnType with either { success: true, data } or { success: false, error }
-     *
-     * @example
-     * ```typescript
-     * const result = schema.safeLoad({ env: process.env });
-     *
-     * if (result.success) {
-     *   console.log('Config:', result.data);
-     * } else {
-     *   console.error('Errors:', result.error.issues);
-     * }
-     * ```
-     */
-    safeLoad(input: LoadParams): import("zod").ZodSafeParseResult<import("zod/v4/core").$InferObjectOutput<T, {}>>;
+    load(...loaders: [Loader, ...Loader[]]): ZodInfer<ZodObject<T>>;
+    safeLoad(...loaders: [Loader, ...Loader[]]): import("zod").ZodSafeParseResult<import("zod/v4/core").$InferObjectOutput<T, {}>>;
 }
-/**
- * Creates a configuration schema with environment variable bindings.
- *
- * @param shape - An object defining the configuration structure where each field
- *                uses `env()` to bind to environment variables or `object()` for nesting
- * @returns A ZodConfSchema instance with `load()` and `safeLoad()` methods
- *
- * @example
- * ```typescript
- * // define a configuration schema
- * const schema = define({
- *   port: env('PORT').number().default(3000),
- *   host: env('HOST').string().default('localhost'),
- *   database: object({
- *     url: env('DATABASE_URL').string(),
- *     poolSize: env('DB_POOL_SIZE').number().default(10),
- *   }),
- * });
- *
- * // load configuration from environment
- * const config = schema.load({ env: process.env });
- *
- * // safe load without throwing
- * const result = schema.safeLoad({ env: process.env });
- * if (result.success) {
- *   console.log(result.data);
- * }
- * ```
- */
 export declare const define: <T extends ZodRawShape>(shape: T) => ZodConfSchema<T>;
 export {};
 //# sourceMappingURL=define.d.ts.map

package/dist/values/define.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"define.d.ts","sourceRoot":"","sources":["../../src/values/define.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAU,KAAK,WAAW,EAAgB,KAAK,KAAK,IAAI,QAAQ,EAAE,MAAM,KAAK,CAAC;AAGhG,KAAK,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;AAE9C,MAAM,MAAM,UAAU,GAAG;IACvB,GAAG,EAAE,GAAG,CAAC;CACV,CAAC;AAEF,qBAAa,aAAa,CAAC,CAAC,SAAS,WAAW;IAE5C,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,MAAM;gBADN,KAAK,EAAE,CAAC,EACR,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IAG9B,OAAO,CAAC,SAAS;IA6EjB;;;;;;;;;;;;;OAaG;IACH,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAU/C;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,KAAK,EAAE,UAAU;CAK3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,WAAW,EAAE,OAAO,CAAC,KAAG,aAAa,CAAC,CAAC,CAEvE,CAAC"}
+{"version":3,"file":"define.d.ts","sourceRoot":"","sources":["../../src/values/define.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAU,KAAK,WAAW,EAAgB,KAAK,KAAK,IAAI,QAAQ,EAAE,MAAM,KAAK,CAAC;AAGhG,KAAK,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;AAE9C,MAAM,MAAM,SAAS,GAAG;IAAE,GAAG,EAAE,GAAG,CAAC;IAAC,MAAM,CAAC,EAAE,KAAK,GAAG,SAAS,CAAA;CAAE,CAAC;AACjE,MAAM,MAAM,YAAY,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,GAAG,CAAC,EAAE,KAAK,GAAG,SAAS,CAAA;CAAE,CAAC;AACxF,MAAM,MAAM,MAAM,GAAG,SAAS,GAAG,YAAY,CAAC;AAE9C,qBAAa,aAAa,CAAC,CAAC,SAAS,WAAW;IAE5C,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,MAAM;gBADN,KAAK,EAAE,CAAC,EACR,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IAG9B,OAAO,CAAC,eAAe;IA2DvB,OAAO,CAAC,SAAS;IA6DjB,IAAI,CAAC,GAAG,OAAO,EAAE,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IA8B/D,QAAQ,CAAC,GAAG,OAAO,EAAE,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;CAK3C;AA4BD,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,WAAW,EAAE,OAAO,CAAC,KAAG,aAAa,CAAC,CAAC,CAEvE,CAAC"}

package/dist/values/define.js

@@ -7,150 +7,96 @@ export class ZodConfSchema {
         this.shape = shape;
         this.schema = schema;
     }
-    loadValue(shape, env) {
+    resolveEnvValue(schema, env) {
+        let currentSchema = schema;
+        let envKey;
+        let envType;
+        while (currentSchema && !envKey) {
+            const metadata = _envMetadata.get(currentSchema);
+            if (metadata) {
+                envKey = metadata.key;
+                envType = metadata.type;
+                break;
+            }
+            const def = currentSchema._def;
+            if (def?.innerType) {
+                currentSchema = def.innerType;
+            }
+            else if (def?.schema) {
+                currentSchema = def.schema;
+            }
+            else {
+                break;
+            }
+        }
+        if (!envKey) {
+            return undefined;
+        }
+        const value = env[envKey];
+        switch (envType) {
+            case 'string':
+                return value;
+            case 'number':
+                return value ? Number(value) : undefined;
+            case 'boolean':
+                return value === 'true' ? true : value === 'false' ? false : undefined;
+            case 'enum': {
+                const numValue = Number(value);
+                if (value && !isNaN(numValue) && Number.isInteger(numValue)) {
+                    return numValue;
+                }
+                return value;
+            }
+            default:
+                return undefined;
+        }
+    }
+    loadValue(shape, loaders) {
         const input = {};
         for (const key in shape) {
             const schema = shape[key];
             if (schema instanceof ZodObject) {
-                // for nested objects, recurse
-                input[key] = this.loadValue(schema.shape, env);
+                const subLoaders = loaders.map((loader) => {
+                    if ('values' in loader && loader.values) {
+                        const nested = loader.values[key];
+                        return { values: nested && typeof nested === 'object' ? nested : {} };
+                    }
+                    return loader;
+                });
+                input[key] = this.loadValue(schema.shape, subLoaders);
             }
             else {
-                let currentSchema = schema;
-                let envKey;
-                let envType;
-                // traverse wrapped schemas to find metadata
-                while (currentSchema && !envKey) {
-                    const metadata = _envMetadata.get(currentSchema);
-                    if (metadata) {
-                        // found metadata -> use it
-                        envKey = metadata.key;
-                        envType = metadata.type;
-                        break;
-                    }
-                    // check if this is a wrapped schema (default, optional, etc.)
-                    const def = currentSchema._def;
-                    if (def?.innerType) {
-                        // zod wrappers like optional, default, nullable, etc.
-                        currentSchema = def.innerType;
-                    }
-                    else if (def?.schema) {
-                        // zod effects
-                        currentSchema = def.schema;
-                    }
-                    else {
-                        // end of the chain, no metadata found
-                        break;
+                for (const loader of loaders) {
+                    if ('values' in loader && loader.values) {
+                        const value = loader.values[key];
+                        if (value !== undefined) {
+                            input[key] = value;
+                        }
                     }
-                }
-                if (envKey) {
-                    const value = env[envKey];
-                    switch (envType) {
-                        case 'string':
+                    else if ('env' in loader && loader.env) {
+                        const value = this.resolveEnvValue(schema, loader.env);
+                        if (value !== undefined) {
                             input[key] = value;
-                            break;
-                        case 'number':
-                            input[key] = value ? Number(value) : undefined;
-                            break;
-                        case 'boolean':
-                            input[key] = value === 'true' ? true : value === 'false' ? false : undefined;
-                            break;
-                        case 'enum': {
-                            const numValue = Number(value);
-                            // guess if enum is number-based
-                            if (value && !isNaN(numValue) && Number.isInteger(numValue)) {
-                                input[key] = numValue;
-                            }
-                            else {
-                                input[key] = value;
-                            }
-                            break;
                         }
-                        default:
-                            input[key] = undefined;
                     }
                 }
-                else {
-                    input[key] = undefined;
-                }
             }
         }
         return input;
     }
-    /**
-     * Loads and validates configuration from environment variables.
-     * Throws a ZodError if validation fails.
-     *
-     * @param input - Object containing environment variables
-     * @param input.env - Environment variables as key-value pairs
-     * @returns Validated configuration object
-     * @throws {ZodError} If validation fails
-     *
-     * @example
-     * ```typescript
-     * const config = schema.load({ env: process.env });
-     * ```
-     */
-    load(input) {
-        const result = this.safeLoad(input);
+    load(...loaders) {
+        const result = this.safeLoad(...loaders);
         if (!result.success) {
             throw result.error;
         }
         return result.data;
     }
-    /**
-     * Safely loads and validates configuration without throwing.
-     * Returns a result object with either success or error.
-     *
-     * @param input - Object containing environment variables
-     * @param input.env - Environment variables as key-value pairs
-     * @returns SafeParseReturnType with either { success: true, data } or { success: false, error }
-     *
-     * @example
-     * ```typescript
-     * const result = schema.safeLoad({ env: process.env });
-     *
-     * if (result.success) {
-     *   console.log('Config:', result.data);
-     * } else {
-     *   console.error('Errors:', result.error.issues);
-     * }
-     * ```
-     */
-    safeLoad(input) {
-        const value = this.loadValue(this.shape, input.env);
+    safeLoad(...loaders) {
+        const value = this.loadValue(this.shape, loaders);
         return this.schema.safeParse(value);
     }
 }
-/**
- * Creates a configuration schema with environment variable bindings.
- *
- * @param shape - An object defining the configuration structure where each field
- *                uses `env()` to bind to environment variables or `object()` for nesting
- * @returns A ZodConfSchema instance with `load()` and `safeLoad()` methods
- *
- * @example
- * ```typescript
- * // define a configuration schema
- * const schema = define({
- *   port: env('PORT').number().default(3000),
- *   host: env('HOST').string().default('localhost'),
- *   database: object({
- *     url: env('DATABASE_URL').string(),
- *     poolSize: env('DB_POOL_SIZE').number().default(10),
- *   }),
- * });
- *
- * // load configuration from environment
- * const config = schema.load({ env: process.env });
- *
- * // safe load without throwing
- * const result = schema.safeLoad({ env: process.env });
- * if (result.success) {
- *   console.log(result.data);
- * }
- * ```
- */
 export const define = (shape) => {
     return new ZodConfSchema(shape, object(shape));
 };
+//# sourceMappingURL=define.js.map

package/dist/values/define.js.map

@@ -1 +1 @@
-{"version":3,"file":"define.js","sourceRoot":"","sources":["../../src/values/define.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"define.js","sourceRoot":"","sources":["../../src/values/define.ts"],"names":[],"mappings":"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"}

package/dist/values/env-metadata.js

@@ -1,3 +1,2 @@
-// the metadata stores env key and type for each schema
-// we can use it when building the input object
 export const _envMetadata = new WeakMap();
+//# sourceMappingURL=env-metadata.js.map

package/dist/values/env.d.ts

@@ -1,34 +1,5 @@
 import { type util, type ZodEnum } from 'zod';
 import { coerce } from 'zod';
-/**
- * Binds a Zod schema to an environment variable.
- *
- * @param key - The name of the environment variable to bind to
- * @returns An object with methods to create different types of schemas:
- *   - `string()` - Creates a string schema
- *   - `number()` - Creates a number schema (auto-coerced from string)
- *   - `boolean()` - Creates a boolean schema (accepts 'true'/'false')
- *   - `enum(values)` - Creates an enum schema (string array or TypeScript enum)
- *
- * @example
- * ```typescript
- * // string environment variable
- * const apiUrl = env('API_URL').string();
- *
- * // number with default
- * const port = env('PORT').number().default(3000);
- *
- * // boolean
- * const debug = env('DEBUG').boolean().default(false);
- *
- * // enum with string array
- * const logLevel = env('LOG_LEVEL').enum(['info', 'debug', 'error']);
- *
- * // enum with TypeScript enum
- * enum Level { INFO = 'info', DEBUG = 'debug' }
- * const level = env('LOG_LEVEL').enum(Level);
- * ```
- */
 export declare const env: (key: string) => {
     string: () => import("zod").ZodString;
     number: () => coerce.ZodCoercedNumber<unknown>;

package/dist/values/env.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../src/values/env.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,OAAO,EAAgB,MAAM,KAAK,CAAC;AAC5D,OAAO,EAAE,MAAM,EAAyB,MAAM,KAAK,CAAC;AAGpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,GAAG,GAAI,KAAK,MAAM;;;;;eA2CC,CAAC,SAAS,SAAS,MAAM,EAAE,UAAU,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;eAExE,CAAC,6DAA4B,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;;CAS1E,CAAC"}
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../src/values/env.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,OAAO,EAAgB,MAAM,KAAK,CAAC;AAC5D,OAAO,EAAE,MAAM,EAAyB,MAAM,KAAK,CAAC;AAgCpD,eAAO,MAAM,GAAG,GAAI,KAAK,MAAM;;;;;eA2CC,CAAC,SAAS,SAAS,MAAM,EAAE,UAAU,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;eAExE,CAAC,6DAA4B,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;;CAS1E,CAAC"}

package/dist/values/env.js

@@ -1,58 +1,22 @@
 import { coerce, string, enum as zenum } from 'zod';
 import { _envMetadata } from './env-metadata.js';
-/**
- * Binds a Zod schema to an environment variable.
- *
- * @param key - The name of the environment variable to bind to
- * @returns An object with methods to create different types of schemas:
- *   - `string()` - Creates a string schema
- *   - `number()` - Creates a number schema (auto-coerced from string)
- *   - `boolean()` - Creates a boolean schema (accepts 'true'/'false')
- *   - `enum(values)` - Creates an enum schema (string array or TypeScript enum)
- *
- * @example
- * ```typescript
- * // string environment variable
- * const apiUrl = env('API_URL').string();
- *
- * // number with default
- * const port = env('PORT').number().default(3000);
- *
- * // boolean
- * const debug = env('DEBUG').boolean().default(false);
- *
- * // enum with string array
- * const logLevel = env('LOG_LEVEL').enum(['info', 'debug', 'error']);
- *
- * // enum with TypeScript enum
- * enum Level { INFO = 'info', DEBUG = 'debug' }
- * const level = env('LOG_LEVEL').enum(Level);
- * ```
- */
 export const env = (key) => {
     const wrap = (schema, envKey, envType) => {
-        // create a proxy to preserve metadata through method chaining
         const proxied = new Proxy(schema, {
             get(target, prop) {
                 const value = target[prop];
-                // if it's a method, wrap the result to preserve metadata
-                // e.g. .default(), .optional(), etc.
                 if (typeof value === 'function') {
                     return (...args) => {
-                        // call original method
                         const result = value.apply(target, args);
                         if (result && typeof result === 'object' && result._def) {
-                            // if result is a new chained Zod schema, wrap it in a new proxy
                             return wrap(result, envKey, envType);
                         }
                         return result;
                     };
                 }
-                // regular property, just return it
                 return value;
             },
         });
-        // remember metadata for the proxied object
         _envMetadata.set(proxied, { key: envKey, type: envType });
         return proxied;
     };
@@ -61,7 +25,6 @@ export const env = (key) => {
         number: () => wrap(coerce.number(), key, 'number'),
         boolean: () => wrap(coerce.boolean(), key, 'boolean'),
         enum: (() => {
-            // implementation
             function enumMethod(values) {
                 return wrap(zenum(values), key, 'enum');
             }
@@ -69,3 +32,4 @@ export const env = (key) => {
         })(),
     };
 };
+//# sourceMappingURL=env.js.map

package/dist/values/object.d.ts

@@ -1,34 +1,4 @@
 import { type ZodObject } from 'zod';
 import { type ZodRawShape } from 'zod';
-/**
- * Creates a nested object schema for grouping related configuration.
- * This is a convenience wrapper around Zod's object() for consistency.
- *
- * @param shape - An object where values are environment bindings or nested objects
- * @returns A Zod object schema
- *
- * @example
- * ```typescript
- * const schema = define({
- *   // group related configuration
- *   server: object({
- *     host: env('SERVER_HOST').string().default('localhost'),
- *     port: env('SERVER_PORT').number().default(3000),
- *   }),
- *
- *   // nested objects
- *   database: object({
- *     connection: object({
- *       url: env('DATABASE_URL').string(),
- *       timeout: env('DB_TIMEOUT').number().default(5000),
- *     }),
- *     pool: object({
- *       min: env('DB_POOL_MIN').number().default(1),
- *       max: env('DB_POOL_MAX').number().default(10),
- *     }),
- *   }),
- * });
- * ```
- */
 export declare const object: <T extends ZodRawShape>(shape: T) => ZodObject<T>;
 //# sourceMappingURL=object.d.ts.map

package/dist/values/object.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../src/values/object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,KAAK,CAAC;AACrC,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,KAAK,CAAC;AAGvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,WAAW,EAAE,OAAO,CAAC,KAAG,SAAS,CAAC,CAAC,CAEnE,CAAC"}
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../src/values/object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,KAAK,CAAC;AACrC,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,KAAK,CAAC;AAiCvC,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,WAAW,EAAE,OAAO,CAAC,KAAG,SAAS,CAAC,CAAC,CAEnE,CAAC"}

package/dist/values/object.js

@@ -1,34 +1,5 @@
 import { object as zobject } from 'zod';
-/**
- * Creates a nested object schema for grouping related configuration.
- * This is a convenience wrapper around Zod's object() for consistency.
- *
- * @param shape - An object where values are environment bindings or nested objects
- * @returns A Zod object schema
- *
- * @example
- * ```typescript
- * const schema = define({
- *   // group related configuration
- *   server: object({
- *     host: env('SERVER_HOST').string().default('localhost'),
- *     port: env('SERVER_PORT').number().default(3000),
- *   }),
- *
- *   // nested objects
- *   database: object({
- *     connection: object({
- *       url: env('DATABASE_URL').string(),
- *       timeout: env('DB_TIMEOUT').number().default(5000),
- *     }),
- *     pool: object({
- *       min: env('DB_POOL_MIN').number().default(1),
- *       max: env('DB_POOL_MAX').number().default(10),
- *     }),
- *   }),
- * });
- * ```
- */
 export const object = (shape) => {
     return zobject(shape);
 };
+//# sourceMappingURL=object.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-conf",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Type-safe configuration management with Zod schemas and environment variables",
   "license": "MIT",
   "author": "smnbbrv",
@@ -42,9 +42,9 @@
     "clean": "rm -rf dist",
     "prebuild": "npm run clean",
     "prepublishOnly": "npm run build && npm run test && npm run lint",
-    "lint": "run-s lint:*",
-    "lint:eslint": "eslint . --report-unused-disable-directives --max-warnings 0",
-    "lint:tsc": "tsc",
+    "validate": "run-s lint typecheck test",
+    "lint": "eslint . --report-unused-disable-directives --max-warnings 0",
+    "typecheck": "tsc",
     "test": "npx tsx --test --experimental-test-coverage src/index.test.ts",
     "prepare": "husky",
     "semantic-release": "semantic-release"
@@ -57,24 +57,24 @@
     "zod": "^4.0.0"
   },
   "devDependencies": {
-    "@commitlint/cli": "^19.8.1",
-    "@commitlint/config-conventional": "^19.8.1",
+    "@commitlint/cli": "^20.4.1",
+    "@commitlint/config-conventional": "^20.4.1",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
-    "@types/node": "^24.3.1",
-    "@typescript-eslint/eslint-plugin": "^8.38.0",
-    "dotenv": "^17.2.2",
-    "eslint": "^9.32.0",
+    "@types/node": "^25.2.0",
+    "@typescript-eslint/eslint-plugin": "^8.54.0",
+    "dotenv": "^17.2.3",
+    "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-prettier": "^5.5.3",
+    "eslint-plugin-prettier": "^5.5.5",
     "husky": "^9.1.7",
     "npm-run-all": "^4.1.5",
-    "semantic-release": "^24.2.7",
-    "tsx": "^4.20.5",
-    "typescript": "^5.9.2",
-    "typescript-eslint": "^8.38.0",
-    "zod": "^4.0.13"
+    "semantic-release": "^25.0.3",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.54.0",
+    "zod": "^4.3.6"
   }
 }

package/dist/index.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=index.test.d.ts.map

package/dist/index.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../src/index.test.ts"],"names":[],"mappings":""}

package/dist/index.test.js

@@ -1,372 +0,0 @@
-import { strictEqual, deepStrictEqual } from 'node:assert';
-import { test } from 'node:test';
-import zc from './index.js';
-test('zod-conf configuration parsing', async (t) => {
-    await t.test('parses string environment variables', () => {
-        const schema = zc.define({
-            apiUrl: zc.env('API_URL').string(),
-        });
-        const config = schema.load({
-            env: { API_URL: 'https://api.example.com' },
-        });
-        strictEqual(config.apiUrl, 'https://api.example.com');
-    });
-    await t.test('parses number environment variables', () => {
-        const schema = zc.define({
-            port: zc.env('PORT').number(),
-        });
-        const config = schema.load({
-            env: { PORT: '3000' },
-        });
-        strictEqual(config.port, 3000);
-    });
-    await t.test('parses boolean environment variables', () => {
-        const schema = zc.define({
-            debug: zc.env('DEBUG').boolean(),
-            verbose: zc.env('VERBOSE').boolean(),
-        });
-        const config = schema.load({
-            env: { DEBUG: 'true', VERBOSE: 'false' },
-        });
-        strictEqual(config.debug, true);
-        strictEqual(config.verbose, false);
-    });
-    await t.test('parses enum environment variables with string array', () => {
-        const schema = zc.define({
-            logLevel: zc.env('LOG_LEVEL').enum(['info', 'debug', 'error']),
-        });
-        const config = schema.load({
-            env: { LOG_LEVEL: 'debug' },
-        });
-        strictEqual(config.logLevel, 'debug');
-    });
-    await t.test('parses enum environment variables with string enum', () => {
-        let LogLevel;
-        (function (LogLevel) {
-            LogLevel["INFO"] = "info";
-            LogLevel["DEBUG"] = "debug";
-            LogLevel["ERROR"] = "error";
-        })(LogLevel || (LogLevel = {}));
-        const schema = zc.define({
-            logLevel: zc.env('LOG_LEVEL').enum(LogLevel),
-        });
-        const config = schema.load({
-            env: { LOG_LEVEL: 'info' },
-        });
-        strictEqual(config.logLevel, 'info');
-    });
-    await t.test('parses enum environment variables with numeric enum', () => {
-        let Priority;
-        (function (Priority) {
-            Priority[Priority["LOW"] = 1] = "LOW";
-            Priority[Priority["MEDIUM"] = 2] = "MEDIUM";
-            Priority[Priority["HIGH"] = 3] = "HIGH";
-            Priority[Priority["URGENT"] = 4] = "URGENT";
-        })(Priority || (Priority = {}));
-        const schema = zc.define({
-            priority: zc.env('PRIORITY').enum(Priority),
-        });
-        const config = schema.load({
-            env: { PRIORITY: '3' },
-        });
-        strictEqual(config.priority, 3);
-    });
-    await t.test('parses enum environment variables with mixed enum', () => {
-        let Status;
-        (function (Status) {
-            Status[Status["INACTIVE"] = 0] = "INACTIVE";
-            Status[Status["ACTIVE"] = 1] = "ACTIVE";
-            Status["PENDING"] = "pending";
-            Status["ARCHIVED"] = "archived";
-        })(Status || (Status = {}));
-        const schema = zc.define({
-            statusNum: zc.env('STATUS_NUM').enum(Status),
-            statusStr: zc.env('STATUS_STR').enum(Status),
-        });
-        const config = schema.load({
-            env: {
-                STATUS_NUM: '1',
-                STATUS_STR: 'pending',
-            },
-        });
-        strictEqual(config.statusNum, 1);
-        strictEqual(config.statusStr, 'pending');
-    });
-    await t.test('handles default values', () => {
-        const schema = zc.define({
-            host: zc.env('HOST').string().default('localhost'),
-            port: zc.env('PORT').number().default(8080),
-            secure: zc.env('SECURE').boolean().default(false),
-        });
-        const config = schema.load({
-            env: {},
-        });
-        strictEqual(config.host, 'localhost');
-        strictEqual(config.port, 8080);
-        strictEqual(config.secure, false);
-    });
-    await t.test('handles optional values', () => {
-        const schema = zc.define({
-            optionalKey: zc.env('OPTIONAL_KEY').string().optional(),
-        });
-        const config = schema.load({
-            env: {},
-        });
-        strictEqual(config.optionalKey, undefined);
-    });
-    await t.test('handles nested objects', () => {
-        const schema = zc.define({
-            server: zc.object({
-                host: zc.env('SERVER_HOST').string().default('localhost'),
-                port: zc.env('SERVER_PORT').number().default(3000),
-            }),
-            database: zc.object({
-                url: zc.env('DB_URL').string(),
-                pool: zc.object({
-                    min: zc.env('DB_POOL_MIN').number().default(1),
-                    max: zc.env('DB_POOL_MAX').number().default(10),
-                }),
-            }),
-        });
-        const config = schema.load({
-            env: {
-                SERVER_HOST: '0.0.0.0',
-                SERVER_PORT: '4000',
-                DB_URL: 'postgres://localhost/mydb',
-                DB_POOL_MAX: '20',
-            },
-        });
-        deepStrictEqual(config, {
-            server: {
-                host: '0.0.0.0',
-                port: 4000,
-            },
-            database: {
-                url: 'postgres://localhost/mydb',
-                pool: {
-                    min: 1,
-                    max: 20,
-                },
-            },
-        });
-    });
-    await t.test('handles complex configuration', () => {
-        const schema = zc.define({
-            app: zc.object({
-                name: zc.env('APP_NAME').string().default('MyApp'),
-                version: zc.env('APP_VERSION').string().default('1.0.0'),
-                debug: zc.env('DEBUG').boolean().default(false),
-            }),
-            server: zc.object({
-                host: zc.env('HOST').string().default('localhost'),
-                port: zc.env('PORT').number().default(3000),
-                ssl: zc.object({
-                    enabled: zc.env('SSL_ENABLED').boolean().default(false),
-                    cert: zc.env('SSL_CERT').string().optional(),
-                    key: zc.env('SSL_KEY').string().optional(),
-                }),
-            }),
-            features: zc.object({
-                auth: zc.env('FEATURE_AUTH').boolean().default(true),
-                analytics: zc.env('FEATURE_ANALYTICS').boolean().default(false),
-            }),
-        });
-        const config = schema.load({
-            env: {
-                APP_NAME: 'TestApp',
-                DEBUG: 'true',
-                PORT: '5000',
-                SSL_ENABLED: 'true',
-                SSL_CERT: '/path/to/cert.pem',
-                SSL_KEY: '/path/to/key.pem',
-                FEATURE_ANALYTICS: 'true',
-            },
-        });
-        deepStrictEqual(config, {
-            app: {
-                name: 'TestApp',
-                version: '1.0.0',
-                debug: true,
-            },
-            server: {
-                host: 'localhost',
-                port: 5000,
-                ssl: {
-                    enabled: true,
-                    cert: '/path/to/cert.pem',
-                    key: '/path/to/key.pem',
-                },
-            },
-            features: {
-                auth: true,
-                analytics: true,
-            },
-        });
-    });
-    await t.test('safeLoad returns success for valid config', () => {
-        const schema = zc.define({
-            apiKey: zc.env('API_KEY').string(),
-        });
-        const result = schema.safeLoad({
-            env: { API_KEY: 'secret-key' },
-        });
-        strictEqual(result.success, true);
-        if (result.success) {
-            strictEqual(result.data.apiKey, 'secret-key');
-        }
-    });
-    await t.test('safeLoad returns error for invalid config', () => {
-        const schema = zc.define({
-            port: zc.env('PORT').number(),
-        });
-        const result = schema.safeLoad({
-            env: { PORT: 'not-a-number' },
-        });
-        strictEqual(result.success, false);
-        if (!result.success) {
-            strictEqual(result.error.issues.length > 0, true);
-        }
-    });
-    await t.test('handles fields without env metadata', () => {
-        const schema = zc.define({
-            // this field has no env binding, just a plain zod schema
-            plainField: zc.object({
-                nestedPlain: zc.env('SHOULD_WORK').string().default('default'),
-            }),
-        });
-        const config = schema.load({
-            env: {},
-        });
-        deepStrictEqual(config, {
-            plainField: {
-                nestedPlain: 'default',
-            },
-        });
-    });
-    await t.test('load throws error for invalid config', () => {
-        const schema = zc.define({
-            requiredField: zc.env('REQUIRED').string(),
-        });
-        let error;
-        try {
-            schema.load({
-                env: {},
-            });
-        }
-        catch (e) {
-            error = e;
-        }
-        strictEqual(error !== undefined, true);
-        strictEqual(error.issues !== undefined, true);
-    });
-    await t.test('handles enum with non-integer number strings', () => {
-        const schema = zc.define({
-            value: zc.env('VALUE').enum(['a', 'b', 'c']),
-        });
-        const config = schema.load({
-            env: { VALUE: 'a' },
-        });
-        strictEqual(config.value, 'a');
-    });
-    await t.test('handles enum with decimal number string', () => {
-        const schema = zc.define({
-            value: zc.env('DECIMAL_VALUE').enum(['3.14', 'pi', 'e']),
-        });
-        // this should pass the string through since "3.14" is not an integer
-        const config = schema.load({
-            env: { DECIMAL_VALUE: '3.14' },
-        });
-        strictEqual(config.value, '3.14');
-    });
-    await t.test('handles undefined env values for enum', () => {
-        const schema = zc.define({
-            optionalEnum: zc.env('OPT_ENUM').enum(['a', 'b']).optional(),
-        });
-        const config = schema.load({
-            env: {},
-        });
-        strictEqual(config.optionalEnum, undefined);
-    });
-    await t.test('handles schema without innerType or schema properties', () => {
-        // this tests the branch where we break out of the while loop
-        const schema = zc.define({
-            value: zc.env('VALUE').string(),
-        });
-        const config = schema.load({
-            env: { VALUE: 'test' },
-        });
-        strictEqual(config.value, 'test');
-    });
-    await t.test('handles deeply wrapped schemas with transformations', () => {
-        const schema = zc.define({
-            transformed: zc
-                .env('TRANSFORMED')
-                .string()
-                .optional()
-                .default('default')
-                .transform((v) => v.toUpperCase()),
-        });
-        const config = schema.load({
-            env: {},
-        });
-        strictEqual(config.transformed, 'DEFAULT');
-    });
-    await t.test('handles schema with no env metadata at all', async () => {
-        // create a plain zod schema without env bindings
-        const z = await import('zod');
-        const plainSchema = z.object({
-            plainField: z.string().default('plain'),
-        });
-        // mix it with env-bound fields
-        const schema = zc.define({
-            envField: zc.env('ENV_FIELD').string().default('env'),
-            plainNested: plainSchema.shape.plainField,
-        });
-        const config = schema.load({
-            env: {},
-        });
-        strictEqual(config.envField, 'env');
-        // plain fields without env binding will still use their Zod defaults
-        strictEqual(config.plainNested, 'plain');
-    });
-    await t.test('env proxy preserves non-schema properties and methods', async () => {
-        const envSchema = zc.env('TEST').string();
-        // test that metadata is stored in WeakMap (we can't directly access it from here)
-        // but we can verify the schema works correctly
-        const schema = zc.define({
-            test: envSchema,
-        });
-        const config = schema.load({ env: { TEST: 'value' } });
-        strictEqual(config.test, 'value');
-        // call methods that don't return schemas
-        const parsed = envSchema.parse('test');
-        strictEqual(parsed, 'test');
-        // access description property
-        const withDesc = zc.env('DESC').string().describe('A test field');
-        strictEqual(withDesc.description, 'A test field');
-        // test safeParse which returns a result object, not a schema
-        const result = zc.env('SAFE').number().safeParse('123');
-        strictEqual(result.success, true);
-        if (result.success) {
-            strictEqual(result.data, 123);
-        }
-    });
-    await t.test('env proxy handles methods returning non-objects', () => {
-        const schema = zc.env('TEST').string();
-        // test parse method returns the parsed value (not a schema)
-        const parsed = schema.parse('test');
-        strictEqual(parsed, 'test');
-        // test safeParse returns a result object (not a schema)
-        const result = schema.safeParse('value');
-        strictEqual(result.success, true);
-        if (result.success) {
-            strictEqual(result.data, 'value');
-        }
-        // test that optional() and nullable() still work (these are NOT deprecated)
-        const optionalSchema = schema.optional();
-        const nullableSchema = schema.nullable();
-        // verify they can parse undefined/null respectively
-        strictEqual(optionalSchema.parse(undefined), undefined);
-        strictEqual(nullableSchema.parse(null), null);
-    });
-});