zod-conf 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 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
+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

@@ -0,0 +1,217 @@
+# zod-conf
+
+Type-safe configuration management with Zod schemas and environment variables.
+
+## Features
+
+- **Type-safe** - Full TypeScript support with Zod schema validation
+- **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
+- **Lightweight** - Only Zod as peer dependency, no extra bloat
+- **Universal** - Works with process.env, dotenv, or any environment loader
+
+## Installation
+
+```bash
+npm install zod-conf zod
+# or
+yarn add zod-conf zod
+# or
+pnpm add zod-conf zod
+```
+
+## Quick Start
+
+```typescript
+import zc from 'zod-conf';
+
+// define your configuration schema
+const schema = zc.define({
+  port: zc.env('PORT').number().default(3000),
+  host: zc.env('HOST').string().default('localhost'),
+  debug: zc.env('DEBUG').boolean().default(false),
+});
+
+// load configuration from environment
+const config = schema.load({
+  env: process.env,
+});
+
+console.log(config);
+// { port: 3000, host: 'localhost', debug: false }
+```
+
+## Usage
+
+### Basic Types
+
+```typescript
+const schema = zc.define({
+  // string
+  apiUrl: zc.env('API_URL').string(),
+  
+  // number  
+  port: zc.env('PORT').number(),
+  
+  // boolean
+  isProduction: zc.env('NODE_ENV').boolean(),
+  
+  // enum
+  logLevel: zc.env('LOG_LEVEL').enum(['debug', 'info', 'warn', 'error']),
+});
+```
+
+### Defaults and Optional Values
+
+```typescript
+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(),
+});
+```
+
+### Nested Objects
+
+```typescript
+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('DATABASE_URL').string(),
+    pool: zc.object({
+      min: zc.env('DB_POOL_MIN').number().default(1),
+      max: zc.env('DB_POOL_MAX').number().default(10),
+    }),
+  }),
+});
+```
+
+### TypeScript Enums
+
+```typescript
+enum LogLevel {
+  DEBUG = 'debug',
+  INFO = 'info',
+  WARN = 'warn',
+  ERROR = 'error',
+}
+
+const schema = zc.define({
+  logLevel: zc.env('LOG_LEVEL').enum(LogLevel).default(LogLevel.INFO),
+});
+```
+
+### Loading Configuration
+
+```typescript
+// from process.env
+const config = schema.load({ env: process.env });
+
+// from .env file (using dotenv)
+import { config as dotenvConfig } from 'dotenv';
+
+const env = dotenvConfig();
+const config = schema.load({ env: env.parsed });
+
+// from custom source
+const config = schema.load({
+  env: {
+    PORT: '8080',
+    HOST: '0.0.0.0',
+  },
+});
+```
+
+### Error Handling
+
+The error-handling is similar to Zod's standard behavior:
+
+```typescript
+// throws on validation error
+try {
+  const config = schema.load({ env: process.env });
+} catch (error) {
+  console.error('Configuration validation failed:', error);
+}
+
+// safe parsing without throwing
+const result = schema.safeLoad({ env: process.env });
+if (result.success) {
+  console.log('Config:', result.data);
+} else {
+  console.error('Validation errors:', result.error);
+}
+```
+
+### Advanced: Transformations
+
+All Zod transformations work seamlessly:
+
+```typescript
+const schema = zc.define({
+  port: zc.env('PORT')
+    .number()
+    .default(3000)
+    .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
+});
+```
+
+## API Reference
+
+### `zc.define(shape)`
+
+Creates a configuration schema with environment variable bindings.
+
+- **shape**: An object where each value is created using `zc.env()` or `zc.object()`
+- **returns**: A `ZodConfSchema` instance with `load()` and `safeLoad()` methods
+
+### `zc.env(key)`
+
+Binds a schema field to an environment variable.
+
+- **key**: The environment variable name
+- **returns**: An object with methods for different types:
+  - `.string()` - String value
+  - `.number()` - Numeric value (auto-converted)
+  - `.boolean()` - Boolean value (accepts 'true'/'false')
+  - `.enum(values)` - Enum value (string array or TypeScript enum)
+
+### `zc.object(shape)`
+
+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)`
+
+Loads and validates configuration.
+
+- **params.env**: Environment variables object
+- **returns**: Validated configuration object
+- **throws**: ZodError if validation fails
+
+### `schema.safeLoad(params)`
+
+Safely loads configuration without throwing.
+
+- **params.env**: Environment variables object  
+- **returns**: `{ success: true, data: T }` or `{ success: false, error: ZodError }`
+
+## License
+
+MIT
+

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import { boolean, number, string, enum as zenum } from 'zod';
+export declare const zc: {
+    define: <T extends import("zod").ZodRawShape>(shape: T) => import("./values/define.js").ZodConfSchema<T>;
+    env: (key: string) => {
+        string: () => import("zod").ZodString;
+        number: () => import("zod").ZodCoercedNumber<unknown>;
+        boolean: () => import("zod").ZodCoercedBoolean<unknown>;
+        enum: {
+            <const T extends readonly string[]>(values: T): import("zod").ZodEnum<{ [k_1 in T[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never>;
+            <const T extends Readonly<Record<string, string | number>>>(entries: T): import("zod").ZodEnum<T>;
+        };
+    };
+    object: <T extends import("zod").ZodRawShape>(shape: T) => import("zod").ZodObject<T>;
+    string: typeof string;
+    boolean: typeof boolean;
+    number: typeof number;
+    enum: typeof zenum;
+};
+export default zc;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -0,0 +1,16 @@
+import { boolean, number, string, enum as zenum } from 'zod';
+import { define } from './values/define.js';
+import { env } from './values/env.js';
+import { object } from './values/object.js';
+export const zc = {
+    // core values
+    define,
+    env,
+    object,
+    // re-export common zod values for convenience
+    string,
+    boolean,
+    number,
+    enum: zenum,
+};
+export default zc;

package/dist/index.js.map

@@ -0,0 +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,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/index.test.d.ts

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

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

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

package/dist/index.test.js

@@ -0,0 +1,372 @@
+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);
+    });
+});

package/dist/values/define.d.ts

@@ -0,0 +1,78 @@
+import { ZodObject, type ZodRawShape, type infer as ZodInfer } from 'zod';
+type Env = Record<string, string | undefined>;
+export type LoadParams = {
+    env: Env;
+};
+export declare class ZodConfSchema<T extends ZodRawShape> {
+    private shape;
+    private schema;
+    constructor(shape: T, schema: ZodObject<T>);
+    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, {}>>;
+}
+/**
+ * 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

@@ -0,0 +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"}

package/dist/values/define.js

@@ -0,0 +1,156 @@
+import { ZodObject, object } from 'zod';
+import { _envMetadata } from './env-metadata.js';
+export class ZodConfSchema {
+    shape;
+    schema;
+    constructor(shape, schema) {
+        this.shape = shape;
+        this.schema = schema;
+    }
+    loadValue(shape, env) {
+        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);
+            }
+            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;
+                    }
+                }
+                if (envKey) {
+                    const value = env[envKey];
+                    switch (envType) {
+                        case 'string':
+                            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);
+        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);
+        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));
+};

package/dist/values/define.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define.js","sourceRoot":"","sources":["../../src/values/define.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,EAA0D,MAAM,KAAK,CAAC;AAChG,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAQjD,MAAM,OAAO,aAAa;IAEd;IACA;IAFV,YACU,KAAQ,EACR,MAAoB;QADpB,UAAK,GAAL,KAAK,CAAG;QACR,WAAM,GAAN,MAAM,CAAc;IAC3B,CAAC;IAEI,SAAS,CAAC,KAAkB,EAAE,GAAQ;QAC5C,MAAM,KAAK,GAAQ,EAAE,CAAC;QAEtB,KAAK,MAAM,GAAG,IAAI,KAAK,EAAE,CAAC;YACxB,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;YAE1B,IAAI,MAAM,YAAY,SAAS,EAAE,CAAC;gBAEhC,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YACjD,CAAC;iBAAM,CAAC;gBACN,IAAI,aAAa,GAAG,MAAiB,CAAC;gBACtC,IAAI,MAA0B,CAAC;gBAC/B,IAAI,OAA2B,CAAC;gBAGhC,OAAO,aAAa,IAAI,CAAC,MAAM,EAAE,CAAC;oBAChC,MAAM,QAAQ,GAAG,YAAY,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;oBAEjD,IAAI,QAAQ,EAAE,CAAC;wBAEb,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC;wBACtB,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC;wBACxB,MAAM;oBACR,CAAC;oBAGD,MAAM,GAAG,GAAI,aAAqB,CAAC,IAAI,CAAC;oBAExC,IAAI,GAAG,EAAE,SAAS,EAAE,CAAC;wBAEnB,aAAa,GAAG,GAAG,CAAC,SAAS,CAAC;oBAChC,CAAC;yBAAM,IAAI,GAAG,EAAE,MAAM,EAAE,CAAC;wBAEvB,aAAa,GAAG,GAAG,CAAC,MAAM,CAAC;oBAC7B,CAAC;yBAAM,CAAC;wBAEN,MAAM;oBACR,CAAC;gBACH,CAAC;gBAED,IAAI,MAAM,EAAE,CAAC;oBACX,MAAM,KAAK,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC;oBAE1B,QAAQ,OAAO,EAAE,CAAC;wBAChB,KAAK,QAAQ;4BACX,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;4BACnB,MAAM;wBACR,KAAK,QAAQ;4BACX,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;4BAC/C,MAAM;wBACR,KAAK,SAAS;4BACZ,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;4BAC7E,MAAM;wBACR,KAAK,MAAM,CAAC,CAAC,CAAC;4BACZ,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;4BAG/B,IAAI,KAAK,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC;gCAC5D,KAAK,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC;4BACxB,CAAC;iCAAM,CAAC;gCACN,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;4BACrB,CAAC;4BAED,MAAM;wBACR,CAAC;wBACD;4BACE,KAAK,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;oBAC3B,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,KAAK,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;gBACzB,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAgBD,IAAI,CAAC,KAAiB;QACpB,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAEpC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACpB,MAAM,MAAM,CAAC,KAAK,CAAC;QACrB,CAAC;QAED,OAAO,MAAM,CAAC,IAAI,CAAC;IACrB,CAAC;IAqBD,QAAQ,CAAC,KAAiB;QACxB,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;QAEpD,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;CACF;AA+BD,MAAM,CAAC,MAAM,MAAM,GAAG,CAAwB,KAAQ,EAAoB,EAAE;IAC1E,OAAO,IAAI,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;AACjD,CAAC,CAAC"}

package/dist/values/env-metadata.d.ts

@@ -0,0 +1,6 @@
+import { type ZodType } from 'zod';
+export declare const _envMetadata: WeakMap<ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>, {
+    key: string;
+    type: string;
+}>;
+//# sourceMappingURL=env-metadata.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"env-metadata.d.ts","sourceRoot":"","sources":["../../src/values/env-metadata.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,KAAK,CAAC;AAGnC,eAAO,MAAM,YAAY;SAA+B,MAAM;UAAQ,MAAM;EAAK,CAAC"}

package/dist/values/env-metadata.js

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

package/dist/values/env-metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-metadata.js","sourceRoot":"","sources":["../../src/values/env-metadata.ts"],"names":[],"mappings":"AAKA,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,OAAO,EAA0C,CAAC"}

package/dist/values/env.d.ts

@@ -0,0 +1,41 @@
+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>;
+    boolean: () => coerce.ZodCoercedBoolean<unknown>;
+    enum: {
+        <const T extends readonly string[]>(values: T): ZodEnum<util.ToEnum<T[number]>>;
+        <const T extends Readonly<Record<string, string | number>>>(entries: T): ZodEnum<T>;
+    };
+};
+//# sourceMappingURL=env.d.ts.map

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

@@ -0,0 +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"}

package/dist/values/env.js

@@ -0,0 +1,71 @@
+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;
+    };
+    return {
+        string: () => wrap(string(), key, 'string'),
+        number: () => wrap(coerce.number(), key, 'number'),
+        boolean: () => wrap(coerce.boolean(), key, 'boolean'),
+        enum: (() => {
+            // implementation
+            function enumMethod(values) {
+                return wrap(zenum(values), key, 'enum');
+            }
+            return enumMethod;
+        })(),
+    };
+};

package/dist/values/env.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.js","sourceRoot":"","sources":["../../src/values/env.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,IAAI,KAAK,EAAE,MAAM,KAAK,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AA+BjD,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,GAAW,EAAE,EAAE;IACjC,MAAM,IAAI,GAAG,CAAoB,MAAS,EAAE,MAAc,EAAE,OAAe,EAAK,EAAE;QAEhF,MAAM,OAAO,GAAG,IAAI,KAAK,CAAC,MAAM,EAAE;YAChC,GAAG,CAAC,MAAM,EAAE,IAAI;gBACd,MAAM,KAAK,GAAI,MAAc,CAAC,IAAI,CAAC,CAAC;gBAIpC,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE,CAAC;oBAChC,OAAO,CAAC,GAAG,IAAW,EAAE,EAAE;wBAExB,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;wBAEzC,IAAI,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;4BAExD,OAAO,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;wBACvC,CAAC;wBAED,OAAO,MAAM,CAAC;oBAChB,CAAC,CAAC;gBACJ,CAAC;gBAGD,OAAO,KAAK,CAAC;YACf,CAAC;SACF,CAAM,CAAC;QAGR,YAAY,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;QAE1D,OAAO,OAAO,CAAC;IACjB,CAAC,CAAC;IAEF,OAAO;QACL,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,GAAG,EAAE,QAAQ,CAAC;QAC3C,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,GAAG,EAAE,QAAQ,CAAC;QAClD,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,CAAC;QACrD,IAAI,EAAE,CAAC,GAAG,EAAE;YASV,SAAS,UAAU,CAAC,MAAW;gBAC7B,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC;YAC1C,CAAC;YAED,OAAO,UAAU,CAAC;QACpB,CAAC,CAAC,EAAE;KACL,CAAC;AACJ,CAAC,CAAC"}

package/dist/values/object.d.ts

@@ -0,0 +1,34 @@
+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

@@ -0,0 +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"}

package/dist/values/object.js

@@ -0,0 +1,34 @@
+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);
+};

package/dist/values/object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.js","sourceRoot":"","sources":["../../src/values/object.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,IAAI,OAAO,EAAE,MAAM,KAAK,CAAC;AAgCxC,MAAM,CAAC,MAAM,MAAM,GAAG,CAAwB,KAAQ,EAAgB,EAAE;IACtE,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC;AACxB,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "zod-conf",
+  "version": "1.0.0",
+  "description": "Type-safe configuration management with Zod schemas and environment variables",
+  "license": "MIT",
+  "author": "smnbbrv",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "zod",
+    "config",
+    "configuration",
+    "env",
+    "environment",
+    "schema",
+    "validation",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/smnbbrv/zod-conf.git"
+  },
+  "bugs": {
+    "url": "https://github.com/smnbbrv/zod-conf/issues"
+  },
+  "homepage": "https://github.com/smnbbrv/zod-conf#readme",
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "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",
+    "test": "npx tsx --test --experimental-test-coverage src/index.test.ts",
+    "prepare": "husky",
+    "semantic-release": "semantic-release"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "peerDependencies": {
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19.8.1",
+    "@commitlint/config-conventional": "^19.8.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",
+    "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",
+    "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"
+  }
+}