sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ AWS/ Pipes/ PipeDelivery.test.ts

import * as AWS from "@alchemy.run/aws";
import { describe, expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as SQS from "@distilled.cloud/aws/sqs";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as HttpClient from "effect/http/HttpClient";
import * as Schedule from "effect/Schedule";
import PipeTargetFunctionLive, { PipeTargetFunction } from "./pipe-handler.ts";

const { test } = Test.make({ providers: AWS.providers() });

describe.sequential(
  "AWS.Pipes delivery",
  {
    tags: ["provider:aws", "provider:aws:lambda", "provider:aws:pipes", "provider:aws:sqs", "live"],
  },
  () => {
    test.provider(
      "delivers SQS messages through a pipe to the Lambda target",
      (stack) =>
        Effect.gen(function* () {
          yield* stack.destroy();

          const fn = yield* stack.deploy(
            PipeTargetFunction.pipe(Effect.provide(PipeTargetFunctionLive)),
          );

          const functionUrl = fn.functionUrl!;

          // First request rides out cold-start / URL propagation; keep polling
          // until the fixture reports both queue identifiers.
          const { sourceQueueUrl, sinkQueueUrl } = yield* HttpClient.get(functionUrl).pipe(
            Effect.flatMap((response) =>
              response.status === 200
                ? (response.json as Effect.Effect<{
                    sourceQueueUrl?: string;
                    sinkQueueUrl?: string;
                  }>)
                : Effect.fail(new FunctionNotReady(`Function not ready: ${response.status}`)),
            ),
            Effect.flatMap((body) =>
              body.sourceQueueUrl && body.sinkQueueUrl
                ? Effect.succeed(body as { sourceQueueUrl: string; sinkQueueUrl: string })
                : Effect.fail(new FunctionNotReady("Function returned empty queue identifiers")),
            ),
            Effect.retry({
              schedule: Schedule.max([Schedule.fixed("1 seconds"), Schedule.recurs(45)]),
            }),
          );

          // The Pipe provider waits for RUNNING inside reconcile, so the pipe
          // is already active. Send a message to the source queue out-of-band;
          // the pipe delivers it to the Lambda target, whose listener forwards
          // the body into the sink queue.
          const messageBody = `pipe-delivery-${crypto.randomUUID()}`;
          yield* SQS.sendMessage({ QueueUrl: sourceQueueUrl, MessageBody: messageBody });

          // Poll the sink queue until the forwarded body shows up. Nine 8s
          // long polls with 500ms spacing give delivery a bounded ~76s budget
          // without spending half the time asleep between polls.
          const received = yield* Effect.gen(function* () {
            const result = yield* SQS.receiveMessage({
              QueueUrl: sinkQueueUrl,
              MaxNumberOfMessages: 10,
              WaitTimeSeconds: 8,
            });
            const match = (result.Messages ?? []).find((message) => message.Body === messageBody);
            if (!match?.ReceiptHandle) {
              return yield* Effect.fail(new MessageNotDelivered());
            }
            yield* SQS.deleteMessage({
              QueueUrl: sinkQueueUrl,
              ReceiptHandle: match.ReceiptHandle,
            });
            return match.Body!;
          }).pipe(
            Effect.retry({
              while: (error) => error._tag === "MessageNotDelivered",
              schedule: Schedule.max([Schedule.spaced("500 millis"), Schedule.recurs(8)]),
            }),
          );

          expect(received).toEqual(messageBody);

          yield* stack.destroy();
        }),
      { timeout: 240_000 },
    );
  },
);

class MessageNotDelivered extends Data.TaggedError("MessageNotDelivered") {}

class FunctionNotReady extends Data.TaggedError("FunctionNotReady")<{ message: string }> {
  constructor(message: string) {
    super({ message });
  }
}