alchemy 2.0.0-beta.36 → 2.0.0-beta.37

package/bin/exec.js

@@ -1,4 +1,3 @@
-import { createRequire } from "node:module";
 import * as ConfigProvider from "effect/ConfigProvider";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
@@ -12,6 +11,8 @@ import * as Redacted from "effect/Redacted";
 import path from "pathe";
 import * as Config from "effect/Config";
 import os from "node:os";
+import * as dns from "node:dns";
+import * as undici from "undici";
 import * as Console from "effect/Console";
 import * as Logger from "effect/Logger";
 import * as Option from "effect/Option";
@@ -23,6 +24,7 @@ import * as Deferred from "effect/Deferred";
 import { pipe } from "effect/Function";
 import { SingleShotGen } from "effect/Utils";
 import { pipeArguments } from "effect/Pipeable";
+import "effect/Scope";
 import * as Duration from "effect/Duration";
 import * as Exit from "effect/Exit";
 import * as Metric from "effect/Metric";
@@ -152,22 +154,16 @@ const isLocalhost = (hostname) => hostname === "localhost" || hostname === "[::1
 const installLocalhostDns = () => {
 	if (installed) return;
 	installed = true;
-	if (typeof globalThis.Bun !== "undefined") return;
-	try {
-		const require = createRequire(import.meta.url);
-		const undici = require("undici");
-		const dns = require("node:dns");
-		undici.setGlobalDispatcher(new undici.Agent({ connect: { lookup: (hostname, options, cb) => {
-			if (isLocalhost(hostname)) {
-				if (options && options.all) return cb(null, [{
-					address: "127.0.0.1",
-					family: 4
-				}]);
-				return cb(null, "127.0.0.1", 4);
-			}
-			return dns.lookup(hostname, options, cb);
-		} } }));
-	} catch {}
+	undici.setGlobalDispatcher(new undici.Agent({ connect: { lookup: (hostname, options, cb) => {
+		if (isLocalhost(hostname)) {
+			if (options && options.all) return cb(null, [{
+				address: "127.0.0.1",
+				family: 4
+			}]);
+			return cb(null, "127.0.0.1", 4);
+		}
+		return dns.lookup(hostname, options, cb);
+	} } }));
 };
 
 //#endregion
@@ -358,18 +354,7 @@ var Cli = class extends EffectContext.Service()("CLI") {};
 //#region lib/Ref.js
 const RefMetadata = Symbol.for("alchemy/RefMetadata");
 const isRef = (s) => s && s[RefMetadata] !== void 0;
-const getRefMetadata = (ref$1) => ref$1[RefMetadata];
-const ref = ({ stack, id, stage: stage$1 }) => {
-	const ref$1 = new Proxy({}, { get: (_, prop) => {
-		if (prop === RefMetadata) return {
-			stack,
-			stage: stage$1,
-			id
-		};
-		return of(ref$1)[prop];
-	} });
-	return ref$1;
-};
+const getRefMetadata = (ref) => ref[RefMetadata];
 
 //#endregion
 //#region lib/FQN.js
@@ -479,6 +464,17 @@ const loadConfigProvider = (envFile$1) => {
 
 //#endregion
 //#region lib/Util/effect.js
+const effectClass = ((impl) => impl === void 0 ? (innerImpl) => effectClass(innerImpl) : Object.assign(class {
+	static asEffect() {
+		return impl;
+	}
+	static [Symbol.iterator]() {
+		return new SingleShotGen(this);
+	}
+	static pipe(...fns) {
+		return pipeArguments(this.asEffect(), fns);
+	}
+}, impl));
 const taggedFunction = (tag$1, fn) => {
 	const overrides = {
 		asEffect: () => tag$1.asEffect(),
@@ -505,14 +501,17 @@ const fileLogger = Effect.fnUntraced(function* (...segments) {
 
 //#endregion
 //#region lib/Stack.js
-const Stack = Object.assign(taggedFunction(EffectContext.Service()("Stack"), (stackName, options, eff) => eff.pipe(make$1({
-	name: stackName,
-	...options
-}), (eff$1) => Object.assign(eff$1, { stage: new Proxy({}, { get: (_, stage$1) => ref({
-	stack: stackName,
-	stage: stage$1,
-	id: stackName
-}) }) }))));
+const Stack = Object.assign(taggedFunction(EffectContext.Service()("Stack"), (stackName, options, eff) => {
+	if (!stackName) return (stackName$1) => Object.assign(stackRef(stackName$1).pipe(effectClass), {
+		stage: createStageProxy(stackName$1),
+		make: (options$1, eff$1) => Stack(stackName$1, options$1, eff$1)
+	});
+	return eff.pipe(make$1({
+		name: stackName,
+		...options
+	}), (eff$1) => Object.assign(eff$1, { stage: createStageProxy(stackName) }));
+}));
+const createStageProxy = (stackName) => new Proxy({}, { get: (_, stage$1) => stackRef(stackName, { stage: stage$1 }) });
 const StackName = Stack.use((stack) => Effect.succeed(stack.name));
 const make$1 = (options) => (effect) => Effect.scope.pipe(Effect.flatMap((scope) => {
 	if (options.state == null) return Effect.die(/* @__PURE__ */ new Error(`Stack "${options.name}" is missing a state store. Add a \`state\` layer to the stack options, e.g.:\n  Alchemy.Stack("${options.name}", {\n    providers: Cloudflare.providers(),\n    state: Cloudflare.state(), // <-- required\n  }, ...)\nSee https://v2.alchemy.run/concepts/state-store for available state stores.`));
@@ -667,6 +666,28 @@ var EffectExpr = class extends BaseExpr {
 		return `${this.expr[inspect]()}.mapEffect(${this.f.toString()})`;
 	}
 };
+const isNamedExpr = (node) => node?.kind === "NamedExpr";
+/**
+* Wraps another `Expr` and overrides its `toString()` / inspect output.
+*
+* `BaseExpr.asEffect()` derives the binding id from `this.toString()`, so
+* wrapping an expression in `NamedExpr` makes that derived id stable and
+* caller-controlled (e.g. an env var name like `"API_KEY"`).
+*/
+var NamedExpr = class extends BaseExpr {
+	expr;
+	bindingName;
+	kind = "NamedExpr";
+	constructor(expr, bindingName) {
+		super();
+		this.expr = expr;
+		this.bindingName = bindingName;
+		return proxy(this);
+	}
+	[inspect]() {
+		return this.bindingName;
+	}
+};
 const isAllExpr = (node) => node?.kind === "AllExpr";
 var AllExpr = class extends BaseExpr {
 	outs;
@@ -697,6 +718,39 @@ var RefExpr = class extends BaseExpr {
 		return `ref(${this.resourceId}, { stack: ${this.stack}, stage: ${this.stage} })`;
 	}
 };
+const isStackRefExpr = (node) => node?.kind === "StackRefExpr";
+/**
+* A reference to the persisted output of a Stack at `(stack, stage)`.
+*
+* Resolved at evaluation time by reading `state.getOutput({ stack,
+* stage })`. Distinct from {@link RefExpr}, which references a
+* single resource's attributes within a stack/stage. `stage` may be
+* `undefined`, in which case it falls back to the current stage.
+*/
+var StackRefExpr = class extends BaseExpr {
+	stack;
+	stage;
+	kind = "StackRefExpr";
+	constructor(stack, stage$1) {
+		super();
+		this.stack = stack;
+		this.stage = stage$1;
+		return proxy(this);
+	}
+	[inspect]() {
+		return `stackRef(${this.stack}${this.stage ? `, { stage: ${this.stage} }` : ""})`;
+	}
+};
+/**
+* Build an `Output<A>` referencing the persisted output of another
+* Stack. The returned Effect resolves to a lazy `Output<A>` whose
+* value is read from the state store at plan/apply time.
+*
+* Returns `Effect<Output<A>>` (not `Output<A>` directly) so that
+* `yield* Output.stackRef(...)` reads ergonomically inside an Effect
+* generator and lines up with `Resource.ref` and `Stack.stage.<name>`.
+*/
+const stackRef = (stack, options = {}) => Effect.succeed(new StackRefExpr(stack, options.stage));
 function proxy(self) {
 	const target = Object.assign(() => {}, self);
 	if (inspect in self) Object.defineProperty(target, inspect, {
@@ -705,7 +759,9 @@ function proxy(self) {
 	});
 	const proxy$1 = new Proxy(target, {
 		has: (_, prop) => prop === ExprSymbol || prop === inspect ? true : prop in self,
-		get: (target$1, prop) => prop === Symbol.toPrimitive ? (hint) => hint === "number" ? NaN : self.toString() : prop === ExprSymbol ? self : prop === inspect ? target$1[inspect] : isResourceExpr(self) && self.stables && prop in self.stables ? self.stables[prop] : prop === "apply" ? self[prop] : prop in self ? typeof self[prop] === "function" && !("kind" in self) ? new PropExpr(proxy$1, prop) : self[prop] : new PropExpr(proxy$1, prop),
+		get: (target$1, prop) => prop === Symbol.toPrimitive ? (hint) => {
+			throw new Error(`Cannot coerce Output<${self[inspect]()}> to a ${hint === "number" ? "number" : "string"} via JS coercion. Use Output.interpolate\`...\` or Output.map(output, fn) to compose Outputs — the value isn't known until deploy time.`);
+		} : prop === ExprSymbol ? self : prop === inspect ? target$1[inspect] : isResourceExpr(self) && self.stables && prop in self.stables ? self.stables[prop] : prop === "apply" ? self[prop] : prop in self ? typeof self[prop] === "function" && !("kind" in self) ? new PropExpr(proxy$1, prop) : self[prop] : new PropExpr(proxy$1, prop),
 		apply: (_, thisArg, args) => {
 			if (isPropExpr(self)) {
 				if (self.identifier === "apply") return new ApplyExpr(self.expr, args[0]);
@@ -740,6 +796,7 @@ const evaluate = (expr, upstream$1) => Effect.gen(function* () {
 		else if (isEffectExpr(expr)) return yield* expr.f(yield* evaluate(expr.expr, upstream$1));
 		else if (isAllExpr(expr)) return yield* Effect.all(expr.outs.map((out) => evaluate(out, upstream$1)));
 		else if (isPropExpr(expr)) return (yield* evaluate(expr.expr, upstream$1))?.[expr.identifier];
+		else if (isNamedExpr(expr)) return yield* evaluate(expr.expr, upstream$1);
 		else if (isRefExpr(expr)) {
 			const state = yield* State;
 			const stack = expr.stack ?? (yield* Stack).name;
@@ -756,6 +813,21 @@ const evaluate = (expr, upstream$1) => Effect.gen(function* () {
 				resourceId: expr.resourceId
 			}));
 			return resource.attr;
+		} else if (isStackRefExpr(expr)) {
+			const state = yield* State;
+			const stack = expr.stack;
+			const stage$1 = expr.stage ?? (yield* Stage);
+			const output = yield* state.getOutput({
+				stack,
+				stage: stage$1
+			});
+			if (output == null) return yield* Effect.fail(new InvalidReferenceError({
+				message: `Reference to stack '${stack}' at stage '${stage$1}' not found. Have you deployed stage '${stage$1}' of '${stack}'?`,
+				stack,
+				stage: stage$1,
+				resourceId: stack
+			}));
+			return output;
 		}
 	}
 	if (Array.isArray(expr)) return yield* Effect.all(expr.map((item) => evaluate(item, upstream$1)));
@@ -776,7 +848,7 @@ const upstream = (expr) => {
 	else if (isResourceExpr(expr)) return { [expr.src.FQN]: expr.src };
 	else if (isPropExpr(expr)) return upstream(expr.expr);
 	else if (isAllExpr(expr)) return Object.assign({}, ...expr.outs.map((out) => upstream(out)));
-	else if (isEffectExpr(expr) || isApplyExpr(expr)) return upstream(expr.expr);
+	else if (isEffectExpr(expr) || isApplyExpr(expr) || isNamedExpr(expr)) return upstream(expr.expr);
 	else if (Array.isArray(expr)) return expr.map(upstream).reduce(toObject, {});
 	else if (typeof expr === "object" && expr !== null) return Object.values(expr).map((v) => upstream(v)).reduce(toObject, {});
 	return {};
@@ -1074,7 +1146,37 @@ const make = (stack, options = {}) => Effect.gen(function* () {
 			return hasOutputs(upstream$1) ? expr : yield* expr.f(upstream$1);
 		} else if (isAllExpr(expr)) return yield* Effect.all(expr.outs.map(resolveOutput), { concurrency: "unbounded" });
 		else if (isLiteralExpr(expr)) return expr.value;
-		return yield* Effect.die(/* @__PURE__ */ new Error("Not implemented yet"));
+		else if (isRefExpr(expr)) {
+			const refStack = expr.stack ?? stackName;
+			const refStage = expr.stage ?? stage$1;
+			const refState = yield* state.get({
+				stack: refStack,
+				stage: refStage,
+				fqn: expr.resourceId
+			}).pipe(Effect.orDie);
+			if (!refState) return yield* Effect.die(new InvalidReferenceError({
+				message: `Reference to '${expr.resourceId}' in stack '${refStack}' and stage '${refStage}' not found. Have you deployed '${refStage}' of '${refStack}'?`,
+				stack: refStack,
+				stage: refStage,
+				resourceId: expr.resourceId
+			}));
+			return refState.attr;
+		} else if (isStackRefExpr(expr)) {
+			const refStack = expr.stack;
+			const refStage = expr.stage ?? stage$1;
+			const output = yield* state.getOutput({
+				stack: refStack,
+				stage: refStage
+			}).pipe(Effect.orDie);
+			if (output == null) return yield* Effect.die(new InvalidReferenceError({
+				message: `Reference to stack '${refStack}' at stage '${refStage}' not found. Have you deployed stage '${refStage}' of '${refStack}'?`,
+				stack: refStack,
+				stage: refStage,
+				resourceId: refStack
+			}));
+			return output;
+		} else if (isNamedExpr(expr)) return yield* resolveOutput(expr.expr);
+		return yield* Effect.die(/* @__PURE__ */ new Error("Not implemented yet" + expr.kind));
 	});
 	const oldDownstreamDependencies = Object.fromEntries(oldResources.filter((resource) => !!resource).map((resource) => [resource.fqn, resource.downstream]));
 	const newResourceFqns = new Set(resources.map((r) => r.FQN));
@@ -1090,7 +1192,22 @@ const make = (stack, options = {}) => Effect.gen(function* () {
 		const fqn = resource.FQN;
 		return [fqn, (rawUpstreamDependencies[fqn] ?? []).filter((dep) => newResourceFqns.has(dep))];
 	}));
-	const newDownstreamDependencies = Object.fromEntries(resources.map((resource) => [resource.FQN, Object.entries(newUpstreamDependencies).filter(([_, upstream$1]) => upstream$1.includes(resource.FQN)).map(([depFqn]) => depFqn)]));
+	const combinedCycleMembers = findCycleMembers(allUpstreamDependencies);
+	const newDownstreamDependencies = Object.fromEntries(resources.map((resource) => {
+		const upFqn = resource.FQN;
+		const downstream = [];
+		for (const [downFqn, upstreams] of Object.entries(rawUpstreamDependencies)) {
+			if (downFqn === upFqn) continue;
+			if (!upstreams.includes(upFqn)) continue;
+			if ((newUpstreamDependencies[downFqn] ?? []).includes(upFqn)) {
+				downstream.push(downFqn);
+				continue;
+			}
+			if (combinedCycleMembers.has(upFqn) && combinedCycleMembers.has(downFqn)) continue;
+			downstream.push(downFqn);
+		}
+		return [upFqn, downstream];
+	}));
 	const resourceGraph = Object.fromEntries((yield* Effect.all(resources.map(Effect.fn("plan.diff.resource")(function* (resource) {
 		const provider = yield* findProviderByType(resource.Type);
 		const id = resource.LogicalId;
@@ -1273,7 +1390,7 @@ const make = (stack, options = {}) => Effect.gen(function* () {
 			state: oldState
 		});
 	})), { concurrency: "unbounded" })).map((update) => [update.resource.FQN, update]));
-	const cycleMembers = findCycleMembers(allUpstreamDependencies);
+	const cycleMembers = combinedCycleMembers;
 	{
 		const createReplaceNodes = new Set(Object.entries(resourceGraph).filter(([_, node]) => node.action === "create" || node.action === "replace").map(([fqn]) => fqn));
 		if (createReplaceNodes.size > 0) {
@@ -1417,7 +1534,13 @@ const apply = (plan) => Effect.gen(function* () {
 	yield* session.done();
 	if (!plan.output) return;
 	const outputs = Object.fromEntries(Object.entries(tracker).map(([fqn, t]) => [fqn, t.output]));
-	return yield* evaluate(plan.output, outputs);
+	const resolved = yield* evaluate(plan.output, outputs);
+	yield* state.setOutput({
+		stack: stackName,
+		stage: stage$1,
+		value: resolved
+	});
+	return resolved;
 }).pipe(ensureArtifactStore, Effect.withSpan("apply", { attributes: {
 	"alchemy.resources.count": Object.keys(plan.resources).length,
 	"alchemy.deletions.count": Object.keys(plan.deletions).length