strict-env-resolver 0.5.1

package/.devcontainer/devcontainer.json

@@ -0,0 +1,26 @@
+{
+  "name": "dev-strict-env-resolver",
+  "image": "mcr.microsoft.com/devcontainers/base:bookworm",
+  "features": {
+    "ghcr.io/devcontainers/features/common-utils:2": {
+      "username": "developer",
+      "upgradePackages": true
+    },
+    "ghcr.io/devcontainers/features/git:1": {},
+    "ghcr.io/devcontainers/features/node:1": {
+      "version": "24"
+    }
+  },
+  "workspaceMount": "source=${localWorkspaceFolder},target=/workspace,type=bind",
+  "workspaceFolder": "/workspace",
+  "mounts": [
+    "target=/workspace/node_modules"
+  ],
+  "remoteUser": "developer",
+  "remoteEnv": {
+    "npm_config_loglevel": "error"
+  },
+  "postCreateCommand": {
+    "fixVolumePerms": "sudo chown -R $(whoami): /workspace"
+  }
+}

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,188 @@
+# Strict Env Resolver
+
+[![npm version](https://img.shields.io/npm/v/strict-env-resolver.svg)](https://www.npmjs.com/package/strict-env-resolver)
+[![npm downloads](https://img.shields.io/npm/dm/strict-env-resolver.svg)](https://www.npmjs.com/package/strict-env-resolver)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+Type-safe environment variable resolver for Node.js. Reads and parses `process.env` with specs (`string`, `number`, `boolean`, `enum`), optional defaults, configurable trimming, and structured validation errors when values are missing or invalid.
+
+## Features
+
+- **Typed specs**: `string`, `number`, `boolean`, and `enum` with TypeScript inference
+- **Finite numbers**: `StrictEnvType.Number` parses any finite numeric value (`Number()`); rejects `NaN` and `Infinity`
+- **Optional defaults**: Fallback when a variable is unset, empty (`""`), or whitespace-only (when trimming is enabled)
+- **Configurable trim**: `trim` defaults to `true` for parsed types and `false` for strings; override per variable
+- **Batch parsing**: `resolveAll()` evaluates every key and throws once with all validation errors
+- **Structured errors**: `StrictEnvValidationError` exposes `errors` (`key`, `message`, `raw`, `kind`) and `keys`
+- **Boolean parsing**: `1`, `true`, `yes`, `on` (case-insensitive, after trim) → `true`; any other non-empty value → `false`
+- **Enum constraint**: Values must match one of the allowed choices (compared after trim)
+
+## Installation
+
+**npm**
+
+```bash
+npm install strict-env-resolver
+```
+
+**yarn**
+
+```bash
+yarn add strict-env-resolver
+```
+
+## Usage
+
+```ts
+import {
+  StrictEnvResolver,
+  StrictEnvError,
+  StrictEnvValidationError,
+  StrictEnvType,
+} from 'strict-env-resolver';
+
+// String (spec omitted → StrictEnvType.String; throws if missing)
+const nodeEnv = StrictEnvResolver.resolve('NODE_ENV');
+
+// String with default (used when unset or empty)
+const logLevel = StrictEnvResolver.resolve('LOG_LEVEL', StrictEnvType.String, { default: 'info' });
+
+// Trim strings and treat whitespace-only as missing
+const trimmedLogLevel = StrictEnvResolver.resolve('LOG_LEVEL', StrictEnvType.String, {
+  trim: true,
+  default: 'info',
+});
+
+// Number (e.g. port, ratio, timeout)
+const port = StrictEnvResolver.resolve('PORT', StrictEnvType.Number, { default: 3000 });
+// Valid: "42", "-1", "3.14", "1e5", "+42", "0x10", "  42  " (trimmed)
+// Missing: "", "   " (whitespace-only, trim default true)
+// Invalid: "Infinity", "NaN", "not-a-number"
+
+// Boolean (1/true/yes/on → true after trim; other non-empty values → false)
+const debug = StrictEnvResolver.resolve('DEBUG', StrictEnvType.Boolean, { default: false });
+// " true " → true
+
+// Enum (value must be in choices, compared after trim)
+const mode = StrictEnvResolver.resolve('MODE', StrictEnvType.Enum(['read', 'write'] as const));
+const modeWithDefault = StrictEnvResolver.resolve(
+  'MODE',
+  StrictEnvType.Enum(['read', 'write'] as const),
+  { default: 'read' },
+);
+
+// Read multiple env vars at once (collects all errors, then throws once)
+const envs = StrictEnvResolver.resolveAll({
+  PORT: [StrictEnvType.Number, { default: 3000 }],
+  DEBUG: [StrictEnvType.Boolean, { default: false }],
+  MODE: StrictEnvType.Enum(['read', 'write'] as const),
+  LOG_LEVEL: [StrictEnvType.String, { trim: true, default: 'info' }],
+});
+
+// Handle structured validation errors
+try {
+  StrictEnvResolver.resolveAll({
+    PORT: StrictEnvType.Number,
+    MODE: StrictEnvType.Enum(['read', 'write'] as const),
+  });
+} catch (e) {
+  if (e instanceof StrictEnvValidationError) {
+    // e.errors: [{ key, message, raw?, kind }, ...]
+    // e.keys:  ['PORT', 'MODE', ...]
+    // kind: 'missing' | 'invalid_number' | 'invalid_enum'
+    console.error(e.errors);
+  } else if (e instanceof StrictEnvError) {
+    // Other package errors
+  }
+  throw e;
+}
+```
+
+## Options
+
+### `StrictEnvResolver.resolve(key, spec?, options?)`
+
+| Argument | Required | Description |
+|----------|----------|-------------|
+| **key** | Yes | Environment variable name (e.g. `"PORT"`, `"NODE_ENV"`). |
+| **spec** | No | Type spec; defaults to `StrictEnvType.String`. Use `StrictEnvType.String`, `StrictEnvType.Number`, `StrictEnvType.Boolean`, or `StrictEnvType.Enum(choices)`. |
+| **options** | No | See [`StrictEnvOptions`](#strictenvoptions) below. |
+
+### `StrictEnvResolver.resolveAll(schema)`
+
+`schema` is an object where each key is an env var name and each value is either:
+
+- A spec (e.g. `StrictEnvType.Number`)
+- A tuple `[spec, options]` (e.g. `[StrictEnvType.Number, { default: 3000, trim: true }]`)
+
+Evaluates every entry in `schema`. If any value is missing, empty without a default, whitespace-only without a default (when trimming is enabled), or invalid, throws a single `StrictEnvValidationError` containing all issues.
+
+### `StrictEnvOptions`
+
+| Field | Type | Description |
+|-------|------|-------------|
+| **default** | Spec-dependent | Fallback when the variable is unset, empty (`""`), or whitespace-only (when `trim` is enabled). |
+| **trim** | `boolean` | Trims leading/trailing whitespace before validation. Defaults to `true` for `number`, `boolean`, and `enum`; `false` for `string`. |
+
+### Spec types
+
+| Spec | Constant | Description |
+|------|----------|-------------|
+| `string` | `StrictEnvType.String` | Raw string value. Not trimmed by default; set `trim: true` to trim and treat whitespace-only as missing. |
+| `number` | `StrictEnvType.Number` | Finite numeric value (see below). Trimmed by default. |
+| `boolean` | `StrictEnvType.Boolean` | `1` / `true` / `yes` / `on` (case-insensitive, trimmed) → `true`; otherwise → `false`. Trimmed by default. |
+| `enum` | `StrictEnvType.Enum(choices)` | Value must be in `choices` (compared after trim). Trimmed by default. |
+
+#### `StrictEnvType.Number`
+
+- Trims leading/trailing whitespace before validation (default `trim: true`).
+- Parsed with `Number()`; the result must be finite (`NaN` and `Infinity` are rejected).
+- **Accepted examples**: `"3000"`, `"3.14"`, `"1e5"`, `"+42"`, `"0x10"`, `"  42  "`, `"-1"`
+- **Missing examples**: `""`, `"   "` (whitespace-only; `kind: 'missing'` unless a default is set)
+- **Rejected examples**: `"Infinity"`, `"NaN"`, `"not-a-number"`
+
+### Whitespace and trim
+
+| Spec | `trim` default | `""` | `"   "` (whitespace-only) | `" true "` |
+|------|----------------|------|---------------------------|------------|
+| `string` | `false` | missing (or default) | returned as-is (`"   "`) | returned as-is |
+| `number` | `true` | missing (or default) | missing (or default) | `invalid_number` |
+| `boolean` | `true` | missing (or default) | missing (or default) | `true` |
+| `enum` | `true` | missing (or default) | missing (or default) | `invalid_enum` (unless a choice matches after trim) |
+
+Override with `trim: true` or `trim: false` in options:
+
+```ts
+// Trim strings and treat whitespace-only as missing
+StrictEnvResolver.resolve('LOG_LEVEL', StrictEnvType.String, { trim: true, default: 'info' });
+
+// Preserve exact whitespace in a string value
+StrictEnvResolver.resolve('PADDING', StrictEnvType.String, { trim: false });
+```
+
+### Validation errors
+
+| `kind` | When |
+|--------|------|
+| `missing` | Variable unset, empty (`""`), or whitespace-only when trimming is enabled, without a default. |
+| `invalid_number` | Value is not a finite number. |
+| `invalid_enum` | Value is not in `choices`. |
+
+**Message formats:**
+
+- Missing: `Missing required environment variable: <key>`
+- Number: `Env <key>: expected number, got "<raw>"`
+- Enum: `Env <key>: must be one of [choice1, choice2, ...]`
+
+`StrictEnvValidationError` fields:
+
+- `errors`: `[{ key, message, raw?, kind }, ...]`
+- `keys`: `['KEY1', 'KEY2', ...]`
+
+## Requirements
+
+- **Node.js** >= 20.0.0
+
+## License
+
+This project is licensed under the Apache-2.0 License.

package/lib/index.d.ts

@@ -0,0 +1,211 @@
+/**
+ * Spec for a string environment variable.
+ * Returned as-is by default (`trim` defaults to `false`). Set `trim: true` in options to trim
+ * whitespace and treat whitespace-only values as missing.
+ * The default value is passed via the third argument of `resolve` or a `[spec, options]` tuple in `resolveAll`, not in the spec.
+ */
+export type StrictEnvTypeString = {
+    type: 'string';
+    default?: string;
+};
+/**
+ * Spec for a numeric environment variable.
+ * Values are parsed with `Number()`; `NaN`, `Infinity`, and `-Infinity` are rejected.
+ * The default value is passed via the third argument of `resolve` or a `[spec, options]` tuple in `resolveAll`, not in the spec.
+ */
+export type StrictEnvTypeNumber = {
+    type: 'number';
+    default?: number;
+};
+/**
+ * Spec for a boolean environment variable.
+ * Parses `1`, `true`, `yes`, `on` (case-insensitive, after trim) as `true`; any other non-empty value as `false`.
+ * Trims leading/trailing whitespace by default (see `StrictEnvOptions.trim`).
+ * The default value is passed via the third argument of `resolve` or a `[spec, options]` tuple in `resolveAll`, not in the spec.
+ */
+export type StrictEnvTypeBoolean = {
+    type: 'boolean';
+    default?: boolean;
+};
+/**
+ * Spec for an enum environment variable with a fixed set of choices.
+ * The value must be one of `choices` (compared after trim); otherwise validation fails.
+ * Trims leading/trailing whitespace by default (see `StrictEnvOptions.trim`).
+ * The default value is passed via the third argument of `resolve` or a `[spec, options]` tuple in `resolveAll`, not in the spec.
+ *
+ * @template T - Literal string union of allowed values.
+ */
+export type StrictEnvTypeEnum<T extends string = string> = {
+    type: 'enum';
+    choices: readonly T[];
+    default?: T;
+};
+/** Union of all environment variable spec types. */
+export type StrictEnvSpec = StrictEnvTypeString | StrictEnvTypeNumber | StrictEnvTypeBoolean | StrictEnvTypeEnum;
+/**
+ * Discriminated union of error kinds emitted during environment variable parsing.
+ *
+ * - `missing` — Variable unset, empty string, or whitespace-only (when trim is enabled) without a default.
+ * - `invalid_number` — Value is not a finite number (see `StrictEnvTypeNumber`).
+ * - `invalid_enum` — Value is not one of the allowed enum choices.
+ */
+export type StrictEnvErrorKind = 'missing' | 'invalid_number' | 'invalid_enum';
+/**
+ * A structured validation error entry for a single environment variable.
+ *
+ * @template K - Environment variable key type.
+ */
+export type StrictEnvValidationEntry<K extends string = string> = {
+    /** Environment variable name. */
+    key: K;
+    /** Human-readable error message. */
+    message: string;
+    /** Raw value from `process.env`, if present. */
+    raw?: string;
+    /** Error category for programmatic handling. */
+    kind: StrictEnvErrorKind;
+};
+/**
+ * Base error class for this package.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   StrictEnvResolver.resolve('PORT', StrictEnvType.Number);
+ * } catch (e) {
+ *   if (e instanceof StrictEnvError) {
+ *     // Handle all strict-env-resolver errors
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class StrictEnvError extends Error {
+    /**
+     * @param message - Error message.
+     */
+    protected constructor(message: string);
+}
+/**
+ * Validation error that carries one or more environment variable issues.
+ *
+ * Thrown by `StrictEnvResolver.resolve()` (single-entry `errors`) and
+ * `StrictEnvResolver.resolveAll()` (multi-entry `errors`).
+ * Individual entries are produced by the internal `parseEnvValue` helper.
+ *
+ * @template K - Union of environment variable keys included in `errors`.
+ */
+export declare class StrictEnvValidationError<K extends string = string> extends StrictEnvError {
+    /**
+     * Formats validation errors into a human-readable error message.
+     *
+     * @template K - Environment variable key type.
+     * @param errors - Validation error entries to format.
+     * @returns Multi-line summary listing each key and message.
+     */
+    static format<K extends string>(errors: readonly StrictEnvValidationEntry<K>[]): string;
+    /**
+     * Structured list of validation errors.
+     */
+    readonly errors: readonly StrictEnvValidationEntry<K>[];
+    /**
+     * Convenience list of keys included in `errors`.
+     */
+    readonly keys: readonly K[];
+    /**
+     * Creates a new validation error from one or more `StrictEnvValidationEntry` entries.
+     *
+     * @param errors - One or more structured validation errors.
+     */
+    constructor(errors: readonly StrictEnvValidationEntry<K>[]);
+}
+/**
+ * Predefined spec constants for use with `resolve` or as schema values in `resolveAll`.
+ * Provide defaults via the third argument of `resolve` or a `[spec, { default }]` tuple in `resolveAll`.
+ */
+export declare const StrictEnvType: {
+    /** Spec for a string value (returned as-is unless `trim: true` is set in options). */
+    readonly String: {
+        readonly type: "string";
+    };
+    /**
+     * Spec for a finite numeric value (`Number()` parsing; rejects `NaN` and `Infinity`).
+     */
+    readonly Number: {
+        readonly type: "number";
+    };
+    /** Spec for a boolean value (`1`/`true`/`yes`/`on` → `true`; other non-empty values → `false`). */
+    readonly Boolean: {
+        readonly type: "boolean";
+    };
+    /**
+     * Returns a spec that restricts the value to one of the given choices.
+     *
+     * @param choices - Allowed string literals.
+     * @returns Enum spec for use with `resolve` or `resolveAll`.
+     */
+    readonly Enum: <T extends string>(choices: readonly T[]) => StrictEnvTypeEnum<T>;
+};
+/**
+ * Infers the return type from the given spec.
+ * @template S - A `StrictEnvSpec` variant.
+ */
+export type StrictEnvSpecToType<S> = S extends StrictEnvTypeString ? string : S extends StrictEnvTypeNumber ? number : S extends StrictEnvTypeBoolean ? boolean : S extends StrictEnvTypeEnum<infer T> ? T : never;
+/**
+ * Options for reading an environment variable with an optional default.
+ * Used as the third argument to `resolve` or as the second element of a `[spec, options]` tuple in `resolveAll`.
+ *
+ * `trim` defaults to `true` for `number`, `boolean`, and `enum` specs (whitespace-only values are
+ * treated as missing). For `string` specs it defaults to `false` (values are returned as-is).
+ *
+ * @template S - Environment variable spec type.
+ */
+export type StrictEnvOptions<S extends StrictEnvSpec> = {
+    default?: StrictEnvSpecToType<S>;
+    /** When `true`, trims leading/trailing whitespace before validation. */
+    trim?: boolean;
+};
+/**
+ * Schema entry for a single env var.
+ *
+ * Either provide a spec directly, or a tuple of `[spec, options]` to attach a default.
+ */
+export type StrictEnvSchemaEntry<S extends StrictEnvSpec = StrictEnvSpec> = S | readonly [S, StrictEnvOptions<S>];
+/**
+ * Schema object used by `resolveAll()`.
+ *
+ * Keys are env var names, values are specs (optionally with defaults).
+ */
+export type StrictEnvSchema = Record<string, StrictEnvSchemaEntry>;
+/**
+ * Extracts the spec type from a schema entry or `[spec, options]` tuple.
+ *
+ * @template E - Schema entry type.
+ */
+type StrictEnvSchemaEntryToSpec<E> = E extends readonly [infer S, unknown] ? S : E;
+/**
+ * Maps a schema object to the resulting parsed environment object type.
+ *
+ * @template TSchema - Schema object type passed to `resolveAll`.
+ */
+export type StrictEnvSchemaToType<TSchema extends StrictEnvSchema> = {
+    [K in keyof TSchema]: StrictEnvSpecToType<StrictEnvSchemaEntryToSpec<TSchema[K]> & StrictEnvSpec>;
+};
+/**
+ * Type-safe environment variable resolver for Node.js `process.env`.
+ *
+ * @example
+ * ```ts
+ * const port = StrictEnvResolver.resolve('PORT', StrictEnvType.Number);
+ * const envs = StrictEnvResolver.resolveAll({
+ *   PORT: StrictEnvType.Number,
+ *   DEBUG: [StrictEnvType.Boolean, { default: false }],
+ * });
+ * ```
+ */
+export declare const StrictEnvResolver: {
+    /** Reads and parses a single environment variable. See {@link resolve}. */
+    readonly resolve: <K extends string, S extends StrictEnvSpec = StrictEnvTypeString>(key: K, spec?: S, options?: StrictEnvOptions<S>) => StrictEnvSpecToType<S>;
+    /** Reads and parses multiple environment variables in one pass. See {@link resolveAll}. */
+    readonly resolveAll: <TSchema extends StrictEnvSchema>(schema: TSchema) => StrictEnvSchemaToType<TSchema>;
+};
+export {};

package/lib/index.js

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrictEnvResolver = exports.StrictEnvType = exports.StrictEnvValidationError = exports.StrictEnvError = void 0;
+/**
+ * Pattern for boolean env values that parse as `true`.
+ * Matches `1`, `true`, `yes`, and `on` (case-insensitive) on the full trimmed string.
+ */
+const TRUE_BOOLEAN_PATTERN = /^(1|true|yes|on)$/i;
+/**
+ * Parses a string as a finite number for environment variables.
+ *
+ * @param raw - Trimmed environment variable value.
+ * @returns Parsed number, or `undefined` when the value is not a finite number.
+ */
+const parseNumber = (raw) => {
+    const n = Number(raw);
+    if (!Number.isFinite(n)) {
+        return undefined;
+    }
+    return n;
+};
+/**
+ * Parses a trimmed string as a boolean environment variable value.
+ *
+ * @param normalizedRaw - Trimmed raw environment variable value.
+ * @returns `true` for `1`/`true`/`yes`/`on` (case-insensitive); otherwise `false`.
+ */
+const parseBooleanEnvValue = (normalizedRaw) => TRUE_BOOLEAN_PATTERN.test(normalizedRaw);
+/**
+ * Base error class for this package.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   StrictEnvResolver.resolve('PORT', StrictEnvType.Number);
+ * } catch (e) {
+ *   if (e instanceof StrictEnvError) {
+ *     // Handle all strict-env-resolver errors
+ *   }
+ * }
+ * ```
+ */
+class StrictEnvError extends Error {
+    /**
+     * @param message - Error message.
+     */
+    constructor(message) {
+        super(message);
+        this.name = 'StrictEnvError';
+    }
+}
+exports.StrictEnvError = StrictEnvError;
+/**
+ * Validation error that carries one or more environment variable issues.
+ *
+ * Thrown by `StrictEnvResolver.resolve()` (single-entry `errors`) and
+ * `StrictEnvResolver.resolveAll()` (multi-entry `errors`).
+ * Individual entries are produced by the internal `parseEnvValue` helper.
+ *
+ * @template K - Union of environment variable keys included in `errors`.
+ */
+class StrictEnvValidationError extends StrictEnvError {
+    /**
+     * Formats validation errors into a human-readable error message.
+     *
+     * @template K - Environment variable key type.
+     * @param errors - Validation error entries to format.
+     * @returns Multi-line summary listing each key and 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 `StrictEnvValidationEntry` entries.
+     *
+     * @param errors - One or more structured validation errors.
+     */
+    constructor(errors) {
+        const msg = StrictEnvValidationError.format(errors);
+        super(msg);
+        this.name = 'StrictEnvValidationError';
+        this.errors = errors;
+        this.keys = errors.map((e) => e.key);
+    }
+}
+exports.StrictEnvValidationError = StrictEnvValidationError;
+/**
+ * Predefined spec constants for use with `resolve` or as schema values in `resolveAll`.
+ * Provide defaults via the third argument of `resolve` or a `[spec, { default }]` tuple in `resolveAll`.
+ */
+exports.StrictEnvType = {
+    /** Spec for a string value (returned as-is unless `trim: true` is set in options). */
+    String: { type: 'string' },
+    /**
+     * Spec for a finite numeric value (`Number()` parsing; rejects `NaN` and `Infinity`).
+     */
+    Number: { type: 'number' },
+    /** Spec for a boolean value (`1`/`true`/`yes`/`on` → `true`; other non-empty values → `false`). */
+    Boolean: { type: 'boolean' },
+    /**
+     * Returns a spec that restricts the value to one of the given choices.
+     *
+     * @param choices - Allowed string literals.
+     * @returns Enum spec for use with `resolve` or `resolveAll`.
+     */
+    Enum: (choices) => ({ type: 'enum', choices }),
+};
+/**
+ * Default trim behavior per spec type.
+ * Parsed types trim by default; strings preserve the raw value unless opted in.
+ *
+ * @param spec - Environment variable spec.
+ * @returns Whether leading/trailing whitespace should be trimmed before validation.
+ */
+const defaultTrimForSpec = (spec) => spec.type !== 'string';
+/**
+ * Normalizes a raw environment variable value before validation.
+ *
+ * @param raw - Raw value from `process.env`, if present.
+ * @param trim - Whether to trim leading/trailing whitespace.
+ * @returns Normalized value, or `undefined` when unset.
+ */
+const normalizeEnvRaw = (raw, trim) => {
+    if (raw == null) {
+        return undefined;
+    }
+    if (!trim) {
+        return raw;
+    }
+    return raw.trim();
+};
+/**
+ * Resolves a schema entry into its spec and optional per-key options.
+ *
+ * @param entry - Schema entry or `[spec, options]` tuple.
+ * @returns Parsed spec and options for `resolveAll`.
+ */
+const resolveSchemaEntry = (entry) => ({
+    spec: (Array.isArray(entry) ? entry[0] : entry),
+    options: (Array.isArray(entry) ? entry[1] : undefined),
+});
+/**
+ * Parses a single environment variable according to the given spec.
+ *
+ * Central validation helper shared by `resolve` and `resolveAll`. Does not throw;
+ * callers decide whether to throw immediately or collect errors.
+ *
+ * Missing or empty (`""`) values use `defaultValue` when provided. When `trim` is enabled,
+ * whitespace-only values are treated as empty. Number specs delegate to `parseNumber`.
+ * Boolean specs treat `1`/`true`/`yes`/`on` (case-insensitive, after trim) as `true`.
+ * Enum specs require an exact match in `choices` (after trim).
+ *
+ * @template K - Environment variable key type.
+ * @template S - Environment variable spec type.
+ * @param key - Environment variable name.
+ * @param spec - Type spec for the value.
+ * @param raw - Raw value from `process.env`, if present.
+ * @param defaultValue - Fallback when `raw` is missing or empty.
+ * @param options - Optional trim override (`trim` defaults per spec type).
+ * @returns Parsed value or a structured validation error.
+ */
+const parseEnvValue = (key, spec, raw, defaultValue, options) => {
+    const trim = options?.trim ?? defaultTrimForSpec(spec);
+    const normalizedRaw = normalizeEnvRaw(raw, trim);
+    const hasDefault = defaultValue !== undefined;
+    if (normalizedRaw == null || normalizedRaw === '') {
+        if (hasDefault) {
+            return { ok: true, value: defaultValue };
+        }
+        return {
+            ok: false,
+            error: { key, message: `Missing required environment variable: ${key}`, raw, kind: 'missing' },
+        };
+    }
+    switch (spec.type) {
+        case 'number': {
+            const n = parseNumber(normalizedRaw);
+            if (n === undefined) {
+                return {
+                    ok: false,
+                    error: { key, message: `Env ${key}: expected number, got "${raw}"`, raw, kind: 'invalid_number' },
+                };
+            }
+            return { ok: true, value: n };
+        }
+        case 'boolean':
+            return { ok: true, value: parseBooleanEnvValue(normalizedRaw) };
+        case 'enum':
+            if (!spec.choices.includes(normalizedRaw)) {
+                return {
+                    ok: false,
+                    error: {
+                        key,
+                        message: `Env ${key}: must be one of [${spec.choices.join(', ')}]`,
+                        raw,
+                        kind: 'invalid_enum',
+                    },
+                };
+            }
+            return { ok: true, value: normalizedRaw };
+        default:
+            return { ok: true, value: normalizedRaw };
+    }
+};
+/**
+ * Reads and parses an environment variable according to the given spec.
+ *
+ * Delegates validation to `parseEnvValue`. Missing or empty (`""`) values use
+ * `options.default` when provided; otherwise a `StrictEnvValidationError` is thrown.
+ * For `StrictEnvType.Number`, values are parsed as finite numbers (see `StrictEnvTypeNumber`).
+ *
+ * @template K - Environment variable key type.
+ * @template S - Environment variable spec type.
+ * @param key - Environment variable name (e.g. `"PORT"`, `"NODE_ENV"`).
+ * @param spec - Type spec; defaults to `StrictEnvType.String` when omitted.
+ * @param options - Optional `{ default, trim }`; see {@link StrictEnvOptions}.
+ * @returns Parsed value with type inferred from `spec`.
+ * @throws {StrictEnvValidationError} When the variable is missing, empty without a default, or invalid for the spec.
+ */
+const resolve = (key, spec = exports.StrictEnvType.String, options) => {
+    const result = parseEnvValue(key, spec, process.env[key], options?.default, options);
+    if (!result.ok) {
+        throw new StrictEnvValidationError([result.error]);
+    }
+    return result.value;
+};
+/**
+ * Reads and parses multiple environment variables according to the given schema.
+ *
+ * Always evaluates every key in `schema`. Each entry is validated via `parseEnvValue`;
+ * all errors are collected and thrown once in a single `StrictEnvValidationError`.
+ * Number specs use the same finite-number rules as `resolve`.
+ *
+ * @template TSchema - Schema object type.
+ * @param schema - Map of environment variable names to specs, optionally with per-key defaults via `[spec, { default }]`.
+ * @returns Parsed environment object with types inferred from the schema.
+ * @throws {StrictEnvValidationError} When one or more variables are missing, empty without a default, or invalid.
+ */
+const resolveAll = (schema) => {
+    const envs = {};
+    const errors = [];
+    for (const key of Object.keys(schema)) {
+        const { spec, options } = resolveSchemaEntry(schema[key]);
+        const result = parseEnvValue(key, spec, process.env[key], options?.default, options);
+        if (!result.ok) {
+            errors.push(result.error);
+            continue;
+        }
+        envs[key] = result.value;
+    }
+    if (errors.length > 0)
+        throw new StrictEnvValidationError(errors);
+    return envs;
+};
+/**
+ * Type-safe environment variable resolver for Node.js `process.env`.
+ *
+ * @example
+ * ```ts
+ * const port = StrictEnvResolver.resolve('PORT', StrictEnvType.Number);
+ * const envs = StrictEnvResolver.resolveAll({
+ *   PORT: StrictEnvType.Number,
+ *   DEBUG: [StrictEnvType.Boolean, { default: false }],
+ * });
+ * ```
+ */
+exports.StrictEnvResolver = {
+    /** Reads and parses a single environment variable. See {@link resolve}. */
+    resolve,
+    /** Reads and parses multiple environment variables in one pass. See {@link resolveAll}. */
+    resolveAll,
+};
+//# 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 * Returned as-is by default (`trim` defaults to `false`). Set `trim: true` in options to trim\n * whitespace and treat whitespace-only values as missing.\n * The default value is passed via the third argument of `resolve` or a `[spec, options]` tuple in `resolveAll`, not in the spec.\n */\nexport type StrictEnvTypeString = { type: 'string'; default?: string };\n\n/**\n * Spec for a numeric environment variable.\n * Values are parsed with `Number()`; `NaN`, `Infinity`, and `-Infinity` are rejected.\n * The default value is passed via the third argument of `resolve` or a `[spec, options]` tuple in `resolveAll`, not in the spec.\n */\nexport type StrictEnvTypeNumber = { type: 'number'; default?: number };\n\n/**\n * Pattern for boolean env values that parse as `true`.\n * Matches `1`, `true`, `yes`, and `on` (case-insensitive) on the full trimmed string.\n */\nconst TRUE_BOOLEAN_PATTERN = /^(1|true|yes|on)$/i;\n\n/**\n * Parses a string as a finite number for environment variables.\n *\n * @param raw - Trimmed environment variable value.\n * @returns Parsed number, or `undefined` when the value is not a finite number.\n */\nconst parseNumber = (raw: string): number | undefined => {\n  const n = Number(raw);\n  if (!Number.isFinite(n)) {\n    return undefined;\n  }\n  return n;\n};\n\n/**\n * Parses a trimmed string as a boolean environment variable value.\n *\n * @param normalizedRaw - Trimmed raw environment variable value.\n * @returns `true` for `1`/`true`/`yes`/`on` (case-insensitive); otherwise `false`.\n */\nconst parseBooleanEnvValue = (normalizedRaw: string): boolean => TRUE_BOOLEAN_PATTERN.test(normalizedRaw);\n\n/**\n * Spec for a boolean environment variable.\n * Parses `1`, `true`, `yes`, `on` (case-insensitive, after trim) as `true`; any other non-empty value as `false`.\n * Trims leading/trailing whitespace by default (see `StrictEnvOptions.trim`).\n * The default value is passed via the third argument of `resolve` or a `[spec, options]` tuple in `resolveAll`, not in the spec.\n */\nexport type StrictEnvTypeBoolean = { 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` (compared after trim); otherwise validation fails.\n * Trims leading/trailing whitespace by default (see `StrictEnvOptions.trim`).\n * The default value is passed via the third argument of `resolve` or a `[spec, options]` tuple in `resolveAll`, not in the spec.\n *\n * @template T - Literal string union of allowed values.\n */\nexport type StrictEnvTypeEnum<T extends string = string> = { type: 'enum'; choices: readonly T[]; default?: T };\n\n/** Union of all environment variable spec types. */\nexport type StrictEnvSpec =\n  | StrictEnvTypeString\n  | StrictEnvTypeNumber\n  | StrictEnvTypeBoolean\n  | StrictEnvTypeEnum;\n\n/**\n * Discriminated union of error kinds emitted during environment variable parsing.\n *\n * - `missing` — Variable unset, empty string, or whitespace-only (when trim is enabled) without a default.\n * - `invalid_number` — Value is not a finite number (see `StrictEnvTypeNumber`).\n * - `invalid_enum` — Value is not one of the allowed enum choices.\n */\nexport type StrictEnvErrorKind = 'missing' | 'invalid_number' | 'invalid_enum';\n\n/**\n * A structured validation error entry for a single environment variable.\n *\n * @template K - Environment variable key type.\n */\nexport type StrictEnvValidationEntry<K extends string = string> = {\n  /** Environment variable name. */\n  key: K;\n  /** Human-readable error message. */\n  message: string;\n  /** Raw value from `process.env`, if present. */\n  raw?: string;\n  /** Error category for programmatic handling. */\n  kind: StrictEnvErrorKind;\n};\n\n/**\n * Base error class for this package.\n *\n * @example\n * ```ts\n * try {\n *   StrictEnvResolver.resolve('PORT', StrictEnvType.Number);\n * } catch (e) {\n *   if (e instanceof StrictEnvError) {\n *     // Handle all strict-env-resolver errors\n *   }\n * }\n * ```\n */\nexport abstract class StrictEnvError extends Error {\n  /**\n   * @param message - Error message.\n   */\n  protected constructor(message: string) {\n    super(message);\n    this.name = 'StrictEnvError';\n  }\n}\n\n/**\n * Validation error that carries one or more environment variable issues.\n *\n * Thrown by `StrictEnvResolver.resolve()` (single-entry `errors`) and\n * `StrictEnvResolver.resolveAll()` (multi-entry `errors`).\n * Individual entries are produced by the internal `parseEnvValue` helper.\n *\n * @template K - Union of environment variable keys included in `errors`.\n */\nexport class StrictEnvValidationError<K extends string = string> extends StrictEnvError {\n  /**\n   * Formats validation errors into a human-readable error message.\n   *\n   * @template K - Environment variable key type.\n   * @param errors - Validation error entries to format.\n   * @returns Multi-line summary listing each key and message.\n   */\n  public static format<K extends string>(errors: readonly StrictEnvValidationEntry<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 StrictEnvValidationEntry<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 `StrictEnvValidationEntry` entries.\n   *\n   * @param errors - One or more structured validation errors.\n   */\n  public constructor(errors: readonly StrictEnvValidationEntry<K>[]) {\n    const msg = StrictEnvValidationError.format(errors);\n    super(msg);\n    this.name = 'StrictEnvValidationError';\n    this.errors = errors;\n    this.keys = errors.map((e) => e.key);\n  }\n}\n\n/**\n * Predefined spec constants for use with `resolve` or as schema values in `resolveAll`.\n * Provide defaults via the third argument of `resolve` or a `[spec, { default }]` tuple in `resolveAll`.\n */\nexport const StrictEnvType = {\n  /** Spec for a string value (returned as-is unless `trim: true` is set in options). */\n  String: { type: 'string' } as const satisfies StrictEnvTypeString,\n  /**\n   * Spec for a finite numeric value (`Number()` parsing; rejects `NaN` and `Infinity`).\n   */\n  Number: { type: 'number' } as const satisfies StrictEnvTypeNumber,\n  /** Spec for a boolean value (`1`/`true`/`yes`/`on` → `true`; other non-empty values → `false`). */\n  Boolean: { type: 'boolean' } as const satisfies StrictEnvTypeBoolean,\n  /**\n   * Returns a spec that restricts the value to one of the given choices.\n   *\n   * @param choices - Allowed string literals.\n   * @returns Enum spec for use with `resolve` or `resolveAll`.\n   */\n  Enum: <T extends string>(choices: readonly T[]) => ({ type: 'enum', choices }) as StrictEnvTypeEnum<T>,\n} as const;\n\n/**\n * Infers the return type from the given spec.\n * @template S - A `StrictEnvSpec` variant.\n */\nexport type StrictEnvSpecToType<S> =\n  S extends StrictEnvTypeString ? string\n    : S extends StrictEnvTypeNumber ? number\n      : S extends StrictEnvTypeBoolean ? boolean\n        : S extends StrictEnvTypeEnum<infer T> ? T\n          : never;\n\n/**\n * Options for reading an environment variable with an optional default.\n * Used as the third argument to `resolve` or as the second element of a `[spec, options]` tuple in `resolveAll`.\n *\n * `trim` defaults to `true` for `number`, `boolean`, and `enum` specs (whitespace-only values are\n * treated as missing). For `string` specs it defaults to `false` (values are returned as-is).\n *\n * @template S - Environment variable spec type.\n */\nexport type StrictEnvOptions<S extends StrictEnvSpec> = {\n  default?: StrictEnvSpecToType<S>;\n  /** When `true`, trims leading/trailing whitespace before validation. */\n  trim?: boolean;\n};\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 StrictEnvSchemaEntry<S extends StrictEnvSpec = StrictEnvSpec> = S | readonly [S, StrictEnvOptions<S>];\n\n/**\n * Schema object used by `resolveAll()`.\n *\n * Keys are env var names, values are specs (optionally with defaults).\n */\nexport type StrictEnvSchema = Record<string, StrictEnvSchemaEntry>;\n\n/**\n * Extracts the spec type from a schema entry or `[spec, options]` tuple.\n *\n * @template E - Schema entry type.\n */\ntype StrictEnvSchemaEntryToSpec<E> = E extends readonly [infer S, unknown] ? S : E;\n\n/**\n * Maps a schema object to the resulting parsed environment object type.\n *\n * @template TSchema - Schema object type passed to `resolveAll`.\n */\nexport type StrictEnvSchemaToType<TSchema extends StrictEnvSchema> = {\n  [K in keyof TSchema]: StrictEnvSpecToType<StrictEnvSchemaEntryToSpec<TSchema[K]> & StrictEnvSpec>;\n};\n\n/**\n * Discriminated result of parsing a single environment variable.\n *\n * On success, `value` holds the parsed result. On failure, `error` holds a structured\n * `StrictEnvValidationEntry` entry (never throws).\n *\n * @template K - Environment variable key type.\n * @template S - Environment variable spec type.\n */\ntype ParseEnvValueResult<K extends string, S extends StrictEnvSpec> =\n  | { ok: true; value: StrictEnvSpecToType<S> }\n  | { ok: false; error: StrictEnvValidationEntry<K> };\n\n/**\n * Default trim behavior per spec type.\n * Parsed types trim by default; strings preserve the raw value unless opted in.\n *\n * @param spec - Environment variable spec.\n * @returns Whether leading/trailing whitespace should be trimmed before validation.\n */\nconst defaultTrimForSpec = (spec: StrictEnvSpec): boolean => spec.type !== 'string';\n\n/**\n * Normalizes a raw environment variable value before validation.\n *\n * @param raw - Raw value from `process.env`, if present.\n * @param trim - Whether to trim leading/trailing whitespace.\n * @returns Normalized value, or `undefined` when unset.\n */\nconst normalizeEnvRaw = (raw: string | undefined, trim: boolean): string | undefined => {\n  if (raw == null) {\n    return undefined;\n  }\n  if (!trim) {\n    return raw;\n  }\n  return raw.trim();\n};\n\n/** Options accepted by `parseEnvValue` (subset of `StrictEnvOptions`). */\ntype ParseEnvValueOptions<S extends StrictEnvSpec> = Pick<StrictEnvOptions<S>, 'trim'>;\n\n/**\n * Resolves a schema entry into its spec and optional per-key options.\n *\n * @param entry - Schema entry or `[spec, options]` tuple.\n * @returns Parsed spec and options for `resolveAll`.\n */\nconst resolveSchemaEntry = (\n  entry: StrictEnvSchemaEntry,\n): { spec: StrictEnvSpec; options: StrictEnvOptions<StrictEnvSpec> | undefined } => ({\n  spec: (Array.isArray(entry) ? entry[0] : entry) as StrictEnvSpec,\n  options: (Array.isArray(entry) ? entry[1] : undefined) as StrictEnvOptions<StrictEnvSpec> | undefined,\n});\n\n/**\n * Parses a single environment variable according to the given spec.\n *\n * Central validation helper shared by `resolve` and `resolveAll`. Does not throw;\n * callers decide whether to throw immediately or collect errors.\n *\n * Missing or empty (`\"\"`) values use `defaultValue` when provided. When `trim` is enabled,\n * whitespace-only values are treated as empty. Number specs delegate to `parseNumber`.\n * Boolean specs treat `1`/`true`/`yes`/`on` (case-insensitive, after trim) as `true`.\n * Enum specs require an exact match in `choices` (after trim).\n *\n * @template K - Environment variable key type.\n * @template S - Environment variable spec type.\n * @param key - Environment variable name.\n * @param spec - Type spec for the value.\n * @param raw - Raw value from `process.env`, if present.\n * @param defaultValue - Fallback when `raw` is missing or empty.\n * @param options - Optional trim override (`trim` defaults per spec type).\n * @returns Parsed value or a structured validation error.\n */\nconst parseEnvValue = <K extends string, S extends StrictEnvSpec>(\n  key: K,\n  spec: S,\n  raw: string | undefined,\n  defaultValue: StrictEnvSpecToType<S> | undefined,\n  options?: ParseEnvValueOptions<S>,\n): ParseEnvValueResult<K, S> => {\n  const trim = options?.trim ?? defaultTrimForSpec(spec);\n  const normalizedRaw = normalizeEnvRaw(raw, trim);\n  const hasDefault = defaultValue !== undefined;\n\n  if (normalizedRaw == null || normalizedRaw === '') {\n    if (hasDefault) {\n      return { ok: true, value: defaultValue as StrictEnvSpecToType<S> };\n    }\n    return {\n      ok: false,\n      error: { key, message: `Missing required environment variable: ${key}`, raw, kind: 'missing' },\n    };\n  }\n\n  switch (spec.type) {\n    case 'number': {\n      const n = parseNumber(normalizedRaw);\n      if (n === undefined) {\n        return {\n          ok: false,\n          error: { key, message: `Env ${key}: expected number, got \"${raw}\"`, raw, kind: 'invalid_number' },\n        };\n      }\n      return { ok: true, value: n as StrictEnvSpecToType<S> };\n    }\n    case 'boolean':\n      return { ok: true, value: parseBooleanEnvValue(normalizedRaw) as StrictEnvSpecToType<S> };\n    case 'enum':\n      if (!spec.choices.includes(normalizedRaw)) {\n        return {\n          ok: false,\n          error: {\n            key,\n            message: `Env ${key}: must be one of [${spec.choices.join(', ')}]`,\n            raw,\n            kind: 'invalid_enum',\n          },\n        };\n      }\n      return { ok: true, value: normalizedRaw as StrictEnvSpecToType<S> };\n    default:\n      return { ok: true, value: normalizedRaw as StrictEnvSpecToType<S> };\n  }\n};\n\n/**\n * Reads and parses an environment variable according to the given spec.\n *\n * Delegates validation to `parseEnvValue`. Missing or empty (`\"\"`) values use\n * `options.default` when provided; otherwise a `StrictEnvValidationError` is thrown.\n * For `StrictEnvType.Number`, values are parsed as finite numbers (see `StrictEnvTypeNumber`).\n *\n * @template K - Environment variable key type.\n * @template S - Environment variable spec type.\n * @param key - Environment variable name (e.g. `\"PORT\"`, `\"NODE_ENV\"`).\n * @param spec - Type spec; defaults to `StrictEnvType.String` when omitted.\n * @param options - Optional `{ default, trim }`; see {@link StrictEnvOptions}.\n * @returns Parsed value with type inferred from `spec`.\n * @throws {StrictEnvValidationError} When the variable is missing, empty without a default, or invalid for the spec.\n */\nconst resolve = <K extends string, S extends StrictEnvSpec = StrictEnvTypeString>(\n  key: K,\n  spec: S = StrictEnvType.String as S,\n  options?: StrictEnvOptions<S>,\n): StrictEnvSpecToType<S> => {\n  const result = parseEnvValue(key, spec, process.env[key], options?.default, options);\n  if (!result.ok) {\n    throw new StrictEnvValidationError([result.error]);\n  }\n  return result.value;\n};\n\n/**\n * Reads and parses multiple environment variables according to the given schema.\n *\n * Always evaluates every key in `schema`. Each entry is validated via `parseEnvValue`;\n * all errors are collected and thrown once in a single `StrictEnvValidationError`.\n * Number specs use the same finite-number rules as `resolve`.\n *\n * @template TSchema - Schema object type.\n * @param schema - Map of environment variable names to specs, optionally with per-key defaults via `[spec, { default }]`.\n * @returns Parsed environment object with types inferred from the schema.\n * @throws {StrictEnvValidationError} When one or more variables are missing, empty without a default, or invalid.\n */\nconst resolveAll = <TSchema extends StrictEnvSchema>(schema: TSchema): StrictEnvSchemaToType<TSchema> => {\n  const envs: Partial<StrictEnvSchemaToType<TSchema>> = {};\n  const errors: StrictEnvValidationEntry<Extract<keyof TSchema, string>>[] = [];\n\n  for (const key of Object.keys(schema) as Array<Extract<keyof TSchema, string>>) {\n    const { spec, options } = resolveSchemaEntry(schema[key]);\n\n    const result = parseEnvValue(key, spec, process.env[key], options?.default, options);\n    if (!result.ok) {\n      errors.push(result.error);\n      continue;\n    }\n    envs[key] = result.value as StrictEnvSchemaToType<TSchema>[typeof key];\n  }\n\n  if (errors.length > 0) throw new StrictEnvValidationError(errors);\n  return envs as StrictEnvSchemaToType<TSchema>;\n};\n\n/**\n * Type-safe environment variable resolver for Node.js `process.env`.\n *\n * @example\n * ```ts\n * const port = StrictEnvResolver.resolve('PORT', StrictEnvType.Number);\n * const envs = StrictEnvResolver.resolveAll({\n *   PORT: StrictEnvType.Number,\n *   DEBUG: [StrictEnvType.Boolean, { default: false }],\n * });\n * ```\n */\nexport const StrictEnvResolver = {\n  /** Reads and parses a single environment variable. See {@link resolve}. */\n  resolve,\n  /** Reads and parses multiple environment variables in one pass. See {@link resolveAll}. */\n  resolveAll,\n} as const;\n"]}

package/package.json

@@ -0,0 +1,114 @@
+{
+  "name": "strict-env-resolver",
+  "description": "Type-safe environment variable getter for Node.js. Reads and parses process.env with specs (string, number, boolean, enum), optional defaults, and structured validation errors when values are missing or invalid.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gammarers-labs/strict-env-resolver.git"
+  },
+  "scripts": {
+    "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",
+    "email": "yicr@users.noreply.github.com",
+    "organization": false
+  },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "^2",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^20",
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
+    "commit-and-tag-version": "^12",
+    "constructs": "^10.0.0",
+    "eslint": "^9",
+    "eslint-import-resolver-typescript": "^4.4.5",
+    "eslint-plugin-import": "^2.32.0",
+    "jest": "^30.4.2",
+    "jest-junit": "^17",
+    "projen": "^0.100.2",
+    "ts-jest": "^29.4.11",
+    "ts-node": "^10.9.2",
+    "typescript": "5.9.x"
+  },
+  "keywords": [
+    "env",
+    "environment",
+    "getter",
+    "safe",
+    "variables"
+  ],
+  "engines": {
+    "node": ">= 20.0.0"
+  },
+  "main": "lib/index.js",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.5.1",
+  "jest": {
+    "coverageProvider": "v8",
+    "testMatch": [
+      "<rootDir>/@(src|test)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(src|test)/**/__tests__/**/*.ts?(x)",
+      "<rootDir>/@(projenrc)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(projenrc)/**/__tests__/**/*.ts?(x)"
+    ],
+    "clearMocks": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "lcov",
+      "clover",
+      "cobertura",
+      "text"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "watchPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "reporters": [
+      "default",
+      [
+        "jest-junit",
+        {
+          "outputDirectory": "test-reports"
+        }
+      ]
+    ],
+    "transform": {
+      "^.+\\.[t]sx?$": [
+        "ts-jest",
+        {
+          "tsconfig": "tsconfig.dev.json"
+        }
+      ]
+    }
+  },
+  "types": "lib/index.d.ts",
+  "//": "~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\"."
+}