@geekmidas/envkit 9.0.2 → 10.0.0-alpha.1

package/src/__tests__/ConfigParser.spec.ts

@@ -1,394 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { z } from 'zod/v4';
-import { ConfigParser } from '../EnvironmentParser';
-
-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: undefined,
-			});
-		});
-
-		it('should validate and use provided default values', () => {
-			const config = {
-				port: z.number().default(3000),
-				host: z.string().default('localhost'),
-				debug: z.boolean().default(false),
-			};
-
-			const parser = new ConfigParser(config);
-			const result = parser.parse();
-
-			expect(result).toEqual({
-				port: 3000,
-				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(5000),
-				},
-			};
-
-			const parser = new ConfigParser(config);
-			const result = parser.parse();
-
-			expect(result).toEqual({
-				database: {
-					host: 'localhost',
-					port: 5432,
-					ssl: false,
-				},
-				api: {
-					key: 'default-key',
-					timeout: 5000,
-				},
-			});
-		});
-
-		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(3000),
-				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: 3000,
-				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();
-				// Should not reach here
-				expect(true).toBe(false);
-			} catch (error) {
-				expect(error).toBeInstanceOf(z.ZodError);
-				const zodError = error as z.ZodError;
-				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();
-				// Should not reach here
-				expect(true).toBe(false);
-			} catch (error) {
-				expect(error).toBeInstanceOf(z.ZodError);
-				const zodError = error as z.ZodError;
-
-				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(1000).max(65535).default(3000),
-				email: z.string().email().default('admin@example.com'),
-			};
-
-			const parser = new ConfigParser(config);
-			const result = parser.parse();
-
-			expect(result).toEqual({
-				port: 3000,
-				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();
-
-			// TypeScript should infer the correct types
-			type ResultType = typeof result;
-			type ExpectedType = {
-				name: string;
-				count: number;
-				enabled: boolean;
-			};
-
-			const _typeCheck: ResultType extends ExpectedType ? true : false = true;
-			const _typeCheck2: ExpectedType extends ResultType ? true : false = 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();
-
-			// TypeScript should infer the correct nested structure
-			type ResultType = typeof result;
-			type ExpectedType = {
-				database: { host: string; port: number };
-				features: { auth: boolean };
-			};
-
-			const _typeCheck: ResultType extends ExpectedType ? true : false = true;
-			const _typeCheck2: ExpectedType extends ResultType ? true : false = 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(3000),
-				timeout: z.union([z.number(), z.null()]).default(null),
-			};
-
-			const parser = new ConfigParser(config);
-			const result = parser.parse();
-
-			expect(result).toEqual({
-				port: 3000,
-				timeout: null,
-			});
-		});
-
-		it('should handle array schemas', () => {
-			const config = {
-				tags: z.array(z.string()).default(['tag1', 'tag2']),
-				ports: z.array(z.number()).default([3000, 3001]),
-			};
-
-			const parser = new ConfigParser(config);
-			const result = parser.parse();
-
-			expect(result).toEqual({
-				tags: ['tag1', 'tag2'],
-				ports: [3000, 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' },
-			});
-		});
-	});
-});

package/src/__tests__/EnvironmentBuilder.spec.ts

@@ -1,254 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-import { EnvironmentBuilder, environmentCase } from '../EnvironmentBuilder';
-
-describe('environmentCase', () => {
-	it('should convert camelCase to UPPER_SNAKE_CASE', () => {
-		expect(environmentCase('myVariable')).toBe('MY_VARIABLE');
-		expect(environmentCase('apiUrl')).toBe('API_URL');
-		expect(environmentCase('databaseName')).toBe('DATABASE_NAME');
-	});
-
-	it('should handle already snake_case', () => {
-		expect(environmentCase('my_variable')).toBe('MY_VARIABLE');
-		expect(environmentCase('api_url')).toBe('API_URL');
-	});
-
-	it('should remove underscore directly before numbers', () => {
-		// The regex /_\d+/g only removes underscores that are directly followed by digits
-		expect(environmentCase('api_v2')).toBe('API_V2');
-		expect(environmentCase('value_123')).toBe('VALUE123');
-		expect(environmentCase('my_var_2')).toBe('MY_VAR2');
-	});
-
-	it('should handle single words', () => {
-		expect(environmentCase('name')).toBe('NAME');
-		expect(environmentCase('port')).toBe('PORT');
-	});
-});
-
-describe('EnvironmentBuilder', () => {
-	describe('basic functionality', () => {
-		it('should pass through plain string values with key transformation', () => {
-			const env = new EnvironmentBuilder(
-				{
-					appName: 'my-app',
-					nodeEnv: 'production',
-				},
-				{},
-			).build();
-
-			expect(env).toEqual({
-				APP_NAME: 'my-app',
-				NODE_ENV: 'production',
-			});
-		});
-
-		it('should resolve object values using type-based resolvers', () => {
-			const env = new EnvironmentBuilder(
-				{
-					apiKey: { type: 'secret', value: 'xyz' },
-				},
-				{
-					secret: (key, value: { type: string; value: string }) => ({
-						[key]: value.value,
-					}),
-				},
-			).build();
-
-			expect(env).toEqual({
-				API_KEY: 'xyz',
-			});
-		});
-
-		it('should transform resolver output keys to UPPER_SNAKE_CASE', () => {
-			const env = new EnvironmentBuilder(
-				{
-					auth: { type: 'auth0', domain: 'example.auth0.com', clientId: 'abc' },
-				},
-				{
-					auth0: (
-						key,
-						value: { type: string; domain: string; clientId: string },
-					) => ({
-						[`${key}Domain`]: value.domain,
-						[`${key}ClientId`]: value.clientId,
-					}),
-				},
-			).build();
-
-			expect(env).toEqual({
-				AUTH_DOMAIN: 'example.auth0.com',
-				AUTH_CLIENT_ID: 'abc',
-			});
-		});
-
-		it('should handle mixed string and object values', () => {
-			const env = new EnvironmentBuilder(
-				{
-					appName: 'my-app',
-					apiKey: { type: 'secret', value: 'secret-key' },
-					nodeEnv: 'production',
-				},
-				{
-					secret: (key, value: { type: string; value: string }) => ({
-						[key]: value.value,
-					}),
-				},
-			).build();
-
-			expect(env).toEqual({
-				APP_NAME: 'my-app',
-				API_KEY: 'secret-key',
-				NODE_ENV: 'production',
-			});
-		});
-	});
-
-	describe('nested values', () => {
-		it('should support nested object values', () => {
-			const env = new EnvironmentBuilder(
-				{
-					database: {
-						type: 'multi-db',
-						primary: 'pg://primary',
-						replica: 'pg://replica',
-					},
-				},
-				{
-					'multi-db': (
-						key,
-						value: { type: string; primary: string; replica: string },
-					) => ({
-						[key]: {
-							primary: value.primary,
-							replica: value.replica,
-						},
-					}),
-				},
-			).build();
-
-			expect(env).toEqual({
-				DATABASE: {
-					primary: 'pg://primary',
-					replica: 'pg://replica',
-				},
-			});
-		});
-
-		it('should not transform nested object keys', () => {
-			const env = new EnvironmentBuilder(
-				{
-					config: { type: 'nested', camelCase: 'value', snake_case: 'value2' },
-				},
-				{
-					nested: (
-						key,
-						value: { type: string; camelCase: string; snake_case: string },
-					) => ({
-						[key]: {
-							camelCase: value.camelCase,
-							snake_case: value.snake_case,
-						},
-					}),
-				},
-			).build();
-
-			expect(env).toEqual({
-				CONFIG: {
-					camelCase: 'value',
-					snake_case: 'value2',
-				},
-			});
-		});
-	});
-
-	describe('unmatched values', () => {
-		it('should call onUnmatchedValue for objects without matching resolver', () => {
-			const onUnmatchedValue = vi.fn();
-
-			new EnvironmentBuilder(
-				{
-					unknown: { type: 'unknown-type', data: 'test' },
-				},
-				{},
-				{ onUnmatchedValue },
-			).build();
-
-			expect(onUnmatchedValue).toHaveBeenCalledWith('unknown', {
-				type: 'unknown-type',
-				data: 'test',
-			});
-		});
-	});
-
-	describe('value types', () => {
-		it('should support number values', () => {
-			const env = new EnvironmentBuilder(
-				{
-					port: { type: 'port', value: 3000 },
-				},
-				{
-					port: (key, value: { type: string; value: number }) => ({
-						[key]: value.value,
-					}),
-				},
-			).build();
-
-			expect(env).toEqual({
-				PORT: 3000,
-			});
-		});
-
-		it('should support boolean values', () => {
-			const env = new EnvironmentBuilder(
-				{
-					enabled: { type: 'flag', value: true },
-				},
-				{
-					flag: (key, value: { type: string; value: boolean }) => ({
-						[key]: value.value,
-					}),
-				},
-			).build();
-
-			expect(env).toEqual({
-				ENABLED: true,
-			});
-		});
-	});
-
-	describe('multiple resolvers', () => {
-		it('should use the correct resolver for each type', () => {
-			const env = new EnvironmentBuilder(
-				{
-					secret: { type: 'secret', value: 'my-secret' },
-					database: { type: 'postgres', host: 'localhost', port: 5432 },
-					bucket: { type: 'bucket', name: 'my-bucket' },
-				},
-				{
-					secret: (key, value: { type: string; value: string }) => ({
-						[key]: value.value,
-					}),
-					postgres: (
-						key,
-						value: { type: string; host: string; port: number },
-					) => ({
-						[`${key}Host`]: value.host,
-						[`${key}Port`]: value.port,
-					}),
-					bucket: (key, value: { type: string; name: string }) => ({
-						[`${key}Name`]: value.name,
-					}),
-				},
-			).build();
-
-			expect(env).toEqual({
-				SECRET: 'my-secret',
-				DATABASE_HOST: 'localhost',
-				DATABASE_PORT: 5432,
-				BUCKET_NAME: 'my-bucket',
-			});
-		});
-	});
-});