@geekmidas/envkit 0.0.2 → 0.0.4

package/dist/EnvironmentParser-Bo2CCl_K.cjs

@@ -0,0 +1,178 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const lodash_get = require_chunk.__toESM(require("lodash.get"));
+const lodash_set = require_chunk.__toESM(require("lodash.set"));
+const zod_v4 = require_chunk.__toESM(require("zod/v4"));
+
+//#region src/EnvironmentParser.ts
+/**
+* Parses and validates configuration objects against Zod schemas.
+* Handles nested configurations and aggregates validation errors.
+* 
+* @template TResponse - The shape of the configuration object
+*/
+var ConfigParser = class {
+	/**
+	* Creates a new ConfigParser instance.
+	* 
+	* @param config - The configuration object to parse
+	*/
+	constructor(config) {
+		this.config = config;
+	}
+	/**
+	* Parses the config object and validates it against the Zod schemas
+	* @returns The parsed config object
+	*/
+	parse() {
+		const errors = [];
+		const parseDeep = (config, path = []) => {
+			const result = {};
+			if (config && typeof config !== "object") return config;
+			for (const key in config) {
+				const schema = config[key];
+				const currentPath = [...path, key];
+				if (schema instanceof zod_v4.z.ZodType) {
+					const parsed = schema.safeParse(void 0);
+					if (parsed.success) (0, lodash_set.default)(result, key, parsed.data);
+					else errors.push(...parsed.error.issues.map((issue) => ({
+						...issue,
+						path: [...currentPath, ...issue.path]
+					})));
+				} else if (schema) (0, lodash_set.default)(result, key, parseDeep(schema, currentPath));
+			}
+			return result;
+		};
+		const parsedConfig = parseDeep(this.config);
+		if (errors.length > 0) throw new zod_v4.z.ZodError(errors);
+		return parsedConfig;
+	}
+};
+/**
+* Parses environment variables with type-safe validation using Zod schemas.
+* Provides a fluent API for defining environment variable schemas with automatic
+* error context enrichment.
+* 
+* @template T - The type of the configuration object (typically process.env)
+* 
+* @example
+* ```typescript
+* const config = new EnvironmentParser(process.env)
+*   .create((get) => ({
+*     port: get('PORT').string().transform(Number).default(3000),
+*     database: {
+*       url: get('DATABASE_URL').string().url()
+*     }
+*   }))
+*   .parse();
+* ```
+*/
+var EnvironmentParser = class {
+	/**
+	* Creates a new EnvironmentParser instance.
+	* 
+	* @param config - The configuration object to parse (typically process.env)
+	*/
+	constructor(config) {
+		this.config = config;
+	}
+	/**
+	* Wraps a Zod schema to intercept parse/safeParse calls and enrich error messages
+	* with environment variable context.
+	* 
+	* @param schema - The Zod schema to wrap
+	* @param name - The environment variable name for error context
+	* @returns A wrapped Zod schema with enhanced error reporting
+	*/
+	wrapSchema = (schema, name) => {
+		return new Proxy(schema, { get: (target, prop) => {
+			if (prop === "parse") return () => {
+				const value = (0, lodash_get.default)(this.config, name);
+				try {
+					return target.parse(value);
+				} catch (error) {
+					if (error instanceof zod_v4.z.ZodError) {
+						const modifiedIssues = error.issues.map((issue) => ({
+							...issue,
+							message: `Environment variable "${name}": ${issue.message}`,
+							path: [name, ...issue.path]
+						}));
+						throw new zod_v4.z.ZodError(modifiedIssues);
+					}
+					throw error;
+				}
+			};
+			if (prop === "safeParse") return () => {
+				const value = (0, lodash_get.default)(this.config, name);
+				const result = target.safeParse(value);
+				if (!result.success) {
+					const modifiedIssues = result.error.issues.map((issue) => ({
+						...issue,
+						message: `Environment variable "${name}": ${issue.message}`,
+						path: [name, ...issue.path]
+					}));
+					return {
+						success: false,
+						error: new zod_v4.z.ZodError(modifiedIssues)
+					};
+				}
+				return result;
+			};
+			const originalProp = target[prop];
+			if (typeof originalProp === "function") return (...args) => {
+				const result = originalProp.apply(target, args);
+				if (result && typeof result === "object" && "parse" in result) return this.wrapSchema(result, name);
+				return result;
+			};
+			return originalProp;
+		} });
+	};
+	/**
+	* Creates a proxied version of the Zod object that wraps all schema creators
+	* to provide enhanced error messages with environment variable context.
+	* 
+	* @param name - The environment variable name
+	* @returns A proxied Zod object with wrapped schema creators
+	*/
+	getZodGetter = (name) => {
+		return new Proxy({ ...zod_v4.z }, { get: (target, prop) => {
+			const value = target[prop];
+			if (typeof value === "function") return (...args) => {
+				const schema = value(...args);
+				return this.wrapSchema(schema, name);
+			};
+			if (value && typeof value === "object") return new Proxy(value, { get: (nestedTarget, nestedProp) => {
+				const nestedValue = nestedTarget[nestedProp];
+				if (typeof nestedValue === "function") return (...args) => {
+					const schema = nestedValue(...args);
+					return this.wrapSchema(schema, name);
+				};
+				return nestedValue;
+			} });
+			return value;
+		} });
+	};
+	/**
+	* Creates a new ConfigParser object that can be used to parse the config object
+	*
+	* @param builder - A function that takes a getter function and returns a config object
+	* @returns A ConfigParser object that can be used to parse the config object
+	*/
+	create(builder) {
+		const config = builder(this.getZodGetter);
+		return new ConfigParser(config);
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'ConfigParser', {
+  enumerable: true,
+  get: function () {
+    return ConfigParser;
+  }
+});
+Object.defineProperty(exports, 'EnvironmentParser', {
+  enumerable: true,
+  get: function () {
+    return EnvironmentParser;
+  }
+});

package/dist/EnvironmentParser-jKrGMBhP.mjs

@@ -0,0 +1,166 @@
+import get from "lodash.get";
+import set from "lodash.set";
+import { z } from "zod/v4";
+
+//#region src/EnvironmentParser.ts
+/**
+* Parses and validates configuration objects against Zod schemas.
+* Handles nested configurations and aggregates validation errors.
+* 
+* @template TResponse - The shape of the configuration object
+*/
+var ConfigParser = class {
+	/**
+	* Creates a new ConfigParser instance.
+	* 
+	* @param config - The configuration object to parse
+	*/
+	constructor(config) {
+		this.config = config;
+	}
+	/**
+	* Parses the config object and validates it against the Zod schemas
+	* @returns The parsed config object
+	*/
+	parse() {
+		const errors = [];
+		const parseDeep = (config, path = []) => {
+			const result = {};
+			if (config && typeof config !== "object") return config;
+			for (const key in config) {
+				const schema = config[key];
+				const currentPath = [...path, key];
+				if (schema instanceof z.ZodType) {
+					const parsed = schema.safeParse(void 0);
+					if (parsed.success) set(result, key, parsed.data);
+					else errors.push(...parsed.error.issues.map((issue) => ({
+						...issue,
+						path: [...currentPath, ...issue.path]
+					})));
+				} else if (schema) set(result, key, parseDeep(schema, currentPath));
+			}
+			return result;
+		};
+		const parsedConfig = parseDeep(this.config);
+		if (errors.length > 0) throw new z.ZodError(errors);
+		return parsedConfig;
+	}
+};
+/**
+* Parses environment variables with type-safe validation using Zod schemas.
+* Provides a fluent API for defining environment variable schemas with automatic
+* error context enrichment.
+* 
+* @template T - The type of the configuration object (typically process.env)
+* 
+* @example
+* ```typescript
+* const config = new EnvironmentParser(process.env)
+*   .create((get) => ({
+*     port: get('PORT').string().transform(Number).default(3000),
+*     database: {
+*       url: get('DATABASE_URL').string().url()
+*     }
+*   }))
+*   .parse();
+* ```
+*/
+var EnvironmentParser = class {
+	/**
+	* Creates a new EnvironmentParser instance.
+	* 
+	* @param config - The configuration object to parse (typically process.env)
+	*/
+	constructor(config) {
+		this.config = config;
+	}
+	/**
+	* Wraps a Zod schema to intercept parse/safeParse calls and enrich error messages
+	* with environment variable context.
+	* 
+	* @param schema - The Zod schema to wrap
+	* @param name - The environment variable name for error context
+	* @returns A wrapped Zod schema with enhanced error reporting
+	*/
+	wrapSchema = (schema, name) => {
+		return new Proxy(schema, { get: (target, prop) => {
+			if (prop === "parse") return () => {
+				const value = get(this.config, name);
+				try {
+					return target.parse(value);
+				} catch (error) {
+					if (error instanceof z.ZodError) {
+						const modifiedIssues = error.issues.map((issue) => ({
+							...issue,
+							message: `Environment variable "${name}": ${issue.message}`,
+							path: [name, ...issue.path]
+						}));
+						throw new z.ZodError(modifiedIssues);
+					}
+					throw error;
+				}
+			};
+			if (prop === "safeParse") return () => {
+				const value = get(this.config, name);
+				const result = target.safeParse(value);
+				if (!result.success) {
+					const modifiedIssues = result.error.issues.map((issue) => ({
+						...issue,
+						message: `Environment variable "${name}": ${issue.message}`,
+						path: [name, ...issue.path]
+					}));
+					return {
+						success: false,
+						error: new z.ZodError(modifiedIssues)
+					};
+				}
+				return result;
+			};
+			const originalProp = target[prop];
+			if (typeof originalProp === "function") return (...args) => {
+				const result = originalProp.apply(target, args);
+				if (result && typeof result === "object" && "parse" in result) return this.wrapSchema(result, name);
+				return result;
+			};
+			return originalProp;
+		} });
+	};
+	/**
+	* Creates a proxied version of the Zod object that wraps all schema creators
+	* to provide enhanced error messages with environment variable context.
+	* 
+	* @param name - The environment variable name
+	* @returns A proxied Zod object with wrapped schema creators
+	*/
+	getZodGetter = (name) => {
+		return new Proxy({ ...z }, { get: (target, prop) => {
+			const value = target[prop];
+			if (typeof value === "function") return (...args) => {
+				const schema = value(...args);
+				return this.wrapSchema(schema, name);
+			};
+			if (value && typeof value === "object") return new Proxy(value, { get: (nestedTarget, nestedProp) => {
+				const nestedValue = nestedTarget[nestedProp];
+				if (typeof nestedValue === "function") return (...args) => {
+					const schema = nestedValue(...args);
+					return this.wrapSchema(schema, name);
+				};
+				return nestedValue;
+			} });
+			return value;
+		} });
+	};
+	/**
+	* Creates a new ConfigParser object that can be used to parse the config object
+	*
+	* @param builder - A function that takes a getter function and returns a config object
+	* @returns A ConfigParser object that can be used to parse the config object
+	*/
+	create(builder) {
+		const config = builder(this.getZodGetter);
+		return new ConfigParser(config);
+	}
+};
+
+//#endregion
+export { ConfigParser, EnvironmentParser };

package/dist/EnvironmentParser.cjs

@@ -1,4 +1,4 @@
-const require_EnvironmentParser = require('./EnvironmentParser-nZnZXM_Y.cjs');
+const require_EnvironmentParser = require('./EnvironmentParser-Bo2CCl_K.cjs');
 
 exports.ConfigParser = require_EnvironmentParser.ConfigParser;
 exports.EnvironmentParser = require_EnvironmentParser.EnvironmentParser;

package/dist/EnvironmentParser.mjs

@@ -1,3 +1,3 @@
-import { ConfigParser, EnvironmentParser } from "./EnvironmentParser-Dd6TbwJC.mjs";
+import { ConfigParser, EnvironmentParser } from "./EnvironmentParser-jKrGMBhP.mjs";
 
 export { ConfigParser, EnvironmentParser };

package/dist/__tests__/ConfigParser.spec.cjs

@@ -0,0 +1,323 @@
+const require_chunk = require('../chunk-CUT6urMc.cjs');
+const require_EnvironmentParser = require('../EnvironmentParser-Bo2CCl_K.cjs');
+const zod_v4 = require_chunk.__toESM(require("zod/v4"));
+const vitest = require_chunk.__toESM(require("vitest"));
+
+//#region src/__tests__/ConfigParser.spec.ts
+(0, vitest.describe)("ConfigParser", () => {
+	(0, vitest.describe)("Basic functionality", () => {
+		(0, vitest.it)("should parse simple Zod schemas", () => {
+			const config = {
+				name: zod_v4.z.string().default("Test"),
+				age: zod_v4.z.number().default(25),
+				active: zod_v4.z.boolean().default(true)
+			};
+			const parser = new require_EnvironmentParser.ConfigParser(config);
+			const result = parser.parse();
+			(0, vitest.expect)(result).toEqual({
+				name: "Test",
+				age: 25,
+				active: true
+			});
+		});
+		(0, vitest.it)("should handle optional values", () => {
+			const config = {
+				required: zod_v4.z.string().default("value"),
+				optional: zod_v4.z.string().optional()
+			};
+			const parser = new require_EnvironmentParser.ConfigParser(config);
+			const result = parser.parse();
+			(0, vitest.expect)(result).toEqual({
+				required: "value",
+				optional: void 0
+			});
+		});
+		(0, vitest.it)("should validate and use provided default values", () => {
+			const config = {
+				port: zod_v4.z.number().default(3e3),
+				host: zod_v4.z.string().default("localhost"),
+				debug: zod_v4.z.boolean().default(false)
+			};
+			const parser = new require_EnvironmentParser.ConfigParser(config);
+			const result = parser.parse();
+			(0, vitest.expect)(result).toEqual({
+				port: 3e3,
+				host: "localhost",
+				debug: false
+			});
+		});
+	});
+	(0, vitest.describe)("Nested objects", () => {
+		(0, vitest.it)("should parse nested configuration objects", () => {
+			const config = {
+				database: {
+					host: zod_v4.z.string().default("localhost"),
+					port: zod_v4.z.number().default(5432),
+					ssl: zod_v4.z.boolean().default(false)
+				},
+				api: {
+					key: zod_v4.z.string().default("default-key"),
+					timeout: zod_v4.z.number().default(5e3)
+				}
+			};
+			const parser = new require_EnvironmentParser.ConfigParser(config);
+			const result = parser.parse();
+			(0, vitest.expect)(result).toEqual({
+				database: {
+					host: "localhost",
+					port: 5432,
+					ssl: false
+				},
+				api: {
+					key: "default-key",
+					timeout: 5e3
+				}
+			});
+		});
+		(0, vitest.it)("should handle deeply nested objects", () => {
+			const config = { app: {
+				name: zod_v4.z.string().default("MyApp"),
+				version: zod_v4.z.string().default("1.0.0"),
+				features: {
+					auth: {
+						enabled: zod_v4.z.boolean().default(true),
+						provider: zod_v4.z.string().default("local")
+					},
+					cache: {
+						enabled: zod_v4.z.boolean().default(false),
+						ttl: zod_v4.z.number().default(3600)
+					}
+				}
+			} };
+			const parser = new require_EnvironmentParser.ConfigParser(config);
+			const result = parser.parse();
+			(0, vitest.expect)(result).toEqual({ app: {
+				name: "MyApp",
+				version: "1.0.0",
+				features: {
+					auth: {
+						enabled: true,
+						provider: "local"
+					},
+					cache: {
+						enabled: false,
+						ttl: 3600
+					}
+				}
+			} });
+		});
+		(0, vitest.it)("should handle mixed nested and flat configuration", () => {
+			const config = {
+				appName: zod_v4.z.string().default("Test App"),
+				database: {
+					url: zod_v4.z.string().default("postgres://localhost/test"),
+					poolSize: zod_v4.z.number().default(10)
+				},
+				port: zod_v4.z.number().default(3e3),
+				features: { logging: {
+					level: zod_v4.z.string().default("info"),
+					pretty: zod_v4.z.boolean().default(true)
+				} }
+			};
+			const parser = new require_EnvironmentParser.ConfigParser(config);
+			const result = parser.parse();
+			(0, vitest.expect)(result).toEqual({
+				appName: "Test App",
+				database: {
+					url: "postgres://localhost/test",
+					poolSize: 10
+				},
+				port: 3e3,
+				features: { logging: {
+					level: "info",
+					pretty: true
+				} }
+			});
+		});
+	});
+	(0, vitest.describe)("Error handling", () => {
+		(0, vitest.it)("should throw ZodError for schemas without defaults", () => {
+			const config = {
+				required: zod_v4.z.string(),
+				alsoRequired: zod_v4.z.number()
+			};
+			const parser = new require_EnvironmentParser.ConfigParser(config);
+			(0, vitest.expect)(() => parser.parse()).toThrow(zod_v4.z.ZodError);
+		});
+		(0, vitest.it)("should collect multiple validation errors", () => {
+			const config = {
+				field1: zod_v4.z.string(),
+				field2: zod_v4.z.number(),
+				field3: zod_v4.z.boolean()
+			};
+			const parser = new require_EnvironmentParser.ConfigParser(config);
+			try {
+				parser.parse();
+				(0, vitest.expect)(true).toBe(false);
+			} catch (error) {
+				(0, vitest.expect)(error).toBeInstanceOf(zod_v4.z.ZodError);
+				const zodError = error;
+				(0, vitest.expect)(zodError.issues).toHaveLength(3);
+			}
+		});
+		(0, vitest.it)("should include correct paths in nested validation errors", () => {
+			const config = {
+				database: {
+					host: zod_v4.z.string(),
+					port: zod_v4.z.number()
+				},
+				api: { key: zod_v4.z.string() }
+			};
+			const parser = new require_EnvironmentParser.ConfigParser(config);
+			try {
+				parser.parse();
+				(0, vitest.expect)(true).toBe(false);
+			} catch (error) {
+				(0, vitest.expect)(error).toBeInstanceOf(zod_v4.z.ZodError);
+				const zodError = error;
+				const paths = zodError.issues.map((err) => err.path.join("."));
+				(0, vitest.expect)(paths).toContain("database.host");
+				(0, vitest.expect)(paths).toContain("database.port");
+				(0, vitest.expect)(paths).toContain("api.key");
+			}
+		});
+		(0, vitest.it)("should use default values that pass validation", () => {
+			const config = {
+				port: zod_v4.z.number().min(1e3).max(65535).default(3e3),
+				email: zod_v4.z.string().email().default("admin@example.com")
+			};
+			const parser = new require_EnvironmentParser.ConfigParser(config);
+			const result = parser.parse();
+			(0, vitest.expect)(result).toEqual({
+				port: 3e3,
+				email: "admin@example.com"
+			});
+		});
+	});
+	(0, vitest.describe)("Type safety", () => {
+		(0, vitest.it)("should infer correct types for simple configuration", () => {
+			const config = {
+				name: zod_v4.z.string().default("test"),
+				count: zod_v4.z.number().default(42),
+				enabled: zod_v4.z.boolean().default(true)
+			};
+			const parser = new require_EnvironmentParser.ConfigParser(config);
+			const result = parser.parse();
+			const _typeCheck = true;
+			const _typeCheck2 = true;
+			(0, vitest.expect)(_typeCheck).toBe(true);
+			(0, vitest.expect)(_typeCheck2).toBe(true);
+		});
+		(0, vitest.it)("should infer correct types for nested configuration", () => {
+			const config = {
+				database: {
+					host: zod_v4.z.string().default("localhost"),
+					port: zod_v4.z.number().default(5432)
+				},
+				features: { auth: zod_v4.z.boolean().default(true) }
+			};
+			const parser = new require_EnvironmentParser.ConfigParser(config);
+			const result = parser.parse();
+			const _typeCheck = true;
+			const _typeCheck2 = true;
+			(0, vitest.expect)(_typeCheck).toBe(true);
+			(0, vitest.expect)(_typeCheck2).toBe(true);
+		});
+		(0, vitest.it)("should handle optional types correctly", () => {
+			const config = {
+				required: zod_v4.z.string().default("value"),
+				optional: zod_v4.z.string().optional(),
+				nullable: zod_v4.z.string().nullable().default(null)
+			};
+			const parser = new require_EnvironmentParser.ConfigParser(config);
+			const result = parser.parse();
+		});
+	});
+	(0, vitest.describe)("Complex schemas", () => {
+		(0, vitest.it)("should handle enum schemas", () => {
+			const config = {
+				environment: zod_v4.z.enum([
+					"development",
+					"staging",
+					"production"
+				]).default("development"),
+				logLevel: zod_v4.z.enum([
+					"debug",
+					"info",
+					"warn",
+					"error"
+				]).default("info")
+			};
+			const parser = new require_EnvironmentParser.ConfigParser(config);
+			const result = parser.parse();
+			(0, vitest.expect)(result).toEqual({
+				environment: "development",
+				logLevel: "info"
+			});
+		});
+		(0, vitest.it)("should handle union schemas", () => {
+			const config = {
+				port: zod_v4.z.union([zod_v4.z.string(), zod_v4.z.number()]).default(3e3),
+				timeout: zod_v4.z.union([zod_v4.z.number(), zod_v4.z.null()]).default(null)
+			};
+			const parser = new require_EnvironmentParser.ConfigParser(config);
+			const result = parser.parse();
+			(0, vitest.expect)(result).toEqual({
+				port: 3e3,
+				timeout: null
+			});
+		});
+		(0, vitest.it)("should handle array schemas", () => {
+			const config = {
+				tags: zod_v4.z.array(zod_v4.z.string()).default(["tag1", "tag2"]),
+				ports: zod_v4.z.array(zod_v4.z.number()).default([3e3, 3001])
+			};
+			const parser = new require_EnvironmentParser.ConfigParser(config);
+			const result = parser.parse();
+			(0, vitest.expect)(result).toEqual({
+				tags: ["tag1", "tag2"],
+				ports: [3e3, 3001]
+			});
+		});
+		(0, vitest.it)("should handle record schemas", () => {
+			const config = {
+				metadata: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.string()).default({
+					key1: "value1",
+					key2: "value2"
+				}),
+				counters: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.number()).default({
+					count1: 1,
+					count2: 2
+				})
+			};
+			const parser = new require_EnvironmentParser.ConfigParser(config);
+			const result = parser.parse();
+			(0, vitest.expect)(result).toEqual({
+				metadata: {
+					key1: "value1",
+					key2: "value2"
+				},
+				counters: {
+					count1: 1,
+					count2: 2
+				}
+			});
+		});
+		(0, vitest.it)("should handle transformed schemas", () => {
+			const config = {
+				portString: zod_v4.z.string().transform(Number).default(8080),
+				booleanString: zod_v4.z.string().transform((v) => v === "true").default(false),
+				jsonString: zod_v4.z.string().transform((v) => JSON.parse(v)).default({ key: "value" })
+			};
+			const parser = new require_EnvironmentParser.ConfigParser(config);
+			const result = parser.parse();
+			(0, vitest.expect)(result).toEqual({
+				portString: 8080,
+				booleanString: false,
+				jsonString: { key: "value" }
+			});
+		});
+	});
+});
+
+//#endregion