alchemy 2.0.0-beta.52 → 2.0.0-beta.53

package/src/Neon/Providers.ts

@@ -6,17 +6,12 @@ import * as Provider from "../Provider.ts";
 import { NeonAuth } from "./AuthProvider.ts";
 import { Branch, BranchProvider } from "./Branch.ts";
 import * as Credentials from "./Credentials.ts";
-import { NeonEnvironment, fromProfile } from "./NeonEnvironment.ts";
 import { Project, ProjectProvider } from "./Project.ts";
 
-export { NeonEnvironment } from "./NeonEnvironment.ts";
-
 export class Providers extends Provider.ProviderCollection<Providers>()(
   "Neon",
 ) {}
 
-export type ProviderRequirements = Layer.Services<ReturnType<typeof providers>>;
-
 /**
  * Build a layer that registers all Neon resource providers, the Neon
  * `AuthProvider`, the resolved `Credentials`, and an `HttpClient`. Include
@@ -48,7 +43,6 @@ export const providers = () =>
   Layer.effect(Providers, Provider.collection([Project, Branch])).pipe(
     Layer.provide(Layer.mergeAll(ProjectProvider(), BranchProvider())),
     Layer.provideMerge(Credentials.fromAuthProvider()),
-    Layer.provideMerge(fromProfile()),
     Layer.provideMerge(NeonAuth),
     Layer.provideMerge(ProfileLive),
     Layer.provideMerge(CredentialsStoreLive),

package/src/Neon/index.ts

@@ -1,5 +1,4 @@
 export * from "./Branch.ts";
-export * from "./NeonEnvironment.ts";
 export * from "./PostgresOrigin.ts";
 export * from "./Project.ts";
 export * from "./Providers.ts";

package/src/Output.ts

@@ -1,3 +1,4 @@
+import * as Config from "effect/Config";
 import * as Data from "effect/Data";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
@@ -554,7 +555,7 @@ export const evaluate: <A, Req = never>(
   },
 ) => Effect.Effect<
   A,
-  InvalidReferenceError | MissingSourceError,
+  InvalidReferenceError | MissingSourceError | Config.ConfigError,
   State.State | Req
 > = (expr, upstream) =>
   Effect.gen(function* () {
@@ -644,9 +645,12 @@ export const evaluate: <A, Req = never>(
     }
     if (Array.isArray(expr)) {
       return yield* Effect.all(expr.map((item) => evaluate(item, upstream)));
-    } else if (Redacted.isRedacted(expr)) {
-      return expr;
-    } else if (Duration.isDuration(expr)) {
+    } else if (Config.isConfig(expr)) {
+      // Resolve Config against the deploy environment — see resolveInput in
+      // Plan.ts for rationale. `Config.redacted` resolves to a `Redacted`,
+      // which stays opaque via the branch below.
+      return yield* evaluate(yield* expr, upstream);
+    } else if (Duration.isDuration(expr) || Redacted.isRedacted(expr)) {
       // Opaque value — see resolveInput in Plan.ts for rationale.
       return expr;
     } else if (typeof expr === "object" && expr !== null) {

package/src/Plan.ts

@@ -1,3 +1,4 @@
+import * as Config from "effect/Config";
 import * as Data from "effect/Data";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
@@ -373,18 +374,25 @@ export const make = <A>(
           ));
       });
 
-    const resolveInput = (input: any): Effect.Effect<any> =>
+    const resolveInput = (input: any): Effect.Effect<any, Config.ConfigError> =>
       Effect.gen(function* () {
         if (!input) {
           return input;
         } else if (Output.isExpr(input)) {
           return yield* resolveOutput(input);
-        } else if (Redacted.isRedacted(input)) {
-          return input;
-        } else if (Duration.isDuration(input)) {
-          // Duration is an opaque value; walking its internal `.value`
-          // would destroy the prototype and produce a plain `{ value: ... }`
-          // object that downstream consumers can't interpret.
+        } else if (Config.isConfig(input)) {
+          // Config is a lazy reference to the deploy environment. Resolve it
+          // here so the concrete value flows into diffing/hashing (an opaque
+          // Config hashes the same regardless of the underlying value) and so
+          // providers receive a resolved value instead of a Config object.
+          // `Config.redacted` resolves to a `Redacted`, which stays opaque via
+          // the branch below.
+          return yield* resolveInput(yield* input);
+        } else if (Duration.isDuration(input) || Redacted.isRedacted(input)) {
+          // Opaque values that are resolved downstream. We don't walk them
+          // because it would strip their prototype, resulting in a plain object
+          // that downstream consumers can't interpret. Redacted additionally
+          // stays wrapped to preserve the secrecy boundary.
           return input;
         } else if (Array.isArray(input)) {
           return yield* Effect.all(input.map(resolveInput), {