@geekmidas/envkit 0.0.2 → 0.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/envkit",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "private": false,
   "type": "module",
   "exports": {

package/src/EnvironmentParser.ts

@@ -59,6 +59,73 @@ export class ConfigParser<TResponse extends EmptyObject> {
 export class EnvironmentParser<T extends EmptyObject> {
   constructor(private readonly config: T) {}
 
+  private wrapSchema = (schema: z.ZodType, name: string): z.ZodType => {
+    // Create a proxy that intercepts all method calls on the schema
+    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) {
+                // Modify the error to include the environment variable name
+                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) {
+              // Modify the error to include the environment variable name
+              const modifiedIssues = result.error.issues.map(
+                (issue: z.core.$ZodIssue) => ({
+                  ...issue,
+                  message: `Environment variable "${name}": ${issue.message}`,
+                  path: [name, ...issue.path],
+                }),
+              );
+              return {
+                success: false as const,
+                error: new z.ZodError(modifiedIssues),
+              };
+            }
+
+            return result;
+          };
+        }
+
+        // For any method that returns a new schema (like transform, optional, etc.),
+        // wrap the result as well
+        const originalProp = target[prop as keyof typeof target];
+        if (typeof originalProp === 'function') {
+          return (...args: any[]) => {
+            const result = originalProp.apply(target, args);
+            // If the result is a ZodType, wrap it too
+            if (result && typeof result === 'object' && 'parse' in result) {
+              return this.wrapSchema(result, name);
+            }
+            return result;
+          };
+        }
+
+        return originalProp;
+      },
+    });
+  };
+
   private getZodGetter = (name: string) => {
     // Return an object that has all Zod schemas but with our wrapper
     return new Proxy(
@@ -67,60 +134,33 @@ export class EnvironmentParser<T extends EmptyObject> {
         get: (target, prop) => {
           // deno-lint-ignore ban-ts-comment
           // @ts-ignore
-          const func = target[prop];
+          const value = target[prop];
 
-          if (typeof func === 'function') {
+          if (typeof value === 'function') {
             // Return a wrapper around each Zod schema creator
             return (...args: any[]) => {
-              const schema = func(...args);
-              // Add a custom parse method that gets the value from config
-              const originalParse = schema.parse;
-              const originalSafeParse = schema.safeParse;
-
-              schema.parse = () => {
-                const value = get(this.config, name);
-                try {
-                  return originalParse.call(schema, value);
-                } catch (error) {
-                  if (error instanceof z.ZodError) {
-                    // Modify the error to include the environment variable name
-                    const modifiedIssues = error.issues.map((issue) => ({
-                      ...issue,
-                      message: `Environment variable "${name}": ${issue.message}`,
-                      path: [name, ...issue.path],
-                    }));
-                    throw new z.ZodError(modifiedIssues);
-                  }
-                  throw error;
-                }
-              };
+              const schema = value(...args);
+              return this.wrapSchema(schema, name);
+            };
+          }
 
-              schema.safeParse = () => {
-                const value = get(this.config, name);
-                const result = originalSafeParse.call(schema, value);
-
-                if (!result.success) {
-                  // Modify the error to include the environment variable name
-                  const modifiedIssues = result.error.issues.map(
-                    (issue: z.core.$ZodIssue) => ({
-                      ...issue,
-                      message: `Environment variable "${name}": ${issue.message}`,
-                      path: [name, ...issue.path],
-                    }),
-                  );
-                  return {
-                    success: false as const,
-                    error: new z.ZodError(modifiedIssues),
+          // Handle objects like z.coerce
+          if (value && typeof value === 'object') {
+            return new Proxy(value, {
+              get: (nestedTarget, nestedProp) => {
+                const nestedValue = nestedTarget[nestedProp as keyof typeof nestedTarget];
+                if (typeof nestedValue === 'function') {
+                  return (...args: any[]) => {
+                    const schema = nestedValue(...args);
+                    return this.wrapSchema(schema, name);
                   };
                 }
-
-                return result;
-              };
-
-              return schema;
-            };
+                return nestedValue;
+              },
+            });
           }
-          return func;
+
+          return value;
         },
       },
     );

package/src/__tests__/ConfigParser.spec.ts

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