alchemy-effect 0.1.0 → 0.2.0

package/src/aws/sqs/queue.event-source.ts

@@ -0,0 +1,253 @@
+import { Binding, type From } from "alchemy-effect";
+import * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+import type * as Lambda from "itty-aws/lambda";
+import { createTagger, hasTags } from "../../tags.ts";
+import { Account } from "../account.ts";
+import {
+  Function,
+  LambdaClient,
+  type FunctionBinding,
+} from "../lambda/index.ts";
+import { Region } from "../region.ts";
+import type { Consume } from "./queue.consume.ts";
+import { Queue, type QueueAttrs, type QueueProps } from "./queue.ts";
+
+export interface QueueEventSourceProps {
+  batchSize?: number;
+  maxBatchingWindow?: number;
+  scalingConfig?: Lambda.ScalingConfig;
+}
+
+export interface QueueEventSourceAttr extends FunctionBinding {
+  uuid: string;
+}
+
+export interface QueueEventSource<
+  Q extends Queue,
+  Props extends QueueEventSourceProps,
+> extends Binding<
+    Function,
+    Consume<From<Q>>,
+    Props,
+    QueueEventSourceAttr,
+    "QueueEventSource"
+  > {}
+
+export const QueueEventSource = Binding<
+  <Q extends Queue, const Props extends QueueEventSourceProps>(
+    queue: Q,
+    props?: Props,
+  ) => QueueEventSource<Q, Props>
+>(Function, "AWS.SQS.Consume", "QueueEventSource");
+
+export const queueEventSourceProvider = () =>
+  QueueEventSource.provider.effect(
+    // @ts-expect-error
+    Effect.gen(function* () {
+      const region = yield* Region;
+      const accountId = yield* Account;
+      const lambda = yield* LambdaClient;
+      const tagged = yield* createTagger();
+
+      const findEventSourceMapping: (
+        queue: {
+          id: string;
+          attr: QueueAttrs<QueueProps<any>>;
+          props: QueueProps<any>;
+        },
+        functionName: string,
+        marker?: string,
+      ) => Effect.Effect<Lambda.EventSourceMappingConfiguration | undefined> =
+        Effect.fn(function* (queue, functionName, marker) {
+          const retry = Effect.retry({
+            while: (
+              e:
+                | Lambda.InvalidParameterValueException
+                | Lambda.ResourceNotFoundException
+                | Lambda.ServiceException
+                | Lambda.TooManyRequestsException
+                | Lambda.CommonAwsError
+                | any,
+            ) =>
+              // TODO(sam): figure out how to write a function that generalizes this or upstream into itty-aws
+              e._tag === "InternalFailure" ||
+              e._tag === "RequestExpired" ||
+              e._tag === "ServiceException" ||
+              e._tag === "ServiceUnavailable" ||
+              e._tag === "ThrottlingException" ||
+              e._tag === "TooManyRequestsException",
+            schedule: Schedule.exponential(100),
+          });
+
+          // TODO(sam): return an accepted error
+          // const orDie = Effect.catchAll((e) => Effect.die(e));
+
+          const mappings = yield* lambda
+            .listEventSourceMappings({
+              FunctionName: functionName,
+              Marker: marker,
+            })
+            .pipe(retry, Effect.orDie);
+          const mapping = mappings.EventSourceMappings?.find(
+            (mapping) => mapping.EventSourceArn === queue.attr.queueArn,
+          );
+          if (mapping?.EventSourceArn) {
+            const { Tags } = yield* lambda
+              .listTags({
+                Resource: `arn:aws:lambda:${region}:${accountId}:event-source-mapping:${mapping.UUID!}`,
+              })
+              .pipe(retry, Effect.orDie);
+            if (hasTags(tagged(queue.id), Tags)) {
+              return mapping;
+            }
+            return undefined;
+          }
+          if (mappings.NextMarker) {
+            return yield* findEventSourceMapping(
+              queue,
+              functionName,
+              mappings.NextMarker,
+            );
+          }
+          return undefined;
+        });
+
+      const createFunctionBinding = (queue: {
+        attr: { queueArn: string };
+      }) => ({
+        // we need the policies to be present before the event source mapping is created
+        policyStatements: [
+          {
+            Sid: "AWS.SQS.Consume",
+            Effect: "Allow" as const,
+            Action: [
+              "sqs:ReceiveMessage",
+              "sqs:DeleteMessage",
+              "sqs:ChangeMessageVisibility",
+            ],
+            Resource: [queue.attr.queueArn],
+          },
+        ],
+      });
+
+      return {
+        attach: ({ source: queue }) => {
+          console.log("attaching queue event source", queue.id);
+          return {
+            // we need the policies to be present before the event source mapping is created
+            policyStatements: [
+              {
+                Sid: "AWS.SQS.Consume",
+                Effect: "Allow" as const,
+                Action: [
+                  "sqs:ReceiveMessage",
+                  "sqs:DeleteMessage",
+                  "sqs:ChangeMessageVisibility",
+                  "sqs:GetQueueAttributes",
+                  "sqs:GetQueueUrl",
+                ],
+                Resource: [queue.attr.queueArn],
+              },
+            ],
+          };
+        },
+        postattach: Effect.fn(function* ({
+          source: queue,
+          props: { batchSize, maxBatchingWindow, scalingConfig } = {},
+          attr,
+          target: {
+            attr: { functionName },
+          },
+        }) {
+          console.log(
+            "postattaching queue event source",
+            queue.id,
+            functionName,
+          );
+          const config:
+            | Lambda.CreateEventSourceMappingRequest
+            | Lambda.UpdateEventSourceMappingRequest = {
+            FunctionName: functionName,
+            EventSourceArn: queue.attr.queueArn,
+            BatchSize: batchSize,
+            MaximumBatchingWindowInSeconds: maxBatchingWindow,
+            ScalingConfig: scalingConfig,
+            Enabled: true,
+            FunctionResponseTypes: ["ReportBatchItemFailures"],
+            // https://docs.aws.amazon.com/lambda/latest/dg/monitoring-metrics-types.html#event-source-mapping-metrics
+            MetricsConfig: { Metrics: ["EventCount"] },
+            // KMSKeyArn: (encrypted FilterCriteria)
+
+            // See: https://docs.aws.amazon.com/lambda/latest/dg/invocation-eventfiltering.html
+            // FilterCriteria: {
+            //   Filters: [{Pattern: ""}]
+            // }
+            Tags: tagged(queue.id),
+          };
+
+          const findOrDie = findEventSourceMapping(queue, functionName).pipe(
+            Effect.flatMap((mapping) =>
+              mapping
+                ? Effect.succeed(mapping)
+                : Effect.die(
+                    // how the fuck did we get here?
+                    new Error(
+                      `QueueEventSource(${queue.id}) not found on function ${functionName}`,
+                    ),
+                  ),
+            ),
+          );
+
+          const eventSourceMapping = yield* (
+            attr?.uuid
+              ? lambda.updateEventSourceMapping({
+                  ...config,
+                  UUID: attr.uuid,
+                })
+              : lambda.createEventSourceMapping(config)
+          ).pipe(
+            Effect.catchTags({
+              ResourceConflictException: () => findOrDie,
+              ResourceNotFoundException: () => findOrDie,
+            }),
+            Effect.retry({
+              // It takes a few seconds for the IAM policy to propagate, so retry the following error
+              while: (e) =>
+                e.name === "InvalidParameterValueException" &&
+                e.message?.includes(
+                  "The function execution role does not have permissions to call",
+                ),
+              schedule: Schedule.exponential(100),
+            }),
+          );
+          return {
+            ...attr,
+            uuid: eventSourceMapping.UUID,
+          };
+        }),
+        detach: Effect.fn(function* ({
+          source: queue,
+          target: {
+            attr: { functionName },
+          },
+          attr,
+        }) {
+          const uuid =
+            attr?.uuid ??
+            (yield* findEventSourceMapping(queue, functionName))?.UUID!;
+          if (uuid) {
+            // we found (or were aware of) the event source mapping, so we can delete it
+            yield* (
+              lambda
+                .deleteEventSourceMapping({
+                  UUID: uuid,
+                })
+                // TODO(sam): handle errors properly
+                .pipe(Effect.catchAll(() => Effect.void))
+            );
+          }
+        }),
+      };
+    }),
+  );

package/src/aws/sqs/queue.provider.ts

@@ -2,18 +2,18 @@ import * as Effect from "effect/Effect";
 import * as Schedule from "effect/Schedule";
 
 import { App, type ProviderService } from "alchemy-effect";
-import { AccountID } from "../account.ts";
+import { Account } from "../account.ts";
 import { Region } from "../region.ts";
-import { QueueClient } from "./queue.client.ts";
+import { SQSClient } from "./client.ts";
 import { Queue, type QueueProps } from "./queue.ts";
 
 export const queueProvider = () =>
   Queue.provider.effect(
     Effect.gen(function* () {
-      const sqs = yield* QueueClient;
+      const sqs = yield* SQSClient;
       const app = yield* App;
       const region = yield* Region;
-      const accountId = yield* AccountID;
+      const accountId = yield* Account;
       const createQueueName = (id: string, props: QueueProps) =>
         props.queueName ??
         `${app.name}-${id}-${app.stage}${props.fifo ? ".fifo" : ""}`;

package/src/aws/sqs/queue.send-message.ts

@@ -8,7 +8,7 @@ import {
   type To,
 } from "alchemy-effect";
 import { Function } from "../lambda/index.ts";
-import { QueueClient } from "./queue.client.ts";
+import { SQSClient } from "./client.ts";
 import { Queue } from "./queue.ts";
 
 export interface SendMessage<Q = Queue>
@@ -24,7 +24,7 @@ export const sendMessage = <Q extends Queue>(
 ) =>
   Effect.gen(function* () {
     yield* declare<SendMessage<To<Q>>>();
-    const sqs = yield* QueueClient;
+    const sqs = yield* SQSClient;
     const url = process.env[toEnvKey(queue.id, "QUEUE_URL")]!;
     return yield* sqs.sendMessage({
       QueueUrl: url,

package/src/binding.ts

@@ -2,6 +2,7 @@ import * as Context from "effect/Context";
 import type { Effect } from "effect/Effect";
 import * as Layer from "effect/Layer";
 import type { Capability, ICapability } from "./capability.ts";
+import type { Diff } from "./provider.ts";
 import type { Resource } from "./resource.ts";
 import type { Runtime } from "./runtime.ts";
 
@@ -16,14 +17,16 @@ export type AnyBinding<F extends Runtime = any> = Binding<
   F,
   any,
   any,
+  any,
   string,
   boolean
 >;
 
 export interface Binding<
-  Run extends Runtime,
+  Run extends Runtime<any, any, any>,
   Cap extends Capability = Capability,
   Props = any,
+  Attr extends Run["binding"] = any,
   Tag extends string = Cap["type"],
   IsCustom extends boolean = Cap["type"] extends Tag ? false : true,
 > {
@@ -31,6 +34,7 @@ export interface Binding<
   capability: Cap;
   tag: Tag;
   props: Props;
+  attr: Attr;
   isCustom: IsCustom;
 }
 
@@ -81,7 +85,7 @@ export const Binding: {
         tag: tag ?? cap,
         // @ts-expect-error - we smuggle this property because it interacts poorly with inference
         Tag,
-      }) satisfies Binding<any, any, any, string, false>,
+      }) satisfies Binding<any, any, any, any, string, false>,
     {
       provider: {
         effect: (eff) => Layer.effect(Tag, eff),
@@ -100,45 +104,137 @@ export interface BindingDeclaration<
   provider: {
     effect<Err, Req>(
       eff: Effect<
-        BindingService<Run, Parameters<F>[0], Parameters<F>[1]>,
+        BindingService<
+          Run,
+          Parameters<F>[0],
+          Parameters<F>[1],
+          ReturnType<F>["attr"]
+        >,
         Err,
         Req
       >,
     ): Layer.Layer<Bind<Run, Cap, Tag>, Err, Req>;
     succeed(
-      service: BindingService<Run, Parameters<F>[0], Parameters<F>[1]>,
+      service: BindingService<
+        Run,
+        Parameters<F>[0],
+        Parameters<F>[1],
+        ReturnType<F>["attr"]
+      >,
     ): Layer.Layer<Bind<Run, Cap, Tag>>;
   };
 }
 
+export interface BindingDiffProps<
+  Source extends Resource = Resource,
+  Target extends Resource = Resource,
+  Props = any,
+  Attr = any,
+> {
+  source: {
+    id: string;
+    props: Source["props"];
+    oldProps?: Source["props"];
+    oldAttr?: Source["attr"];
+  };
+  props: Props;
+  attr: Attr | undefined;
+  target: {
+    id: string;
+    props: Target["props"];
+    oldProps?: Target["props"];
+    oldAttr?: Target["attr"];
+  };
+}
+
+export interface BindingAttachProps<
+  Source extends Resource,
+  Target extends Resource,
+  Props,
+  Attr,
+> {
+  source: {
+    id: string;
+    attr: Source["attr"];
+    props: Source["props"];
+  };
+  props: Props;
+  attr: Attr | undefined;
+  target: {
+    id: string;
+    props: Target["props"];
+    attr: Target["attr"];
+  };
+}
+
+export interface BindingReattachProps<
+  Source extends Resource,
+  Target extends Resource,
+  Props,
+  Attr,
+> {
+  source: {
+    id: string;
+    attr: Source["attr"];
+    props: Source["props"];
+  };
+  props: Props;
+  attr: Attr;
+  target: {
+    id: string;
+    props: Target["props"];
+    attr: Target["attr"];
+  };
+}
+
+export interface BindingDetachProps<
+  Source extends Resource,
+  Target extends Resource,
+  Props,
+  Attr,
+> {
+  source: {
+    id: string;
+    attr: Source["attr"];
+    props: Source["props"];
+  };
+  props: Props;
+  attr: Attr | undefined;
+  target: {
+    id: string;
+    props: Target["props"];
+    attr: Target["attr"];
+  };
+}
+
 export type BindingService<
   Target extends Runtime = any,
   Source extends Resource = Resource,
   Props = any,
+  Attr extends Target["binding"] = any,
+  DiffReq = never,
+  PreReattachReq = never,
   AttachReq = never,
+  ReattachReq = never,
   DetachReq = never,
+  PostAttachReq = never,
 > = {
-  attach: (props: {
-    source: {
-      id: string;
-      attr: Source["attr"];
-      props: Source["props"];
-    };
-    props: Props;
-    target: {
-      id: string;
-      props: Target["props"];
-      attr: Target["attr"];
-    };
-  }) =>
-    | Effect<Partial<Target["binding"]> | void, never, AttachReq>
-    | Partial<Target["binding"]>;
+  diff?: (
+    props: BindingDiffProps<Source, Target, Props>,
+  ) => Effect<Diff, never, DiffReq>;
+  preattach?: (
+    props: BindingAttachProps<Source, Target, Props, Attr>,
+  ) => Effect<Partial<Target["attr"]>, never, PreReattachReq>;
+  attach: (
+    props: BindingAttachProps<Source, Target, Props, Attr>,
+  ) => Effect<Attr, never, AttachReq> | Attr;
+  postattach?: (
+    props: BindingAttachProps<Source, Target, Props, Attr>,
+  ) => Effect<Omit<Attr, keyof Target["binding"]>, never, PostAttachReq>;
+  reattach?: (
+    props: BindingReattachProps<Source, Target, Props, Attr>,
+  ) => Effect<Attr, never, ReattachReq> | Attr;
   detach?: (
-    resource: {
-      id: string;
-      attr: Source["attr"];
-      props: Source["props"];
-    },
-    from: Target["binding"],
+    props: BindingDetachProps<Source, Target, Props, Attr>,
   ) => Effect<void, never, DetachReq> | void;
 };

package/src/capability.ts

@@ -1,3 +1,5 @@
+import type { Policy } from "./policy";
+
 export interface ICapability<
   Type extends string = string,
   Resource = unknown,
@@ -17,3 +19,45 @@ export interface Capability<
 > extends ICapability<Type, Resource, Constraint> {
   new (): {};
 }
+
+export declare namespace Capability {
+  export type Simplify<C> = [C] extends [
+    {
+      Constructor: { Reduce: any };
+    },
+  ]
+    ? _Simplify<C>
+    : C;
+
+  type _Simplify<C> = [C] extends [
+    infer c extends { Constructor: any; resource: any; constraint: any },
+  ]
+    ? (c["Constructor"] & {
+        resource: c["resource"];
+        constraint: Constraint.Simplify<c["constraint"]>;
+      })["Reduce"]
+    : never;
+
+  type KeysWithNever<T> = {
+    [K in keyof T]: T[K] extends never | Policy.AnyOf<never> ? K : never;
+  }[keyof T];
+  type DropIrrelevant<T> = T extends any
+    ? {
+        [k in keyof Omit<T, KeysWithNever<T>>]: Omit<T, KeysWithNever<T>>[k];
+      }
+    : never;
+  type Get<T, K extends string | number | symbol> = T extends {
+    [k in K]: infer V;
+  }
+    ? V
+    : never;
+  type Keys<T> = T extends any ? keyof T : never;
+  type BoxPolicy<T> = [T] extends [{ anyOf: (infer U)[] }]
+    ? Policy.AnyOf<U>
+    : never;
+  export namespace Constraint {
+    export type Simplify<Constraint> = {
+      [k in Keys<DropIrrelevant<Constraint>>]: BoxPolicy<Get<Constraint, k>>;
+    };
+  }
+}

package/src/cli/components/Plan.tsx

@@ -1,7 +1,7 @@
 // biome-ignore lint/style/useImportType: UMD global
 import React, { useMemo } from "react";
 
-import type { BindNode, CRUD, Plan } from "alchemy-effect";
+import type { BindNode, Capability, CRUD, Plan } from "alchemy-effect";
 import { Box, Text } from "ink";
 
 export interface PlanProps {
@@ -93,7 +93,7 @@ export function Plan({ plan }: PlanProps): React.JSX.Element {
                   const bindingIcon = bindingActionIcon(node.action);
                   return (
                     <Box
-                      key={node.binding.capability.resource.id}
+                      key={`${item.resource.id}${(node.binding.capability as Capability).sid}`}
                       flexDirection="row"
                     >
                       <Box width={4}>
@@ -142,6 +142,7 @@ const bindingActionColor = (
     attach: "green",
     detach: "red",
     noop: "gray",
+    reattach: "orange",
   })[action];
 
 const bindingActionIcon = (action: BindNode["action"]): string =>
@@ -149,4 +150,5 @@ const bindingActionIcon = (action: BindNode["action"]): string =>
     attach: "+",
     detach: "-",
     noop: "•",
+    reattach: "~",
   })[action];

package/src/cli/progress.tsx

@@ -16,6 +16,7 @@ export interface ProgressEventSource {
 export const reportProgress = Layer.succeed(
   Alchemy.PlanStatusReporter,
   Alchemy.PlanStatusReporter.of({
+    // oxlint-disable-next-line require-yield
     start: Effect.fn(function* (plan) {
       const listeners = new Set<(event: Alchemy.ApplyEvent) => void>();
       const { unmount } = render(