feat: include Phase in the Plan and properly type the output of Apply

Author: sam-goodwin

@alchemy.run/effect-aws/src/lambda/function.provider.ts

@@ -5,13 +5,7 @@ import { FileSystem } from "@effect/platform";
 import * as Effect from "effect/Effect";
 import * as Schedule from "effect/Schedule";
 
-import {
-  App,
-  DotAlchemy,
-  type BindingService,
-  type BindNode,
-  type ProviderService,
-} from "@alchemy.run/effect";
+import { App, DotAlchemy, type ProviderService } from "@alchemy.run/effect";
 
 import type {
   CreateFunctionUrlConfigRequest,
@@ -47,50 +41,26 @@ export const functionProvider = () =>
       const attachBindings = Effect.fn(function* ({
         roleName,
         policyName,
-        functionArn,
-        functionName,
+        // functionArn,
+        // functionName,
         bindings,
       }: {
         roleName: string;
         policyName: string;
         functionArn: string;
         functionName: string;
-        bindings: BindNode[];
+        bindings: Function["binding"][];
       }) {
-        let env: Record<string, string> = {};
-        const policyStatements: IAM.PolicyStatement[] = [];
-
-        for (const binding of bindings) {
-          if (binding.action === "attach") {
-            const binder = yield* Function(
-              binding.capability,
-              // erase the Lambda(Capability) requirement
-              // TODO(sam): move bindings into the core engine instead of replicating them here
-            ) as unknown as Effect.Effect<BindingService, never, never>;
-            const bound = yield* binder.attach(
-              {
-                id: binding.capability.resource.id,
-                attr: binding.attributes,
-                props: binding.capability.resource.props,
-              },
-              binding.capability,
-              {
-                env,
-                policyStatements,
-              },
-            );
-            env = { ...env, ...(bound?.env ?? {}) };
-
-            policyStatements.push(
-              ...bound?.policyStatements?.map((stmt: IAM.PolicyStatement) => ({
-                ...stmt,
-                Sid: stmt.Sid?.replace(/[^A-Za-z0-9]+/gi, ""),
-              })),
-            );
-          } else if (binding.action === "detach") {
-            // no-op: PutRolePolicy will remove the removed statements
-          }
-        }
+        const env = bindings.reduce(
+          (acc, binding) => ({ ...acc, ...binding?.env }),
+          {},
+        );
+        const policyStatements = bindings.flatMap((binding) =>
+          binding?.policyStatements?.map((stmt: IAM.PolicyStatement) => ({
+            ...stmt,
+            Sid: stmt.Sid?.replace(/[^A-Za-z0-9]+/gi, ""),
+          })),
+        );
 
         if (policyStatements.length > 0) {
           yield* iam.putRolePolicy({

@alchemy.run/effect-aws/src/lambda/function.ts

@@ -25,13 +25,13 @@ export type FunctionAttr<Props extends FunctionProps = FunctionProps> = {
 };
 
 export interface Function extends Runtime<"AWS.Lambda.Function"> {
+  props: FunctionProps;
+  attr: FunctionAttr<Extract<this["props"], FunctionProps>>;
   binding: {
     env: {
       [key: string]: string;
     };
     policyStatements: IAM.PolicyStatement[];
   };
-  props: FunctionProps;
-  attr: FunctionAttr<Extract<this["props"], FunctionProps>>;
 }
 export const Function = Runtime("AWS.Lambda.Function")<Function>();

@alchemy.run/effect-aws/src/sqs/queue.send-message.ts

@@ -34,22 +34,19 @@ export const sendMessage = <Q extends Queue>(
 
 export const sendMessageFromLambdaFunction = () =>
   SendMessage.provider.succeed({
-    // oxlint-disable-next-line require-yield
-    attach: Effect.fn(function* (queue) {
-      return {
-        env: {
-          // ask what attribute is needed to interact? e.g. is it the Queue ARN or the Queue URL?
-          [`${queue.id.toUpperCase().replace(/-/g, "_")}_QUEUE_URL`]:
-            queue.attr.queueUrl,
+    attach: (queue) => ({
+      env: {
+        // ask what attribute is needed to interact? e.g. is it the Queue ARN or the Queue URL?
+        [`${queue.id.toUpperCase().replace(/-/g, "_")}_QUEUE_URL`]:
+          queue.attr.queueUrl,
+      },
+      policyStatements: [
+        {
+          Sid: "SendMessage",
+          Effect: "Allow",
+          Action: ["sqs:SendMessage"], // <- ask LLM how to generate this
+          Resource: [queue.attr.queueArn],
         },
-        policyStatements: [
-          {
-            Sid: "AWS.SQS.SendMessage",
-            Effect: "Allow",
-            Action: ["sqs:SendMessage"], // <- ask LLM how to generate this
-            Resource: [queue.attr.queueArn],
-          },
-        ],
-      };
+      ],
     }),
   });

@alchemy.run/effect-example/alchemy.run.ts

@@ -6,15 +6,18 @@ import { NodeContext } from "@effect/platform-node";
 import * as Effect from "effect/Effect";
 import { Api } from "./src/index.ts";
 
+const phase = process.argv.includes("--destroy") ? "destroy" : "update";
+
 const plan = Alchemy.plan({
-  // phase: process.argv.includes("--destroy") ? "destroy" : "update",
-  phase: "update",
+  phase,
+  // phase: "update",
+  // phase: "destroy",
   services: [Api],
 });
 
 const stack = await plan.pipe(
   Alchemy.apply,
-  Effect.catchTag("PlanRejected", () => Effect.void),
+  Effect.catchTag("PlanRejected", () => Effect.die("Plan rejected")),
   Effect.provide(AlchemyCLI.layer),
   Effect.provide(AWS.live),
   Effect.provide(Alchemy.State.localFs),

@alchemy.run/effect-example/src/api.ts

@@ -5,6 +5,23 @@ import * as Effect from "effect/Effect";
 import * as S from "effect/Schema";
 import { Message, Messages } from "./messages.ts";
 
+const __ = Lambda.serve("Api", {
+  fetch: Effect.fn(function* (event) {
+    const msg = yield* S.validate(Message)(event.body).pipe(
+      Effect.catchAll(Effect.die),
+    );
+    yield* SQS.sendMessage(Messages, msg).pipe(
+      Effect.catchAll(() => Effect.void),
+    );
+    return {
+      body: JSON.stringify(null),
+    };
+  }),
+})({
+  main: import.meta.filename,
+  bindings: $(SQS.SendMessage(Messages)),
+});
+
 export class Api extends Lambda.serve("Api", {
   fetch: Effect.fn(function* (event) {
     const msg = yield* S.validate(Message)(event.body).pipe(

@alchemy.run/effect/src/apply.ts

@@ -32,7 +32,7 @@ export class PlanStatusReporter extends Context.Tag("PlanStatusReporter")<
   }
 >() {}
 
-export const apply = <const P extends Plan, Err, Req>(
+export const apply = <P extends Plan, Err, Req>(
   plan: Effect.Effect<P, Err, Req>,
 ) =>
   plan.pipe(
@@ -66,7 +66,7 @@ export const apply = <const P extends Plan, Err, Req>(
                   const resourceId = isBindNode(node)
                     ? node.binding.capability.resource.id
                     : node.resource.id;
-                  const resource = plan[resourceId];
+                  const resource = plan.resources[resourceId];
                   return !resource
                     ? Effect.dieMessage(`Resource ${resourceId} not found`)
                     : apply(resource);
@@ -165,8 +165,12 @@ export const apply = <const P extends Plan, Err, Req>(
                 } else if (node.action === "delete") {
                   yield* Effect.all(
                     node.downstream.map((dep) =>
-                      dep in plan
-                        ? apply(plan[dep] as P[keyof P])
+                      dep in plan.resources
+                        ? apply(
+                            plan.resources[
+                              dep
+                            ] as P["resources"][keyof P["resources"]],
+                          )
                         : Effect.void,
                     ),
                   );
@@ -228,7 +232,7 @@ export const apply = <const P extends Plan, Err, Req>(
 
         const resources: any = Object.fromEntries(
           yield* Effect.all(
-            Object.entries(plan).map(
+            Object.entries(plan.resources).map(
               Effect.fn(function* ([id, node]) {
                 return [id, yield* apply(node as P[keyof P])];
               }),
@@ -245,17 +249,19 @@ export const apply = <const P extends Plan, Err, Req>(
       }),
     ),
   ) as Effect.Effect<
-    {
-      [id in keyof P]: P[id] extends Delete<Resource> | undefined | never
-        ? never
-        : Simplify<P[id]["resource"]["attr"]>;
-    } extends infer O
-      ? O extends {
-          [key: string]: never;
-        }
-        ? undefined
-        : O
-      : never,
+    "update" extends P["phase"]
+      ?
+          | {
+              [id in keyof P["resources"]]: P["resources"][id] extends
+                | Delete<Resource>
+                | undefined
+                | never
+                ? never
+                : Simplify<P["resources"][id]["resource"]["attr"]>;
+            }
+          // union distribution isn't happening, so we gotta add this additional void here just in case
+          | ("destroy" extends P["phase"] ? void : never)
+      : void,
     Err | PlanRejected,
     Req
   >;