safe-env-getter 0.1.9 → 0.2.0

package/README.md

@@ -10,7 +10,7 @@ Type-safe environment variable getter for Node.js. Reads and parses `process.env
 
 - **Typed specs**: `string`, `number`, `boolean`, and `enum` with TypeScript inference
 - **Optional defaults**: Fallback values when the variable is unset or empty
-- **Strict validation**: Throws with clear messages for missing or invalid values
+- **Strict validation**: Throws `SafeEnvGetterValidationError` with structured errors
 - **Boolean parsing**: Accepts `1`, `true`, `yes`, `on` (case-insensitive) as `true`
 - **Enum constraint**: Restricts values to a fixed set of choices
 
@@ -31,7 +31,7 @@ yarn add safe-env-getter
 ## Usage
 
 ```ts
-import { SafeEnvGetter, SafeEnvType } from 'safe-env-getter';
+import { SafeEnvGetter, SafeEnvGetterValidationError, SafeEnvType } from 'safe-env-getter';
 
 // String (spec omitted → defaults to SafeEnvType.String; throws if missing)
 const nodeEnv = SafeEnvGetter.getEnv('NODE_ENV');
@@ -46,14 +46,36 @@ const port = SafeEnvGetter.getEnv('PORT', SafeEnvType.Number, { default: 3000 })
 const debug = SafeEnvGetter.getEnv('DEBUG', SafeEnvType.Boolean, { default: false });
 
 // Enum (required)
-const mode = SafeEnvGetter.getEnv('MODE', SafeEnvType.Enum(['read', 'write']));
+const mode = SafeEnvGetter.getEnv('MODE', SafeEnvType.Enum(['read', 'write'] as const));
 // Enum with default
-const modeWithDefault = SafeEnvGetter.getEnv('MODE', SafeEnvType.Enum(['read', 'write']), { default: 'read' });
+const modeWithDefault = SafeEnvGetter.getEnv('MODE', SafeEnvType.Enum(['read', 'write'] as const), { default: 'read' });
+
+// Read multiple envs at once (collects all missing/invalid errors and throws once)
+const envs = SafeEnvGetter.getEnvs({
+  PORT: [SafeEnvType.Number, { default: 3000 }],
+  DEBUG: [SafeEnvType.Boolean, { default: false }],
+  MODE: SafeEnvType.Enum(['read', 'write'] as const),
+});
+
+// Access structured validation errors
+try {
+  SafeEnvGetter.getEnvs({
+    PORT: SafeEnvType.Number,
+    MODE: SafeEnvType.Enum(['read', 'write'] as const),
+  });
+} catch (e) {
+  if (e instanceof SafeEnvGetterValidationError) {
+    // e.errors: [{ key, message, raw?, kind }, ...]
+    // e.keys:  ['PORT', 'MODE', ...]
+    console.error(e.errors);
+  }
+  throw e;
+}
 ```
 
 ## Options
 
-`SafeEnvGetter.getEnv(key, spec?, options?)` takes:
+### `SafeEnvGetter.getEnv(key, spec?, options?)`
 
 | Argument | Required | Description |
 |----------|----------|-------------|
@@ -61,6 +83,13 @@ const modeWithDefault = SafeEnvGetter.getEnv('MODE', SafeEnvType.Enum(['read', '
 | **spec** | No       | Type spec; defaults to `SafeEnvType.String` when omitted. Use `SafeEnvType.String`, `SafeEnvType.Number`, `SafeEnvType.Boolean`, or `SafeEnvType.Enum(choices)`. |
 | **options** | No    | Optional object. Use `{ default: value }` to provide a fallback when the variable is missing or empty. |
 
+### `SafeEnvGetter.getEnvs(schema)`
+
+`schema` is an object where each key is an env var name and each value is either:
+
+- A spec (e.g. `SafeEnvType.Number`)
+- A tuple of `[spec, { default }]` (e.g. `[SafeEnvType.Number, { default: 3000 }]`)
+
 **Spec types:**
 
 | Spec | Shape | Description |
@@ -72,10 +101,15 @@ const modeWithDefault = SafeEnvGetter.getEnv('MODE', SafeEnvType.Enum(['read', '
 
 **Errors:**
 
-- If the variable is missing or empty and `options.default` is not set: `Missing required environment variable: <key>`.
+- Missing/empty without a default: `Missing required environment variable: <key>`.
 - For `number`, invalid values: `Env <key>: expected number, got "<raw>"`.
 - For `enum`, invalid values: `Env <key>: must be one of [choice1, choice2, ...]`.
 
+Both `getEnv()` and `getEnvs()` throw `SafeEnvGetterValidationError`, which exposes structured data:
+
+- `errors`: `[{ key, message, raw?, kind }, ...]`
+- `keys`: `['KEY1', 'KEY2', ...]`
+
 ## Requirements
 
 - **Node.js** >= 20.0.0

package/lib/index.d.ts

@@ -38,6 +38,62 @@ export type SafeEnvTypeEnum<T extends string = string> = {
 };
 /** Union of all environment variable spec types. */
 export type SafeEnvSpec = SafeEnvTypeString | SafeEnvTypeNumber | SafeEnvTypeBoolean | SafeEnvTypeEnum;
+/**
+ * Discriminated union error kinds emitted during env parsing/validation.
+ */
+export type SafeEnvErrorKind = 'missing' | 'invalid_number' | 'invalid_enum';
+/**
+ * A structured validation error entry for a single env var.
+ *
+ * @template K - Environment variable key type.
+ */
+export type SafeEnvError<K extends string = string> = {
+    key: K;
+    message: string;
+    raw?: string;
+    kind: SafeEnvErrorKind;
+};
+/**
+ * Base error class for this package.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   SafeEnvGetter.getEnv('PORT', SafeEnvType.Number);
+ * } catch (e) {
+ *   if (e instanceof SafeEnvGetterError) {
+ *     // Handle all safe-env-getter errors
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class SafeEnvGetterError extends Error {
+    protected constructor(message: string);
+}
+/**
+ * Validation error that carries one or more environment variable issues.
+ *
+ * It is thrown by `SafeEnvGetter.getEnv()` (single-entry `errors`) and
+ * `SafeEnvGetter.getEnvs()` (multi-entry `errors`).
+ */
+export declare class SafeEnvGetterValidationError<K extends string = string> extends SafeEnvGetterError {
+    /**
+     * Formats validation errors into a human-readable error message.
+     */
+    static format<K extends string>(errors: readonly SafeEnvError<K>[]): string;
+    /**
+     * Structured list of validation errors.
+     */
+    readonly errors: readonly SafeEnvError<K>[];
+    /**
+     * Convenience list of keys included in `errors`.
+     */
+    readonly keys: readonly K[];
+    /**
+     * Creates a new validation error from one or more `SafeEnvError` entries.
+     */
+    constructor(errors: readonly SafeEnvError<K>[]);
+}
 /**
  * Predefined spec constants for use as the second argument to `getEnv`.
  * Use the third argument `options: { default: value }` to provide a fallback when the variable is missing.
@@ -67,6 +123,31 @@ export declare const SafeEnvType: {
  * @template S - A `SafeEnvSpec` variant.
  */
 export type SafeEnvSpecToType<S> = S extends SafeEnvTypeString ? string : S extends SafeEnvTypeNumber ? number : S extends SafeEnvTypeBoolean ? boolean : S extends SafeEnvTypeEnum<infer T> ? T : never;
+/**
+ * Options for reading an env var with an optional default.
+ */
+export type SafeGetEnvOptions<S extends SafeEnvSpec> = {
+    default?: SafeEnvSpecToType<S>;
+};
+/**
+ * Schema entry for a single env var.
+ *
+ * Either provide a spec directly, or a tuple of `[spec, options]` to attach a default.
+ */
+export type SafeEnvSchemaEntry<S extends SafeEnvSpec = SafeEnvSpec> = S | readonly [S, SafeGetEnvOptions<S>];
+/**
+ * Schema object used by `getEnvs()`.
+ *
+ * Keys are env var names, values are specs (optionally with defaults).
+ */
+export type SafeEnvSchema = Record<string, SafeEnvSchemaEntry>;
+type SafeEnvSchemaEntryToSpec<E> = E extends readonly [infer S, unknown] ? S : E;
+/**
+ * Maps a schema object to the resulting parsed env object type.
+ */
+export type SafeEnvSchemaToType<TSchema extends SafeEnvSchema> = {
+    [K in keyof TSchema]: SafeEnvSpecToType<SafeEnvSchemaEntryToSpec<TSchema[K]> & SafeEnvSpec>;
+};
 /**
  * Reads and parses an environment variable according to the given spec.
  * If the variable is missing or empty and no default is provided in `options`, throws an error.
@@ -75,9 +156,7 @@ export type SafeEnvSpecToType<S> = S extends SafeEnvTypeString ? string : S exte
  * @param spec - Type spec; defaults to `SafeEnvType.String` when omitted.
  * @param options - Optional. Use `{ default: value }` to provide a fallback when the variable is missing.
  * @returns Parsed value with type inferred from `spec`.
- * @throws {Error} When the variable is missing and `options.default` is not set.
- * @throws {Error} When `spec.type` is `"number"` and the value is not a valid number.
- * @throws {Error} When `spec.type` is `"enum"` and the value is not in `spec.choices`.
+ * @throws {SafeEnvGetterValidationError} When the variable is missing/invalid and `options.default` is not set (or not applicable).
  */
 declare function getEnv<K extends string, S extends SafeEnvSpec = SafeEnvTypeString>(key: K, spec?: S, options?: {
     default?: SafeEnvSpecToType<S>;
@@ -88,5 +167,6 @@ declare function getEnv<K extends string, S extends SafeEnvSpec = SafeEnvTypeStr
  */
 export declare const SafeEnvGetter: {
     readonly getEnv: typeof getEnv;
+    readonly getEnvs: <TSchema extends SafeEnvSchema>(schema: TSchema) => SafeEnvSchemaToType<TSchema>;
 };
 export {};

package/lib/index.js

@@ -1,6 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SafeEnvGetter = exports.SafeEnvType = void 0;
+exports.SafeEnvGetter = exports.SafeEnvType = exports.SafeEnvGetterValidationError = exports.SafeEnvGetterError = void 0;
+/**
+ * Base error class for this package.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   SafeEnvGetter.getEnv('PORT', SafeEnvType.Number);
+ * } catch (e) {
+ *   if (e instanceof SafeEnvGetterError) {
+ *     // Handle all safe-env-getter errors
+ *   }
+ * }
+ * ```
+ */
+class SafeEnvGetterError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SafeEnvGetterError';
+    }
+}
+exports.SafeEnvGetterError = SafeEnvGetterError;
+/**
+ * Validation error that carries one or more environment variable issues.
+ *
+ * It is thrown by `SafeEnvGetter.getEnv()` (single-entry `errors`) and
+ * `SafeEnvGetter.getEnvs()` (multi-entry `errors`).
+ */
+class SafeEnvGetterValidationError extends SafeEnvGetterError {
+    /**
+     * Formats validation errors into a human-readable error message.
+     */
+    static format(errors) {
+        const lines = errors.map((e) => `- ${e.key}: ${e.message}${e.raw == null ? '' : ` (raw="${e.raw}")`}`);
+        return `Invalid environment variables (${errors.length}):\n${lines.join('\n')}`;
+    }
+    /**
+     * Creates a new validation error from one or more `SafeEnvError` entries.
+     */
+    constructor(errors) {
+        const msg = SafeEnvGetterValidationError.format(errors);
+        super(msg);
+        this.name = 'SafeEnvGetterValidationError';
+        this.errors = errors;
+        this.keys = errors.map((e) => e.key);
+    }
+}
+exports.SafeEnvGetterValidationError = SafeEnvGetterValidationError;
 /**
  * Predefined spec constants for use as the second argument to `getEnv`.
  * Use the third argument `options: { default: value }` to provide a fallback when the variable is missing.
@@ -27,41 +74,109 @@ exports.SafeEnvType = {
  * @param spec - Type spec; defaults to `SafeEnvType.String` when omitted.
  * @param options - Optional. Use `{ default: value }` to provide a fallback when the variable is missing.
  * @returns Parsed value with type inferred from `spec`.
- * @throws {Error} When the variable is missing and `options.default` is not set.
- * @throws {Error} When `spec.type` is `"number"` and the value is not a valid number.
- * @throws {Error} When `spec.type` is `"enum"` and the value is not in `spec.choices`.
+ * @throws {SafeEnvGetterValidationError} When the variable is missing/invalid and `options.default` is not set (or not applicable).
  */
 function getEnv(key, spec = exports.SafeEnvType.String, options) {
     const raw = process.env[key];
     const defaultValue = options?.default;
     const hasDefault = defaultValue !== undefined;
     if (raw == null || raw === '') {
-        if (!hasDefault)
-            throw new Error(`Missing required environment variable: ${key}`);
+        if (!hasDefault) {
+            throw new SafeEnvGetterValidationError([
+                { key, message: `Missing required environment variable: ${key}`, raw, kind: 'missing' },
+            ]);
+        }
         return defaultValue;
     }
     switch (spec.type) {
         case 'number': {
             const n = Number(raw);
-            if (Number.isNaN(n))
-                throw new Error(`Env ${key}: expected number, got "${raw}"`);
+            if (Number.isNaN(n)) {
+                throw new SafeEnvGetterValidationError([
+                    { key, message: `Env ${key}: expected number, got "${raw}"`, raw, kind: 'invalid_number' },
+                ]);
+            }
             return n;
         }
         case 'boolean':
             return (/^(1|true|yes|on)$/i.test(raw) ? true : false);
         case 'enum':
-            if (!spec.choices.includes(raw))
-                throw new Error(`Env ${key}: must be one of [${spec.choices.join(', ')}]`);
+            if (!spec.choices.includes(raw)) {
+                throw new SafeEnvGetterValidationError([
+                    { key, message: `Env ${key}: must be one of [${spec.choices.join(', ')}]`, raw, kind: 'invalid_enum' },
+                ]);
+            }
             return raw;
         default:
             return raw;
     }
 }
+/**
+ * Reads and parses multiple environment variables according to the given schema.
+ *
+ * This function always evaluates every key in `schema`. If any missing/invalid values
+ * are found, it throws once with a `SafeEnvGetterValidationError` that contains all issues.
+ *
+ * @param schema - Map of env var names to specs, optionally with per-key defaults via `[spec, { default }]`.
+ * @returns An object of parsed envs with types inferred from the schema.
+ * @throws {SafeEnvGetterValidationError} When one or more required env vars are missing or invalid.
+ */
+const getEnvs = (schema) => {
+    const envs = {};
+    const errors = [];
+    for (const key of Object.keys(schema)) {
+        const entry = schema[key];
+        const spec = (Array.isArray(entry) ? entry[0] : entry);
+        const options = (Array.isArray(entry) ? entry[1] : undefined);
+        const raw = process.env[key];
+        const defaultValue = options?.default;
+        const hasDefault = defaultValue !== undefined;
+        if (raw == null || raw === '') {
+            if (!hasDefault) {
+                errors.push({ key, message: `Missing required environment variable: ${key}`, raw, kind: 'missing' });
+                continue;
+            }
+            envs[key] = defaultValue;
+            continue;
+        }
+        if (spec.type === 'number') {
+            const n = Number(raw);
+            if (Number.isNaN(n)) {
+                errors.push({ key, message: `Env ${key}: expected number, got "${raw}"`, raw, kind: 'invalid_number' });
+                continue;
+            }
+            envs[key] = n;
+            continue;
+        }
+        if (spec.type === 'boolean') {
+            envs[key] = (/^(1|true|yes|on)$/i.test(raw) ? true : false);
+            continue;
+        }
+        if (spec.type === 'enum') {
+            if (!spec.choices.includes(raw)) {
+                errors.push({
+                    key,
+                    message: `Env ${key}: must be one of [${spec.choices.join(', ')}]`,
+                    raw,
+                    kind: 'invalid_enum',
+                });
+                continue;
+            }
+            envs[key] = raw;
+            continue;
+        }
+        envs[key] = raw;
+    }
+    if (errors.length > 0)
+        throw new SafeEnvGetterValidationError(errors);
+    return envs;
+};
 /**
  * Safe environment variable getter.
  * Use `SafeEnvGetter.getEnv(key, spec?, options?)` to read and parse environment variables with type safety.
  */
 exports.SafeEnvGetter = {
     getEnv,
+    getEnvs,
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAoCA;;;GAGG;AACU,QAAA,WAAW,GAAG;IACzB,+BAA+B;IAC/B,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAuC;IAC/D,gCAAgC;IAChC,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAuC;IAC/D,uDAAuD;IACvD,OAAO,EAAE,EAAE,IAAI,EAAE,SAAS,EAAwC;IAClE;;;;OAIG;IACH,IAAI,EAAE,CAAmB,OAAqB,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAuB;CAC5F,CAAC;AAaX;;;;;;;;;;;GAWG;AACH,SAAS,MAAM,CACb,GAAM,EACN,OAAU,mBAAW,CAAC,MAAW,EACjC,OAA4C;IAE5C,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC7B,MAAM,YAAY,GAAG,OAAO,EAAE,OAAO,CAAC;IACtC,MAAM,UAAU,GAAG,YAAY,KAAK,SAAS,CAAC;IAE9C,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,KAAK,EAAE,EAAE,CAAC;QAC9B,IAAI,CAAC,UAAU;YAAE,MAAM,IAAI,KAAK,CAAC,0CAA0C,GAAG,EAAE,CAAC,CAAC;QAClF,OAAO,YAAoC,CAAC;IAC9C,CAAC;IAED,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YACtB,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;gBAAE,MAAM,IAAI,KAAK,CAAC,OAAO,GAAG,2BAA2B,GAAG,GAAG,CAAC,CAAC;YAClF,OAAO,CAAyB,CAAC;QACnC,CAAC;QACD,KAAK,SAAS;YACZ,OAAO,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAyB,CAAC;QACjF,KAAK,MAAM;YACT,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC;gBAAE,MAAM,IAAI,KAAK,CAAC,OAAO,GAAG,qBAAqB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC5G,OAAO,GAA2B,CAAC;QACrC;YACE,OAAO,GAA2B,CAAC;IACvC,CAAC;AACH,CAAC;AAED;;;GAGG;AACU,QAAA,aAAa,GAAG;IAC3B,MAAM;CACE,CAAC","sourcesContent":["/**\n * Spec for a string environment variable.\n * The default value is passed via the third argument of `getEnv`, not in the spec.\n */\nexport type SafeEnvTypeString = { type: 'string'; default?: string };\n\n/**\n * Spec for a numeric environment variable.\n * Values are parsed with `Number()`; invalid values throw.\n * The default value is passed via the third argument of `getEnv`, not in the spec.\n */\nexport type SafeEnvTypeNumber = { type: 'number'; default?: number };\n\n/**\n * Spec for a boolean environment variable.\n * Parses `1`, `true`, `yes`, `on` (case-insensitive) as `true`; anything else as `false`.\n * The default value is passed via the third argument of `getEnv`, not in the spec.\n */\nexport type SafeEnvTypeBoolean = { type: 'boolean'; default?: boolean };\n\n/**\n * Spec for an enum environment variable with a fixed set of choices.\n * The value must be one of `choices`; otherwise an error is thrown.\n * The default value is passed via the third argument of `getEnv`, not in the spec.\n *\n * @template T - Literal string union of allowed values.\n */\nexport type SafeEnvTypeEnum<T extends string = string> = { type: 'enum'; choices: readonly T[]; default?: T };\n\n/** Union of all environment variable spec types. */\nexport type SafeEnvSpec =\n  | SafeEnvTypeString\n  | SafeEnvTypeNumber\n  | SafeEnvTypeBoolean\n  | SafeEnvTypeEnum;\n\n/**\n * Predefined spec constants for use as the second argument to `getEnv`.\n * Use the third argument `options: { default: value }` to provide a fallback when the variable is missing.\n */\nexport const SafeEnvType = {\n  /** Spec for a string value. */\n  String: { type: 'string' } as const satisfies SafeEnvTypeString,\n  /** Spec for a numeric value. */\n  Number: { type: 'number' } as const satisfies SafeEnvTypeNumber,\n  /** Spec for a boolean value (1/true/yes/on → true). */\n  Boolean: { type: 'boolean' } as const satisfies SafeEnvTypeBoolean,\n  /**\n   * Returns a spec that restricts the value to one of the given choices.\n   * @param choices - Allowed string literals.\n   * @returns Enum spec for use with `getEnv`.\n   */\n  Enum: <T extends string>(choices: readonly T[]) => ({ type: 'enum', choices }) as SafeEnvTypeEnum<T>,\n} as const;\n\n/**\n * Infers the return type from the given spec.\n * @template S - A `SafeEnvSpec` variant.\n */\nexport type SafeEnvSpecToType<S> =\n  S extends SafeEnvTypeString ? string\n    : S extends SafeEnvTypeNumber ? number\n      : S extends SafeEnvTypeBoolean ? boolean\n        : S extends SafeEnvTypeEnum<infer T> ? T\n          : never;\n\n/**\n * Reads and parses an environment variable according to the given spec.\n * If the variable is missing or empty and no default is provided in `options`, throws an error.\n *\n * @param key - Environment variable name (e.g. `\"PORT\"`, `\"NODE_ENV\"`).\n * @param spec - Type spec; defaults to `SafeEnvType.String` when omitted.\n * @param options - Optional. Use `{ default: value }` to provide a fallback when the variable is missing.\n * @returns Parsed value with type inferred from `spec`.\n * @throws {Error} When the variable is missing and `options.default` is not set.\n * @throws {Error} When `spec.type` is `\"number\"` and the value is not a valid number.\n * @throws {Error} When `spec.type` is `\"enum\"` and the value is not in `spec.choices`.\n */\nfunction getEnv<K extends string, S extends SafeEnvSpec = SafeEnvTypeString>(\n  key: K,\n  spec: S = SafeEnvType.String as S,\n  options?: { default?: SafeEnvSpecToType<S> },\n): SafeEnvSpecToType<S> {\n  const raw = process.env[key];\n  const defaultValue = options?.default;\n  const hasDefault = defaultValue !== undefined;\n\n  if (raw == null || raw === '') {\n    if (!hasDefault) throw new Error(`Missing required environment variable: ${key}`);\n    return defaultValue as SafeEnvSpecToType<S>;\n  }\n\n  switch (spec.type) {\n    case 'number': {\n      const n = Number(raw);\n      if (Number.isNaN(n)) throw new Error(`Env ${key}: expected number, got \"${raw}\"`);\n      return n as SafeEnvSpecToType<S>;\n    }\n    case 'boolean':\n      return (/^(1|true|yes|on)$/i.test(raw) ? true : false) as SafeEnvSpecToType<S>;\n    case 'enum':\n      if (!spec.choices.includes(raw)) throw new Error(`Env ${key}: must be one of [${spec.choices.join(', ')}]`);\n      return raw as SafeEnvSpecToType<S>;\n    default:\n      return raw as SafeEnvSpecToType<S>;\n  }\n}\n\n/**\n * Safe environment variable getter.\n * Use `SafeEnvGetter.getEnv(key, spec?, options?)` to read and parse environment variables with type safety.\n */\nexport const SafeEnvGetter = {\n  getEnv,\n} as const;"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Spec for a string environment variable.\n * The default value is passed via the third argument of `getEnv`, not in the spec.\n */\nexport type SafeEnvTypeString = { type: 'string'; default?: string };\n\n/**\n * Spec for a numeric environment variable.\n * Values are parsed with `Number()`; invalid values throw.\n * The default value is passed via the third argument of `getEnv`, not in the spec.\n */\nexport type SafeEnvTypeNumber = { type: 'number'; default?: number };\n\n/**\n * Spec for a boolean environment variable.\n * Parses `1`, `true`, `yes`, `on` (case-insensitive) as `true`; anything else as `false`.\n * The default value is passed via the third argument of `getEnv`, not in the spec.\n */\nexport type SafeEnvTypeBoolean = { type: 'boolean'; default?: boolean };\n\n/**\n * Spec for an enum environment variable with a fixed set of choices.\n * The value must be one of `choices`; otherwise an error is thrown.\n * The default value is passed via the third argument of `getEnv`, not in the spec.\n *\n * @template T - Literal string union of allowed values.\n */\nexport type SafeEnvTypeEnum<T extends string = string> = { type: 'enum'; choices: readonly T[]; default?: T };\n\n/** Union of all environment variable spec types. */\nexport type SafeEnvSpec =\n  | SafeEnvTypeString\n  | SafeEnvTypeNumber\n  | SafeEnvTypeBoolean\n  | SafeEnvTypeEnum;\n\n/**\n * Discriminated union error kinds emitted during env parsing/validation.\n */\nexport type SafeEnvErrorKind = 'missing' | 'invalid_number' | 'invalid_enum';\n\n/**\n * A structured validation error entry for a single env var.\n *\n * @template K - Environment variable key type.\n */\nexport type SafeEnvError<K extends string = string> = {\n  key: K;\n  message: string;\n  raw?: string;\n  kind: SafeEnvErrorKind;\n};\n\n/**\n * Base error class for this package.\n *\n * @example\n * ```ts\n * try {\n *   SafeEnvGetter.getEnv('PORT', SafeEnvType.Number);\n * } catch (e) {\n *   if (e instanceof SafeEnvGetterError) {\n *     // Handle all safe-env-getter errors\n *   }\n * }\n * ```\n */\nexport abstract class SafeEnvGetterError extends Error {\n  protected constructor(message: string) {\n    super(message);\n    this.name = 'SafeEnvGetterError';\n  }\n}\n\n/**\n * Validation error that carries one or more environment variable issues.\n *\n * It is thrown by `SafeEnvGetter.getEnv()` (single-entry `errors`) and\n * `SafeEnvGetter.getEnvs()` (multi-entry `errors`).\n */\nexport class SafeEnvGetterValidationError<K extends string = string> extends SafeEnvGetterError {\n  /**\n   * Formats validation errors into a human-readable error message.\n   */\n  public static format<K extends string>(errors: readonly SafeEnvError<K>[]): string {\n    const lines = errors.map((e) => `- ${e.key}: ${e.message}${e.raw == null ? '' : ` (raw=\"${e.raw}\")`}`);\n    return `Invalid environment variables (${errors.length}):\\n${lines.join('\\n')}`;\n  }\n\n  /**\n   * Structured list of validation errors.\n   */\n  public readonly errors: readonly SafeEnvError<K>[];\n  /**\n   * Convenience list of keys included in `errors`.\n   */\n  public readonly keys: readonly K[];\n\n  /**\n   * Creates a new validation error from one or more `SafeEnvError` entries.\n   */\n  public constructor(errors: readonly SafeEnvError<K>[]) {\n    const msg = SafeEnvGetterValidationError.format(errors);\n    super(msg);\n    this.name = 'SafeEnvGetterValidationError';\n    this.errors = errors;\n    this.keys = errors.map((e) => e.key);\n  }\n}\n\n/**\n * Predefined spec constants for use as the second argument to `getEnv`.\n * Use the third argument `options: { default: value }` to provide a fallback when the variable is missing.\n */\nexport const SafeEnvType = {\n  /** Spec for a string value. */\n  String: { type: 'string' } as const satisfies SafeEnvTypeString,\n  /** Spec for a numeric value. */\n  Number: { type: 'number' } as const satisfies SafeEnvTypeNumber,\n  /** Spec for a boolean value (1/true/yes/on → true). */\n  Boolean: { type: 'boolean' } as const satisfies SafeEnvTypeBoolean,\n  /**\n   * Returns a spec that restricts the value to one of the given choices.\n   * @param choices - Allowed string literals.\n   * @returns Enum spec for use with `getEnv`.\n   */\n  Enum: <T extends string>(choices: readonly T[]) => ({ type: 'enum', choices }) as SafeEnvTypeEnum<T>,\n} as const;\n\n/**\n * Infers the return type from the given spec.\n * @template S - A `SafeEnvSpec` variant.\n */\nexport type SafeEnvSpecToType<S> =\n  S extends SafeEnvTypeString ? string\n    : S extends SafeEnvTypeNumber ? number\n      : S extends SafeEnvTypeBoolean ? boolean\n        : S extends SafeEnvTypeEnum<infer T> ? T\n          : never;\n\n/**\n * Options for reading an env var with an optional default.\n */\nexport type SafeGetEnvOptions<S extends SafeEnvSpec> = { default?: SafeEnvSpecToType<S> };\n\n/**\n * Schema entry for a single env var.\n *\n * Either provide a spec directly, or a tuple of `[spec, options]` to attach a default.\n */\nexport type SafeEnvSchemaEntry<S extends SafeEnvSpec = SafeEnvSpec> = S | readonly [S, SafeGetEnvOptions<S>];\n\n/**\n * Schema object used by `getEnvs()`.\n *\n * Keys are env var names, values are specs (optionally with defaults).\n */\nexport type SafeEnvSchema = Record<string, SafeEnvSchemaEntry>;\n\ntype SafeEnvSchemaEntryToSpec<E> = E extends readonly [infer S, unknown] ? S : E;\n\n/**\n * Maps a schema object to the resulting parsed env object type.\n */\nexport type SafeEnvSchemaToType<TSchema extends SafeEnvSchema> = {\n  [K in keyof TSchema]: SafeEnvSpecToType<SafeEnvSchemaEntryToSpec<TSchema[K]> & SafeEnvSpec>;\n};\n\n/**\n * Reads and parses an environment variable according to the given spec.\n * If the variable is missing or empty and no default is provided in `options`, throws an error.\n *\n * @param key - Environment variable name (e.g. `\"PORT\"`, `\"NODE_ENV\"`).\n * @param spec - Type spec; defaults to `SafeEnvType.String` when omitted.\n * @param options - Optional. Use `{ default: value }` to provide a fallback when the variable is missing.\n * @returns Parsed value with type inferred from `spec`.\n * @throws {SafeEnvGetterValidationError} When the variable is missing/invalid and `options.default` is not set (or not applicable).\n */\nfunction getEnv<K extends string, S extends SafeEnvSpec = SafeEnvTypeString>(\n  key: K,\n  spec: S = SafeEnvType.String as S,\n  options?: { default?: SafeEnvSpecToType<S> },\n): SafeEnvSpecToType<S> {\n  const raw = process.env[key];\n  const defaultValue = options?.default;\n  const hasDefault = defaultValue !== undefined;\n\n  if (raw == null || raw === '') {\n    if (!hasDefault) {\n      throw new SafeEnvGetterValidationError([\n        { key, message: `Missing required environment variable: ${key}`, raw, kind: 'missing' },\n      ]);\n    }\n    return defaultValue as SafeEnvSpecToType<S>;\n  }\n\n  switch (spec.type) {\n    case 'number': {\n      const n = Number(raw);\n      if (Number.isNaN(n)) {\n        throw new SafeEnvGetterValidationError([\n          { key, message: `Env ${key}: expected number, got \"${raw}\"`, raw, kind: 'invalid_number' },\n        ]);\n      }\n      return n as SafeEnvSpecToType<S>;\n    }\n    case 'boolean':\n      return (/^(1|true|yes|on)$/i.test(raw) ? true : false) as SafeEnvSpecToType<S>;\n    case 'enum':\n      if (!spec.choices.includes(raw)) {\n        throw new SafeEnvGetterValidationError([\n          { key, message: `Env ${key}: must be one of [${spec.choices.join(', ')}]`, raw, kind: 'invalid_enum' },\n        ]);\n      }\n      return raw as SafeEnvSpecToType<S>;\n    default:\n      return raw as SafeEnvSpecToType<S>;\n  }\n}\n\n/**\n * Reads and parses multiple environment variables according to the given schema.\n *\n * This function always evaluates every key in `schema`. If any missing/invalid values\n * are found, it throws once with a `SafeEnvGetterValidationError` that contains all issues.\n *\n * @param schema - Map of env var names to specs, optionally with per-key defaults via `[spec, { default }]`.\n * @returns An object of parsed envs with types inferred from the schema.\n * @throws {SafeEnvGetterValidationError} When one or more required env vars are missing or invalid.\n */\nconst getEnvs = <TSchema extends SafeEnvSchema>(schema: TSchema): SafeEnvSchemaToType<TSchema> => {\n  const envs: Partial<SafeEnvSchemaToType<TSchema>> = {};\n  const errors: SafeEnvError<Extract<keyof TSchema, string>>[] = [];\n\n  for (const key of Object.keys(schema) as Array<Extract<keyof TSchema, string>>) {\n    const entry = schema[key];\n    const spec = (Array.isArray(entry) ? entry[0] : entry) as SafeEnvSpec;\n    const options = (Array.isArray(entry) ? entry[1] : undefined) as SafeGetEnvOptions<SafeEnvSpec> | undefined;\n\n    const raw = process.env[key];\n    const defaultValue = options?.default;\n    const hasDefault = defaultValue !== undefined;\n\n    if (raw == null || raw === '') {\n      if (!hasDefault) {\n        errors.push({ key, message: `Missing required environment variable: ${key}`, raw, kind: 'missing' });\n        continue;\n      }\n      envs[key] = defaultValue as SafeEnvSchemaToType<TSchema>[typeof key];\n      continue;\n    }\n\n    if (spec.type === 'number') {\n      const n = Number(raw);\n      if (Number.isNaN(n)) {\n        errors.push({ key, message: `Env ${key}: expected number, got \"${raw}\"`, raw, kind: 'invalid_number' });\n        continue;\n      }\n      envs[key] = n as SafeEnvSchemaToType<TSchema>[typeof key];\n      continue;\n    }\n\n    if (spec.type === 'boolean') {\n      envs[key] = (/^(1|true|yes|on)$/i.test(raw) ? true : false) as SafeEnvSchemaToType<TSchema>[typeof key];\n      continue;\n    }\n\n    if (spec.type === 'enum') {\n      if (!spec.choices.includes(raw)) {\n        errors.push({\n          key,\n          message: `Env ${key}: must be one of [${spec.choices.join(', ')}]`,\n          raw,\n          kind: 'invalid_enum',\n        });\n        continue;\n      }\n      envs[key] = raw as SafeEnvSchemaToType<TSchema>[typeof key];\n      continue;\n    }\n\n    envs[key] = raw as SafeEnvSchemaToType<TSchema>[typeof key];\n  }\n\n  if (errors.length > 0) throw new SafeEnvGetterValidationError(errors);\n  return envs as SafeEnvSchemaToType<TSchema>;\n};\n\n/**\n * Safe environment variable getter.\n * Use `SafeEnvGetter.getEnv(key, spec?, options?)` to read and parse environment variables with type safety.\n */\nexport const SafeEnvGetter = {\n  getEnv,\n  getEnvs,\n} as const;"]}

package/package.json

@@ -5,24 +5,24 @@
     "url": "https://github.com/gammarers-labs/safe-env-getter.git"
   },
   "scripts": {
-    "build": "npx projen build",
-    "bump": "npx projen bump",
-    "clobber": "npx projen clobber",
-    "compile": "npx projen compile",
-    "default": "npx projen default",
-    "eject": "npx projen eject",
-    "eslint": "npx projen eslint",
-    "package": "npx projen package",
-    "post-compile": "npx projen post-compile",
-    "post-upgrade": "npx projen post-upgrade",
-    "pre-compile": "npx projen pre-compile",
-    "release": "npx projen release",
-    "test": "npx projen test",
-    "test:watch": "npx projen test:watch",
-    "unbump": "npx projen unbump",
-    "upgrade": "npx projen upgrade",
-    "watch": "npx projen watch",
-    "projen": "npx projen"
+    "build": "projen build",
+    "bump": "projen bump",
+    "clobber": "projen clobber",
+    "compile": "projen compile",
+    "default": "projen default",
+    "eject": "projen eject",
+    "eslint": "projen eslint",
+    "package": "projen package",
+    "post-compile": "projen post-compile",
+    "post-upgrade": "projen post-upgrade",
+    "pre-compile": "projen pre-compile",
+    "release": "projen release",
+    "test": "projen test",
+    "test:watch": "projen test:watch",
+    "unbump": "projen unbump",
+    "upgrade": "projen upgrade",
+    "watch": "projen watch",
+    "projen": "projen"
   },
   "author": {
     "name": "yicr",
@@ -42,8 +42,8 @@
     "eslint-plugin-import": "^2.32.0",
     "jest": "^30.3.0",
     "jest-junit": "^16",
-    "projen": "^0.99.26",
-    "ts-jest": "^29.4.6",
+    "projen": "^0.99.42",
+    "ts-jest": "^29.4.9",
     "ts-node": "^10.9.2",
     "typescript": "5.9.x"
   },
@@ -55,7 +55,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.9",
+  "version": "0.2.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [