@geekmidas/envkit 0.0.2 → 0.0.4

package/dist/__tests__/EnvironmentParser.spec.mjs

@@ -0,0 +1,421 @@
+import { EnvironmentParser } from "../EnvironmentParser-jKrGMBhP.mjs";
+import { z } from "zod/v4";
+import { describe, expect, it } from "vitest";
+
+//#region src/__tests__/EnvironmentParser.spec.ts
+describe("EnvironmentParser", () => {
+	describe("Basic parsing functionality", () => {
+		it("should parse simple string values", () => {
+			const env = { APP_NAME: "Test App" };
+			const parser = new EnvironmentParser(env);
+			const config = parser.create((get) => ({ appName: get("APP_NAME").string() })).parse();
+			expect(config).toEqual({ appName: "Test App" });
+		});
+		it("should parse with default values when env var is missing", () => {
+			const env = {};
+			const parser = new EnvironmentParser(env);
+			const config = parser.create((get) => ({
+				appName: get("APP_NAME").string().default("Default App"),
+				port: get("PORT").string().transform(Number).default(3e3)
+			})).parse();
+			expect(config).toEqual({
+				appName: "Default App",
+				port: 3e3
+			});
+		});
+		it("should transform string to number", () => {
+			const env = { PORT: "8080" };
+			const parser = new EnvironmentParser(env);
+			const config = parser.create((get) => ({ port: get("PORT").string().transform(Number) })).parse();
+			expect(config).toEqual({ port: 8080 });
+		});
+		it("should transform string to boolean", () => {
+			const env = {
+				FEATURE_ENABLED: "true",
+				FEATURE_DISABLED: "false",
+				FEATURE_TRUTHY: "yes"
+			};
+			const parser = new EnvironmentParser(env);
+			const config = parser.create((get) => ({
+				enabled: get("FEATURE_ENABLED").string().transform((v) => v === "true"),
+				disabled: get("FEATURE_DISABLED").string().transform((v) => v === "true"),
+				truthy: get("FEATURE_TRUTHY").string().transform((v) => v === "true")
+			})).parse();
+			expect(config).toEqual({
+				enabled: true,
+				disabled: false,
+				truthy: false
+			});
+		});
+		it("should handle optional values", () => {
+			const env = { REQUIRED: "value" };
+			const parser = new EnvironmentParser(env);
+			const config = parser.create((get) => ({
+				required: get("REQUIRED").string(),
+				optional: get("OPTIONAL").string().optional()
+			})).parse();
+			expect(config).toEqual({
+				required: "value",
+				optional: void 0
+			});
+		});
+		it("should validate URLs", () => {
+			const env = {
+				VALID_URL: "https://example.com",
+				DATABASE_URL: "postgresql://user:pass@localhost:5432/db"
+			};
+			const parser = new EnvironmentParser(env);
+			const config = parser.create((get) => ({
+				apiUrl: get("VALID_URL").string().url(),
+				dbUrl: get("DATABASE_URL").string().url()
+			})).parse();
+			expect(config).toEqual({
+				apiUrl: "https://example.com",
+				dbUrl: "postgresql://user:pass@localhost:5432/db"
+			});
+		});
+		it("should validate email addresses", () => {
+			const env = { ADMIN_EMAIL: "admin@example.com" };
+			const parser = new EnvironmentParser(env);
+			const config = parser.create((get) => ({ adminEmail: get("ADMIN_EMAIL").string().email() })).parse();
+			expect(config).toEqual({ adminEmail: "admin@example.com" });
+		});
+		it("should validate enums", () => {
+			const env = { NODE_ENV: "production" };
+			const parser = new EnvironmentParser(env);
+			const config = parser.create((get) => ({ env: get("NODE_ENV").enum([
+				"development",
+				"staging",
+				"production"
+			]) })).parse();
+			expect(config).toEqual({ env: "production" });
+		});
+	});
+	describe("Nested configuration", () => {
+		it("should handle nested objects", () => {
+			const env = {
+				DB_HOST: "localhost",
+				DB_PORT: "5432",
+				DB_NAME: "myapp",
+				API_KEY: "secret123",
+				API_URL: "https://api.example.com"
+			};
+			const parser = new EnvironmentParser(env);
+			const config = parser.create((get) => ({
+				database: {
+					host: get("DB_HOST").string(),
+					port: get("DB_PORT").string().transform(Number),
+					name: get("DB_NAME").string()
+				},
+				api: {
+					key: get("API_KEY").string(),
+					url: get("API_URL").string().url()
+				}
+			})).parse();
+			expect(config).toEqual({
+				database: {
+					host: "localhost",
+					port: 5432,
+					name: "myapp"
+				},
+				api: {
+					key: "secret123",
+					url: "https://api.example.com"
+				}
+			});
+		});
+		it("should handle deeply nested objects", () => {
+			const env = {
+				FEATURE_AUTH_ENABLED: "true",
+				FEATURE_AUTH_PROVIDER: "oauth",
+				FEATURE_CACHE_ENABLED: "false",
+				FEATURE_CACHE_TTL: "3600"
+			};
+			const parser = new EnvironmentParser(env);
+			const config = parser.create((get) => ({ features: {
+				authentication: {
+					enabled: get("FEATURE_AUTH_ENABLED").string().transform((v) => v === "true"),
+					provider: get("FEATURE_AUTH_PROVIDER").string()
+				},
+				cache: {
+					enabled: get("FEATURE_CACHE_ENABLED").string().transform((v) => v === "true"),
+					ttl: get("FEATURE_CACHE_TTL").string().transform(Number)
+				}
+			} })).parse();
+			expect(config).toEqual({ features: {
+				authentication: {
+					enabled: true,
+					provider: "oauth"
+				},
+				cache: {
+					enabled: false,
+					ttl: 3600
+				}
+			} });
+		});
+		it("should handle mixed nested objects with defaults", () => {
+			const env = {
+				DB_HOST: "custom-host",
+				REDIS_TTL: "7200"
+			};
+			const parser = new EnvironmentParser(env);
+			const config = parser.create((get) => ({
+				database: {
+					host: get("DB_HOST").string(),
+					port: get("DB_PORT").string().transform(Number).default(5432),
+					ssl: get("DB_SSL").string().transform((v) => v === "true").default(false)
+				},
+				cache: { redis: {
+					host: get("REDIS_HOST").string().default("localhost"),
+					port: get("REDIS_PORT").string().transform(Number).default(6379),
+					ttl: get("REDIS_TTL").string().transform(Number)
+				} }
+			})).parse();
+			expect(config).toEqual({
+				database: {
+					host: "custom-host",
+					port: 5432,
+					ssl: false
+				},
+				cache: { redis: {
+					host: "localhost",
+					port: 6379,
+					ttl: 7200
+				} }
+			});
+		});
+	});
+	describe("Error handling and validation", () => {
+		it("should throw ZodError for missing required values", () => {
+			const env = {};
+			const parser = new EnvironmentParser(env);
+			expect(() => {
+				parser.create((get) => ({ required: get("REQUIRED_VAR").string() })).parse();
+			}).toThrow(z.ZodError);
+		});
+		it("should throw ZodError with descriptive error messages", () => {
+			const env = {};
+			const parser = new EnvironmentParser(env);
+			try {
+				parser.create((get) => ({
+					apiKey: get("API_KEY").string().min(32),
+					dbUrl: get("DATABASE_URL").string().url()
+				})).parse();
+			} catch (error) {
+				expect(error).toBeInstanceOf(z.ZodError);
+				const zodError = error;
+				expect(zodError.issues).toHaveLength(2);
+				expect(zodError.issues[0].message).toContain("Environment variable \"API_KEY\"");
+				expect(zodError.issues[1].message).toContain("Environment variable \"DATABASE_URL\"");
+			}
+		});
+		it("should validate minimum string length", () => {
+			const env = { API_KEY: "short" };
+			const parser = new EnvironmentParser(env);
+			expect(() => {
+				parser.create((get) => ({ apiKey: get("API_KEY").string().min(32) })).parse();
+			}).toThrow(z.ZodError);
+		});
+		it("should validate maximum string length", () => {
+			const env = { SHORT_TEXT: "a".repeat(100) };
+			const parser = new EnvironmentParser(env);
+			expect(() => {
+				parser.create((get) => ({ shortText: get("SHORT_TEXT").string().max(50) })).parse();
+			}).toThrow(z.ZodError);
+		});
+		it("should validate exact string length", () => {
+			const env = {
+				VALID_KEY: "a".repeat(32),
+				INVALID_KEY: "short"
+			};
+			const parser = new EnvironmentParser(env);
+			const validConfig = parser.create((get) => ({ key: get("VALID_KEY").string().length(32) })).parse();
+			expect(validConfig).toEqual({ key: "a".repeat(32) });
+			expect(() => {
+				parser.create((get) => ({ key: get("INVALID_KEY").string().length(32) })).parse();
+			}).toThrow(z.ZodError);
+		});
+		it("should validate invalid URLs", () => {
+			const env = { INVALID_URL: "not-a-url" };
+			const parser = new EnvironmentParser(env);
+			expect(() => {
+				parser.create((get) => ({ url: get("INVALID_URL").string().url() })).parse();
+			}).toThrow(z.ZodError);
+		});
+		it("should validate invalid email addresses", () => {
+			const env = { INVALID_EMAIL: "not-an-email" };
+			const parser = new EnvironmentParser(env);
+			expect(() => {
+				parser.create((get) => ({ email: get("INVALID_EMAIL").string().email() })).parse();
+			}).toThrow(z.ZodError);
+		});
+		it("should validate invalid enum values", () => {
+			const env = { NODE_ENV: "invalid" };
+			const parser = new EnvironmentParser(env);
+			expect(() => {
+				parser.create((get) => ({ env: get("NODE_ENV").enum([
+					"development",
+					"staging",
+					"production"
+				]) })).parse();
+			}).toThrow(z.ZodError);
+		});
+		it("should validate number ranges", () => {
+			const env = {
+				VALID_PORT: "8080",
+				INVALID_PORT_LOW: "0",
+				INVALID_PORT_HIGH: "70000"
+			};
+			const parser = new EnvironmentParser(env);
+			const validConfig = parser.create((get) => ({ port: get("VALID_PORT").coerce.number().min(1).max(65535) })).parse();
+			expect(validConfig).toEqual({ port: 8080 });
+			expect(() => {
+				parser.create((get) => ({ port: get("INVALID_PORT_LOW").coerce.number().min(1).max(65535) })).parse();
+			}).toThrow(z.ZodError);
+			expect(() => {
+				parser.create((get) => ({ port: get("INVALID_PORT_HIGH").coerce.number().min(1).max(65535) })).parse();
+			}).toThrow(z.ZodError);
+		});
+		it("should handle transformation errors", () => {
+			const env = { INVALID_NUMBER: "not-a-number" };
+			const parser = new EnvironmentParser(env);
+			expect(() => {
+				parser.create((get) => ({ number: get("INVALID_NUMBER").string().transform((v) => {
+					const num = Number(v);
+					if (isNaN(num)) throw new Error("Invalid number");
+					return num;
+				}) })).parse();
+			}).toThrow();
+		});
+	});
+	describe("Complex scenarios", () => {
+		it("should handle array transformations", () => {
+			const env = {
+				ALLOWED_ORIGINS: "http://localhost:3000,https://example.com,https://app.example.com",
+				FEATURE_FLAGS: "auth,cache,notifications"
+			};
+			const parser = new EnvironmentParser(env);
+			const config = parser.create((get) => ({
+				cors: { origins: get("ALLOWED_ORIGINS").string().transform((origins) => origins.split(",").map((o) => o.trim())) },
+				features: get("FEATURE_FLAGS").string().transform((flags) => flags.split(",").map((f) => f.trim()))
+			})).parse();
+			expect(config).toEqual({
+				cors: { origins: [
+					"http://localhost:3000",
+					"https://example.com",
+					"https://app.example.com"
+				] },
+				features: [
+					"auth",
+					"cache",
+					"notifications"
+				]
+			});
+		});
+		it("should handle JSON parsing", () => {
+			const env = {
+				FEATURE_CONFIG: "{\"auth\":true,\"cache\":false,\"debug\":true}",
+				RATE_LIMITS: "{\"requests\":100,\"window\":60000}"
+			};
+			const parser = new EnvironmentParser(env);
+			const config = parser.create((get) => ({
+				features: get("FEATURE_CONFIG").string().transform((str) => JSON.parse(str)).pipe(z.record(z.string(), z.boolean())),
+				rateLimits: get("RATE_LIMITS").string().transform((str) => JSON.parse(str)).pipe(z.object({
+					requests: z.number(),
+					window: z.number()
+				}))
+			})).parse();
+			expect(config).toEqual({
+				features: {
+					auth: true,
+					cache: false,
+					debug: true
+				},
+				rateLimits: {
+					requests: 100,
+					window: 6e4
+				}
+			});
+		});
+		it("should handle custom refinements", () => {
+			const env = {
+				CORS_ORIGINS: "https://example.com,https://app.example.com",
+				API_KEYS: "key1234567890123456789012345678901,key2345678901234567890123456789012"
+			};
+			const parser = new EnvironmentParser(env);
+			const config = parser.create((get) => ({
+				cors: { origins: get("CORS_ORIGINS").string().transform((origins) => origins.split(",").map((o) => o.trim())).refine((origins) => origins.every((o) => o.startsWith("https://")), { message: "All CORS origins must use HTTPS" }) },
+				apiKeys: get("API_KEYS").string().transform((keys) => keys.split(",").map((k) => k.trim())).pipe(z.array(z.string().min(32)))
+			})).parse();
+			expect(config).toEqual({
+				cors: { origins: ["https://example.com", "https://app.example.com"] },
+				apiKeys: ["key1234567890123456789012345678901", "key2345678901234567890123456789012"]
+			});
+		});
+		it("should fail refinements with descriptive errors", () => {
+			const env = { CORS_ORIGINS: "http://example.com,https://app.example.com" };
+			const parser = new EnvironmentParser(env);
+			expect(() => {
+				parser.create((get) => ({ cors: { origins: get("CORS_ORIGINS").string().transform((origins) => origins.split(",").map((o) => o.trim())).refine((origins) => origins.every((o) => o.startsWith("https://")), { message: "All CORS origins must use HTTPS" }) } })).parse();
+			}).toThrow(z.ZodError);
+		});
+	});
+	describe("Type inference", () => {
+		it("should correctly infer string types", () => {
+			const env = { APP_NAME: "Test App" };
+			const parser = new EnvironmentParser(env);
+			const config = parser.create((get) => ({ appName: get("APP_NAME").string() })).parse();
+			const _typeCheck = true;
+			const _typeCheck2 = true;
+			expect(_typeCheck).toBe(true);
+			expect(_typeCheck2).toBe(true);
+		});
+		it("should correctly infer number types after transformation", () => {
+			const env = { PORT: "3000" };
+			const parser = new EnvironmentParser(env);
+			const config = parser.create((get) => ({ port: get("PORT").string().transform(Number) })).parse();
+			const _typeCheck = true;
+			const _typeCheck2 = true;
+			expect(_typeCheck).toBe(true);
+			expect(_typeCheck2).toBe(true);
+		});
+		it("should correctly infer boolean types after transformation", () => {
+			const env = { FEATURE_ENABLED: "true" };
+			const parser = new EnvironmentParser(env);
+			const config = parser.create((get) => ({ enabled: get("FEATURE_ENABLED").string().transform((v) => v === "true") })).parse();
+			const _typeCheck = true;
+			const _typeCheck2 = true;
+			expect(_typeCheck).toBe(true);
+			expect(_typeCheck2).toBe(true);
+		});
+		it("should correctly infer optional types", () => {
+			const env = { REQUIRED: "value" };
+			const parser = new EnvironmentParser(env);
+			const config = parser.create((get) => ({
+				required: get("REQUIRED").string(),
+				optional: get("OPTIONAL").string().optional()
+			})).parse();
+		});
+		it("should correctly infer nested object types", () => {
+			const env = {
+				DB_HOST: "localhost",
+				DB_PORT: "5432",
+				API_KEY: "secret"
+			};
+			const parser = new EnvironmentParser(env);
+			const config = parser.create((get) => ({
+				database: {
+					host: get("DB_HOST").string(),
+					port: get("DB_PORT").string().transform(Number)
+				},
+				api: { key: get("API_KEY").string() }
+			})).parse();
+			const _typeCheck = true;
+			const _typeCheck2 = true;
+			expect(_typeCheck).toBe(true);
+			expect(_typeCheck2).toBe(true);
+		});
+	});
+});
+
+//#endregion

package/dist/chunk-CUT6urMc.cjs

@@ -0,0 +1,30 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/index.cjs

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

package/dist/index.mjs

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

package/dist/sst.cjs

@@ -0,0 +1,131 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const lodash_snakecase = require_chunk.__toESM(require("lodash.snakecase"));
+
+//#region src/sst.ts
+/**
+* Converts a string to environment variable case format (UPPER_SNAKE_CASE).
+* Numbers following underscores are preserved without the underscore.
+* 
+* @param name - The string to convert
+* @returns The converted string in environment variable format
+* 
+* @example
+* environmentCase('myVariable') // 'MY_VARIABLE'
+* environmentCase('api_v2') // 'APIV2'
+*/
+function environmentCase(name) {
+	return (0, lodash_snakecase.default)(name).toUpperCase().replace(/_\d+/g, (r) => {
+		return r.replace("_", "");
+	});
+}
+/**
+* Enumeration of supported SST (Serverless Stack Toolkit) resource types.
+* Used to identify and process different AWS and SST resources.
+*/
+let ResourceType = /* @__PURE__ */ function(ResourceType$1) {
+	ResourceType$1["ApiGatewayV2"] = "sst.aws.ApiGatewayV2";
+	ResourceType$1["Postgres"] = "sst.aws.Postgres";
+	ResourceType$1["Function"] = "sst.aws.Function";
+	ResourceType$1["Bucket"] = "sst.aws.Bucket";
+	ResourceType$1["Vpc"] = "sst.aws.Vpc";
+	ResourceType$1["Secret"] = "sst.sst.Secret";
+	ResourceType$1["SSTSecret"] = "sst:sst:Secret";
+	ResourceType$1["SSTFunction"] = "sst:sst:Function";
+	ResourceType$1["SSTApiGatewayV2"] = "sst:aws:ApiGatewayV2";
+	ResourceType$1["SSTPostgres"] = "sst:aws:Postgres";
+	ResourceType$1["SSTBucket"] = "sst:aws:Bucket";
+	return ResourceType$1;
+}({});
+/**
+* Processes a Secret resource into environment variables.
+* 
+* @param name - The resource name
+* @param value - The Secret resource
+* @returns Object with environment variable mappings
+*/
+const secret = (name, value) => ({ [environmentCase(name)]: value.value });
+/**
+* Processes a Postgres database resource into environment variables.
+* Creates multiple environment variables for database connection details.
+* 
+* @param key - The resource key
+* @param value - The Postgres resource
+* @returns Object with database connection environment variables
+*/
+const postgres = (key, value) => {
+	const prefix = `${environmentCase(key)}`;
+	return {
+		[`${prefix}_NAME`]: value.database,
+		[`${prefix}_HOST`]: value.host,
+		[`${prefix}_PASSWORD`]: value.password,
+		[`${prefix}_PORT`]: value.port,
+		[`${prefix}_USERNAME`]: value.username
+	};
+};
+/**
+* Processes a Bucket resource into environment variables.
+* 
+* @param name - The resource name
+* @param value - The Bucket resource
+* @returns Object with bucket name environment variable
+*/
+const bucket = (name, value) => {
+	const prefix = `${environmentCase(name)}`;
+	return { [`${prefix}_NAME`]: value.name };
+};
+/**
+* No-operation processor for resources that don't require environment variables.
+* 
+* @param name - The resource name (unused)
+* @param value - The resource value (unused)
+* @returns Empty object
+*/
+const noop = (name, value) => ({});
+/**
+* Map of resource types to their corresponding processor functions.
+* Each processor converts resource data into environment variables.
+*/
+const processors = {
+	[ResourceType.ApiGatewayV2]: noop,
+	[ResourceType.Function]: noop,
+	[ResourceType.Vpc]: noop,
+	[ResourceType.Secret]: secret,
+	[ResourceType.Postgres]: postgres,
+	[ResourceType.Bucket]: bucket,
+	[ResourceType.SSTSecret]: secret,
+	[ResourceType.SSTBucket]: bucket,
+	[ResourceType.SSTFunction]: noop,
+	[ResourceType.SSTPostgres]: postgres,
+	[ResourceType.SSTApiGatewayV2]: noop
+};
+/**
+* Normalizes SST resources and plain strings into environment variables.
+* Processes resources based on their type and converts names to environment case.
+* 
+* @param record - Object containing resources and/or string values
+* @returns Normalized environment variables object
+* 
+* @example
+* normalizeResourceEnv({
+*   apiUrl: 'https://api.example.com',
+*   database: { type: ResourceType.Postgres, ... }
+* })
+*/
+function normalizeResourceEnv(record) {
+	const env = {};
+	for (const [k, value] of Object.entries(record)) {
+		if (typeof value === "string") {
+			env[environmentCase(k)] = value;
+			continue;
+		}
+		const processor = processors[value.type];
+		if (processor) Object.assign(env, processor(k, value));
+		else console.warn(`No processor found for resource type: `, { value });
+	}
+	return env;
+}
+
+//#endregion
+exports.ResourceType = ResourceType;
+exports.environmentCase = environmentCase;
+exports.normalizeResourceEnv = normalizeResourceEnv;