import { ConfigError } from "effect/Config"; import * as ConfigProvider from "effect/ConfigProvider"; import * as Context from "effect/Context"; import * as Effect from "effect/Effect"; import * as FileSystem from "effect/FileSystem"; import * as Layer from "effect/Layer"; import * as Option from "effect/Option"; import { ProcessEnv } from "../Secrets/ProcessEnv.ts"; import { resolveSecretsOption } from "../Secrets/Provider.ts"; import type { StackSecrets, StackServices } from "../Stack.ts"; /** * Command-line settings that shape a stack's configuration. * * @internal */ export interface StackConfigOverrides { /** * The `--env-file` flag: the file the CLI reads instead of * `.env`. A stack that declares its own `secrets` cannot be combined with * it; the list is the single place that decides what loads. */ readonly envFile?: string; /** The `--profile` flag. */ readonly profile?: string; } /** @internal */ export const StackConfigOverrides = Context.Reference( "Alchemy/StackConfigOverrides", { defaultValue: () => ({}) }, ); /** Report a secrets provider's own failure as the ConfigError a stack fails with. */ const toConfigError = (error: unknown) => error instanceof ConfigError ? error : new ConfigError( new ConfigProvider.SourceError({ message: error instanceof Error ? error.message : String(error), cause: error, }), ); /** * Build the ConfigProvider a stack runs under from its `secrets` list. * When omitted, leave the caller's configuration unchanged. * * Each provider is a layer that requires the configuration assembled so far * and provides the merged result, so the list folds with `Layer.provide`: * later providers override earlier ones. With an explicit list, `ALCHEMY_PROFILE` is taken * from `--profile` or the real process environment only, never from a * provider, so a dotenv file or a secrets manager cannot redirect which * credentials every other provider uses. * * @internal */ export const stackConfigLayer = ( secrets?: StackSecrets, ): Layer.Layer => secrets === undefined ? Layer.empty : Layer.effect( ConfigProvider.ConfigProvider, Effect.gen(function* () { const overrides = yield* StackConfigOverrides; if (overrides.envFile !== undefined) { return yield* Effect.fail( new ConfigError( new ConfigProvider.SourceError({ message: `--env-file cannot be combined with a stack that declares \`secrets\`. Add Secrets.DotEnv({ path: "${overrides.envFile}" }) to the list instead, or drop the flag.`, }), ), ); } const declared = yield* resolveSecretsOption(secrets); // Every list ends with the shell unless the user placed (or disabled) it. const entries = Array.isArray(declared) ? [...declared] : [declared]; const shellListed = entries.some( (entry) => "_tag" in entry && entry._tag === "alchemy/SecretProvider::ProcessEnv", ); if (!shellListed) entries.push(ProcessEnv()); // `ALCHEMY_PROFILE` is answered from `--profile` or the real shell, // never from a provider. Every provider is built on a pinned view (so // its credentials resolve against the right profile) and the stack // gets a pinned view of the final result. const profile = overrides.profile ?? // oxlint-disable-next-line effecttsgo/process-env-in-effect -- ALCHEMY_PROFILE must come from the real shell while the ConfigProvider is being built (yield* Effect.sync(() => process.env.ALCHEMY_PROFILE || undefined)); const pinned = ConfigProvider.fromEnv({ env: profile === undefined ? {} : { ALCHEMY_PROFILE: profile }, }); const pin = (provider: ConfigProvider.ConfigProvider) => ConfigProvider.make((path) => (path[0] === "ALCHEMY_PROFILE" ? pinned : provider).load(path), ); const chain = entries.reduce>( (below, entry) => ("layer" in entry ? entry.layer : entry).pipe( // A reused entry must merge with this position's configuration, // not return the result memoized at its first position. Layer.fresh, Layer.provide( ConfigProvider.layer(Effect.map(ConfigProvider.ConfigProvider, pin)).pipe( Layer.provide(below), ), ), ), ConfigProvider.layer(ConfigProvider.fromEnv({ env: {} })), ); const context = yield* Layer.build(chain).pipe(Effect.mapError(toConfigError)); return pin(Context.get(context, ConfigProvider.ConfigProvider)); }), ); /** * The ConfigProvider a CLI command runs under before any stack is loaded: * an explicit `--env-file` overrides the process environment. Without that * flag, the process environment overrides an optional `.env` file. */ export const loadConfigProvider = Effect.fn("loadConfigProvider")(function* ( envFile: Option.Option, ) { const fs = yield* FileSystem.FileSystem; let path: string | undefined; if (Option.isSome(envFile)) { path = envFile.value; } else if (yield* fs.exists(".env")) { path = ".env"; } // `fromEnv` snapshots `process.env` when called, so build it here rather // than once at module load. const shell = ConfigProvider.fromEnv(); if (path === undefined) return shell; const dotEnv = yield* ConfigProvider.fromDotEnv({ path }); return Option.isSome(envFile) ? ConfigProvider.orElse(dotEnv, shell) : ConfigProvider.orElse(shell, dotEnv); });