@scania-nl/tegel-angular-extensions 0.0.4 → 0.0.5

package/esm2022/lib/env/angular/provide-runtime-config.mjs

@@ -0,0 +1,161 @@
+import { inject, Injectable, InjectionToken, makeEnvironmentProviders, provideAppInitializer, } from '@angular/core';
+import { catchError, defer, firstValueFrom, from, map, of, switchMap, tap, } from 'rxjs';
+import { parseEnvFile } from '../core/parse-env-file';
+import * as i0 from "@angular/core";
+/**
+ * Builds styled console arguments for RuntimeConfig logs.
+ *
+ * The returned tuple can be spread directly into `console.log`,
+ * allowing the browser to render a colored `[RuntimeConfig]` prefix
+ * while preserving the original caller location in DevTools.
+ *
+ * Example:
+ * ```ts
+ * console.log(...rcArgs('Runtime overrides loaded.'));
+ * ```
+ *
+ * @param msg - The message text to append after the colored prefix.
+ * @returns A tuple of arguments (`[format, style, reset]`) for `console.log`.
+ */
+const rcArgs = (msg) => [
+    '%c[RuntimeConfig]%c ' + msg,
+    'color:#0cf;',
+    '',
+];
+/**
+ * Registers providers that:
+ * - Fetch a runtime `.env` file at startup,
+ * - Parse it to a deep-partial structure via the kit,
+ * - Enforce runtime-required keys when appropriate,
+ * - Merge with the static environment,
+ * - Validate the **final** configuration against the Zod schema,
+ * - Expose the resulting config via a generated `InjectionToken`.
+ *
+ * @typeParam S - Zod schema type describing the full config shape.
+ * @typeParam K - List of runtime-required top-level keys.
+ *
+ * @param kit
+ * The `EnvKit` created by `createEnvKit(schema, runtimeRequiredKeys)`.
+ *
+ * @param options
+ * Runtime loading behavior and DI token description. See {@link ProvideRuntimeConfigOptions}.
+ *
+ * @returns The `EnvironmentProviders` to be added to `appConfig.providers`,
+ *
+ * @remarks
+ * - This uses an Angular **functional app initializer** to perform the load step.
+ * - If the server returns an HTML SPA fallback (instead of the `.env` file), the provider
+ *   quietly uses the static environment (no runtime overrides).
+ */
+export function provideRuntimeConfig(kit, staticEnv, { envPath = '/env/runtime.env', debug = false, stopOnError = true, token, } = {}) {
+    // Typed token used to expose the final validated config via DI.
+    const configToken = token ?? new InjectionToken('ENV_CONFIG');
+    /**
+     * Angular service that handles fetching, parsing, validating, and caching
+     * of the runtime environment configuration.
+     */
+    class RuntimeConfigService {
+        // Cached instance of the validated configuration.
+        config;
+        /**
+         * Loads, parses, merges and validates the runtime configuration.
+         * Returns an `Observable<ConfigShape>` and caches the final result.
+         */
+        load() {
+            return defer(() => from(fetch(envPath).then((res) => {
+                // Handle HTTP errors explicitly so they go through catchError
+                if (!res.ok) {
+                    throw new Error(`Failed to load runtime config: ${res.status} ${res.statusText}`);
+                }
+                return res.text();
+            })).pipe(
+            // 1. SPA fallback guard (server returned HTML instead of .env)
+            map((raw) => {
+                const trimmed = raw.trim();
+                const looksHtml = /^\s*<!doctype/i.test(trimmed) || /^\s*<html[\s>]/i.test(trimmed);
+                if (looksHtml) {
+                    if (debug) {
+                        console.log(...rcArgs('No runtime environment file detected, using static environment only.'));
+                    }
+                    // Signal “no runtime.env, use static only”
+                    return null;
+                }
+                return raw;
+            }), tap((v) => {
+                if (!debug)
+                    return;
+                console.log(...rcArgs(v === null
+                    ? 'No runtime environment file defined, using static environment'
+                    : 'Runtime environment file loaded, applying overrides.'));
+            }), 
+            // 2. Either continue the pipe or return defaults
+            switchMap((raw) => {
+                if (raw === null) {
+                    return from(kit.mergeAndValidateAsync(staticEnv)).pipe(tap((cfg) => (this.config = cfg)));
+                }
+                // 3. Parse raw `.env` text -> object, then deep-partial-parse via kit
+                const runtimeConfigRaw = parseEnvFile(raw);
+                return from(kit.parseRuntimeOverridesAsync(runtimeConfigRaw)).pipe(tap((overrides) => {
+                    if (debug)
+                        console.log(...rcArgs('Runtime config (parsed):'), overrides);
+                }), 
+                // 4. Merge static + overrides and validate the final config (async)
+                switchMap((overrides) => from(kit.mergeAndValidateAsync(staticEnv, overrides))), 
+                // 5. Cache the validated config for synchronous access later
+                tap((mergedConfig) => {
+                    if (debug)
+                        console.log(...rcArgs('Merged config:'), mergedConfig);
+                    this.config = mergedConfig;
+                }));
+            }), 
+            // 6. Error handling: fail fast or gracefully fall back to static-only
+            catchError((err) => {
+                if (stopOnError) {
+                    // Reject app initialization (recommended for production)
+                    throw err;
+                }
+                console.error(...rcArgs('Error occurred while loading runtime config:'), err);
+                return of(this.useDefaults());
+            })));
+        }
+        /**
+         * Returns the current configuration.
+         * If not yet loaded, returns a validated static-only configuration.
+         */
+        get() {
+            if (!this.config) {
+                throw new Error('RuntimeConfigService.get() called before configuration was loaded. ' +
+                    'Ensure provideAppInitializer waits for RuntimeConfigService.load().');
+            }
+            return this.config;
+        }
+        /**
+         * Sets the current configuration to a validated static-only configuration
+         * Used when the runtime `.env` file is missing.
+         */
+        useDefaults() {
+            // Note: this uses the static env; merge+validate is performed in `get()` if needed.
+            this.config ??= staticEnv;
+            return this.config;
+        }
+        static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: RuntimeConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+        static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: RuntimeConfigService, providedIn: 'root' });
+    }
+    i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: RuntimeConfigService, decorators: [{
+                type: Injectable,
+                args: [{ providedIn: 'root' }]
+            }] });
+    // Register the service + initializer + token exposure with Angular DI.
+    return makeEnvironmentProviders([
+        RuntimeConfigService,
+        // Angular 19+ functional initializer (subscribes to the load Observable)
+        // Using firstValueFrom to enforece "await until loaded" semantics
+        provideAppInitializer(() => firstValueFrom(inject(RuntimeConfigService).load())),
+        // Expose the final validated config via the generated token
+        {
+            provide: configToken,
+            useFactory: () => inject(RuntimeConfigService).get(),
+        },
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provide-runtime-config.js","sourceRoot":"","sources":["../../../../../../../libs/tegel-angular-extensions/src/lib/env/angular/provide-runtime-config.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  EnvironmentProviders,\n  inject,\n  Injectable,\n  InjectionToken,\n  makeEnvironmentProviders,\n  provideAppInitializer,\n} from '@angular/core';\nimport {\n  catchError,\n  defer,\n  firstValueFrom,\n  from,\n  map,\n  Observable,\n  of,\n  switchMap,\n  tap,\n} from 'rxjs';\nimport z from 'zod';\nimport { EnvKit, SchemaOutput, StaticEnvFrom } from '../core/env-types';\nimport { parseEnvFile } from '../core/parse-env-file';\n\n/**\n * Builds styled console arguments for RuntimeConfig logs.\n *\n * The returned tuple can be spread directly into `console.log`,\n * allowing the browser to render a colored `[RuntimeConfig]` prefix\n * while preserving the original caller location in DevTools.\n *\n * Example:\n * ```ts\n * console.log(...rcArgs('Runtime overrides loaded.'));\n * ```\n *\n * @param msg - The message text to append after the colored prefix.\n * @returns A tuple of arguments (`[format, style, reset]`) for `console.log`.\n */\nconst rcArgs = (msg: string): Parameters<typeof console.log> => [\n  '%c[RuntimeConfig]%c ' + msg,\n  'color:#0cf;',\n  '',\n];\n\n/**\n * Options for configuring the Angular runtime-config provider.\n *\n * @property envPath\n * The URL (or path) to the runtime `.env` file that will be fetched at app start.\n * Defaults to `\"/env/runtime.env\"`.\n *\n * @property debug\n * Enables verbose console logging when `true`. Defaults to `false`.\n *\n * @property stopOnError\n * If `true`, any failure while loading/parsing/validating the runtime config\n * will reject the app initializer and **abort boot** (recommended for prod).\n * If `false`, the provider falls back to the static environment only.\n * Defaults to `true`.\n *\n * @property token\n * Optional `InjectionToken` used to expose the validated configuration\n * via Angular dependency injection. If omitted, the provider will create one\n * automatically named `ENV_CONFIG`.\n */\ninterface ProvideRuntimeConfigOptions<S extends z.ZodObject<z.ZodRawShape>> {\n  /** Path to the runtime env file (default: /env/runtime.env) */\n  envPath?: string;\n  /** Log debug info to console */\n  debug?: boolean;\n  /** Throw on error to stop app boot (default: true) */\n  stopOnError?: boolean;\n  /** Injection token used to provide the validated config via Angular DI */\n  token?: InjectionToken<SchemaOutput<S>>;\n}\n\n/**\n * Registers providers that:\n * - Fetch a runtime `.env` file at startup,\n * - Parse it to a deep-partial structure via the kit,\n * - Enforce runtime-required keys when appropriate,\n * - Merge with the static environment,\n * - Validate the **final** configuration against the Zod schema,\n * - Expose the resulting config via a generated `InjectionToken`.\n *\n * @typeParam S - Zod schema type describing the full config shape.\n * @typeParam K - List of runtime-required top-level keys.\n *\n * @param kit\n * The `EnvKit` created by `createEnvKit(schema, runtimeRequiredKeys)`.\n *\n * @param options\n * Runtime loading behavior and DI token description. See {@link ProvideRuntimeConfigOptions}.\n *\n * @returns The `EnvironmentProviders` to be added to `appConfig.providers`,\n *\n * @remarks\n * - This uses an Angular **functional app initializer** to perform the load step.\n * - If the server returns an HTML SPA fallback (instead of the `.env` file), the provider\n *   quietly uses the static environment (no runtime overrides).\n */\nexport function provideRuntimeConfig<\n  S extends z.ZodObject<z.ZodRawShape>,\n  K extends readonly (keyof z.output<S>)[]\n>(\n  kit: EnvKit<S, K>,\n  staticEnv: StaticEnvFrom<S, K>,\n  {\n    envPath = '/env/runtime.env',\n    debug = false,\n    stopOnError = true,\n    token,\n  }: ProvideRuntimeConfigOptions<S> = {}\n): EnvironmentProviders {\n  // The validated config type derived from the schema.\n  type EnvConfig = SchemaOutput<S>;\n\n  // Typed token used to expose the final validated config via DI.\n  const configToken = token ?? new InjectionToken<EnvConfig>('ENV_CONFIG');\n\n  /**\n   * Angular service that handles fetching, parsing, validating, and caching\n   * of the runtime environment configuration.\n   */\n  @Injectable({ providedIn: 'root' })\n  class RuntimeConfigService {\n    // Cached instance of the validated configuration.\n    private config?: EnvConfig;\n\n    /**\n     * Loads, parses, merges and validates the runtime configuration.\n     * Returns an `Observable<ConfigShape>` and caches the final result.\n     */\n    load(): Observable<EnvConfig> {\n      return defer(() =>\n        from(\n          fetch(envPath).then((res) => {\n            // Handle HTTP errors explicitly so they go through catchError\n            if (!res.ok) {\n              throw new Error(\n                `Failed to load runtime config: ${res.status} ${res.statusText}`\n              );\n            }\n            return res.text();\n          })\n        ).pipe(\n          // 1. SPA fallback guard (server returned HTML instead of .env)\n          map((raw: string): string | null => {\n            const trimmed = raw.trim();\n            const looksHtml =\n              /^\\s*<!doctype/i.test(trimmed) || /^\\s*<html[\\s>]/i.test(trimmed);\n            if (looksHtml) {\n              if (debug) {\n                console.log(\n                  ...rcArgs(\n                    'No runtime environment file detected, using static environment only.'\n                  )\n                );\n              }\n              // Signal “no runtime.env, use static only”\n              return null;\n            }\n            return raw;\n          }),\n          tap((v: string | null) => {\n            if (!debug) return;\n            console.log(\n              ...rcArgs(\n                v === null\n                  ? 'No runtime environment file defined, using static environment'\n                  : 'Runtime environment file loaded, applying overrides.'\n              )\n            );\n          }),\n          // 2. Either continue the pipe or return defaults\n          switchMap((raw: string | null): Observable<EnvConfig> => {\n            if (raw === null) {\n              return from(kit.mergeAndValidateAsync(staticEnv)).pipe(\n                tap((cfg) => (this.config = cfg))\n              );\n            }\n\n            // 3. Parse raw `.env` text -> object, then deep-partial-parse via kit\n            const runtimeConfigRaw: Record<string, unknown> = parseEnvFile(raw);\n            return from(kit.parseRuntimeOverridesAsync(runtimeConfigRaw)).pipe(\n              tap((overrides: Partial<EnvConfig>) => {\n                if (debug)\n                  console.log(...rcArgs('Runtime config (parsed):'), overrides);\n              }),\n              // 4. Merge static + overrides and validate the final config (async)\n              switchMap(\n                (overrides: Partial<EnvConfig>): Observable<EnvConfig> =>\n                  from(kit.mergeAndValidateAsync(staticEnv, overrides))\n              ),\n\n              // 5. Cache the validated config for synchronous access later\n              tap((mergedConfig: EnvConfig) => {\n                if (debug)\n                  console.log(...rcArgs('Merged config:'), mergedConfig);\n                this.config = mergedConfig;\n              })\n            );\n          }),\n\n          // 6. Error handling: fail fast or gracefully fall back to static-only\n          catchError((err: unknown) => {\n            if (stopOnError) {\n              // Reject app initialization (recommended for production)\n              throw err;\n            }\n            console.error(\n              ...rcArgs('Error occurred while loading runtime config:'),\n              err\n            );\n\n            return of(this.useDefaults());\n          })\n        )\n      );\n    }\n\n    /**\n     * Returns the current configuration.\n     * If not yet loaded, returns a validated static-only configuration.\n     */\n    get(): EnvConfig {\n      if (!this.config) {\n        throw new Error(\n          'RuntimeConfigService.get() called before configuration was loaded. ' +\n            'Ensure provideAppInitializer waits for RuntimeConfigService.load().'\n        );\n      }\n\n      return this.config;\n    }\n\n    /**\n     * Sets the current configuration to a validated static-only configuration\n     * Used when the runtime `.env` file is missing.\n     */\n    private useDefaults(): EnvConfig {\n      // Note: this uses the static env; merge+validate is performed in `get()` if needed.\n      this.config ??= staticEnv as EnvConfig;\n      return this.config;\n    }\n  }\n\n  // Register the service + initializer + token exposure with Angular DI.\n  return makeEnvironmentProviders([\n    RuntimeConfigService,\n\n    // Angular 19+ functional initializer (subscribes to the load Observable)\n    // Using firstValueFrom to enforece \"await until loaded\" semantics\n    provideAppInitializer(() =>\n      firstValueFrom(inject(RuntimeConfigService).load())\n    ),\n\n    // Expose the final validated config via the generated token\n    {\n      provide: configToken,\n      useFactory: () => inject(RuntimeConfigService).get(),\n    },\n  ]);\n}\n"]}

package/esm2022/lib/env/angular/provide-static-config.mjs

@@ -0,0 +1,44 @@
+import { makeEnvironmentProviders, } from '@angular/core';
+/**
+ * Registers providers that:
+ * - Expose a **static** environment configuration object via Angular DI,
+ * - Perform **no** runtime `.env` fetching or asynchronous initialization,
+ * - Mirror Angular’s standard build-time pattern:
+ *
+ *     { provide: SOME_TOKEN, useValue: environment }
+ *
+ * This is intended for applications that:
+ * - Use only `environment.ts` build-time configuration,
+ * - Do not require runtime overrides or external `.env` files,
+ * - Wish to keep bootstrap logic minimal and predictable,
+ * - Or are running in unit tests where a fixed static config is sufficient.
+ *
+ * @typeParam T - The shape of the static configuration object.
+ *
+ * @param env
+ * The static configuration instance to expose via DI. Defaults to an empty
+ * object if omitted, enabling callers to provide minimal configuration
+ * without boilerplate.
+ *
+ * @param options
+ * A `ProvideStaticConfigOptions<T>` containing the **required**
+ * `InjectionToken<T>` under which the configuration will be registered.
+ * Angular DI resolves providers solely by token instance identity, so the
+ * caller must supply the exact token that consumers will inject.
+ *
+ * @returns The `EnvironmentProviders` to be added to `appConfig.providers`.
+ *
+ * @remarks
+ * The static provider is intentionally minimal, offering a lightweight
+ * counterpart to `provideRuntimeConfig` for apps that rely on build-time
+ * environment values only.
+ */
+export function provideStaticConfig(env = {}, options) {
+    return makeEnvironmentProviders([
+        {
+            provide: options.token,
+            useValue: env,
+        },
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/env/core/create-env-kit.mjs

@@ -0,0 +1,81 @@
+import { zx } from '@traversable/zod';
+/**
+ * Builds a **type-safe environment kit** around a Zod schema.
+ *
+ * This utility encapsulates all environment configuration logic in a reusable,
+ * strongly-typed structure that:
+ * - Validates **deep-partial** runtime overrides using `zx.deepPartial(schema)`.
+ * - Ensures that **runtime-required keys** are provided when `production=true`.
+ * - Merges static defaults with runtime overrides and validates the **final config** asynchronously.
+ *
+ * @typeParam S - The Zod schema type describing the full environment configuration.
+ * @typeParam K - The list of top-level keys that must be supplied at runtime in production builds.
+ *
+ * @param params.schema - The full Zod schema defining the configuration structure.
+ * @param params.runtimeRequiredKeys - Keys that must be present in runtime overrides for production.
+ *
+ * @returns A fully-typed {@link EnvKit} instance exposing validation helpers, runtime parsers, and type tokens.
+ */
+export function createEnvKit(params) {
+    const { schema, runtimeRequiredKeys } = params;
+    /** Deep-partial schema — allows validation of incomplete runtime overrides. */
+    const runtimeOverridesSchema = zx.deepPartial(schema);
+    /**
+     * Parses a raw `.env` object into a **deep-partial** structure matching the schema.
+     * @param raw - The raw key-value object parsed from a `.env` file.
+     * @returns A validated deep-partial configuration matching the schema shape.
+     * @throws ZodError if the structure is invalid.
+     */
+    function parseRuntimeOverridesAsync(raw) {
+        return runtimeOverridesSchema.parseAsync(raw);
+    }
+    /**
+     * Validates that all runtime-required keys are defined when `production=true`.
+     * Prevents missing values from being silently filled from static defaults.
+     *
+     * @param overrides - The runtime overrides to inspect.
+     * @param production - Whether the environment is running in production mode.
+     * @throws Error if any runtime-required key is missing.
+     */
+    function ensureRuntimeKeysPresent(overrides, production) {
+        if (!production)
+            return;
+        const missing = runtimeRequiredKeys.filter((k) => overrides[k] === undefined);
+        console.log('Overrides', overrides);
+        if (missing.length) {
+            throw new Error(`Missing required runtime overrides for production: ${missing.join(', ')}`);
+        }
+    }
+    /**
+     * Merges the provided static environment with runtime overrides,
+     * enforces runtime key presence when necessary, and validates the
+     * **final merged configuration** against the full schema.
+     *
+     * @param staticEnv - The static environment configuration (dev or prod).
+     * @param overrides - The runtime overrides to merge in.
+     * @returns A fully validated, strongly typed configuration object.
+     * @throws ZodError if validation fails, or Error if required keys are missing in production.
+     */
+    function mergeAndValidateAsync(staticEnv, overrides = {}) {
+        // Determine production mode; runtime override takes precedence if defined
+        const effectiveProduction = (overrides['production'] ?? staticEnv.production) === true;
+        ensureRuntimeKeysPresent(overrides, effectiveProduction);
+        // Validate the merged result asynchronously with the full schema
+        return schema.parseAsync({ ...staticEnv, ...overrides });
+    }
+    return {
+        /** The full Zod schema provided by the consumer. */
+        schema,
+        /** Deep-partial schema used for validating runtime overrides (via `zx.deepPartial`). */
+        runtimeOverridesSchema,
+        /** Keys that must be provided in runtime overrides when `production=true`. */
+        runtimeRequiredKeys,
+        /** Parses a raw `.env` object into deep-partial runtime overrides (async). */
+        parseRuntimeOverridesAsync,
+        /** Merges static + runtime configs and validates the final schema (async). */
+        mergeAndValidateAsync,
+        /** Type tokens for compile-time inference; erased at runtime. */
+        types: {},
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-env-kit.js","sourceRoot":"","sources":["../../../../../../../libs/tegel-angular-extensions/src/lib/env/core/create-env-kit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAWtC;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,YAAY,CAG1B,MAKD;IACC,MAAM,EAAE,MAAM,EAAE,mBAAmB,EAAE,GAAG,MAAM,CAAC;IAK/C,+EAA+E;IAC/E,MAAM,sBAAsB,GAAG,EAAE,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAEtD;;;;;OAKG;IACH,SAAS,0BAA0B,CACjC,GAA4B;QAE5B,OAAO,sBAAsB,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;IAChD,CAAC;IAED;;;;;;;OAOG;IACH,SAAS,wBAAwB,CAC/B,SAA6B,EAC7B,UAAmB;QAEnB,IAAI,CAAC,UAAU;YAAE,OAAO;QACxB,MAAM,OAAO,GACX,mBACD,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC;QAE5C,OAAO,CAAC,GAAG,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;QAEpC,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;YACnB,MAAM,IAAI,KAAK,CACb,sDAAsD,OAAO,CAAC,IAAI,CAChE,IAAI,CACL,EAAE,CACJ,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;;;;;;OASG;IACH,SAAS,qBAAqB,CAC5B,SAA2D,EAC3D,YAAgC,EAAE;QAElC,0EAA0E;QAC1E,MAAM,mBAAmB,GACvB,CAAC,SAAS,CAAC,YAAY,CAAC,IAAI,SAAS,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC;QAE7D,wBAAwB,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;QAEzD,iEAAiE;QACjE,OAAO,MAAM,CAAC,UAAU,CAAC,EAAE,GAAG,SAAS,EAAE,GAAG,SAAS,EAAE,CAAC,CAAC;IAC3D,CAAC;IAED,OAAO;QACL,oDAAoD;QACpD,MAAM;QAEN,wFAAwF;QACxF,sBAAsB;QAEtB,8EAA8E;QAC9E,mBAAmB;QAEnB,8EAA8E;QAC9E,0BAA0B;QAE1B,8EAA8E;QAC9E,qBAAqB;QAErB,iEAAiE;QACjE,KAAK,EAAE,EAON;KACF,CAAC;AACJ,CAAC","sourcesContent":["import { zx } from '@traversable/zod';\nimport { z } from 'zod';\nimport {\n  DevDefaultsFrom,\n  DevStaticEnvFrom,\n  EnvKit,\n  ProdStaticEnvFrom,\n  SchemaOutput,\n  StaticEnvFrom,\n} from './env-types';\n\n/**\n * Builds a **type-safe environment kit** around a Zod schema.\n *\n * This utility encapsulates all environment configuration logic in a reusable,\n * strongly-typed structure that:\n * - Validates **deep-partial** runtime overrides using `zx.deepPartial(schema)`.\n * - Ensures that **runtime-required keys** are provided when `production=true`.\n * - Merges static defaults with runtime overrides and validates the **final config** asynchronously.\n *\n * @typeParam S - The Zod schema type describing the full environment configuration.\n * @typeParam K - The list of top-level keys that must be supplied at runtime in production builds.\n *\n * @param params.schema - The full Zod schema defining the configuration structure.\n * @param params.runtimeRequiredKeys - Keys that must be present in runtime overrides for production.\n *\n * @returns A fully-typed {@link EnvKit} instance exposing validation helpers, runtime parsers, and type tokens.\n */\nexport function createEnvKit<\n  S extends z.ZodObject<z.ZodRawShape>,\n  K extends readonly (keyof z.output<S>)[]\n>(params: {\n  /** The full Zod schema describing the app's configuration shape. */\n  schema: S;\n  /** Keys that must be provided at runtime when `production=true`. */\n  runtimeRequiredKeys: K;\n}): EnvKit<S, K> {\n  const { schema, runtimeRequiredKeys } = params;\n\n  /** Concrete schema output type for convenience inside this factory. */\n  type EnvConfig = SchemaOutput<S>;\n\n  /** Deep-partial schema — allows validation of incomplete runtime overrides. */\n  const runtimeOverridesSchema = zx.deepPartial(schema);\n\n  /**\n   * Parses a raw `.env` object into a **deep-partial** structure matching the schema.\n   * @param raw - The raw key-value object parsed from a `.env` file.\n   * @returns A validated deep-partial configuration matching the schema shape.\n   * @throws ZodError if the structure is invalid.\n   */\n  function parseRuntimeOverridesAsync(\n    raw: Record<string, unknown>\n  ): Promise<Partial<EnvConfig>> {\n    return runtimeOverridesSchema.parseAsync(raw);\n  }\n\n  /**\n   * Validates that all runtime-required keys are defined when `production=true`.\n   * Prevents missing values from being silently filled from static defaults.\n   *\n   * @param overrides - The runtime overrides to inspect.\n   * @param production - Whether the environment is running in production mode.\n   * @throws Error if any runtime-required key is missing.\n   */\n  function ensureRuntimeKeysPresent(\n    overrides: Partial<EnvConfig>,\n    production: boolean\n  ): void {\n    if (!production) return;\n    const missing = (\n      runtimeRequiredKeys as readonly (keyof EnvConfig)[]\n    ).filter((k) => overrides[k] === undefined);\n\n    console.log('Overrides', overrides);\n\n    if (missing.length) {\n      throw new Error(\n        `Missing required runtime overrides for production: ${missing.join(\n          ', '\n        )}`\n      );\n    }\n  }\n\n  /**\n   * Merges the provided static environment with runtime overrides,\n   * enforces runtime key presence when necessary, and validates the\n   * **final merged configuration** against the full schema.\n   *\n   * @param staticEnv - The static environment configuration (dev or prod).\n   * @param overrides - The runtime overrides to merge in.\n   * @returns A fully validated, strongly typed configuration object.\n   * @throws ZodError if validation fails, or Error if required keys are missing in production.\n   */\n  function mergeAndValidateAsync(\n    staticEnv: DevStaticEnvFrom<S, K> | ProdStaticEnvFrom<S, K>,\n    overrides: Partial<EnvConfig> = {}\n  ): Promise<EnvConfig> {\n    // Determine production mode; runtime override takes precedence if defined\n    const effectiveProduction =\n      (overrides['production'] ?? staticEnv.production) === true;\n\n    ensureRuntimeKeysPresent(overrides, effectiveProduction);\n\n    // Validate the merged result asynchronously with the full schema\n    return schema.parseAsync({ ...staticEnv, ...overrides });\n  }\n\n  return {\n    /** The full Zod schema provided by the consumer. */\n    schema,\n\n    /** Deep-partial schema used for validating runtime overrides (via `zx.deepPartial`). */\n    runtimeOverridesSchema,\n\n    /** Keys that must be provided in runtime overrides when `production=true`. */\n    runtimeRequiredKeys,\n\n    /** Parses a raw `.env` object into deep-partial runtime overrides (async). */\n    parseRuntimeOverridesAsync,\n\n    /** Merges static + runtime configs and validates the final schema (async). */\n    mergeAndValidateAsync,\n\n    /** Type tokens for compile-time inference; erased at runtime. */\n    types: {} as {\n      EnvConfig: EnvConfig;\n      DevDefaults: DevDefaultsFrom<S, K>;\n      DevStaticEnv: DevStaticEnvFrom<S, K>;\n      ProdStaticEnv: ProdStaticEnvFrom<S, K>;\n      StaticEnv: StaticEnvFrom<S, K>;\n      RuntimeRequired: K[number];\n    },\n  };\n}\n"]}

package/esm2022/lib/env/core/env-types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/env/core/parse-env-file.mjs

@@ -0,0 +1,140 @@
+/**
+ * Parses the contents of a `.env`-style file into a nested JavaScript object.
+ *
+ * Each line in the input string is expected to follow the format `KEY=VALUE`.
+ * Nested keys can be created using a configurable delimiter (default: `"__"`).
+ * Lines starting with `#` or containing only whitespace are ignored.
+ *
+ * Examples:
+ * ```env
+ * API_URL=https://api.local
+ * LOG__LEVEL=debug
+ * DB__CONNECTION__TIMEOUT=30
+ * ```
+ * Produces:
+ * ```ts
+ * {
+ *   API_URL: "https://api.local",
+ *   LOG: { LEVEL: "debug" },
+ *   DB: { CONNECTION: { TIMEOUT: "30" } }
+ * }
+ * ```
+ *
+ * @param raw - The raw `.env` file content as a string.
+ * @param delimiter - The delimiter used to represent nested keys (default: `"__"`).
+ * @returns A nested object representing all parsed key-value pairs.
+ */
+export function parseEnvFile(raw, delimiter = '__') {
+    const result = {};
+    // Normalize CRLF -> LF and split into lines
+    const lines = raw.replace(/\r/g, '').split('\n');
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        // Skip blank lines and comments
+        if (!line || line.startsWith('#'))
+            continue;
+        // Split "KEY=VALUE" (first '=' only)
+        const { key, value } = splitEnvLine(line);
+        if (!key)
+            continue; // malformed line with no key
+        // Support nesting via delimiter: "A__B__C" -> ["A","B","C"]
+        const path = key.split(delimiter).filter(Boolean);
+        // Coerce value (handles simple arrays)
+        const parsedValue = parseEnvValue(value);
+        // Write into `result` at nested path, creating objects as needed
+        assignNested(result, path, parsedValue);
+    }
+    return result;
+}
+/**
+ * Parses an environment variable value into a typed representation.
+ *
+ * Supports array syntax in square brackets:
+ * ```
+ * [one, two, three]  -> ['one', 'two', 'three']
+ * ["a", "b", "c"]    -> ['"a"', '"b"', '"c"']
+ * ```
+ * All other values are returned as raw strings.
+ *
+ * @param value - The raw string value to parse from a `.env` line.
+ * @returns The parsed value (string or array of strings).
+ */
+function parseEnvValue(value) {
+    // Remove leading/trailing whitespace
+    const trimmed = value.trim();
+    // Detect array syntax: [item1, item2, item3]
+    if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+        // Remove surrounding brackets and trim inner content
+        const inner = trimmed.slice(1, -1).trim();
+        if (!inner)
+            return []; // Empty array → []
+        // Split by comma and trim each entry
+        return inner.split(',').map((item) => item.trim());
+    }
+    // For non-array values, return as-is
+    return value;
+}
+/**
+ * Writes a value into a nested object structure using a key path.
+ *
+ * Example:
+ * ```ts
+ * const obj = {};
+ * assignNested(obj, ['Database', 'Host'], 'localhost');
+ * // Result: { Database: { Host: 'localhost' } }
+ * ```
+ *
+ * Intermediate objects are created automatically if they do not exist.
+ *
+ * @typeParam T - The type of the value being assigned.
+ * @param target - The root object to modify.
+ * @param path - The array of path segments (e.g., ['A','B','C']).
+ * @param value - The value to assign at the final key.
+ */
+function assignNested(target, path, value) {
+    // Start from the root object reference
+    let ref = target;
+    // Walk through all path segments except the last one
+    for (let i = 0; i < path.length - 1; i++) {
+        const seg = path[i];
+        // Ensure that each segment points to a plain object;
+        // replace invalid types (null, arrays, primitives) with {}
+        if (typeof ref[seg] !== 'object' ||
+            ref[seg] === null ||
+            Array.isArray(ref[seg])) {
+            ref[seg] = {};
+        }
+        // Move deeper into the structure
+        ref = ref[seg];
+    }
+    // Set the final property to the given value
+    ref[path[path.length - 1]] = value;
+}
+/**
+ * Splits a `.env` line into its key and value components.
+ *
+ * Example:
+ * ```
+ * "API_URL=https://api.example.com"
+ *   -> { key: "API_URL", value: "https://api.example.com" }
+ * ```
+ *
+ * The split occurs at the **first** '=' character only.
+ * If the line does not contain '=', an empty `{ key: '', value: '' }` is returned.
+ *
+ * @param line - A single `.env` line to split.
+ * @returns An object containing the key and value strings.
+ */
+function splitEnvLine(line) {
+    // Find first '='; keys in .env files never contain '='
+    const eq = line.indexOf('=');
+    // Skip malformed lines
+    if (eq === -1)
+        return { key: '', value: '' };
+    // Extract key before '=' and value after '='
+    const key = line.slice(0, eq).trim();
+    const value = line.slice(eq + 1).trim();
+    // Return key-value pair
+    return { key, value };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parse-env-file.js","sourceRoot":"","sources":["../../../../../../../libs/tegel-angular-extensions/src/lib/env/core/parse-env-file.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Parses the contents of a `.env`-style file into a nested JavaScript object.\n *\n * Each line in the input string is expected to follow the format `KEY=VALUE`.\n * Nested keys can be created using a configurable delimiter (default: `\"__\"`).\n * Lines starting with `#` or containing only whitespace are ignored.\n *\n * Examples:\n * ```env\n * API_URL=https://api.local\n * LOG__LEVEL=debug\n * DB__CONNECTION__TIMEOUT=30\n * ```\n * Produces:\n * ```ts\n * {\n *   API_URL: \"https://api.local\",\n *   LOG: { LEVEL: \"debug\" },\n *   DB: { CONNECTION: { TIMEOUT: \"30\" } }\n * }\n * ```\n *\n * @param raw - The raw `.env` file content as a string.\n * @param delimiter - The delimiter used to represent nested keys (default: `\"__\"`).\n * @returns A nested object representing all parsed key-value pairs.\n */\nexport function parseEnvFile(\n  raw: string,\n  delimiter = '__'\n): Record<string, unknown> {\n  const result: Record<string, unknown> = {};\n\n  // Normalize CRLF -> LF and split into lines\n  const lines = raw.replace(/\\r/g, '').split('\\n');\n\n  for (const rawLine of lines) {\n    const line = rawLine.trim();\n\n    // Skip blank lines and comments\n    if (!line || line.startsWith('#')) continue;\n\n    // Split \"KEY=VALUE\" (first '=' only)\n    const { key, value } = splitEnvLine(line);\n    if (!key) continue; // malformed line with no key\n\n    // Support nesting via delimiter: \"A__B__C\" -> [\"A\",\"B\",\"C\"]\n    const path = key.split(delimiter).filter(Boolean);\n\n    // Coerce value (handles simple arrays)\n    const parsedValue = parseEnvValue(value);\n\n    // Write into `result` at nested path, creating objects as needed\n    assignNested(result, path, parsedValue);\n  }\n\n  return result;\n}\n\n/**\n * Parses an environment variable value into a typed representation.\n *\n * Supports array syntax in square brackets:\n * ```\n * [one, two, three]  -> ['one', 'two', 'three']\n * [\"a\", \"b\", \"c\"]    -> ['\"a\"', '\"b\"', '\"c\"']\n * ```\n * All other values are returned as raw strings.\n *\n * @param value - The raw string value to parse from a `.env` line.\n * @returns The parsed value (string or array of strings).\n */\nfunction parseEnvValue(value: string): unknown {\n  // Remove leading/trailing whitespace\n  const trimmed = value.trim();\n\n  // Detect array syntax: [item1, item2, item3]\n  if (trimmed.startsWith('[') && trimmed.endsWith(']')) {\n    // Remove surrounding brackets and trim inner content\n    const inner = trimmed.slice(1, -1).trim();\n    if (!inner) return []; // Empty array → []\n\n    // Split by comma and trim each entry\n    return inner.split(',').map((item) => item.trim());\n  }\n\n  // For non-array values, return as-is\n  return value;\n}\n\n/**\n * Writes a value into a nested object structure using a key path.\n *\n * Example:\n * ```ts\n * const obj = {};\n * assignNested(obj, ['Database', 'Host'], 'localhost');\n * // Result: { Database: { Host: 'localhost' } }\n * ```\n *\n * Intermediate objects are created automatically if they do not exist.\n *\n * @typeParam T - The type of the value being assigned.\n * @param target - The root object to modify.\n * @param path - The array of path segments (e.g., ['A','B','C']).\n * @param value - The value to assign at the final key.\n */\nfunction assignNested<T>(\n  target: Record<string, T>,\n  path: string[],\n  value: T\n): void {\n  // Start from the root object reference\n  let ref: Record<string, unknown> = target;\n\n  // Walk through all path segments except the last one\n  for (let i = 0; i < path.length - 1; i++) {\n    const seg = path[i];\n\n    // Ensure that each segment points to a plain object;\n    // replace invalid types (null, arrays, primitives) with {}\n    if (\n      typeof ref[seg] !== 'object' ||\n      ref[seg] === null ||\n      Array.isArray(ref[seg])\n    ) {\n      ref[seg] = {};\n    }\n\n    // Move deeper into the structure\n    ref = ref[seg] as Record<string, unknown>;\n  }\n\n  // Set the final property to the given value\n  ref[path[path.length - 1]] = value;\n}\n\n/**\n * Splits a `.env` line into its key and value components.\n *\n * Example:\n * ```\n * \"API_URL=https://api.example.com\"\n *   -> { key: \"API_URL\", value: \"https://api.example.com\" }\n * ```\n *\n * The split occurs at the **first** '=' character only.\n * If the line does not contain '=', an empty `{ key: '', value: '' }` is returned.\n *\n * @param line - A single `.env` line to split.\n * @returns An object containing the key and value strings.\n */\nfunction splitEnvLine(line: string): { key: string; value: string } {\n  // Find first '='; keys in .env files never contain '='\n  const eq = line.indexOf('=');\n\n  // Skip malformed lines\n  if (eq === -1) return { key: '', value: '' };\n\n  // Extract key before '=' and value after '='\n  const key = line.slice(0, eq).trim();\n  const value = line.slice(eq + 1).trim();\n\n  // Return key-value pair\n  return { key, value };\n}\n"]}