@geekmidas/envkit 0.0.7 → 0.1.0

package/dist/EnvironmentBuilder-DfmYRBm-.mjs

@@ -0,0 +1,83 @@
+import snakecase from "lodash.snakecase";
+
+//#region src/EnvironmentBuilder.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('apiV2') // 'APIV2'
+*/
+function environmentCase(name) {
+	return snakecase(name).toUpperCase().replace(/_\d+/g, (r) => {
+		return r.replace("_", "");
+	});
+}
+/**
+* A generic, extensible class for building environment variables from
+* objects with type-discriminated values.
+*
+* @template TRecord - The input record type for type inference
+* @template TResolvers - The resolvers type (defaults to TypedResolvers<TRecord>)
+*
+* @example
+* ```typescript
+* const env = new EnvironmentBuilder(
+*   {
+*     apiKey: { type: 'secret', value: 'xyz' },
+*     appName: 'my-app'
+*   },
+*   {
+*     // `value` is typed as { value: string } (without `type`)
+*     secret: (key, value) => ({ [key]: value.value }),
+*   }
+* ).build();
+* // { API_KEY: 'xyz', APP_NAME: 'my-app' }
+* ```
+*/
+var EnvironmentBuilder = class {
+	record;
+	resolvers;
+	options;
+	constructor(record, resolvers, options = {}) {
+		this.record = record;
+		this.resolvers = resolvers;
+		this.options = { onUnmatchedValue: options.onUnmatchedValue ?? ((key, value) => {
+			console.warn(`No resolver found for key "${key}":`, { value });
+		}) };
+	}
+	/**
+	* Build environment variables from the input record.
+	*
+	* - Plain string values are passed through with key transformation
+	* - Object values with a `type` property are matched against resolvers
+	* - Resolvers receive values without the `type` key
+	* - Only root-level keys are transformed to UPPER_SNAKE_CASE
+	*
+	* @returns A record of environment variables
+	*/
+	build() {
+		const env = {};
+		for (const [key, value] of Object.entries(this.record)) {
+			if (typeof value === "string") {
+				env[environmentCase(key)] = value;
+				continue;
+			}
+			const { type,...rest } = value;
+			const resolver = this.resolvers[type];
+			if (resolver) {
+				const resolved = resolver(key, rest);
+				for (const [resolvedKey, resolvedValue] of Object.entries(resolved)) env[environmentCase(resolvedKey)] = resolvedValue;
+			} else this.options.onUnmatchedValue(key, value);
+		}
+		return env;
+	}
+};
+
+//#endregion
+export { EnvironmentBuilder, environmentCase };
+//# sourceMappingURL=EnvironmentBuilder-DfmYRBm-.mjs.map

package/dist/EnvironmentBuilder-DfmYRBm-.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnvironmentBuilder-DfmYRBm-.mjs","names":["name: string","record: TRecord","resolvers: TResolvers","options: EnvironmentBuilderOptions","env: EnvRecord"],"sources":["../src/EnvironmentBuilder.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('apiV2') // 'APIV2'\n */\nexport function environmentCase(name: string): string {\n  return snakecase(name)\n    .toUpperCase()\n    .replace(/_\\d+/g, (r) => {\n      return r.replace('_', '');\n    });\n}\n\n/**\n * A record of environment variable names to their values.\n * Values can be primitives or nested records.\n */\nexport interface EnvRecord {\n  [key: string]: EnvValue;\n}\n\n/**\n * Represents a value that can be stored in an environment record.\n * Can be a primitive value or a nested record of environment values.\n */\nexport type EnvValue = string | number | boolean | EnvRecord;\n\n/**\n * A resolver function that converts a typed value into environment variables.\n *\n * @template T - The type of value this resolver handles (without the `type` key)\n * @param key - The key name from the input record\n * @param value - The value to resolve (without the `type` key)\n * @returns A record of environment variable names to their values\n */\nexport type EnvironmentResolver<T = any> = (key: string, value: T) => EnvRecord;\n\n/**\n * A map of type discriminator strings to their resolver functions.\n */\nexport type Resolvers = Record<string, EnvironmentResolver<any>>;\n\n/**\n * Options for configuring the EnvironmentBuilder.\n */\nexport interface EnvironmentBuilderOptions {\n  /**\n   * Handler called when a value's type doesn't match any registered resolver.\n   * Defaults to console.warn.\n   */\n  onUnmatchedValue?: (key: string, value: unknown) => void;\n}\n\n/**\n * Input value type - either a string or an object with a `type` discriminator.\n */\nexport type InputValue = string | { type: string; [key: string]: unknown };\n\n/**\n * Base type for typed input values with a specific type discriminator.\n */\nexport type TypedInputValue<TType extends string = string> = {\n  type: TType;\n  [key: string]: unknown;\n};\n\n/**\n * Extracts the `type` string value from an input value.\n */\ntype ExtractType<T> = T extends { type: infer U extends string } ? U : never;\n\n/**\n * Removes the `type` key from an object type.\n */\ntype OmitType<T> = T extends { type: string } ? Omit<T, 'type'> : never;\n\n/**\n * Extracts all unique `type` values from a record (excluding plain strings).\n */\ntype AllTypeValues<TRecord extends Record<string, InputValue>> = {\n  [K in keyof TRecord]: ExtractType<TRecord[K]>;\n}[keyof TRecord];\n\n/**\n * For a given type value, finds the corresponding value type (without `type` key).\n */\ntype ValueForType<\n  TRecord extends Record<string, InputValue>,\n  TType extends string,\n> = {\n  [K in keyof TRecord]: TRecord[K] extends { type: TType }\n    ? OmitType<TRecord[K]>\n    : never;\n}[keyof TRecord];\n\n/**\n * Generates typed resolvers based on the input record.\n * Keys are the `type` values, values are resolver functions receiving the value without `type`.\n */\nexport type TypedResolvers<TRecord extends Record<string, InputValue>> = {\n  [TType in AllTypeValues<TRecord>]: EnvironmentResolver<\n    ValueForType<TRecord, TType>\n  >;\n};\n\n/**\n * A generic, extensible class for building environment variables from\n * objects with type-discriminated values.\n *\n * @template TRecord - The input record type for type inference\n * @template TResolvers - The resolvers type (defaults to TypedResolvers<TRecord>)\n *\n * @example\n * ```typescript\n * const env = new EnvironmentBuilder(\n *   {\n *     apiKey: { type: 'secret', value: 'xyz' },\n *     appName: 'my-app'\n *   },\n *   {\n *     // `value` is typed as { value: string } (without `type`)\n *     secret: (key, value) => ({ [key]: value.value }),\n *   }\n * ).build();\n * // { API_KEY: 'xyz', APP_NAME: 'my-app' }\n * ```\n */\nexport class EnvironmentBuilder<\n  TRecord extends Record<string, InputValue> = Record<string, InputValue>,\n  TResolvers extends Resolvers = TypedResolvers<TRecord>,\n> {\n  private readonly record: TRecord;\n  private readonly resolvers: TResolvers;\n  private readonly options: Required<EnvironmentBuilderOptions>;\n\n  constructor(\n    record: TRecord,\n    resolvers: TResolvers,\n    options: EnvironmentBuilderOptions = {},\n  ) {\n    this.record = record;\n    this.resolvers = resolvers;\n    this.options = {\n      onUnmatchedValue:\n        options.onUnmatchedValue ??\n        ((key, value) => {\n          console.warn(`No resolver found for key \"${key}\":`, { value });\n        }),\n    };\n  }\n\n  /**\n   * Build environment variables from the input record.\n   *\n   * - Plain string values are passed through with key transformation\n   * - Object values with a `type` property are matched against resolvers\n   * - Resolvers receive values without the `type` key\n   * - Only root-level keys are transformed to UPPER_SNAKE_CASE\n   *\n   * @returns A record of environment variables\n   */\n  build(): EnvRecord {\n    const env: EnvRecord = {};\n\n    for (const [key, value] of Object.entries(this.record)) {\n      // Handle plain string values\n      if (typeof value === 'string') {\n        env[environmentCase(key)] = value;\n        continue;\n      }\n\n      // Handle objects with type discriminator\n      const { type, ...rest } = value;\n      const resolver = this.resolvers[type];\n      if (resolver) {\n        const resolved = resolver(key, rest);\n        // Transform only root-level keys from resolver output\n        for (const [resolvedKey, resolvedValue] of Object.entries(resolved)) {\n          env[environmentCase(resolvedKey)] = resolvedValue;\n        }\n      } else {\n        this.options.onUnmatchedValue(key, value);\n      }\n    }\n\n    return env;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,SAAgB,gBAAgBA,MAAsB;AACpD,QAAO,UAAU,KAAK,CACnB,aAAa,CACb,QAAQ,SAAS,CAAC,MAAM;AACvB,SAAO,EAAE,QAAQ,KAAK,GAAG;CAC1B,EAAC;AACL;;;;;;;;;;;;;;;;;;;;;;;AAoHD,IAAa,qBAAb,MAGE;CACA,AAAiB;CACjB,AAAiB;CACjB,AAAiB;CAEjB,YACEC,QACAC,WACAC,UAAqC,CAAE,GACvC;AACA,OAAK,SAAS;AACd,OAAK,YAAY;AACjB,OAAK,UAAU,EACb,kBACE,QAAQ,qBACP,CAAC,KAAK,UAAU;AACf,WAAQ,MAAM,6BAA6B,IAAI,KAAK,EAAE,MAAO,EAAC;EAC/D,GACJ;CACF;;;;;;;;;;;CAYD,QAAmB;EACjB,MAAMC,MAAiB,CAAE;AAEzB,OAAK,MAAM,CAAC,KAAK,MAAM,IAAI,OAAO,QAAQ,KAAK,OAAO,EAAE;AAEtD,cAAW,UAAU,UAAU;AAC7B,QAAI,gBAAgB,IAAI,IAAI;AAC5B;GACD;GAGD,MAAM,EAAE,KAAM,GAAG,MAAM,GAAG;GAC1B,MAAM,WAAW,KAAK,UAAU;AAChC,OAAI,UAAU;IACZ,MAAM,WAAW,SAAS,KAAK,KAAK;AAEpC,SAAK,MAAM,CAAC,aAAa,cAAc,IAAI,OAAO,QAAQ,SAAS,CACjE,KAAI,gBAAgB,YAAY,IAAI;GAEvC,MACC,MAAK,QAAQ,iBAAiB,KAAK,MAAM;EAE5C;AAED,SAAO;CACR;AACF"}

package/dist/EnvironmentBuilder-W2wku49g.cjs

@@ -0,0 +1,95 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const lodash_snakecase = require_chunk.__toESM(require("lodash.snakecase"));
+
+//#region src/EnvironmentBuilder.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('apiV2') // 'APIV2'
+*/
+function environmentCase(name) {
+	return (0, lodash_snakecase.default)(name).toUpperCase().replace(/_\d+/g, (r) => {
+		return r.replace("_", "");
+	});
+}
+/**
+* A generic, extensible class for building environment variables from
+* objects with type-discriminated values.
+*
+* @template TRecord - The input record type for type inference
+* @template TResolvers - The resolvers type (defaults to TypedResolvers<TRecord>)
+*
+* @example
+* ```typescript
+* const env = new EnvironmentBuilder(
+*   {
+*     apiKey: { type: 'secret', value: 'xyz' },
+*     appName: 'my-app'
+*   },
+*   {
+*     // `value` is typed as { value: string } (without `type`)
+*     secret: (key, value) => ({ [key]: value.value }),
+*   }
+* ).build();
+* // { API_KEY: 'xyz', APP_NAME: 'my-app' }
+* ```
+*/
+var EnvironmentBuilder = class {
+	record;
+	resolvers;
+	options;
+	constructor(record, resolvers, options = {}) {
+		this.record = record;
+		this.resolvers = resolvers;
+		this.options = { onUnmatchedValue: options.onUnmatchedValue ?? ((key, value) => {
+			console.warn(`No resolver found for key "${key}":`, { value });
+		}) };
+	}
+	/**
+	* Build environment variables from the input record.
+	*
+	* - Plain string values are passed through with key transformation
+	* - Object values with a `type` property are matched against resolvers
+	* - Resolvers receive values without the `type` key
+	* - Only root-level keys are transformed to UPPER_SNAKE_CASE
+	*
+	* @returns A record of environment variables
+	*/
+	build() {
+		const env = {};
+		for (const [key, value] of Object.entries(this.record)) {
+			if (typeof value === "string") {
+				env[environmentCase(key)] = value;
+				continue;
+			}
+			const { type,...rest } = value;
+			const resolver = this.resolvers[type];
+			if (resolver) {
+				const resolved = resolver(key, rest);
+				for (const [resolvedKey, resolvedValue] of Object.entries(resolved)) env[environmentCase(resolvedKey)] = resolvedValue;
+			} else this.options.onUnmatchedValue(key, value);
+		}
+		return env;
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'EnvironmentBuilder', {
+  enumerable: true,
+  get: function () {
+    return EnvironmentBuilder;
+  }
+});
+Object.defineProperty(exports, 'environmentCase', {
+  enumerable: true,
+  get: function () {
+    return environmentCase;
+  }
+});
+//# sourceMappingURL=EnvironmentBuilder-W2wku49g.cjs.map

package/dist/EnvironmentBuilder-W2wku49g.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnvironmentBuilder-W2wku49g.cjs","names":["name: string","record: TRecord","resolvers: TResolvers","options: EnvironmentBuilderOptions","env: EnvRecord"],"sources":["../src/EnvironmentBuilder.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('apiV2') // 'APIV2'\n */\nexport function environmentCase(name: string): string {\n  return snakecase(name)\n    .toUpperCase()\n    .replace(/_\\d+/g, (r) => {\n      return r.replace('_', '');\n    });\n}\n\n/**\n * A record of environment variable names to their values.\n * Values can be primitives or nested records.\n */\nexport interface EnvRecord {\n  [key: string]: EnvValue;\n}\n\n/**\n * Represents a value that can be stored in an environment record.\n * Can be a primitive value or a nested record of environment values.\n */\nexport type EnvValue = string | number | boolean | EnvRecord;\n\n/**\n * A resolver function that converts a typed value into environment variables.\n *\n * @template T - The type of value this resolver handles (without the `type` key)\n * @param key - The key name from the input record\n * @param value - The value to resolve (without the `type` key)\n * @returns A record of environment variable names to their values\n */\nexport type EnvironmentResolver<T = any> = (key: string, value: T) => EnvRecord;\n\n/**\n * A map of type discriminator strings to their resolver functions.\n */\nexport type Resolvers = Record<string, EnvironmentResolver<any>>;\n\n/**\n * Options for configuring the EnvironmentBuilder.\n */\nexport interface EnvironmentBuilderOptions {\n  /**\n   * Handler called when a value's type doesn't match any registered resolver.\n   * Defaults to console.warn.\n   */\n  onUnmatchedValue?: (key: string, value: unknown) => void;\n}\n\n/**\n * Input value type - either a string or an object with a `type` discriminator.\n */\nexport type InputValue = string | { type: string; [key: string]: unknown };\n\n/**\n * Base type for typed input values with a specific type discriminator.\n */\nexport type TypedInputValue<TType extends string = string> = {\n  type: TType;\n  [key: string]: unknown;\n};\n\n/**\n * Extracts the `type` string value from an input value.\n */\ntype ExtractType<T> = T extends { type: infer U extends string } ? U : never;\n\n/**\n * Removes the `type` key from an object type.\n */\ntype OmitType<T> = T extends { type: string } ? Omit<T, 'type'> : never;\n\n/**\n * Extracts all unique `type` values from a record (excluding plain strings).\n */\ntype AllTypeValues<TRecord extends Record<string, InputValue>> = {\n  [K in keyof TRecord]: ExtractType<TRecord[K]>;\n}[keyof TRecord];\n\n/**\n * For a given type value, finds the corresponding value type (without `type` key).\n */\ntype ValueForType<\n  TRecord extends Record<string, InputValue>,\n  TType extends string,\n> = {\n  [K in keyof TRecord]: TRecord[K] extends { type: TType }\n    ? OmitType<TRecord[K]>\n    : never;\n}[keyof TRecord];\n\n/**\n * Generates typed resolvers based on the input record.\n * Keys are the `type` values, values are resolver functions receiving the value without `type`.\n */\nexport type TypedResolvers<TRecord extends Record<string, InputValue>> = {\n  [TType in AllTypeValues<TRecord>]: EnvironmentResolver<\n    ValueForType<TRecord, TType>\n  >;\n};\n\n/**\n * A generic, extensible class for building environment variables from\n * objects with type-discriminated values.\n *\n * @template TRecord - The input record type for type inference\n * @template TResolvers - The resolvers type (defaults to TypedResolvers<TRecord>)\n *\n * @example\n * ```typescript\n * const env = new EnvironmentBuilder(\n *   {\n *     apiKey: { type: 'secret', value: 'xyz' },\n *     appName: 'my-app'\n *   },\n *   {\n *     // `value` is typed as { value: string } (without `type`)\n *     secret: (key, value) => ({ [key]: value.value }),\n *   }\n * ).build();\n * // { API_KEY: 'xyz', APP_NAME: 'my-app' }\n * ```\n */\nexport class EnvironmentBuilder<\n  TRecord extends Record<string, InputValue> = Record<string, InputValue>,\n  TResolvers extends Resolvers = TypedResolvers<TRecord>,\n> {\n  private readonly record: TRecord;\n  private readonly resolvers: TResolvers;\n  private readonly options: Required<EnvironmentBuilderOptions>;\n\n  constructor(\n    record: TRecord,\n    resolvers: TResolvers,\n    options: EnvironmentBuilderOptions = {},\n  ) {\n    this.record = record;\n    this.resolvers = resolvers;\n    this.options = {\n      onUnmatchedValue:\n        options.onUnmatchedValue ??\n        ((key, value) => {\n          console.warn(`No resolver found for key \"${key}\":`, { value });\n        }),\n    };\n  }\n\n  /**\n   * Build environment variables from the input record.\n   *\n   * - Plain string values are passed through with key transformation\n   * - Object values with a `type` property are matched against resolvers\n   * - Resolvers receive values without the `type` key\n   * - Only root-level keys are transformed to UPPER_SNAKE_CASE\n   *\n   * @returns A record of environment variables\n   */\n  build(): EnvRecord {\n    const env: EnvRecord = {};\n\n    for (const [key, value] of Object.entries(this.record)) {\n      // Handle plain string values\n      if (typeof value === 'string') {\n        env[environmentCase(key)] = value;\n        continue;\n      }\n\n      // Handle objects with type discriminator\n      const { type, ...rest } = value;\n      const resolver = this.resolvers[type];\n      if (resolver) {\n        const resolved = resolver(key, rest);\n        // Transform only root-level keys from resolver output\n        for (const [resolvedKey, resolvedValue] of Object.entries(resolved)) {\n          env[environmentCase(resolvedKey)] = resolvedValue;\n        }\n      } else {\n        this.options.onUnmatchedValue(key, value);\n      }\n    }\n\n    return env;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAaA,SAAgB,gBAAgBA,MAAsB;AACpD,QAAO,8BAAU,KAAK,CACnB,aAAa,CACb,QAAQ,SAAS,CAAC,MAAM;AACvB,SAAO,EAAE,QAAQ,KAAK,GAAG;CAC1B,EAAC;AACL;;;;;;;;;;;;;;;;;;;;;;;AAoHD,IAAa,qBAAb,MAGE;CACA,AAAiB;CACjB,AAAiB;CACjB,AAAiB;CAEjB,YACEC,QACAC,WACAC,UAAqC,CAAE,GACvC;AACA,OAAK,SAAS;AACd,OAAK,YAAY;AACjB,OAAK,UAAU,EACb,kBACE,QAAQ,qBACP,CAAC,KAAK,UAAU;AACf,WAAQ,MAAM,6BAA6B,IAAI,KAAK,EAAE,MAAO,EAAC;EAC/D,GACJ;CACF;;;;;;;;;;;CAYD,QAAmB;EACjB,MAAMC,MAAiB,CAAE;AAEzB,OAAK,MAAM,CAAC,KAAK,MAAM,IAAI,OAAO,QAAQ,KAAK,OAAO,EAAE;AAEtD,cAAW,UAAU,UAAU;AAC7B,QAAI,gBAAgB,IAAI,IAAI;AAC5B;GACD;GAGD,MAAM,EAAE,KAAM,GAAG,MAAM,GAAG;GAC1B,MAAM,WAAW,KAAK,UAAU;AAChC,OAAI,UAAU;IACZ,MAAM,WAAW,SAAS,KAAK,KAAK;AAEpC,SAAK,MAAM,CAAC,aAAa,cAAc,IAAI,OAAO,QAAQ,SAAS,CACjE,KAAI,gBAAgB,YAAY,IAAI;GAEvC,MACC,MAAK,QAAQ,iBAAiB,KAAK,MAAM;EAE5C;AAED,SAAO;CACR;AACF"}

package/dist/EnvironmentBuilder-Xuf2Dd9u.d.cts

@@ -0,0 +1,131 @@
+//#region src/EnvironmentBuilder.d.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('apiV2') // 'APIV2'
+ */
+declare function environmentCase(name: string): string;
+/**
+ * A record of environment variable names to their values.
+ * Values can be primitives or nested records.
+ */
+interface EnvRecord {
+  [key: string]: EnvValue;
+}
+/**
+ * Represents a value that can be stored in an environment record.
+ * Can be a primitive value or a nested record of environment values.
+ */
+type EnvValue = string | number | boolean | EnvRecord;
+/**
+ * A resolver function that converts a typed value into environment variables.
+ *
+ * @template T - The type of value this resolver handles (without the `type` key)
+ * @param key - The key name from the input record
+ * @param value - The value to resolve (without the `type` key)
+ * @returns A record of environment variable names to their values
+ */
+type EnvironmentResolver<T = any> = (key: string, value: T) => EnvRecord;
+/**
+ * A map of type discriminator strings to their resolver functions.
+ */
+type Resolvers = Record<string, EnvironmentResolver<any>>;
+/**
+ * Options for configuring the EnvironmentBuilder.
+ */
+interface EnvironmentBuilderOptions {
+  /**
+   * Handler called when a value's type doesn't match any registered resolver.
+   * Defaults to console.warn.
+   */
+  onUnmatchedValue?: (key: string, value: unknown) => void;
+}
+/**
+ * Input value type - either a string or an object with a `type` discriminator.
+ */
+type InputValue = string | {
+  type: string;
+  [key: string]: unknown;
+};
+/**
+ * Base type for typed input values with a specific type discriminator.
+ */
+type TypedInputValue<TType extends string = string> = {
+  type: TType;
+  [key: string]: unknown;
+};
+/**
+ * Extracts the `type` string value from an input value.
+ */
+type ExtractType<T> = T extends {
+  type: infer U extends string;
+} ? U : never;
+/**
+ * Removes the `type` key from an object type.
+ */
+type OmitType<T> = T extends {
+  type: string;
+} ? Omit<T, 'type'> : never;
+/**
+ * Extracts all unique `type` values from a record (excluding plain strings).
+ */
+type AllTypeValues<TRecord extends Record<string, InputValue>> = { [K in keyof TRecord]: ExtractType<TRecord[K]> }[keyof TRecord];
+/**
+ * For a given type value, finds the corresponding value type (without `type` key).
+ */
+type ValueForType<TRecord extends Record<string, InputValue>, TType extends string> = { [K in keyof TRecord]: TRecord[K] extends {
+  type: TType;
+} ? OmitType<TRecord[K]> : never }[keyof TRecord];
+/**
+ * Generates typed resolvers based on the input record.
+ * Keys are the `type` values, values are resolver functions receiving the value without `type`.
+ */
+type TypedResolvers<TRecord extends Record<string, InputValue>> = { [TType in AllTypeValues<TRecord>]: EnvironmentResolver<ValueForType<TRecord, TType>> };
+/**
+ * A generic, extensible class for building environment variables from
+ * objects with type-discriminated values.
+ *
+ * @template TRecord - The input record type for type inference
+ * @template TResolvers - The resolvers type (defaults to TypedResolvers<TRecord>)
+ *
+ * @example
+ * ```typescript
+ * const env = new EnvironmentBuilder(
+ *   {
+ *     apiKey: { type: 'secret', value: 'xyz' },
+ *     appName: 'my-app'
+ *   },
+ *   {
+ *     // `value` is typed as { value: string } (without `type`)
+ *     secret: (key, value) => ({ [key]: value.value }),
+ *   }
+ * ).build();
+ * // { API_KEY: 'xyz', APP_NAME: 'my-app' }
+ * ```
+ */
+declare class EnvironmentBuilder<TRecord extends Record<string, InputValue> = Record<string, InputValue>, TResolvers extends Resolvers = TypedResolvers<TRecord>> {
+  private readonly record;
+  private readonly resolvers;
+  private readonly options;
+  constructor(record: TRecord, resolvers: TResolvers, options?: EnvironmentBuilderOptions);
+  /**
+   * Build environment variables from the input record.
+   *
+   * - Plain string values are passed through with key transformation
+   * - Object values with a `type` property are matched against resolvers
+   * - Resolvers receive values without the `type` key
+   * - Only root-level keys are transformed to UPPER_SNAKE_CASE
+   *
+   * @returns A record of environment variables
+   */
+  build(): EnvRecord;
+}
+//#endregion
+export { EnvRecord, EnvValue, EnvironmentBuilder, EnvironmentBuilderOptions, EnvironmentResolver, InputValue, Resolvers, TypedInputValue, TypedResolvers, environmentCase };
+//# sourceMappingURL=EnvironmentBuilder-Xuf2Dd9u.d.cts.map

package/dist/EnvironmentBuilder.cjs

@@ -0,0 +1,4 @@
+const require_EnvironmentBuilder = require('./EnvironmentBuilder-W2wku49g.cjs');
+
+exports.EnvironmentBuilder = require_EnvironmentBuilder.EnvironmentBuilder;
+exports.environmentCase = require_EnvironmentBuilder.environmentCase;

package/dist/EnvironmentBuilder.d.cts

@@ -0,0 +1,2 @@
+import { EnvRecord, EnvValue, EnvironmentBuilder, EnvironmentBuilderOptions, EnvironmentResolver, InputValue, Resolvers, TypedInputValue, TypedResolvers, environmentCase } from "./EnvironmentBuilder-Xuf2Dd9u.cjs";
+export { EnvRecord, EnvValue, EnvironmentBuilder, EnvironmentBuilderOptions, EnvironmentResolver, InputValue, Resolvers, TypedInputValue, TypedResolvers, environmentCase };

package/dist/EnvironmentBuilder.d.mts

@@ -0,0 +1,2 @@
+import { EnvRecord, EnvValue, EnvironmentBuilder, EnvironmentBuilderOptions, EnvironmentResolver, InputValue, Resolvers, TypedInputValue, TypedResolvers, environmentCase } from "./EnvironmentBuilder-DHfDXJUm.mjs";
+export { EnvRecord, EnvValue, EnvironmentBuilder, EnvironmentBuilderOptions, EnvironmentResolver, InputValue, Resolvers, TypedInputValue, TypedResolvers, environmentCase };

package/dist/EnvironmentBuilder.mjs

@@ -0,0 +1,3 @@
+import { EnvironmentBuilder, environmentCase } from "./EnvironmentBuilder-DfmYRBm-.mjs";
+
+export { EnvironmentBuilder, environmentCase };

package/dist/{EnvironmentParser-BDPDLv6i.cjs → EnvironmentParser-Bt246UeP.cjs}

@@ -15,9 +15,11 @@ var ConfigParser = class {
 	* Creates a new ConfigParser instance.
 	*
 	* @param config - The configuration object to parse
+	* @param envVars - Set of environment variable names that were accessed
 	*/
-	constructor(config) {
+	constructor(config, envVars = /* @__PURE__ */ new Set()) {
 		this.config = config;
+		this.envVars = envVars;
 	}
 	/**
 	* Parses the config object and validates it against the Zod schemas
@@ -46,6 +48,25 @@ var ConfigParser = class {
 		if (errors.length > 0) throw new zod_v4.z.ZodError(errors);
 		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() {
+		return Array.from(this.envVars).sort();
+	}
 };
 /**
 * Parses environment variables with type-safe validation using Zod schemas.
@@ -67,6 +88,10 @@ var ConfigParser = class {
 * ```
 */
 var EnvironmentParser = class {
+	/**
+	* Set to track which environment variable names have been accessed
+	*/
+	accessedVars = /* @__PURE__ */ new Set();
 	/**
 	* Creates a new EnvironmentParser instance.
 	*
@@ -134,6 +159,7 @@ var EnvironmentParser = class {
 	* @returns A proxied Zod object with wrapped schema creators
 	*/
 	getZodGetter = (name) => {
+		this.accessedVars.add(name);
 		return new Proxy({ ...zod_v4.z }, { get: (target, prop) => {
 			const value = target[prop];
 			if (typeof value === "function") return (...args) => {
@@ -159,7 +185,23 @@ var EnvironmentParser = class {
 	*/
 	create(builder) {
 		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() {
+		return Array.from(this.accessedVars).sort();
 	}
 };
 
@@ -175,4 +217,5 @@ Object.defineProperty(exports, 'EnvironmentParser', {
   get: function () {
     return EnvironmentParser;
   }
-});
+});
+//# sourceMappingURL=EnvironmentParser-Bt246UeP.cjs.map

package/dist/EnvironmentParser-Bt246UeP.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnvironmentParser-Bt246UeP.cjs","names":["config: TResponse","envVars: Set<string>","errors: z.core.$ZodIssue[]","config: T","path: string[]","result: EmptyObject","z","schema: z.ZodType","name: string","issue: z.core.$ZodIssue","builder: (get: EnvFetcher) => TReturn"],"sources":["../src/EnvironmentParser.ts"],"sourcesContent":["import get from 'lodash.get';\nimport set from 'lodash.set';\nimport { z } from 'zod/v4';\n\n/**\n * Parses and validates configuration objects against Zod schemas.\n * Handles nested configurations and aggregates validation errors.\n *\n * @template TResponse - The shape of the configuration object\n */\nexport class ConfigParser<TResponse extends EmptyObject> {\n  /**\n   * Creates a new ConfigParser instance.\n   *\n   * @param config - The configuration object to parse\n   * @param envVars - Set of environment variable names that were accessed\n   */\n  constructor(\n    private readonly config: TResponse,\n    private readonly envVars: Set<string> = new Set(),\n  ) {}\n  /**\n   * Parses the config object and validates it against the Zod schemas\n   * @returns The parsed config object\n   */\n  parse(): InferConfig<TResponse> {\n    const errors: z.core.$ZodIssue[] = [];\n\n    const parseDeep = <T>(config: T, path: string[] = []) => {\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        const currentPath = [...path, key];\n\n        if (schema instanceof z.ZodType) {\n          const parsed = schema.safeParse(undefined);\n          if (parsed.success) {\n            set(result, key, parsed.data);\n          } else {\n            // If the schema is invalid, assign the error\n            errors.push(\n              ...parsed.error.issues.map((issue) => ({\n                ...issue,\n                path: [...currentPath, ...(issue.path as string[])],\n              })),\n            );\n          }\n        } else if (schema) {\n          set(result, key, parseDeep(schema as EmptyObject, currentPath));\n        }\n      }\n\n      return result;\n    };\n\n    const parsedConfig = parseDeep(\n      this.config,\n    ) as unknown as InferConfig<TResponse>;\n\n    if (errors.length > 0) {\n      // If there are errors, throw them\n      throw new z.ZodError(errors);\n    }\n\n    return parsedConfig;\n  }\n\n  /**\n   * Returns an array of environment variable names that were accessed during config creation.\n   * This is useful for deployment and configuration management to know which env vars are required.\n   *\n   * @returns Array of environment variable names, sorted alphabetically\n   *\n   * @example\n   * ```typescript\n   * const config = envParser.create((get) => ({\n   *   dbUrl: get('DATABASE_URL').string(),\n   *   port: get('PORT').number()\n   * }));\n   *\n   * config.getEnvironmentVariables(); // ['DATABASE_URL', 'PORT']\n   * ```\n   */\n  getEnvironmentVariables(): string[] {\n    return Array.from(this.envVars).sort();\n  }\n}\n\n/**\n * Parses environment variables with type-safe validation using Zod schemas.\n * Provides a fluent API for defining environment variable schemas with automatic\n * error context enrichment.\n *\n * @template T - The type of the configuration object (typically process.env)\n *\n * @example\n * ```typescript\n * const config = new EnvironmentParser(process.env)\n *   .create((get) => ({\n *     port: get('PORT').string().transform(Number).default(3000),\n *     database: {\n *       url: get('DATABASE_URL').string().url()\n *     }\n *   }))\n *   .parse();\n * ```\n */\nexport class EnvironmentParser<T extends EmptyObject> {\n  /**\n   * Set to track which environment variable names have been accessed\n   */\n  private readonly accessedVars: Set<string> = new Set();\n\n  /**\n   * Creates a new EnvironmentParser instance.\n   *\n   * @param config - The configuration object to parse (typically process.env)\n   */\n  constructor(private readonly config: T) {}\n\n  /**\n   * Wraps a Zod schema to intercept parse/safeParse calls and enrich error messages\n   * with environment variable context.\n   *\n   * @param schema - The Zod schema to wrap\n   * @param name - The environment variable name for error context\n   * @returns A wrapped Zod schema with enhanced error reporting\n   */\n  private wrapSchema = (schema: z.ZodType, name: string): z.ZodType => {\n    // Create a proxy that intercepts all method calls on the schema\n    return new Proxy(schema, {\n      get: (target, prop) => {\n        if (prop === 'parse') {\n          return () => {\n            const value = get(this.config, name);\n            try {\n              return target.parse(value);\n            } catch (error) {\n              if (error instanceof z.ZodError) {\n                // Modify the error to include the environment variable name\n                const modifiedIssues = error.issues.map((issue) => ({\n                  ...issue,\n                  message: `Environment variable \"${name}\": ${issue.message}`,\n                  path: [name, ...issue.path],\n                }));\n                throw new z.ZodError(modifiedIssues);\n              }\n              throw error;\n            }\n          };\n        }\n\n        if (prop === 'safeParse') {\n          return () => {\n            const value = get(this.config, name);\n            const result = target.safeParse(value);\n\n            if (!result.success) {\n              // Modify the error to include the environment variable name\n              const modifiedIssues = result.error.issues.map(\n                (issue: z.core.$ZodIssue) => ({\n                  ...issue,\n                  message: `Environment variable \"${name}\": ${issue.message}`,\n                  path: [name, ...issue.path],\n                }),\n              );\n              return {\n                success: false as const,\n                error: new z.ZodError(modifiedIssues),\n              };\n            }\n\n            return result;\n          };\n        }\n\n        // For any method that returns a new schema (like transform, optional, etc.),\n        // wrap the result as well\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 the result is a ZodType, wrap it too\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   * Creates a proxied version of the Zod object that wraps all schema creators\n   * to provide enhanced error messages with environment variable context.\n   *\n   * @param name - The environment variable name\n   * @returns A proxied Zod object with wrapped schema creators\n   */\n  private getZodGetter = (name: string) => {\n    // Track that this environment variable was accessed\n    this.accessedVars.add(name);\n\n    // Return an object that has all Zod schemas but with our wrapper\n    return new Proxy(\n      { ...z },\n      {\n        get: (target, prop) => {\n          // deno-lint-ignore ban-ts-comment\n          // @ts-ignore\n          const value = target[prop];\n\n          if (typeof value === 'function') {\n            // Return a wrapper around each Zod schema creator\n            return (...args: any[]) => {\n              const schema = value(...args);\n              return this.wrapSchema(schema, name);\n            };\n          }\n\n          // Handle objects like z.coerce\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 new ConfigParser object that can be used to parse the config object\n   *\n   * @param builder - A function that takes a getter function and returns a config object\n   * @returns A ConfigParser object that can be used to parse the config object\n   */\n  create<TReturn extends EmptyObject>(\n    builder: (get: EnvFetcher) => TReturn,\n  ): ConfigParser<TReturn> {\n    const config = builder(this.getZodGetter);\n    return new ConfigParser(config, this.accessedVars);\n  }\n\n  /**\n   * Returns an array of environment variable names that were accessed via the getter.\n   * This is useful for build-time analysis to determine which env vars a service needs.\n   *\n   * @returns Array of environment variable names, sorted alphabetically\n   *\n   * @example\n   * ```typescript\n   * const sniffer = new EnvironmentParser({});\n   * service.register(sniffer);\n   * const envVars = sniffer.getEnvironmentVariables(); // ['DATABASE_URL', 'PORT']\n   * ```\n   */\n  getEnvironmentVariables(): string[] {\n    return Array.from(this.accessedVars).sort();\n  }\n}\n\n/**\n * Infers the TypeScript type of a configuration object based on its Zod schemas.\n * Recursively processes nested objects and extracts types from Zod schemas.\n *\n * @template T - The configuration object type\n */\nexport type InferConfig<T extends EmptyObject> = {\n  [K in keyof T]: T[K] extends z.ZodSchema\n    ? z.infer<T[K]>\n    : T[K] extends Record<string, unknown>\n      ? InferConfig<T[K]>\n      : T[K];\n};\n\n/**\n * Function type for fetching environment variables with Zod validation.\n * Returns a Zod object scoped to a specific environment variable.\n *\n * @template TPath - The environment variable path type\n * @param name - The environment variable name\n * @returns A Zod object for defining the schema\n */\nexport type EnvFetcher<TPath extends string = string> = (\n  name: TPath,\n) => typeof z;\n\n/**\n * Function type for building environment configuration objects.\n * Takes an EnvFetcher and returns a configuration object with Zod schemas.\n *\n * @template TResponse - The response configuration object type\n * @param get - The environment variable fetcher function\n * @returns The configuration object with Zod schemas\n */\nexport type EnvironmentBuilder<TResponse extends EmptyObject> = (\n  get: EnvFetcher,\n) => TResponse;\n\n/**\n * Type alias for a generic object with unknown values.\n * Used as a constraint for configuration objects.\n */\nexport type EmptyObject = Record<string | number | symbol, unknown>;\n"],"mappings":"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"}

package/dist/{EnvironmentParser-C-arQEHQ.d.mts → EnvironmentParser-CVWU1ooT.d.mts}

@@ -10,17 +10,36 @@ import { z } from "zod/v4";
  */
 declare class ConfigParser<TResponse extends EmptyObject> {
   private readonly config;
+  private readonly envVars;
   /**
    * Creates a new ConfigParser instance.
    *
    * @param config - The configuration object to parse
+   * @param envVars - Set of environment variable names that were accessed
    */
-  constructor(config: TResponse);
+  constructor(config: TResponse, envVars?: Set<string>);
   /**
    * Parses the config object and validates it against the Zod schemas
    * @returns The parsed config object
    */
   parse(): InferConfig<TResponse>;
+  /**
+   * 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[];
 }
 /**
  * Parses environment variables with type-safe validation using Zod schemas.
@@ -43,6 +62,10 @@ declare class ConfigParser<TResponse extends EmptyObject> {
  */
 declare class EnvironmentParser<T extends EmptyObject> {
   private readonly config;
+  /**
+   * Set to track which environment variable names have been accessed
+   */
+  private readonly accessedVars;
   /**
    * Creates a new EnvironmentParser instance.
    *
@@ -73,6 +96,20 @@ declare class EnvironmentParser<T extends EmptyObject> {
    * @returns A ConfigParser object that can be used to parse the config object
    */
   create<TReturn extends EmptyObject>(builder: (get: EnvFetcher) => TReturn): ConfigParser<TReturn>;
+  /**
+   * 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[];
 }
 /**
  * Infers the TypeScript type of a configuration object based on its Zod schemas.
@@ -105,4 +142,5 @@ type EnvironmentBuilder<TResponse extends EmptyObject> = (get: EnvFetcher) => TR
  */
 type EmptyObject = Record<string | number | symbol, unknown>;
 //#endregion
-export { ConfigParser, EmptyObject, EnvFetcher, EnvironmentBuilder, EnvironmentParser, InferConfig };
+export { ConfigParser, EmptyObject, EnvFetcher, EnvironmentBuilder, EnvironmentParser, InferConfig };
+//# sourceMappingURL=EnvironmentParser-CVWU1ooT.d.mts.map

package/dist/{EnvironmentParser-CQUOGqc0.mjs → EnvironmentParser-c06agx31.mjs}

@@ -14,9 +14,11 @@ var ConfigParser = class {
 	* Creates a new ConfigParser instance.
 	*
 	* @param config - The configuration object to parse
+	* @param envVars - Set of environment variable names that were accessed
 	*/
-	constructor(config) {
+	constructor(config, envVars = /* @__PURE__ */ new Set()) {
 		this.config = config;
+		this.envVars = envVars;
 	}
 	/**
 	* Parses the config object and validates it against the Zod schemas
@@ -45,6 +47,25 @@ var ConfigParser = class {
 		if (errors.length > 0) throw new z.ZodError(errors);
 		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() {
+		return Array.from(this.envVars).sort();
+	}
 };
 /**
 * Parses environment variables with type-safe validation using Zod schemas.
@@ -66,6 +87,10 @@ var ConfigParser = class {
 * ```
 */
 var EnvironmentParser = class {
+	/**
+	* Set to track which environment variable names have been accessed
+	*/
+	accessedVars = /* @__PURE__ */ new Set();
 	/**
 	* Creates a new EnvironmentParser instance.
 	*
@@ -133,6 +158,7 @@ var EnvironmentParser = class {
 	* @returns A proxied Zod object with wrapped schema creators
 	*/
 	getZodGetter = (name) => {
+		this.accessedVars.add(name);
 		return new Proxy({ ...z }, { get: (target, prop) => {
 			const value = target[prop];
 			if (typeof value === "function") return (...args) => {
@@ -158,9 +184,26 @@ var EnvironmentParser = class {
 	*/
 	create(builder) {
 		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() {
+		return Array.from(this.accessedVars).sort();
 	}
 };
 
 //#endregion
-export { ConfigParser, EnvironmentParser };
+export { ConfigParser, EnvironmentParser };
+//# sourceMappingURL=EnvironmentParser-c06agx31.mjs.map