@geekmidas/envkit 0.0.7 → 0.0.8

package/dist/__tests__/ConfigParser.spec.cjs

@@ -1,323 +0,0 @@
-const require_chunk = require('../chunk-CUT6urMc.cjs');
-const require_EnvironmentParser = require('../EnvironmentParser-BDPDLv6i.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

package/dist/__tests__/ConfigParser.spec.d.cts

@@ -1 +0,0 @@
-export { };

package/dist/__tests__/ConfigParser.spec.d.mts

@@ -1 +0,0 @@
-export { };

package/dist/__tests__/ConfigParser.spec.mjs

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