@geekmidas/envkit 0.0.7 → 0.0.8

package/dist/SnifferEnvironmentParser.d.mts

@@ -0,0 +1,50 @@
+import { ConfigParser, EmptyObject, EnvFetcher } from "./EnvironmentParser-C_9v2BDw.mjs";
+
+//#region src/SnifferEnvironmentParser.d.ts
+
+/**
+ * A specialized EnvironmentParser for build-time analysis that tracks
+ * which environment variables are accessed without requiring actual values.
+ *
+ * Unlike the regular EnvironmentParser, the sniffer:
+ * - Always returns mock values from .parse() and .safeParse()
+ * - Never throws validation errors
+ * - Tracks all accessed environment variable names
+ *
+ * This allows service registration to succeed during build-time analysis
+ * even when environment variables are not set.
+ *
+ * @example
+ * ```typescript
+ * const sniffer = new SnifferEnvironmentParser();
+ * await service.register(sniffer); // Always succeeds
+ * const envVars = sniffer.getEnvironmentVariables(); // ['DATABASE_URL', 'API_KEY']
+ * ```
+ */
+declare class SnifferEnvironmentParser<T extends EmptyObject = EmptyObject> {
+  private readonly accessedVars;
+  /**
+   * Wraps a Zod schema to always return mock values.
+   * This ensures .parse() and .safeParse() never fail.
+   */
+  private wrapSchema;
+  /**
+   * Returns a mock value based on the Zod schema type.
+   */
+  private getMockValue;
+  /**
+   * Creates a proxied Zod getter that tracks environment variable access.
+   */
+  private getZodGetter;
+  /**
+   * Creates a ConfigParser that will return mock values when parsed.
+   */
+  create<TReturn extends EmptyObject>(builder: (get: EnvFetcher) => TReturn): ConfigParser<TReturn>;
+  /**
+   * Returns all environment variable names that were accessed.
+   */
+  getEnvironmentVariables(): string[];
+}
+//#endregion
+export { SnifferEnvironmentParser };
+//# sourceMappingURL=SnifferEnvironmentParser.d.mts.map

package/dist/SnifferEnvironmentParser.mjs

@@ -0,0 +1,139 @@
+import { ConfigParser } from "./EnvironmentParser-STvN_RCc.mjs";
+import { z } from "zod/v4";
+
+//#region src/SnifferEnvironmentParser.ts
+/**
+* A specialized EnvironmentParser for build-time analysis that tracks
+* which environment variables are accessed without requiring actual values.
+*
+* Unlike the regular EnvironmentParser, the sniffer:
+* - Always returns mock values from .parse() and .safeParse()
+* - Never throws validation errors
+* - Tracks all accessed environment variable names
+*
+* This allows service registration to succeed during build-time analysis
+* even when environment variables are not set.
+*
+* @example
+* ```typescript
+* const sniffer = new SnifferEnvironmentParser();
+* await service.register(sniffer); // Always succeeds
+* const envVars = sniffer.getEnvironmentVariables(); // ['DATABASE_URL', 'API_KEY']
+* ```
+*/
+var SnifferEnvironmentParser = class {
+	accessedVars = /* @__PURE__ */ new Set();
+	/**
+	* Wraps a Zod schema to always return mock values.
+	* This ensures .parse() and .safeParse() never fail.
+	*/
+	wrapSchema = (schema, name) => {
+		return new Proxy(schema, { get: (target, prop) => {
+			if (prop === "parse") return () => this.getMockValue(target);
+			if (prop === "safeParse") return () => ({
+				success: true,
+				data: this.getMockValue(target)
+			});
+			const originalProp = target[prop];
+			if (typeof originalProp === "function") return (...args) => {
+				const result = originalProp.apply(target, args);
+				if (result && typeof result === "object" && "parse" in result) return this.wrapSchema(result, name);
+				return result;
+			};
+			return originalProp;
+		} });
+	};
+	/**
+	* Returns a mock value based on the Zod schema type.
+	*/
+	getMockValue(schema) {
+		if (schema instanceof z.ZodString) return "";
+		if (schema instanceof z.ZodNumber) return 0;
+		if (schema instanceof z.ZodBoolean) return false;
+		if (schema instanceof z.ZodArray) return [];
+		if (schema instanceof z.ZodOptional) return void 0;
+		if (schema instanceof z.ZodNullable) return null;
+		if (schema instanceof z.ZodObject && schema.shape) {
+			const result = {};
+			for (const [key, value] of Object.entries(schema.shape)) if (value instanceof z.ZodType) result[key] = this.getMockValue(value);
+			return result;
+		}
+		return "";
+	}
+	/**
+	* Creates a proxied Zod getter that tracks environment variable access.
+	*/
+	getZodGetter = (name) => {
+		this.accessedVars.add(name);
+		return new Proxy({ ...z }, { get: (target, prop) => {
+			const value = target[prop];
+			if (typeof value === "function") return (...args) => {
+				const schema = value(...args);
+				return this.wrapSchema(schema, name);
+			};
+			if (value && typeof value === "object") return new Proxy(value, { get: (nestedTarget, nestedProp) => {
+				const nestedValue = nestedTarget[nestedProp];
+				if (typeof nestedValue === "function") return (...args) => {
+					const schema = nestedValue(...args);
+					return this.wrapSchema(schema, name);
+				};
+				return nestedValue;
+			} });
+			return value;
+		} });
+	};
+	/**
+	* Creates a ConfigParser that will return mock values when parsed.
+	*/
+	create(builder) {
+		const config = builder(this.getZodGetter);
+		return new SnifferConfigParser(config, this.accessedVars);
+	}
+	/**
+	* Returns all environment variable names that were accessed.
+	*/
+	getEnvironmentVariables() {
+		return Array.from(this.accessedVars).sort();
+	}
+};
+/**
+* A ConfigParser that always succeeds with mock values.
+*/
+var SnifferConfigParser = class extends ConfigParser {
+	parse() {
+		return this.parseWithMocks(this.getConfig());
+	}
+	getConfig() {
+		return this.config;
+	}
+	parseWithMocks(config) {
+		const result = {};
+		if (config && typeof config !== "object") return config;
+		for (const key in config) {
+			const schema = config[key];
+			if (schema instanceof z.ZodType) {
+				const parsed = schema.safeParse(void 0);
+				result[key] = parsed.success ? parsed.data : this.getDefaultForSchema(schema);
+			} else if (schema && typeof schema === "object") result[key] = this.parseWithMocks(schema);
+		}
+		return result;
+	}
+	getDefaultForSchema(schema) {
+		if (schema instanceof z.ZodString) return "";
+		if (schema instanceof z.ZodNumber) return 0;
+		if (schema instanceof z.ZodBoolean) return false;
+		if (schema instanceof z.ZodArray) return [];
+		if (schema instanceof z.ZodOptional) return void 0;
+		if (schema instanceof z.ZodNullable) return null;
+		if (schema instanceof z.ZodObject && schema.shape) {
+			const result = {};
+			for (const [key, value] of Object.entries(schema.shape)) if (value instanceof z.ZodType) result[key] = this.getDefaultForSchema(value);
+			return result;
+		}
+		return "";
+	}
+};
+
+//#endregion
+export { SnifferEnvironmentParser };
+//# sourceMappingURL=SnifferEnvironmentParser.mjs.map

package/dist/SnifferEnvironmentParser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SnifferEnvironmentParser.mjs","names":["schema: z.ZodType","name: string","result: Record<string, unknown>","builder: (get: EnvFetcher) => TReturn","config: T","result: EmptyObject"],"sources":["../src/SnifferEnvironmentParser.ts"],"sourcesContent":["import { z } from 'zod/v4';\nimport {\n  ConfigParser,\n  type EmptyObject,\n  type EnvFetcher,\n} from './EnvironmentParser';\n\n/**\n * A specialized EnvironmentParser for build-time analysis that tracks\n * which environment variables are accessed without requiring actual values.\n *\n * Unlike the regular EnvironmentParser, the sniffer:\n * - Always returns mock values from .parse() and .safeParse()\n * - Never throws validation errors\n * - Tracks all accessed environment variable names\n *\n * This allows service registration to succeed during build-time analysis\n * even when environment variables are not set.\n *\n * @example\n * ```typescript\n * const sniffer = new SnifferEnvironmentParser();\n * await service.register(sniffer); // Always succeeds\n * const envVars = sniffer.getEnvironmentVariables(); // ['DATABASE_URL', 'API_KEY']\n * ```\n */\nexport class SnifferEnvironmentParser<\n  T extends EmptyObject = EmptyObject,\n> {\n  private readonly accessedVars: Set<string> = new Set();\n\n  /**\n   * Wraps a Zod schema to always return mock values.\n   * This ensures .parse() and .safeParse() never fail.\n   */\n  private wrapSchema = (schema: z.ZodType, name: string): z.ZodType => {\n    return new Proxy(schema, {\n      get: (target, prop) => {\n        if (prop === 'parse') {\n          return () => this.getMockValue(target);\n        }\n\n        if (prop === 'safeParse') {\n          return () => ({\n            success: true as const,\n            data: this.getMockValue(target),\n          });\n        }\n\n        const originalProp = target[prop as keyof typeof target];\n        if (typeof originalProp === 'function') {\n          return (...args: any[]) => {\n            const result = originalProp.apply(target, args);\n            if (result && typeof result === 'object' && 'parse' in result) {\n              return this.wrapSchema(result, name);\n            }\n            return result;\n          };\n        }\n\n        return originalProp;\n      },\n    });\n  };\n\n  /**\n   * Returns a mock value based on the Zod schema type.\n   */\n  private getMockValue(schema: z.ZodType): unknown {\n    // Return type-appropriate mock values\n    if (schema instanceof z.ZodString) return '';\n    if (schema instanceof z.ZodNumber) return 0;\n    if (schema instanceof z.ZodBoolean) return false;\n    if (schema instanceof z.ZodArray) return [];\n    if (schema instanceof z.ZodOptional) return undefined;\n    if (schema instanceof z.ZodNullable) return null;\n\n    // For object schemas, build mock object from shape\n    if (schema instanceof z.ZodObject && schema.shape) {\n      const result: Record<string, unknown> = {};\n      for (const [key, value] of Object.entries(schema.shape)) {\n        if (value instanceof z.ZodType) {\n          result[key] = this.getMockValue(value);\n        }\n      }\n      return result;\n    }\n\n    return '';\n  }\n\n  /**\n   * Creates a proxied Zod getter that tracks environment variable access.\n   */\n  private getZodGetter = (name: string) => {\n    this.accessedVars.add(name);\n\n    return new Proxy(\n      { ...z },\n      {\n        get: (target, prop) => {\n          // @ts-ignore\n          const value = target[prop];\n\n          if (typeof value === 'function') {\n            return (...args: any[]) => {\n              const schema = value(...args);\n              return this.wrapSchema(schema, name);\n            };\n          }\n\n          if (value && typeof value === 'object') {\n            return new Proxy(value, {\n              get: (nestedTarget, nestedProp) => {\n                const nestedValue =\n                  nestedTarget[nestedProp as keyof typeof nestedTarget];\n                if (typeof nestedValue === 'function') {\n                  return (...args: any[]) => {\n                    const schema = nestedValue(...args);\n                    return this.wrapSchema(schema, name);\n                  };\n                }\n                return nestedValue;\n              },\n            });\n          }\n\n          return value;\n        },\n      },\n    );\n  };\n\n  /**\n   * Creates a ConfigParser that will return mock values when parsed.\n   */\n  create<TReturn extends EmptyObject>(\n    builder: (get: EnvFetcher) => TReturn,\n  ): ConfigParser<TReturn> {\n    const config = builder(this.getZodGetter);\n    return new SnifferConfigParser(config, this.accessedVars);\n  }\n\n  /**\n   * Returns all environment variable names that were accessed.\n   */\n  getEnvironmentVariables(): string[] {\n    return Array.from(this.accessedVars).sort();\n  }\n}\n\n/**\n * A ConfigParser that always succeeds with mock values.\n */\nclass SnifferConfigParser<TResponse extends EmptyObject> extends ConfigParser<TResponse> {\n  parse(): any {\n    return this.parseWithMocks(this.getConfig());\n  }\n\n  private getConfig(): TResponse {\n    // Access the private config via any cast\n    return (this as any).config;\n  }\n\n  private parseWithMocks<T>(config: T): any {\n    const result: EmptyObject = {};\n\n    if (config && typeof config !== 'object') {\n      return config;\n    }\n\n    for (const key in config) {\n      const schema = config[key];\n\n      if (schema instanceof z.ZodType) {\n        // Use safeParse which will return mock values from our wrapped schema\n        const parsed = schema.safeParse(undefined);\n        result[key] = parsed.success ? parsed.data : this.getDefaultForSchema(schema);\n      } else if (schema && typeof schema === 'object') {\n        result[key] = this.parseWithMocks(schema as EmptyObject);\n      }\n    }\n\n    return result;\n  }\n\n  private getDefaultForSchema(schema: z.ZodType): unknown {\n    if (schema instanceof z.ZodString) return '';\n    if (schema instanceof z.ZodNumber) return 0;\n    if (schema instanceof z.ZodBoolean) return false;\n    if (schema instanceof z.ZodArray) return [];\n    if (schema instanceof z.ZodOptional) return undefined;\n    if (schema instanceof z.ZodNullable) return null;\n\n    if (schema instanceof z.ZodObject && schema.shape) {\n      const result: Record<string, unknown> = {};\n      for (const [key, value] of Object.entries(schema.shape)) {\n        if (value instanceof z.ZodType) {\n          result[key] = this.getDefaultForSchema(value);\n        }\n      }\n      return result;\n    }\n\n    return '';\n  }\n}\n"],"mappings":"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"}

package/dist/index.cjs

@@ -1,3 +1,4 @@
-const require_EnvironmentParser = require('./EnvironmentParser-BDPDLv6i.cjs');
+const require_EnvironmentParser = require('./EnvironmentParser-cnxuy7lw.cjs');
 
+exports.ConfigParser = require_EnvironmentParser.ConfigParser;
 exports.EnvironmentParser = require_EnvironmentParser.EnvironmentParser;

package/dist/index.d.cts

@@ -1,2 +1,2 @@
-import { EnvironmentParser } from "./EnvironmentParser-X4h2Vp4r.cjs";
-export { EnvironmentParser };
+import { ConfigParser, EnvironmentParser } from "./EnvironmentParser-B8--woiB.cjs";
+export { ConfigParser, EnvironmentParser };

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { EnvironmentParser } from "./EnvironmentParser-C-arQEHQ.mjs";
-export { EnvironmentParser };
+import { ConfigParser, EnvironmentParser } from "./EnvironmentParser-C_9v2BDw.mjs";
+export { ConfigParser, EnvironmentParser };

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { EnvironmentParser } from "./EnvironmentParser-CQUOGqc0.mjs";
+import { ConfigParser, EnvironmentParser } from "./EnvironmentParser-STvN_RCc.mjs";
 
-export { EnvironmentParser };
+export { ConfigParser, EnvironmentParser };

package/dist/sst.cjs

@@ -1,5 +1,132 @@
-const require_sst = require('./sst-BSxwaAdz.cjs');
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const lodash_snakecase = require_chunk.__toESM(require("lodash.snakecase"));
 
-exports.ResourceType = require_sst.ResourceType;
-exports.environmentCase = require_sst.environmentCase;
-exports.normalizeResourceEnv = require_sst.normalizeResourceEnv;
+//#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;
+//# sourceMappingURL=sst.cjs.map

package/dist/sst.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sst.cjs","names":["name: string","value: Secret","key: string","value: Postgres","value: Bucket","value: any","processors: Record<ResourceType, ResourceProcessor<any>>","record: Record<string, Resource | string>","env: Record<string, string>"],"sources":["../src/sst.ts"],"sourcesContent":["import snakecase from 'lodash.snakecase';\n\n/**\n * Converts a string to environment variable case format (UPPER_SNAKE_CASE).\n * Numbers following underscores are preserved without the underscore.\n *\n * @param name - The string to convert\n * @returns The converted string in environment variable format\n *\n * @example\n * environmentCase('myVariable') // 'MY_VARIABLE'\n * environmentCase('api_v2') // 'APIV2'\n */\nexport function environmentCase(name: string) {\n  return snakecase(name)\n    .toUpperCase()\n    .replace(/_\\d+/g, (r) => {\n      return r.replace('_', '');\n    });\n}\n\n/**\n * Enumeration of supported SST (Serverless Stack Toolkit) resource types.\n * Used to identify and process different AWS and SST resources.\n */\nexport enum ResourceType {\n  ApiGatewayV2 = 'sst.aws.ApiGatewayV2',\n  Postgres = 'sst.aws.Postgres',\n  Function = 'sst.aws.Function',\n  Bucket = 'sst.aws.Bucket',\n  Vpc = 'sst.aws.Vpc',\n  Secret = 'sst.sst.Secret',\n  SSTSecret = 'sst:sst:Secret',\n  SSTFunction = 'sst:sst:Function',\n  SSTApiGatewayV2 = 'sst:aws:ApiGatewayV2',\n  SSTPostgres = 'sst:aws:Postgres',\n  SSTBucket = 'sst:aws:Bucket',\n}\n\n/**\n * Processes a Secret resource into environment variables.\n *\n * @param name - The resource name\n * @param value - The Secret resource\n * @returns Object with environment variable mappings\n */\nconst secret = (name: string, value: Secret) => ({\n  [environmentCase(name)]: value.value,\n});\n/**\n * Processes a Postgres database resource into environment variables.\n * Creates multiple environment variables for database connection details.\n *\n * @param key - The resource key\n * @param value - The Postgres resource\n * @returns Object with database connection environment variables\n */\nconst postgres = (key: string, value: Postgres) => {\n  const prefix = `${environmentCase(key)}`;\n  return {\n    [`${prefix}_NAME`]: value.database,\n    [`${prefix}_HOST`]: value.host,\n    [`${prefix}_PASSWORD`]: value.password,\n    [`${prefix}_PORT`]: value.port,\n    [`${prefix}_USERNAME`]: value.username,\n  };\n};\n\n/**\n * Processes a Bucket resource into environment variables.\n *\n * @param name - The resource name\n * @param value - The Bucket resource\n * @returns Object with bucket name environment variable\n */\nconst bucket = (name: string, value: Bucket) => {\n  const prefix = `${environmentCase(name)}`;\n  return {\n    [`${prefix}_NAME`]: value.name,\n  };\n};\n\n/**\n * No-operation processor for resources that don't require environment variables.\n *\n * @param name - The resource name (unused)\n * @param value - The resource value (unused)\n * @returns Empty object\n */\nconst noop = (name: string, value: any) => ({});\n\n/**\n * Map of resource types to their corresponding processor functions.\n * Each processor converts resource data into environment variables.\n */\nconst processors: Record<ResourceType, ResourceProcessor<any>> = {\n  [ResourceType.ApiGatewayV2]: noop,\n  [ResourceType.Function]: noop,\n  [ResourceType.Vpc]: noop,\n  [ResourceType.Secret]: secret,\n  [ResourceType.Postgres]: postgres,\n  [ResourceType.Bucket]: bucket,\n\n  [ResourceType.SSTSecret]: secret,\n  [ResourceType.SSTBucket]: bucket,\n  [ResourceType.SSTFunction]: noop,\n  [ResourceType.SSTPostgres]: postgres,\n  [ResourceType.SSTApiGatewayV2]: noop,\n};\n\n/**\n * Normalizes SST resources and plain strings into environment variables.\n * Processes resources based on their type and converts names to environment case.\n *\n * @param record - Object containing resources and/or string values\n * @returns Normalized environment variables object\n *\n * @example\n * normalizeResourceEnv({\n *   apiUrl: 'https://api.example.com',\n *   database: { type: ResourceType.Postgres, ... }\n * })\n */\nexport function normalizeResourceEnv(\n  record: Record<string, Resource | string>,\n): Record<string, string> {\n  const env: Record<string, string> = {};\n  for (const [k, value] of Object.entries(record)) {\n    if (typeof value === 'string') {\n      env[environmentCase(k)] = value;\n      continue;\n    }\n\n    const processor = processors[value.type];\n    if (processor) {\n      Object.assign(env, processor(k, value));\n    } else {\n      console.warn(`No processor found for resource type: `, { value });\n    }\n  }\n\n  return env;\n}\n\n/**\n * AWS API Gateway V2 resource type.\n * Represents an HTTP/WebSocket API.\n */\nexport type ApiGatewayV2 = {\n  type: ResourceType.ApiGatewayV2;\n  url: string;\n};\n\n/**\n * PostgreSQL database resource type.\n * Contains all connection details needed to connect to the database.\n */\nexport type Postgres = {\n  database: string;\n  host: string;\n  password: string;\n  port: number;\n  type: ResourceType.Postgres;\n  username: string;\n};\n\n/**\n * AWS Lambda Function resource type.\n */\nexport type Function = {\n  name: string;\n  type: ResourceType.Function;\n};\n\n/**\n * AWS S3 Bucket resource type.\n */\nexport type Bucket = {\n  name: string;\n  type: ResourceType.Bucket;\n};\n\n/**\n * AWS VPC (Virtual Private Cloud) resource type.\n */\nexport type Vpc = {\n  bastion: string;\n  type: ResourceType.Vpc;\n};\n\n/**\n * Secret resource type for storing sensitive values.\n */\nexport type Secret = {\n  type: ResourceType.Secret;\n  value: string;\n};\n\n/**\n * Union type of all supported SST resource types.\n */\nexport type Resource =\n  | ApiGatewayV2\n  | Postgres\n  | Function\n  | Bucket\n  | Vpc\n  | Secret;\n\n/**\n * Function type for processing a specific resource type into environment variables.\n *\n * @template K - The specific resource type\n * @param name - The resource name\n * @param value - The resource value\n * @returns Object mapping environment variable names to values\n */\nexport type ResourceProcessor<K extends Resource> = (\n  name: string,\n  value: K,\n) => Record<string, string | number>;\n"],"mappings":";;;;;;;;;;;;;;;AAaA,SAAgB,gBAAgBA,MAAc;AAC5C,QAAO,8BAAU,KAAK,CACnB,aAAa,CACb,QAAQ,SAAS,CAAC,MAAM;AACvB,SAAO,EAAE,QAAQ,KAAK,GAAG;CAC1B,EAAC;AACL;;;;;AAMD,IAAY,wDAAL;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACD;;;;;;;;AASD,MAAM,SAAS,CAACA,MAAcC,WAAmB,GAC9C,gBAAgB,KAAK,GAAG,MAAM,MAChC;;;;;;;;;AASD,MAAM,WAAW,CAACC,KAAaC,UAAoB;CACjD,MAAM,UAAU,EAAE,gBAAgB,IAAI,CAAC;AACvC,QAAO;IACH,EAAE,OAAO,SAAS,MAAM;IACxB,EAAE,OAAO,SAAS,MAAM;IACxB,EAAE,OAAO,aAAa,MAAM;IAC5B,EAAE,OAAO,SAAS,MAAM;IACxB,EAAE,OAAO,aAAa,MAAM;CAC/B;AACF;;;;;;;;AASD,MAAM,SAAS,CAACH,MAAcI,UAAkB;CAC9C,MAAM,UAAU,EAAE,gBAAgB,KAAK,CAAC;AACxC,QAAO,IACH,EAAE,OAAO,SAAS,MAAM,KAC3B;AACF;;;;;;;;AASD,MAAM,OAAO,CAACJ,MAAcK,WAAgB,CAAE;;;;;AAM9C,MAAMC,aAA2D;EAC9D,aAAa,eAAe;EAC5B,aAAa,WAAW;EACxB,aAAa,MAAM;EACnB,aAAa,SAAS;EACtB,aAAa,WAAW;EACxB,aAAa,SAAS;EAEtB,aAAa,YAAY;EACzB,aAAa,YAAY;EACzB,aAAa,cAAc;EAC3B,aAAa,cAAc;EAC3B,aAAa,kBAAkB;AACjC;;;;;;;;;;;;;;AAeD,SAAgB,qBACdC,QACwB;CACxB,MAAMC,MAA8B,CAAE;AACtC,MAAK,MAAM,CAAC,GAAG,MAAM,IAAI,OAAO,QAAQ,OAAO,EAAE;AAC/C,aAAW,UAAU,UAAU;AAC7B,OAAI,gBAAgB,EAAE,IAAI;AAC1B;EACD;EAED,MAAM,YAAY,WAAW,MAAM;AACnC,MAAI,UACF,QAAO,OAAO,KAAK,UAAU,GAAG,MAAM,CAAC;MAEvC,SAAQ,MAAM,yCAAyC,EAAE,MAAO,EAAC;CAEpE;AAED,QAAO;AACR"}

package/dist/sst.d.cts

@@ -104,4 +104,5 @@ type Resource = ApiGatewayV2 | Postgres | Function | Bucket | Vpc | Secret;
  */
 type ResourceProcessor<K extends Resource> = (name: string, value: K) => Record<string, string | number>;
 //#endregion
-export { ApiGatewayV2, Bucket, Function, Postgres, Resource, ResourceProcessor, ResourceType, Secret, Vpc, environmentCase, normalizeResourceEnv };
+export { ApiGatewayV2, Bucket, Function, Postgres, Resource, ResourceProcessor, ResourceType, Secret, Vpc, environmentCase, normalizeResourceEnv };
+//# sourceMappingURL=sst.d.cts.map

package/dist/sst.d.mts

@@ -104,4 +104,5 @@ type Resource = ApiGatewayV2 | Postgres | Function | Bucket | Vpc | Secret;
  */
 type ResourceProcessor<K extends Resource> = (name: string, value: K) => Record<string, string | number>;
 //#endregion
-export { ApiGatewayV2, Bucket, Function, Postgres, Resource, ResourceProcessor, ResourceType, Secret, Vpc, environmentCase, normalizeResourceEnv };
+export { ApiGatewayV2, Bucket, Function, Postgres, Resource, ResourceProcessor, ResourceType, Secret, Vpc, environmentCase, normalizeResourceEnv };
+//# sourceMappingURL=sst.d.mts.map

package/dist/sst.mjs

@@ -1,3 +1,129 @@
-import { ResourceType, environmentCase, normalizeResourceEnv } from "./sst-CQhO0S6y.mjs";
+import snakecase from "lodash.snakecase";
 
-export { ResourceType, environmentCase, normalizeResourceEnv };
+//#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 snakecase(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
+export { ResourceType, environmentCase, normalizeResourceEnv };
+//# sourceMappingURL=sst.mjs.map

package/dist/sst.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sst.mjs","names":["name: string","value: Secret","key: string","value: Postgres","value: Bucket","value: any","processors: Record<ResourceType, ResourceProcessor<any>>","record: Record<string, Resource | string>","env: Record<string, string>"],"sources":["../src/sst.ts"],"sourcesContent":["import snakecase from 'lodash.snakecase';\n\n/**\n * Converts a string to environment variable case format (UPPER_SNAKE_CASE).\n * Numbers following underscores are preserved without the underscore.\n *\n * @param name - The string to convert\n * @returns The converted string in environment variable format\n *\n * @example\n * environmentCase('myVariable') // 'MY_VARIABLE'\n * environmentCase('api_v2') // 'APIV2'\n */\nexport function environmentCase(name: string) {\n  return snakecase(name)\n    .toUpperCase()\n    .replace(/_\\d+/g, (r) => {\n      return r.replace('_', '');\n    });\n}\n\n/**\n * Enumeration of supported SST (Serverless Stack Toolkit) resource types.\n * Used to identify and process different AWS and SST resources.\n */\nexport enum ResourceType {\n  ApiGatewayV2 = 'sst.aws.ApiGatewayV2',\n  Postgres = 'sst.aws.Postgres',\n  Function = 'sst.aws.Function',\n  Bucket = 'sst.aws.Bucket',\n  Vpc = 'sst.aws.Vpc',\n  Secret = 'sst.sst.Secret',\n  SSTSecret = 'sst:sst:Secret',\n  SSTFunction = 'sst:sst:Function',\n  SSTApiGatewayV2 = 'sst:aws:ApiGatewayV2',\n  SSTPostgres = 'sst:aws:Postgres',\n  SSTBucket = 'sst:aws:Bucket',\n}\n\n/**\n * Processes a Secret resource into environment variables.\n *\n * @param name - The resource name\n * @param value - The Secret resource\n * @returns Object with environment variable mappings\n */\nconst secret = (name: string, value: Secret) => ({\n  [environmentCase(name)]: value.value,\n});\n/**\n * Processes a Postgres database resource into environment variables.\n * Creates multiple environment variables for database connection details.\n *\n * @param key - The resource key\n * @param value - The Postgres resource\n * @returns Object with database connection environment variables\n */\nconst postgres = (key: string, value: Postgres) => {\n  const prefix = `${environmentCase(key)}`;\n  return {\n    [`${prefix}_NAME`]: value.database,\n    [`${prefix}_HOST`]: value.host,\n    [`${prefix}_PASSWORD`]: value.password,\n    [`${prefix}_PORT`]: value.port,\n    [`${prefix}_USERNAME`]: value.username,\n  };\n};\n\n/**\n * Processes a Bucket resource into environment variables.\n *\n * @param name - The resource name\n * @param value - The Bucket resource\n * @returns Object with bucket name environment variable\n */\nconst bucket = (name: string, value: Bucket) => {\n  const prefix = `${environmentCase(name)}`;\n  return {\n    [`${prefix}_NAME`]: value.name,\n  };\n};\n\n/**\n * No-operation processor for resources that don't require environment variables.\n *\n * @param name - The resource name (unused)\n * @param value - The resource value (unused)\n * @returns Empty object\n */\nconst noop = (name: string, value: any) => ({});\n\n/**\n * Map of resource types to their corresponding processor functions.\n * Each processor converts resource data into environment variables.\n */\nconst processors: Record<ResourceType, ResourceProcessor<any>> = {\n  [ResourceType.ApiGatewayV2]: noop,\n  [ResourceType.Function]: noop,\n  [ResourceType.Vpc]: noop,\n  [ResourceType.Secret]: secret,\n  [ResourceType.Postgres]: postgres,\n  [ResourceType.Bucket]: bucket,\n\n  [ResourceType.SSTSecret]: secret,\n  [ResourceType.SSTBucket]: bucket,\n  [ResourceType.SSTFunction]: noop,\n  [ResourceType.SSTPostgres]: postgres,\n  [ResourceType.SSTApiGatewayV2]: noop,\n};\n\n/**\n * Normalizes SST resources and plain strings into environment variables.\n * Processes resources based on their type and converts names to environment case.\n *\n * @param record - Object containing resources and/or string values\n * @returns Normalized environment variables object\n *\n * @example\n * normalizeResourceEnv({\n *   apiUrl: 'https://api.example.com',\n *   database: { type: ResourceType.Postgres, ... }\n * })\n */\nexport function normalizeResourceEnv(\n  record: Record<string, Resource | string>,\n): Record<string, string> {\n  const env: Record<string, string> = {};\n  for (const [k, value] of Object.entries(record)) {\n    if (typeof value === 'string') {\n      env[environmentCase(k)] = value;\n      continue;\n    }\n\n    const processor = processors[value.type];\n    if (processor) {\n      Object.assign(env, processor(k, value));\n    } else {\n      console.warn(`No processor found for resource type: `, { value });\n    }\n  }\n\n  return env;\n}\n\n/**\n * AWS API Gateway V2 resource type.\n * Represents an HTTP/WebSocket API.\n */\nexport type ApiGatewayV2 = {\n  type: ResourceType.ApiGatewayV2;\n  url: string;\n};\n\n/**\n * PostgreSQL database resource type.\n * Contains all connection details needed to connect to the database.\n */\nexport type Postgres = {\n  database: string;\n  host: string;\n  password: string;\n  port: number;\n  type: ResourceType.Postgres;\n  username: string;\n};\n\n/**\n * AWS Lambda Function resource type.\n */\nexport type Function = {\n  name: string;\n  type: ResourceType.Function;\n};\n\n/**\n * AWS S3 Bucket resource type.\n */\nexport type Bucket = {\n  name: string;\n  type: ResourceType.Bucket;\n};\n\n/**\n * AWS VPC (Virtual Private Cloud) resource type.\n */\nexport type Vpc = {\n  bastion: string;\n  type: ResourceType.Vpc;\n};\n\n/**\n * Secret resource type for storing sensitive values.\n */\nexport type Secret = {\n  type: ResourceType.Secret;\n  value: string;\n};\n\n/**\n * Union type of all supported SST resource types.\n */\nexport type Resource =\n  | ApiGatewayV2\n  | Postgres\n  | Function\n  | Bucket\n  | Vpc\n  | Secret;\n\n/**\n * Function type for processing a specific resource type into environment variables.\n *\n * @template K - The specific resource type\n * @param name - The resource name\n * @param value - The resource value\n * @returns Object mapping environment variable names to values\n */\nexport type ResourceProcessor<K extends Resource> = (\n  name: string,\n  value: K,\n) => Record<string, string | number>;\n"],"mappings":";;;;;;;;;;;;;;AAaA,SAAgB,gBAAgBA,MAAc;AAC5C,QAAO,UAAU,KAAK,CACnB,aAAa,CACb,QAAQ,SAAS,CAAC,MAAM;AACvB,SAAO,EAAE,QAAQ,KAAK,GAAG;CAC1B,EAAC;AACL;;;;;AAMD,IAAY,wDAAL;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACD;;;;;;;;AASD,MAAM,SAAS,CAACA,MAAcC,WAAmB,GAC9C,gBAAgB,KAAK,GAAG,MAAM,MAChC;;;;;;;;;AASD,MAAM,WAAW,CAACC,KAAaC,UAAoB;CACjD,MAAM,UAAU,EAAE,gBAAgB,IAAI,CAAC;AACvC,QAAO;IACH,EAAE,OAAO,SAAS,MAAM;IACxB,EAAE,OAAO,SAAS,MAAM;IACxB,EAAE,OAAO,aAAa,MAAM;IAC5B,EAAE,OAAO,SAAS,MAAM;IACxB,EAAE,OAAO,aAAa,MAAM;CAC/B;AACF;;;;;;;;AASD,MAAM,SAAS,CAACH,MAAcI,UAAkB;CAC9C,MAAM,UAAU,EAAE,gBAAgB,KAAK,CAAC;AACxC,QAAO,IACH,EAAE,OAAO,SAAS,MAAM,KAC3B;AACF;;;;;;;;AASD,MAAM,OAAO,CAACJ,MAAcK,WAAgB,CAAE;;;;;AAM9C,MAAMC,aAA2D;EAC9D,aAAa,eAAe;EAC5B,aAAa,WAAW;EACxB,aAAa,MAAM;EACnB,aAAa,SAAS;EACtB,aAAa,WAAW;EACxB,aAAa,SAAS;EAEtB,aAAa,YAAY;EACzB,aAAa,YAAY;EACzB,aAAa,cAAc;EAC3B,aAAa,cAAc;EAC3B,aAAa,kBAAkB;AACjC;;;;;;;;;;;;;;AAeD,SAAgB,qBACdC,QACwB;CACxB,MAAMC,MAA8B,CAAE;AACtC,MAAK,MAAM,CAAC,GAAG,MAAM,IAAI,OAAO,QAAQ,OAAO,EAAE;AAC/C,aAAW,UAAU,UAAU;AAC7B,OAAI,gBAAgB,EAAE,IAAI;AAC1B;EACD;EAED,MAAM,YAAY,WAAW,MAAM;AACnC,MAAI,UACF,QAAO,OAAO,KAAK,UAAU,GAAG,MAAM,CAAC;MAEvC,SAAQ,MAAM,yCAAyC,EAAE,MAAO,EAAC;CAEpE;AAED,QAAO;AACR"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/envkit",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "private": false,
   "type": "module",
   "exports": {
@@ -13,6 +13,11 @@
       "types": "./dist/sst.d.ts",
       "import": "./dist/sst.mjs",
       "require": "./dist/sst.cjs"
+    },
+    "./sniffer": {
+      "types": "./dist/SnifferEnvironmentParser.d.ts",
+      "import": "./dist/SnifferEnvironmentParser.mjs",
+      "require": "./dist/SnifferEnvironmentParser.cjs"
     }
   },
   "publishConfig": {

package/src/EnvironmentParser.ts

@@ -13,8 +13,12 @@ export class ConfigParser<TResponse extends EmptyObject> {
    * Creates a new ConfigParser instance.
    *
    * @param config - The configuration object to parse
+   * @param envVars - Set of environment variable names that were accessed
    */
-  constructor(private readonly config: TResponse) {}
+  constructor(
+    private readonly config: TResponse,
+    private readonly envVars: Set<string> = new Set(),
+  ) {}
   /**
    * Parses the config object and validates it against the Zod schemas
    * @returns The parsed config object
@@ -65,6 +69,26 @@ export class ConfigParser<TResponse extends EmptyObject> {
 
     return parsedConfig;
   }
+
+  /**
+   * Returns an array of environment variable names that were accessed during config creation.
+   * This is useful for deployment and configuration management to know which env vars are required.
+   *
+   * @returns Array of environment variable names, sorted alphabetically
+   *
+   * @example
+   * ```typescript
+   * const config = envParser.create((get) => ({
+   *   dbUrl: get('DATABASE_URL').string(),
+   *   port: get('PORT').number()
+   * }));
+   *
+   * config.getEnvironmentVariables(); // ['DATABASE_URL', 'PORT']
+   * ```
+   */
+  getEnvironmentVariables(): string[] {
+    return Array.from(this.envVars).sort();
+  }
 }
 
 /**
@@ -87,6 +111,11 @@ export class ConfigParser<TResponse extends EmptyObject> {
  * ```
  */
 export class EnvironmentParser<T extends EmptyObject> {
+  /**
+   * Set to track which environment variable names have been accessed
+   */
+  private readonly accessedVars: Set<string> = new Set();
+
   /**
    * Creates a new EnvironmentParser instance.
    *
@@ -177,6 +206,9 @@ export class EnvironmentParser<T extends EmptyObject> {
    * @returns A proxied Zod object with wrapped schema creators
    */
   private getZodGetter = (name: string) => {
+    // Track that this environment variable was accessed
+    this.accessedVars.add(name);
+
     // Return an object that has all Zod schemas but with our wrapper
     return new Proxy(
       { ...z },
@@ -227,7 +259,24 @@ export class EnvironmentParser<T extends EmptyObject> {
     builder: (get: EnvFetcher) => TReturn,
   ): ConfigParser<TReturn> {
     const config = builder(this.getZodGetter);
-    return new ConfigParser(config);
+    return new ConfigParser(config, this.accessedVars);
+  }
+
+  /**
+   * Returns an array of environment variable names that were accessed via the getter.
+   * This is useful for build-time analysis to determine which env vars a service needs.
+   *
+   * @returns Array of environment variable names, sorted alphabetically
+   *
+   * @example
+   * ```typescript
+   * const sniffer = new EnvironmentParser({});
+   * service.register(sniffer);
+   * const envVars = sniffer.getEnvironmentVariables(); // ['DATABASE_URL', 'PORT']
+   * ```
+   */
+  getEnvironmentVariables(): string[] {
+    return Array.from(this.accessedVars).sort();
   }
 }