alchemy 2.0.0-beta.58 → 2.0.0-beta.59

package/README.md

@@ -44,7 +44,7 @@ One `bind()` wires the binding, env var, and typed connection — at deploy time
 ---
 
 - **One program, one language.** Resources, Lambdas/Workers, IAM, and SDKs live in the same Effect program — no YAML, no second runtime.
-- **Bindings, not glue code.** `S3.GetObject.bind(bucket)` wires the IAM policy, env var, and a typed SDK call in a single line.
+- **Bindings, not glue code.** `S3.GetObject(bucket)` wires the IAM policy, env var, and a typed SDK call in a single line.
 - **Errors in the type system.** Every cloud API failure is a tagged Effect error you handle — or don't — on purpose.
 - **AWS + Cloudflare today.** S3, SQS, DynamoDB, Kinesis, Lambda, EC2 / Workers, R2, D1, Durable Objects, Containers.
 - **Same code, every stage.** Local dev, `plan` / `deploy`, smoke tests, and CI all share one mental model.

package/bin/exec.js

@@ -35,7 +35,6 @@ import * as Console from "effect/Console";
 import * as Command from "effect/unstable/cli/Command";
 import * as Flag from "effect/unstable/cli/Flag";
 import * as Metric from "effect/Metric";
-import { createHash } from "node:crypto";
 import * as Argument from "effect/unstable/cli/Argument";
 import * as CliError from "effect/unstable/cli/CliError";
 import { jsx, jsxs } from "react/jsx-runtime";
@@ -418,10 +417,10 @@ const Provider = (type) => EffectContext.Service()(type);
 const isProviderCollectionService = (value) => {
 	return typeof value === "object" && value !== null && "kind" in value && value.kind === "ProviderCollection";
 };
-const findProviderByType = (type) => tryFindProviderByType(type).pipe(Effect.flatMap(Option.match({
+const findProviderByType = ((type) => tryFindProviderByType(type).pipe(Effect.flatMap(Option.match({
 	onNone: () => Effect.die(`Provider not found for ${type}`),
 	onSome: (provider) => Effect.succeed(provider)
-})));
+}))));
 const tryFindProviderByType = Effect.fn(function* (resourceType) {
 	const Tag = Provider(resourceType);
 	const direct = yield* Effect.serviceOption(Tag);
@@ -1127,13 +1126,23 @@ const recordOutcome = (baseAttrs, status, duration) => {
 };
 
 //#endregion
-//#region lib/Util/hash.js
+//#region lib/Util/sha256.js
+const sha256 = (input) => Effect.promise(async () => {
+	const digest = await crypto.subtle.digest("SHA-256", toArrayBuffer(input));
+	return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+});
 /**
-* Stable hash of a resolved Task input. Wrapped in `Effect.sync` so the
-* call participates in the Effect runtime (tracing/interruption) per the
-* Effect-platform conventions.
+* Stable sha256 hex digest of a resolved Task input. Unlike
+* {@link sha256Object} this does not stabilize key ordering — it hashes the
+* raw `JSON.stringify(input ?? null)` so identical inputs map to identical
+* hashes for caching/equality checks.
 */
-const hashInput = (input) => Effect.sync(() => createHash("sha256").update(JSON.stringify(input ?? null)).digest("hex"));
+const hashInput = (input) => sha256(JSON.stringify(input ?? null));
+const toArrayBuffer = (input) => {
+	if (input instanceof ArrayBuffer) return input;
+	if (typeof input === "string") return new TextEncoder().encode(input);
+	return input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
+};
 
 //#endregion
 //#region lib/Util/scc.js
@@ -2081,6 +2090,22 @@ const executeNode = (fqn, node, tracker, ready, readyStable, terminalStatuses, s
 				removalPolicy: node.resource.RemovalPolicy
 			});
 			else replState = node.state;
+			const deleteOldGenerations = (old) => Effect.gen(function* () {
+				const retain = node.resource.RemovalPolicy === "retain";
+				if (old.attr !== void 0 && !retain) yield* node.provider.delete({
+					id: logicalId,
+					instanceId: old.instanceId,
+					olds: old.props,
+					output: old.attr,
+					session: scopedSession,
+					bindings: []
+				}).pipe(instrumentLifecycle("delete", fqn, node.resource.Type, logicalId, old.instanceId));
+				if (old.status === "replacing" || old.status === "replaced") yield* deleteOldGenerations(old.old);
+			});
+			if (node.deleteFirst) {
+				yield* scopedSession.note("Deleting previous resource before creating its replacement (deleteFirst)...");
+				yield* deleteOldGenerations(replState.old);
+			}
 			let attr = replState.attr;
 			if (attr !== void 0) yield* storeAndSignal({
 				output: attr,
@@ -2134,7 +2159,20 @@ const executeNode = (fqn, node, tracker, ready, readyStable, terminalStatuses, s
 				olds: void 0,
 				output: attr
 			}).pipe(instrumentLifecycle("create", fqn, node.resource.Type, logicalId, instanceId));
-			yield* commit({
+			if (node.deleteFirst) yield* commit({
+				status: "created",
+				fqn,
+				logicalId,
+				instanceId,
+				resourceType: node.resource.Type,
+				props: news,
+				attr,
+				providerVersion: node.provider.version ?? 0,
+				bindings: excludeDeletedBindings(node.bindings),
+				downstream: node.downstream,
+				removalPolicy: node.resource.RemovalPolicy
+			});
+			else yield* commit({
 				status: "replaced",
 				fqn,
 				logicalId,