alchemy-effect 0.6.4 → 0.7.1

package/bin/alchemy-effect.js

@@ -69,7 +69,72 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
 //#region package.json
-var version = "0.6.4";
+var version = "0.7.1";
+
+//#endregion
+//#region src/Artifacts.ts
+/**
+* Per-resource in-memory artifacts shared across a single `Plan.make -> apply`
+* execution.
+*
+* The engine scopes this service by resource `FQN` before invoking lifecycle
+* handlers, so providers should treat it as a resource-local bag for expensive,
+* deterministic intermediate results that can be reused across phases.
+*
+* Expected usage:
+*
+* - `diff` computes an expensive artifact once and stores it
+* - `create` / `update` reads the same artifact and skips recomputing it
+* - artifacts are ephemeral and must never be required for correctness on a
+*   later deploy because the bag is reset between runs
+*
+* Example:
+*
+* ```ts
+* const artifacts = yield* Artifacts;
+* const cached = yield* artifacts.get<PreparedBundle>("bundle");
+* if (cached) return cached;
+*
+* const bundle = yield* prepareBundle();
+* yield* artifacts.set("bundle", bundle);
+* return bundle;
+* ```
+*/
+var Artifacts = class extends ServiceMap.Service()("Artifacts") {};
+var ArtifactStore = class extends ServiceMap.Service()("Artifacts/Store") {};
+/**
+* Create a fresh root store for one deploy/test run.
+*/
+const createArtifactStore = () => /* @__PURE__ */ new Map();
+const getOrCreateBag = (store, fqn) => {
+	const existing = store.get(fqn);
+	if (existing) return existing;
+	const bag = /* @__PURE__ */ new Map();
+	store.set(fqn, bag);
+	return bag;
+};
+const makeScopedArtifacts = (store, fqn) => {
+	const bag = getOrCreateBag(store, fqn);
+	return {
+		get: (key) => Effect.sync(() => bag.get(key)),
+		set: (key, value) => Effect.sync(() => {
+			bag.set(key, value);
+		}),
+		delete: (key) => Effect.sync(() => {
+			bag.delete(key);
+		})
+	};
+};
+/**
+* Run an effect with a fresh artifact root, replacing any existing store.
+* Use this at top-level entrypoints that intentionally define a new deploy run.
+*/
+const provideFreshArtifactStore = (effect) => effect.pipe(Effect.provideServiceEffect(ArtifactStore, Effect.sync(createArtifactStore)));
+/**
+* Ensure an artifact root exists, reusing the ambient store when one is already
+* present. This lets nested helpers participate in the same run-scoped cache.
+*/
+const ensureArtifactStore = (effect) => Effect.serviceOption(ArtifactStore).pipe(Effect.map(Option.getOrUndefined), Effect.flatMap((existing) => effect.pipe(Effect.provideService(ArtifactStore, existing ?? createArtifactStore()))));
 
 //#endregion
 //#region src/Cli/Cli.ts
@@ -210,6 +275,9 @@ const ExprSymbol = Symbol.for("alchemy/Expr");
 const isExpr = (value) => value && (typeof value === "object" || typeof value === "function") && ExprSymbol in value;
 var BaseExpr = class {
 	constructor() {}
+	as() {
+		return this;
+	}
 	[Symbol.iterator]() {
 		return new SingleShotGen(this);
 	}
@@ -492,7 +560,8 @@ const LocalState = Layer.effect(State, Effect.gen(function* () {
 
 //#endregion
 //#region src/Apply.ts
-const apply = (plan) => Effect.gen(function* () {
+const provideLifecycleScope = (fqn, instanceId) => (effect) => Effect.serviceOption(ArtifactStore).pipe(Effect.map(Option.getOrElse(createArtifactStore)), Effect.flatMap((store) => effect.pipe(Effect.provideService(Artifacts, makeScopedArtifacts(store, fqn)), Effect.provideService(InstanceId, instanceId))));
+const apply = (plan) => ensureArtifactStore(Effect.gen(function* () {
 	const session = yield* (yield* Cli).startApplySession(plan);
 	const state = yield* State;
 	const stack = yield* Stack;
@@ -513,7 +582,7 @@ const apply = (plan) => Effect.gen(function* () {
 	if (!plan.output) return;
 	const outputs = Object.fromEntries(Object.entries(tracker).map(([fqn, t]) => [fqn, t.output]));
 	return yield* evaluate(plan.output, outputs);
-});
+}));
 const executePlan = Effect.fnUntraced(function* (plan, tracker, terminalStatuses, session, state, stackName, stage$1) {
 	const ready = Object.fromEntries(yield* Effect.all(Object.keys(plan.resources).map((fqn) => Effect.map(Deferred.make(), (d) => [fqn, d]))));
 	const getOutputs = () => Object.fromEntries(Object.entries(tracker).map(([fqn, t]) => [fqn, t.output]));
@@ -638,7 +707,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 					news: node.props,
 					session: scopedSession,
 					instanceId
-				});
+				}).pipe(provideLifecycleScope(fqn, instanceId));
 				yield* commit({
 					status: "creating",
 					fqn,
@@ -671,7 +740,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 				bindings: bindingOutputs,
 				session: scopedSession,
 				output: attr
-			});
+			}).pipe(provideLifecycleScope(fqn, instanceId));
 			yield* commit({
 				status: "created",
 				fqn,
@@ -734,7 +803,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 				session: scopedSession,
 				olds: previousProps,
 				output: node.state.attr
-			});
+			}).pipe(provideLifecycleScope(fqn, instanceId));
 			if (node.state.status === "replaced") yield* commit({
 				...node.state,
 				attr,
@@ -805,7 +874,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 					news: node.props,
 					session: scopedSession,
 					instanceId
-				});
+				}).pipe(provideLifecycleScope(fqn, instanceId));
 				yield* commit({
 					status: "replacing",
 					fqn,
@@ -840,7 +909,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 				bindings: bindingOutputs,
 				session: scopedSession,
 				output: attr
-			});
+			}).pipe(provideLifecycleScope(fqn, instanceId));
 			yield* commit({
 				status: "replaced",
 				fqn,
@@ -867,7 +936,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 			return;
 		}
 		return yield* Effect.die(`Unknown action: ${node.action}`);
-	}).pipe(Effect.provide(Layer.succeed(InstanceId, instanceId)));
+	});
 });
 const converge = Effect.fnUntraced(function* (plan, tracker, terminalStatuses, session, state, stackName, stage$1) {
 	for (;;) {
@@ -903,7 +972,7 @@ const converge = Effect.fnUntraced(function* (plan, tracker, terminalStatuses, s
 				session: scopedSession,
 				olds: oldProps,
 				output: tracker[fqn].output
-			}).pipe(Effect.provide(Layer.succeed(InstanceId, instanceId)));
+			}).pipe(provideLifecycleScope(fqn, instanceId));
 			tracker[fqn] = {
 				output: attr,
 				props: newProps,
@@ -1024,7 +1093,7 @@ const collectGarbage = Effect.fnUntraced(function* (plan, session) {
 					output: attr,
 					session: scopedSession,
 					bindings: []
-				});
+				}).pipe(provideLifecycleScope(fqn, instanceId));
 				if (isDeleteNode(node)) {
 					yield* state.delete({
 						stack: stackName,
@@ -1064,7 +1133,7 @@ const collectGarbage = Effect.fnUntraced(function* (plan, session) {
 					});
 					yield* scopedSession.note("Replaced resource cleanup complete.");
 				}
-			}).pipe(Effect.provide(Layer.succeed(InstanceId, instanceId))));
+			}));
 		});
 		yield* Effect.all(Object.values(deletionGraph).filter((node) => node !== void 0).map((node) => deleteResource(node)), { concurrency: "unbounded" });
 	});
@@ -41369,8 +41438,8 @@ cliCursor.hide = (writableStream = process$1.stderr) => {
 	isHidden = true;
 	writableStream.write("\x1B[?25l");
 };
-cliCursor.toggle = (force, writableStream) => {
-	if (force !== void 0) isHidden = force;
+cliCursor.toggle = (force$1, writableStream) => {
+	if (force$1 !== void 0) isHidden = force$1;
 	if (isHidden) cliCursor.show(writableStream);
 	else cliCursor.hide(writableStream);
 };
@@ -44249,7 +44318,7 @@ const asEffect = (effect) => Effect.isEffect(effect) ? effect : Effect.succeed(e
 
 //#endregion
 //#region src/Plan.ts
-const make = (stack) => Effect.gen(function* () {
+const make = (stack, options = {}) => ensureArtifactStore(Effect.gen(function* () {
 	const state = yield* State;
 	const resources = Object.values(stack.resources);
 	const stackName = stack.name;
@@ -44286,7 +44355,7 @@ const make = (stack) => Effect.gen(function* () {
 				output: oldState.attr,
 				oldBindings,
 				newBindings
-			}).pipe(Effect.provideService(InstanceId, oldState.instanceId)) : Effect.succeed(void 0);
+			}).pipe(providePlanScope(resource.FQN, oldState.instanceId)) : Effect.succeed(void 0);
 			const stables = [...provider.stables ?? [], ...diff$1?.stables ?? []];
 			const withStables = (output) => stables.length > 0 ? new ResourceExpr(resourceExpr.src, Object.fromEntries(stables.map((stable) => [stable, output?.[stable]]))) : resourceExpr;
 			if (diff$1 == null) {
@@ -44366,7 +44435,7 @@ const make = (stack) => Effect.gen(function* () {
 					instanceId: oldState.instanceId,
 					olds: oldState.props,
 					output: oldState.attr
-				}).pipe(Effect.provideService(InstanceId, oldState.instanceId));
+				}).pipe(providePlanScope(fqn, oldState.instanceId));
 				if (attr) return Node$1({
 					action: "create",
 					props: news,
@@ -44386,7 +44455,7 @@ const make = (stack) => Effect.gen(function* () {
 			news,
 			oldBindings,
 			newBindings
-		}).pipe(Effect.provideService(InstanceId, oldState.instanceId))).pipe(Effect.map((diff$2) => diff$2 ?? { action: havePropsChanged(oldProps, news) || bindingDiffs.some((b) => b.action !== "noop") ? "update" : "noop" }));
+		}).pipe(providePlanScope(fqn, oldState.instanceId))).pipe(Effect.map((diff$2) => diff$2 ?? { action: havePropsChanged(oldProps, news) || bindingDiffs.some((b) => b.action !== "noop") ? "update" : "noop" }), Effect.map((diff$2) => options.force && diff$2.action === "noop" ? { action: "update" } : diff$2));
 		if (oldState.status === "creating") if (diff$1.action === "noop") return Node$1({
 			action: "create",
 			props: news,
@@ -44524,7 +44593,7 @@ const make = (stack) => Effect.gen(function* () {
 					instanceId: oldState.instanceId,
 					olds: oldState.props,
 					output: oldState.attr
-				}).pipe(Effect.provideService(InstanceId, oldState.instanceId));
+				}).pipe(providePlanScope(fqn, oldState.instanceId));
 			}
 			return [fqn, {
 				action: "delete",
@@ -44567,7 +44636,8 @@ const make = (stack) => Effect.gen(function* () {
 		deletions,
 		output: stack.output
 	};
-});
+}));
+const providePlanScope = (fqn, instanceId) => (effect) => Effect.serviceOption(ArtifactStore).pipe(Effect.map(Option.getOrElse(createArtifactStore)), Effect.flatMap((store) => effect.pipe(Effect.provideService(Artifacts, makeScopedArtifacts(store, fqn)), Effect.provideService(InstanceId, instanceId))));
 var DeleteResourceHasDownstreamDependencies = class extends Data.TaggedError("DeleteResourceHasDownstreamDependencies") {};
 var UnsatisfiedResourceCycle = class extends Data.TaggedError("UnsatisfiedResourceCycle") {};
 
@@ -44582,6 +44652,7 @@ const stage = Flag.string("stage").pipe(Flag.withSchema(S.String.check(S.isPatte
 const envFile = Flag.file("env-file").pipe(Flag.optional, Flag.withDescription("File to load environment variables from, defaults to .env"));
 const dryRun = Flag.boolean("dry-run").pipe(Flag.withDescription("Dry run the deployment, do not actually deploy"), Flag.withDefault(false));
 const yes = Flag.boolean("yes").pipe(Flag.withDescription("Yes to all prompts"), Flag.withDefault(false));
+const force = Flag.boolean("force").pipe(Flag.withDescription("Force updates for resources that would otherwise no-op"), Flag.withDefault(false));
 const fileLogger = Effect.fnUntraced(function* (...segments) {
 	const dotAlchemy$1 = yield* DotAlchemy;
 	const fs$2 = yield* FileSystem.FileSystem;
@@ -44600,6 +44671,7 @@ const loadConfigProvider = (envFile$1) => {
 const main = Argument.file("main", { mustExist: true }).pipe(Argument.withDescription("Main file to deploy, defaults to alchemy.run.ts"), Argument.withDefault("alchemy.run.ts"));
 const deployCommand = Command.make("deploy", {
 	dryRun,
+	force,
 	main,
 	envFile,
 	stage,
@@ -44623,7 +44695,7 @@ const planCommand = Command.make("plan", {
 	...args,
 	dryRun: true
 }));
-const execStack = Effect.fn(function* ({ main: main$1, stage: stage$1, envFile: envFile$1, dryRun: dryRun$1 = false, yes: yes$1 = false, destroy = false }) {
+const execStack = Effect.fn(function* ({ main: main$1, stage: stage$1, envFile: envFile$1, dryRun: dryRun$1 = false, force: force$1 = false, yes: yes$1 = false, destroy = false }) {
 	const path = yield* Path;
 	const stackEffect = (yield* Effect.promise(() => import(path.resolve(process.cwd(), main$1)))).default;
 	if (!stackEffect) return yield* Effect.die(/* @__PURE__ */ new Error(`Main file '${main$1}' must export a default stack definition (export default defineStack({...}))`));
@@ -44634,13 +44706,13 @@ const execStack = Effect.fn(function* ({ main: main$1, stage: stage$1, envFile:
 	yield* Effect.gen(function* () {
 		const cli = yield* Cli;
 		const stack = yield* stackEffect;
-		yield* Effect.gen(function* () {
+		yield* provideFreshArtifactStore(Effect.gen(function* () {
 			const updatePlan = yield* make(destroy ? {
 				...stack,
 				resources: {},
 				bindings: {},
 				output: {}
-			} : stack);
+			} : stack, { force: force$1 });
 			if (dryRun$1) yield* cli.displayPlan(updatePlan);
 			else {
 				if (!yes$1) {
@@ -44649,7 +44721,7 @@ const execStack = Effect.fn(function* ({ main: main$1, stage: stage$1, envFile:
 				const outputs = yield* apply(updatePlan);
 				yield* Console.log(outputs);
 			}
-		}).pipe(Effect.provide(stack.services));
+		})).pipe(Effect.provide(stack.services));
 	}).pipe(Effect.provide(Layer.provideMerge(alchemy, Layer.mergeAll(platform$1, Layer.succeed(Stage, stage$1)))), Effect.provideService(ConfigProvider.ConfigProvider, configProvider));
 });
 const resourceFilter = Flag.string("filter").pipe(Flag.withDescription("Comma-separated logical resource IDs (e.g. Api,Sandbox). Only those resources are included."), Flag.optional, Flag.map(Option.getOrUndefined));