alchemy-effect 0.0.0 → 0.2.0

package/src/aws/lambda/serve.ts

@@ -0,0 +1,29 @@
+import * as Effect from "effect/Effect";
+import * as Lambda from "./function.ts";
+
+import type {
+  LambdaFunctionURLEvent as FunctionURLEvent,
+  LambdaFunctionURLResult as FunctionURLResult,
+} from "aws-lambda";
+export type {
+  LambdaFunctionURLEvent as FunctionURLEvent,
+  LambdaFunctionURLResult as FunctionURLResult,
+} from "aws-lambda";
+
+export const serve =
+  <const ID extends string, Req>(
+    id: ID,
+    {
+      fetch,
+    }: {
+      fetch: (
+        event: FunctionURLEvent,
+        context: Lambda.Context,
+      ) => Effect.Effect<FunctionURLResult, never, Req>;
+    },
+  ) =>
+  <const Props extends Lambda.FunctionProps.Simplified<Req>>(props: Props) =>
+    Lambda.Function(id, { handle: fetch })({
+      ...props,
+      url: true,
+    });

package/src/aws/parse-ini.ts

@@ -0,0 +1,80 @@
+import type { ParsedIniData } from "@smithy/types";
+import { IniSectionType } from "@smithy/types";
+
+const CONFIG_PREFIX_SEPARATOR = ".";
+
+const prefixKeyRegex = /^([\w-]+)\s(["'])?([\w-@\+\.%:/]+)\2$/;
+const profileNameBlockList = ["__proto__", "profile __proto__"];
+
+export const parseIni = (iniData: string): ParsedIniData => {
+  const map: ParsedIniData = {};
+
+  let currentSection: string | undefined;
+  let currentSubSection: string | undefined;
+
+  for (const iniLine of iniData.split(/\r?\n/)) {
+    const trimmedLine = iniLine.split(/(^|\s)[;#]/)[0].trim(); // remove comments and trim
+    const isSection: boolean =
+      trimmedLine[0] === "[" && trimmedLine[trimmedLine.length - 1] === "]";
+    if (isSection) {
+      // New section found. Reset currentSection and currentSubSection.
+      currentSection = undefined;
+      currentSubSection = undefined;
+
+      const sectionName = trimmedLine.substring(1, trimmedLine.length - 1);
+      const matches = prefixKeyRegex.exec(sectionName);
+      if (matches) {
+        const [, prefix, , name] = matches;
+        // Add prefix, if the section name starts with `profile`, `sso-session` or `services`.
+        if (Object.values(IniSectionType).includes(prefix as IniSectionType)) {
+          currentSection = [prefix, name].join(CONFIG_PREFIX_SEPARATOR);
+        }
+      } else {
+        // If the section name does not match the regex, use the section name as is.
+        currentSection = sectionName;
+      }
+
+      if (profileNameBlockList.includes(sectionName)) {
+        throw new Error(`Found invalid profile name "${sectionName}"`);
+      }
+    } else if (currentSection) {
+      const indexOfEqualsSign = trimmedLine.indexOf("=");
+      if (![0, -1].includes(indexOfEqualsSign)) {
+        const [name, value]: [string, string] = [
+          trimmedLine.substring(0, indexOfEqualsSign).trim(),
+          trimmedLine.substring(indexOfEqualsSign + 1).trim(),
+        ];
+        if (value === "") {
+          currentSubSection = name;
+        } else {
+          if (currentSubSection && iniLine.trimStart() === iniLine) {
+            // Reset currentSubSection if there is no whitespace
+            currentSubSection = undefined;
+          }
+          map[currentSection] = map[currentSection] || {};
+          const key = currentSubSection
+            ? [currentSubSection, name].join(CONFIG_PREFIX_SEPARATOR)
+            : name;
+          map[currentSection][key] = value;
+        }
+      }
+    }
+  }
+
+  return map;
+};
+
+export const parseSSOSessionData = (data: ParsedIniData): ParsedIniData =>
+  Object.entries(data)
+    // filter out non sso-session keys
+    .filter(([key]) =>
+      key.startsWith(IniSectionType.SSO_SESSION + CONFIG_PREFIX_SEPARATOR),
+    )
+    // replace sso-session key with sso-session name
+    .reduce(
+      (acc, [key, value]) => ({
+        ...acc,
+        [key.substring(key.indexOf(CONFIG_PREFIX_SEPARATOR) + 1)]: value,
+      }),
+      {},
+    );

package/src/aws/profile.ts

@@ -0,0 +1,6 @@
+import * as Context from "effect/Context";
+
+export class AwsProfile extends Context.Tag("AWS::Profile")<
+  AwsProfile,
+  string
+>() {}

package/src/aws/region.ts

@@ -0,0 +1,37 @@
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+export type RegionID = string;
+
+export class Region extends Context.Tag("AWS::Region")<Region, RegionID>() {}
+
+export const of = (region: string) => Layer.succeed(Region, region);
+
+export const fromEnvOrElse = (region: string) =>
+  Layer.succeed(Region, process.env.AWS_REGION ?? region);
+
+export class EnvironmentVariableNotSet extends Data.TaggedError(
+  "EnvironmentVariableNotSet",
+)<{
+  message: string;
+  variable: string;
+}> {}
+
+export const fromEnv = () =>
+  Layer.effect(
+    Region,
+    Effect.gen(function* () {
+      const region = process.env.AWS_REGION;
+      if (!region) {
+        return yield* Effect.fail(
+          new EnvironmentVariableNotSet({
+            message: "AWS_REGION is not set",
+            variable: "AWS_REGION",
+          }),
+        );
+      }
+      return region;
+    }),
+  );

package/src/aws/s3.ts

@@ -0,0 +1,10 @@
+import * as Context from "effect/Context";
+import { S3 } from "itty-aws/s3";
+import { createAWSServiceClientLayer } from "./client.ts";
+
+export class S3Client extends Context.Tag("AWS::S3::Client")<S3Client, S3>() {}
+
+export const client = createAWSServiceClientLayer<typeof S3Client, S3>(
+  S3Client,
+  S3,
+);

package/src/aws/sqs/client.ts

@@ -0,0 +1,20 @@
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+
+import { SQS } from "itty-aws/sqs";
+import { createAWSServiceClientLayer } from "../client.ts";
+import * as Credentials from "../credentials.ts";
+import * as Region from "../region.ts";
+
+export class SQSClient extends Context.Tag("AWS.SQS.Client")<
+  SQSClient,
+  SQS
+>() {}
+
+export const client = createAWSServiceClientLayer<typeof SQSClient, SQS>(
+  SQSClient,
+  SQS,
+);
+
+export const clientFromEnv = () =>
+  Layer.provide(client(), Layer.merge(Credentials.fromEnv(), Region.fromEnv()));

package/src/aws/sqs/index.ts

@@ -0,0 +1,6 @@
+export * from "./client.ts";
+export * from "./queue.consume.ts";
+export * from "./queue.event-source.ts";
+export * from "./queue.provider.ts";
+export * from "./queue.send-message.ts";
+export * from "./queue.ts";

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

@@ -0,0 +1,13 @@
+import { type Capability } from "alchemy-effect";
+import type * as lambda from "aws-lambda";
+import { Queue } from "./queue.ts";
+
+export type QueueRecord<Data> = Omit<lambda.SQSRecord, "body"> & {
+  body: Data;
+};
+
+export type QueueEvent<Data> = Omit<lambda.SQSEvent, "Records"> & {
+  Records: QueueRecord<Data>[];
+};
+
+export interface Consume<Q = Queue> extends Capability<"AWS.SQS.Consume", Q> {}

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

@@ -0,0 +1,94 @@
+import * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+
+import { App, type ProviderService } from "alchemy-effect";
+import { Account } from "../account.ts";
+import { Region } from "../region.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* SQSClient;
+      const app = yield* App;
+      const region = yield* Region;
+      const accountId = yield* Account;
+      const createQueueName = (id: string, props: QueueProps) =>
+        props.queueName ??
+        `${app.name}-${id}-${app.stage}${props.fifo ? ".fifo" : ""}`;
+      const createAttributes = (props: QueueProps) => ({
+        FifoQueue: props.fifo ? "true" : "false",
+        FifoThroughputLimit: props.fifoThroughputLimit,
+        ContentBasedDeduplication: props.contentBasedDeduplication
+          ? "true"
+          : "false",
+        DeduplicationScope: props.deduplicationScope,
+        DelaySeconds: props.delaySeconds?.toString(),
+        MaximumMessageSize: props.maximumMessageSize?.toString(),
+        MessageRetentionPeriod: props.messageRetentionPeriod?.toString(),
+        ReceiveMessageWaitTimeSeconds:
+          props.receiveMessageWaitTimeSeconds?.toString(),
+        VisibilityTimeout: props.visibilityTimeout?.toString(),
+      });
+      return {
+        diff: Effect.fn(function* ({ id, news, olds }) {
+          const oldFifo = olds.fifo ?? false;
+          const newFifo = news.fifo ?? false;
+          if (oldFifo !== newFifo) {
+            return { action: "replace" } as const;
+          }
+          const oldQueueName = createQueueName(id, olds);
+          const newQueueName = createQueueName(id, news);
+          if (oldQueueName !== newQueueName) {
+            return { action: "replace" } as const;
+          }
+          return { action: "noop" } as const;
+        }),
+        create: Effect.fn(function* ({ id, news, session }) {
+          const queueName = createQueueName(id, news);
+          const response = yield* sqs
+            .createQueue({
+              QueueName: queueName,
+              Attributes: createAttributes(news),
+            })
+            .pipe(
+              Effect.retry({
+                while: (e) => e.name === "QueueDeletedRecently",
+                schedule: Schedule.fixed(1000).pipe(
+                  Schedule.tapOutput((i) =>
+                    session.note(
+                      `Queue was deleted recently, retrying... ${i + 1}s`,
+                    ),
+                  ),
+                ),
+              }),
+            );
+          const queueArn =
+            `arn:aws:sqs:${region}:${accountId}:${queueName}` as const;
+          const queueUrl = response.QueueUrl!;
+          yield* session.note(queueUrl);
+          return {
+            queueName,
+            queueUrl,
+            queueArn: queueArn,
+          };
+        }),
+        update: Effect.fn(function* ({ news, output, session }) {
+          yield* sqs.setQueueAttributes({
+            QueueUrl: output.queueUrl,
+            Attributes: createAttributes(news),
+          });
+          yield* session.note(output.queueUrl);
+          return output;
+        }),
+        delete: Effect.fn(function* (input) {
+          yield* sqs
+            .deleteQueue({
+              QueueUrl: input.output.queueUrl,
+            })
+            .pipe(Effect.catchTag("QueueDoesNotExist", () => Effect.void));
+        }),
+      } satisfies ProviderService<Queue>;
+    }),
+  );

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

@@ -0,0 +1,51 @@
+import * as Effect from "effect/Effect";
+
+import {
+  Binding,
+  declare,
+  toEnvKey,
+  type Capability,
+  type To,
+} from "alchemy-effect";
+import { Function } from "../lambda/index.ts";
+import { SQSClient } from "./client.ts";
+import { Queue } from "./queue.ts";
+
+export interface SendMessage<Q = Queue>
+  extends Capability<"AWS.SQS.SendMessage", Q> {}
+
+export const SendMessage = Binding<
+  <Q extends Queue>(queue: Q) => Binding<Function, SendMessage<To<Q>>>
+>(Function, "AWS.SQS.SendMessage");
+
+export const sendMessage = <Q extends Queue>(
+  queue: Q,
+  message: Q["props"]["schema"]["Type"],
+) =>
+  Effect.gen(function* () {
+    yield* declare<SendMessage<To<Q>>>();
+    const sqs = yield* SQSClient;
+    const url = process.env[toEnvKey(queue.id, "QUEUE_URL")]!;
+    return yield* sqs.sendMessage({
+      QueueUrl: url,
+      MessageBody: JSON.stringify(message),
+    });
+  });
+
+export const sendMessageFromLambdaFunction = () =>
+  SendMessage.provider.succeed({
+    attach: ({ source: queue }) => ({
+      env: {
+        // ask what attribute is needed to interact? e.g. is it the Queue ARN or the Queue URL?
+        [toEnvKey(queue.id, "QUEUE_URL")]: queue.attr.queueUrl,
+      },
+      policyStatements: [
+        {
+          Sid: "SendMessage",
+          Effect: "Allow",
+          Action: ["sqs:SendMessage"], // <- ask LLM how to generate this
+          Resource: [queue.attr.queueArn],
+        },
+      ],
+    }),
+  });