@geekmidas/envkit 0.0.6 → 0.0.8

package/src/__tests__/SnifferEnvironmentParser.spec.ts

@@ -0,0 +1,332 @@
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod/v4';
+import { SnifferEnvironmentParser } from '../SnifferEnvironmentParser';
+
+describe('SnifferEnvironmentParser', () => {
+  describe('Environment variable tracking', () => {
+    it('should track accessed environment variables', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      sniffer.create((get) => ({
+        appName: get('APP_NAME').string(),
+        port: get('PORT').string().transform(Number),
+      }));
+
+      const envVars = sniffer.getEnvironmentVariables();
+      expect(envVars).toEqual(['APP_NAME', 'PORT']);
+    });
+
+    it('should track variables in nested configurations', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      sniffer.create((get) => ({
+        database: {
+          host: get('DB_HOST').string(),
+          port: get('DB_PORT').string().transform(Number),
+        },
+        api: {
+          key: get('API_KEY').string(),
+        },
+      }));
+
+      const envVars = sniffer.getEnvironmentVariables();
+      expect(envVars).toEqual(['API_KEY', 'DB_HOST', 'DB_PORT']);
+    });
+
+    it('should return sorted environment variable names', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      sniffer.create((get) => ({
+        zValue: get('Z_VALUE').string(),
+        aValue: get('A_VALUE').string(),
+        mValue: get('M_VALUE').string(),
+      }));
+
+      const envVars = sniffer.getEnvironmentVariables();
+      expect(envVars).toEqual(['A_VALUE', 'M_VALUE', 'Z_VALUE']);
+    });
+
+    it('should deduplicate environment variable names', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      sniffer.create((get) => ({
+        value1: get('SHARED_VAR').string(),
+        value2: get('SHARED_VAR').string(),
+        value3: get('SHARED_VAR').string(),
+      }));
+
+      const envVars = sniffer.getEnvironmentVariables();
+      expect(envVars).toEqual(['SHARED_VAR']);
+    });
+
+    it('should track variables accessed through coerce', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      sniffer.create((get) => ({
+        workers: get('NUM_WORKERS').coerce.number(),
+        timeout: get('TIMEOUT').coerce.number(),
+      }));
+
+      const envVars = sniffer.getEnvironmentVariables();
+      expect(envVars).toEqual(['NUM_WORKERS', 'TIMEOUT']);
+    });
+  });
+
+  describe('Mock value parsing', () => {
+    it('should never throw when parsing - returns mock values', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      const config = sniffer.create((get) => ({
+        required: get('REQUIRED_VAR').string(),
+        alsoRequired: get('ALSO_REQUIRED').string(),
+      }));
+
+      // Should not throw even though env vars are not set
+      expect(() => config.parse()).not.toThrow();
+    });
+
+    it('should return empty string for string schemas', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      const config = sniffer
+        .create((get) => ({
+          value: get('STRING_VAR').string(),
+        }))
+        .parse();
+
+      expect(config.value).toBe('');
+    });
+
+    it('should return 0 for number schemas', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      const config = sniffer
+        .create((get) => ({
+          value: get('NUMBER_VAR').coerce.number(),
+        }))
+        .parse();
+
+      expect(config.value).toBe(0);
+    });
+
+    it('should return false for boolean schemas', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      const config = sniffer
+        .create((get) => ({
+          value: get('BOOL_VAR').coerce.boolean(),
+        }))
+        .parse();
+
+      expect(config.value).toBe(false);
+    });
+
+    it('should return empty array for array schemas', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      const config = sniffer
+        .create((get) => ({
+          value: get('ARRAY_VAR').array(z.string()),
+        }))
+        .parse();
+
+      expect(config.value).toEqual([]);
+    });
+
+    it('should return undefined for optional schemas', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      const config = sniffer
+        .create((get) => ({
+          value: get('OPTIONAL_VAR').string().optional(),
+        }))
+        .parse();
+
+      expect(config.value).toBeUndefined();
+    });
+
+    it('should handle nested configurations', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      const config = sniffer
+        .create((get) => ({
+          database: {
+            host: get('DB_HOST').string(),
+            port: get('DB_PORT').coerce.number(),
+          },
+          cache: {
+            enabled: get('CACHE_ENABLED').coerce.boolean(),
+          },
+        }))
+        .parse();
+
+      expect(config).toEqual({
+        database: {
+          host: '',
+          port: 0,
+        },
+        cache: {
+          enabled: false,
+        },
+      });
+    });
+
+    it('should track variables with transforms', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      sniffer.create((get) => ({
+        origins: get('ALLOWED_ORIGINS')
+          .string()
+          .transform((v) => v.split(',')),
+        port: get('PORT').string().transform(Number),
+      }));
+
+      // Should track the env vars even with transforms
+      expect(sniffer.getEnvironmentVariables()).toEqual([
+        'ALLOWED_ORIGINS',
+        'PORT',
+      ]);
+    });
+  });
+
+  describe('Service registration simulation', () => {
+    it('should allow simulated service registration to succeed', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      // Simulate a service that would normally fail without env vars
+      const mockService = {
+        serviceName: 'database' as const,
+        register(envParser: SnifferEnvironmentParser) {
+          const config = envParser
+            .create((get) => ({
+              url: get('DATABASE_URL').string(),
+              poolSize: get('DB_POOL_SIZE').coerce.number(),
+            }))
+            .parse();
+
+          // Service uses parsed values to create connection
+          return { url: config.url, poolSize: config.poolSize };
+        },
+      };
+
+      // Should not throw
+      expect(() => mockService.register(sniffer)).not.toThrow();
+
+      // Should have tracked the env vars
+      expect(sniffer.getEnvironmentVariables()).toEqual([
+        'DATABASE_URL',
+        'DB_POOL_SIZE',
+      ]);
+    });
+
+    it('should work with multiple services', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      const databaseService = {
+        serviceName: 'db' as const,
+        register(envParser: SnifferEnvironmentParser) {
+          return envParser
+            .create((get) => ({
+              host: get('DB_HOST').string(),
+              port: get('DB_PORT').coerce.number(),
+            }))
+            .parse();
+        },
+      };
+
+      const cacheService = {
+        serviceName: 'cache' as const,
+        register(envParser: SnifferEnvironmentParser) {
+          return envParser
+            .create((get) => ({
+              url: get('REDIS_URL').string(),
+              ttl: get('CACHE_TTL').coerce.number(),
+            }))
+            .parse();
+        },
+      };
+
+      // Register both services
+      databaseService.register(sniffer);
+      cacheService.register(sniffer);
+
+      // Should have tracked all env vars from both services
+      expect(sniffer.getEnvironmentVariables()).toEqual([
+        'CACHE_TTL',
+        'DB_HOST',
+        'DB_PORT',
+        'REDIS_URL',
+      ]);
+    });
+
+    it('should handle async service registration', async () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      const asyncService = {
+        serviceName: 'async' as const,
+        async register(envParser: SnifferEnvironmentParser) {
+          const config = envParser
+            .create((get) => ({
+              apiKey: get('API_KEY').string(),
+              endpoint: get('API_ENDPOINT').string(),
+            }))
+            .parse();
+
+          // Simulate async initialization
+          await Promise.resolve();
+          return config;
+        },
+      };
+
+      await expect(asyncService.register(sniffer)).resolves.not.toThrow();
+      expect(sniffer.getEnvironmentVariables()).toEqual([
+        'API_ENDPOINT',
+        'API_KEY',
+      ]);
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should return empty array when no variables accessed', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      sniffer.create(() => ({}));
+
+      expect(sniffer.getEnvironmentVariables()).toEqual([]);
+    });
+
+    it('should handle deeply nested objects', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      sniffer.create((get) => ({
+        level1: {
+          level2: {
+            level3: {
+              value: get('DEEP_VALUE').string(),
+            },
+          },
+        },
+      }));
+
+      expect(sniffer.getEnvironmentVariables()).toEqual(['DEEP_VALUE']);
+    });
+
+    it('should handle multiple create calls', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      sniffer.create((get) => ({
+        first: get('FIRST_VAR').string(),
+      }));
+
+      sniffer.create((get) => ({
+        second: get('SECOND_VAR').string(),
+      }));
+
+      // Should accumulate vars from both create calls
+      expect(sniffer.getEnvironmentVariables()).toEqual([
+        'FIRST_VAR',
+        'SECOND_VAR',
+      ]);
+    });
+  });
+});

package/src/__tests__/sst.spec.ts

@@ -306,7 +306,9 @@ describe('sst', () => {
 
     describe('edge cases', () => {
       it('should warn for unknown resource types', () => {
-        const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+        const consoleWarnSpy = vi
+          .spyOn(console, 'warn')
+          .mockImplementation(() => {});
 
         const unknownResource = {
           type: 'unknown.resource.Type' as any,
@@ -320,7 +322,7 @@ describe('sst', () => {
         expect(result).toEqual({});
         expect(consoleWarnSpy).toHaveBeenCalledWith(
           'No processor found for resource type: ',
-          { value: unknownResource }
+          { value: unknownResource },
         );
 
         consoleWarnSpy.mockRestore();
@@ -374,7 +376,8 @@ describe('sst', () => {
         });
 
         expect(result).toEqual({
-          THIS_IS_A_VERY_LONG_KEY_NAME_THAT_SHOULD_BE_CONVERTED_PROPERLY: 'value',
+          THIS_IS_A_VERY_LONG_KEY_NAME_THAT_SHOULD_BE_CONVERTED_PROPERLY:
+            'value',
         });
       });
 
@@ -385,8 +388,8 @@ describe('sst', () => {
         };
 
         const result = normalizeResourceEnv({
-          's3_bucket_v2_1': bucket,
-          'bucket_123_456': bucket,
+          s3_bucket_v2_1: bucket,
+          bucket_123_456: bucket,
         });
 
         expect(result).toEqual({
@@ -412,4 +415,4 @@ describe('sst', () => {
       expect(ResourceType.SSTBucket).toBe('sst:aws:Bucket');
     });
   });
-});
+});

package/src/index.ts

@@ -1 +1 @@
-export { EnvironmentParser } from './EnvironmentParser';
+export { EnvironmentParser, ConfigParser } from './EnvironmentParser';

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 { };