sailfork / t3code-github / .repos/ alchemy-effect/ packages/ aws/ src/ Server/ SQSQueueEventSource.ts

import { ServerHost } from "alchemy/Runtime/Process";
import { toWireSeconds } from "alchemy/Util/Duration";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import { processBatch, traceparentLink } from "../internal/EventSourceBatch.ts";
import * as SQS from "../SQS/index.ts";

export const SQSQueueEventSource = Layer.effect(
  SQS.QueueEventSource,
  Effect.gen(function* () {
    const { run } = yield* ServerHost;

    const ReceiveMessage = yield* SQS.ReceiveMessage;
    const DeleteMessageBatch = yield* SQS.DeleteMessageBatch;

    // Cast below: the service type erases `process`'s requirements, so every
    // event source implementation casts its client.
    return Effect.fn(function* <E = never, Req = never>(
      queue: SQS.Queue,
      props: SQS.MessagesProps,
      process: SQS.QueueMessagesHandler<E, Req>,
    ) {
      const QueueArn = yield* queue.queueArn;

      const receiveMessage = yield* ReceiveMessage(queue);
      const deleteMessageBatch = yield* DeleteMessageBatch(queue);

      yield* run(
        Effect.forever(
          Effect.gen(function* () {
            const queueArn = yield* QueueArn;
            const region = queueArn.split(":")[3]!;
            const result = yield* receiveMessage({
              MaxNumberOfMessages: props.maxNumberOfMessages ?? props.batchSize ?? 10,
              MessageAttributeNames: ["All"],
              MessageSystemAttributeNames: ["All"],
              WaitTimeSeconds:
                toWireSeconds(props.waitTime) ?? toWireSeconds(props.maximumBatchingWindow),
            });

            const messages = result.Messages ?? [];
            if (messages.length === 0) return;

            const records: SQS.SQSRecord[] = messages.map((msg) => ({
              messageId: msg.MessageId!,
              receiptHandle: msg.ReceiptHandle!,
              body: msg.Body!,
              attributes: {
                ApproximateReceiveCount: msg.Attributes?.ApproximateReceiveCount!,
                SentTimestamp: msg.Attributes?.SentTimestamp!,
                SenderId: msg.Attributes?.SenderId!,
                ApproximateFirstReceiveTimestamp: msg.Attributes?.ApproximateFirstReceiveTimestamp!,
                ...(msg.Attributes?.MessageGroupId
                  ? { MessageGroupId: msg.Attributes.MessageGroupId }
                  : {}),
                ...(msg.Attributes?.MessageDeduplicationId
                  ? { MessageDeduplicationId: msg.Attributes.MessageDeduplicationId }
                  : {}),
                ...(msg.Attributes?.SequenceNumber
                  ? { SequenceNumber: msg.Attributes.SequenceNumber }
                  : {}),
                ...(msg.Attributes?.AWSTraceHeader
                  ? { AWSTraceHeader: msg.Attributes.AWSTraceHeader }
                  : {}),
              },
              messageAttributes: Object.fromEntries(
                Object.entries(msg.MessageAttributes ?? {}).map(([name, value]) => [
                  name,
                  {
                    dataType: value?.DataType ?? "String",
                    stringValue: value?.StringValue,
                  },
                ]),
              ),
              md5OfBody: msg.MD5OfBody!,
              eventSource: "aws:sqs",
              eventSourceARN: queueArn,
              awsRegion: region,
            }));

            // Same contract as the Lambda event source: the handler's
            // `batchItemFailures` stay on the queue (visible again after the
            // visibility timeout); a failure leaves the whole batch.
            const response = yield* process({ Records: records }).pipe(
              Effect.map((response) => response ?? { batchItemFailures: [] }),
              processBatch({
                system: "aws_sqs",
                destination: queueArn.split(":")[5]!,
                count: records.length,
                links: records.flatMap((record) =>
                  Option.toArray(
                    traceparentLink(record.messageAttributes.traceparent?.stringValue),
                  ),
                ),
              }),
              Effect.exit,
            );
            if (Exit.isFailure(response)) return;

            const failed = new Set(
              response.value.batchItemFailures.map((failure) => failure.itemIdentifier),
            );
            const succeeded = records.filter((record) => !failed.has(record.messageId));
            if (succeeded.length === 0) return;

            yield* deleteMessageBatch({
              Entries: succeeded.map((record) => ({
                Id: record.messageId,
                ReceiptHandle: record.receiptHandle,
              })),
            });
          }),
        ).pipe(Effect.orDie),
      );
    }) as SQS.QueueEventSourceService;
  }),
);