alchemy-effect 0.5.0 → 0.6.0

package/README.md

@@ -3,13 +3,15 @@
 # `alchemy-effect`
 
 `alchemy-effect` is an **Infrastructure-as-Effects (IaE)** framework that unifies business logic and infrastructure config into a single, type-safe program with the following benefits:
+
 1. Type-Checked IAM Policies
 2. Optimally Tree-Shaken Bundles
 3. Testable Business Logic
 4. Re-usable Components
-5. Reviewable Deployment Plans 
+5. Reviewable Deployment Plans
 
 ## Install
+
 ```bash
 bun add alchemy-effect
 ```
@@ -27,11 +29,13 @@ You will receive a type error if you mess up your Bindings:
 > This error means you are missing the `SendMessage<Messages>` binding (you provided `never` instead of `SendMessage<Messages>`).
 
 ## Plan & Deploy
+
 An `alchemy-effect` program produces a Plan that can be reviewed prior to deployment:
 
 <img src="./images/alchemy-effect-plan.gif" alt="alchemy-effect plan video" width="600"/>
 
-## Type-Level Plan 
+## Type-Level Plan
+
 All knowable information about the Plan is available at compile-time:
 
 <img src="./images/alchemy-effect-plan-type.png" alt="alchemy-effect plan type" width="600"/>
@@ -50,17 +54,19 @@ export default Api.handler.pipe(
 );
 ```
 
-## Pluggable Layers 
+## Pluggable Layers
+
 Everything (including the CLI) is provided as Effect layers:
 
 <img src="./images/alchemy-effect-layers.png" alt="alchemy-effect layers" width="600"/>
 
 ## Literally Typed Outputs
+
 The output of deploying a stack is totally known at compile-time, e.g. the `.fifo` suffix of a SQS FIFO Queue:
 
 <img src="./images/alchemy-effect-output.png" alt="alchemy-effect output" width="600"/>
 
-# Concepts 🔱 
+# Concepts 🔱
 
 <img src="./images/alchemy-effect-triple.png" alt="alchemy-effect logo" width="600"/>
 
@@ -78,7 +84,7 @@ Resources are declared along-side your business logic as classes, e.g. a FIFO SQ
 class Messages extends SQS.Queue("Messages", {
   fifo: true,
   schema: S.String,
-}) {} 
+}) {}
 ```
 
 ## Functions
@@ -122,7 +128,7 @@ class Api extends Lambda.serve("Api", {
 
 # Components
 
-Infrastructure and business logic can be encapsulated as a Component using a simple function. 
+Infrastructure and business logic can be encapsulated as a Component using a simple function.
 
 ```ts
 const Monitor = <const ID extends string, ReqAlarm, ReqResolved>(
@@ -176,4 +182,4 @@ const Monitor = <const ID extends string, ReqAlarm, ReqResolved>(
 # Building your own Resources, Capabilities, and Bindings
 
 > [!CAUTION]
-> WIP - docs coming soon!
+> WIP - docs coming soon!

package/bin/alchemy-effect.js

@@ -14042,7 +14042,7 @@ const asEffect = (effect) => Effect.isEffect(effect) ? effect : Effect.succeed(e
 
 //#endregion
 //#region package.json
-var version = "0.5.0";
+var version = "0.6.0";
 
 //#endregion
 //#region src/resource.ts
@@ -14297,7 +14297,7 @@ const plan = (..._resources) => Effect.gen(function* () {
 		stack: app$1.name,
 		stage: app$1.stage,
 		resourceId: id
-	})));
+	})), { concurrency: "unbounded" });
 	const resolvedResources = {};
 	const resolveResource = (resourceExpr) => Effect.gen(function* () {
 		return yield* resolvedResources[resourceExpr.src.id] ??= yield* Effect.cached(Effect.gen(function* () {
@@ -14331,8 +14331,8 @@ const plan = (..._resources) => Effect.gen(function* () {
 	const resolveInput = (input) => Effect.gen(function* () {
 		if (!input) return input;
 		else if (isExpr(input)) return yield* resolveOutput(input);
-		else if (Array.isArray(input)) return yield* Effect.all(input.map(resolveInput));
-		else if (typeof input === "object") return Object.fromEntries(yield* Effect.all(Object.entries(input).map(([key, value]) => resolveInput(value).pipe(Effect.map((value$1) => [key, value$1])))));
+		else if (Array.isArray(input)) return yield* Effect.all(input.map(resolveInput), { concurrency: "unbounded" });
+		else if (typeof input === "object") return Object.fromEntries(yield* Effect.all(Object.entries(input).map(([key, value]) => resolveInput(value).pipe(Effect.map((value$1) => [key, value$1]))), { concurrency: "unbounded" }));
 		return input;
 	});
 	const resolveOutput = (expr) => Effect.gen(function* () {
@@ -14344,7 +14344,7 @@ const plan = (..._resources) => Effect.gen(function* () {
 		} else if (isEffectExpr(expr)) {
 			const upstream$1 = yield* resolveOutput(expr.expr);
 			return hasOutputs(upstream$1) ? expr : yield* expr.f(upstream$1);
-		} else if (isAllExpr(expr)) return yield* Effect.all(expr.outs.map(resolveOutput));
+		} else if (isAllExpr(expr)) return yield* Effect.all(expr.outs.map(resolveOutput), { concurrency: "unbounded" });
 		return yield* Effect.die(/* @__PURE__ */ new Error("Not implemented yet"));
 	});
 	const oldDownstreamDependencies = Object.fromEntries(oldResources.filter((resource) => !!resource).map((resource) => [resource.logicalId, resource.downstream]));
@@ -14491,7 +14491,7 @@ const plan = (..._resources) => Effect.gen(function* () {
 			action: "noop",
 			state: oldState
 		});
-	})))).map((update) => [update.resource.id, update]));
+	})), { concurrency: "unbounded" })).map((update) => [update.resource.id, update]));
 	const deletions = Object.fromEntries((yield* Effect.all((yield* state.list({
 		stack: app$1.name,
 		stage: app$1.stage
@@ -14513,7 +14513,6 @@ const plan = (..._resources) => Effect.gen(function* () {
 					output: oldState.attr,
 					bindings: oldState.bindings ?? []
 				}).pipe(Effect.provide(Layer$1.succeed(InstanceId, oldState.instanceId)));
-				if (attr === void 0) return;
 			}
 			return [id, {
 				action: "delete",
@@ -14532,7 +14531,7 @@ const plan = (..._resources) => Effect.gen(function* () {
 				downstream: oldDownstreamDependencies[id] ?? []
 			}];
 		}
-	})))).filter((v) => !!v));
+	})), { concurrency: "unbounded" })).filter((v) => !!v));
 	for (const [resourceId, deletion] of Object.entries(deletions)) {
 		const dependencies = deletion.state.downstream.filter((d) => d in resourceGraph);
 		if (dependencies.length > 0) return yield* Effect.fail(new DeleteResourceHasDownstreamDependencies({
@@ -14588,7 +14587,7 @@ const diffBindings = Effect.fn(function* ({ oldState, bindings, target }) {
 			attr: oldBinding.attr
 		};
 	});
-	return (yield* Effect.all(bindings.map(diffBinding))).filter((action) => action !== null);
+	return (yield* Effect.all(bindings.map(diffBinding), { concurrency: "unbounded" })).filter((action) => action !== null);
 });
 const isBindingDiff = Effect.fn(function* ({ target, oldBinding: { binding: oldBinding }, newBinding }) {
 	const oldCap = oldBinding.capability;
@@ -14694,7 +14693,7 @@ const expandAndPivot = Effect.fnUntraced(function* (plan$1, session) {
 			};
 		}
 		return oldBindingOutput;
-	})));
+	})), { concurrency: "unbounded" });
 	const apply = (node) => Effect.gen(function* () {
 		const commit = (value) => state.set({
 			stack: app$1.name,
@@ -14720,7 +14719,7 @@ const expandAndPivot = Effect.fnUntraced(function* (plan$1, session) {
 				status
 			});
 			if (node.action === "noop") return node.state.attr;
-			const upstream$1 = Object.fromEntries(yield* Effect.all(Object.entries(resolveUpstream(node.props)).map(([id$1]) => resolveUpstream$1(id$1).pipe(Effect.map(({ upstreamAttr }) => [id$1, upstreamAttr])))));
+			const upstream$1 = Object.fromEntries(yield* Effect.all(Object.entries(resolveUpstream(node.props)).map(([id$1]) => resolveUpstream$1(id$1).pipe(Effect.map(({ upstreamAttr }) => [id$1, upstreamAttr]))), { concurrency: "unbounded" }));
 			const instanceId = yield* Effect.gen(function* () {
 				if (node.action === "create" && !node.state?.instanceId) {
 					const instanceId$1 = yield* generateInstanceId();
@@ -14827,7 +14826,7 @@ const expandAndPivot = Effect.fnUntraced(function* (plan$1, session) {
 					yield* report("created");
 					return attr;
 				} else if (node.action === "update") {
-					const upstream$2 = Object.fromEntries(yield* Effect.all(Object.entries(resolveUpstream(node.props)).map(([id$1]) => resolveUpstream$1(id$1).pipe(Effect.map(({ upstreamAttr }) => [id$1, upstreamAttr])))));
+					const upstream$2 = Object.fromEntries(yield* Effect.all(Object.entries(resolveUpstream(node.props)).map(([id$1]) => resolveUpstream$1(id$1).pipe(Effect.map(({ upstreamAttr }) => [id$1, upstreamAttr]))), { concurrency: "unbounded" }));
 					const news = yield* evaluate(node.props, upstream$2);
 					const checkpoint = (attr$1) => {
 						if (node.state.status === "replaced") return commit({
@@ -14918,7 +14917,7 @@ const expandAndPivot = Effect.fnUntraced(function* (plan$1, session) {
 						downstream: node.downstream
 					});
 					else state$1 = node.state;
-					const upstream$2 = Object.fromEntries(yield* Effect.all(Object.entries(resolveUpstream(node.props)).map(([id$1]) => resolveUpstream$1(id$1).pipe(Effect.map(({ upstreamAttr }) => [id$1, upstreamAttr])))));
+					const upstream$2 = Object.fromEntries(yield* Effect.all(Object.entries(resolveUpstream(node.props)).map(([id$1]) => resolveUpstream$1(id$1).pipe(Effect.map(({ upstreamAttr }) => [id$1, upstreamAttr]))), { concurrency: "unbounded" }));
 					const news = yield* evaluate(node.props, upstream$2);
 					const checkpoint = ({ status, attr: attr$1, bindings }) => commit({
 						status,
@@ -14997,7 +14996,7 @@ const expandAndPivot = Effect.fnUntraced(function* (plan$1, session) {
 	});
 	return Object.fromEntries(yield* Effect.all(Object.entries(plan$1.resources).map(Effect.fn(function* ([id, node]) {
 		return [id, yield* apply(node)];
-	}))));
+	})), { concurrency: "unbounded" }));
 });
 const collectGarbage = Effect.fnUntraced(function* (plan$1, session) {
 	const state = yield* State;
@@ -15051,7 +15050,7 @@ const collectGarbage = Effect.fnUntraced(function* (plan$1, session) {
 			})
 		};
 		return yield* deletions[logicalId] ??= yield* Effect.cached(Effect.gen(function* () {
-			yield* Effect.all(downstream.map((dep) => dep in deletionGraph ? deleteResource(deletionGraph[dep]) : Effect.void));
+			yield* Effect.all(downstream.map((dep) => dep in deletionGraph ? deleteResource(deletionGraph[dep]) : Effect.void), { concurrency: "unbounded" });
 			yield* report("deleting");
 			if (isDeleteNode(node)) yield* commit({
 				status: "deleting",
@@ -15064,7 +15063,7 @@ const collectGarbage = Effect.fnUntraced(function* (plan$1, session) {
 				providerVersion: provider.version ?? 0,
 				bindings: node.bindings
 			});
-			yield* provider.delete({
+			if (attr !== void 0) yield* provider.delete({
 				id: logicalId,
 				instanceId,
 				olds: props,
@@ -15095,7 +15094,7 @@ const collectGarbage = Effect.fnUntraced(function* (plan$1, session) {
 			}
 		}).pipe(Effect.provide(Layer.succeed(InstanceId, instanceId))));
 	});
-	yield* Effect.all(Object.values(deletionGraph).filter((node) => node !== void 0).map(deleteResource));
+	yield* Effect.all(Object.values(deletionGraph).filter((node) => node !== void 0).map(deleteResource), { concurrency: "unbounded" });
 });
 
 //#endregion