sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ AWS/ Local/ Actions.local.test.ts

import { fileURLToPath } from "node:url";
import * as AWS from "@alchemy.run/aws";
import { flociServices } from "@alchemy.run/aws/Local/FlociServices";
import { expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as DynamoDB from "@distilled.cloud/aws/dynamodb";
import * as S3 from "@distilled.cloud/aws/s3";
import * as SQS from "@distilled.cloud/aws/sqs";
import * as SSM from "@distilled.cloud/aws/ssm";
import * as Alchemy from "alchemy";
/**
 * Actions under `alchemy dev`: the common shapes a deploy-time binding client
 * takes, each proven to land on the floci emulator rather than the real
 * cloud.
 *
 * In a dev run every dualized resource resolves to its LOCAL provider, so the
 * physical resource exists only on the emulator. An Action body runs at
 * deploy time in the plan process — whose ambient AWS environment is the
 * live `testing` profile — so without per-resource routing its binding
 * clients would miss the emulated resource or mutate the real cloud. #1308
 * routes each client to the bound resource's registered data plane; this
 * suite pins that for the shapes users actually write:
 *
 *   - one Action binding several services (S3 + SQS + DynamoDB) — each
 *     client routed independently;
 *   - an Action's output feeding a downstream resource's props;
 *   - a single-resource binding on a hand-written floci dual
 *     (`InvokeFunction(fn)`) — the case that used to be left UNROUTED and
 *     silently hit the real cloud;
 *   - a multi-resource binding spanning a `flociDual` and a hand-written
 *     dual (`RunTask(cluster, task)`) — the reported "mixed data planes"
 *     failure;
 *   - a binding that genuinely spans modes (`Alchemy.remote()` on one side)
 *     fails at bind time with a per-resource explanation.
 *
 * Out-of-band checks use the distilled SDK under `flociServices()` (the
 * emulator) and, where it matters, the ambient live environment (to prove
 * absence). Requires Docker (floci runs as a container).
 */
import { Action } from "alchemy/Action";
import * as Cause from "effect/Cause";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Layer from "effect/Layer";
import * as Redacted from "effect/Redacted";
import * as Stream from "effect/Stream";
import { liveContext } from "./fixtures/live.ts";

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

const echoHandlerPath = fileURLToPath(new URL("./fixtures/actions/echo.mjs", import.meta.url));

/** The emulator runs task containers on THIS machine. */
const hostRuntimePlatform = {
  cpuArchitecture: process.arch === "arm64" ? ("ARM64" as const) : ("X86_64" as const),
  operatingSystemFamily: "LINUX" as const,
};

/** Collect a streaming SDK body into its decoded text. */
const readBody = (body: Stream.Stream<Uint8Array, Error>) =>
  Stream.runCollect(body).pipe(
    Effect.map((chunks) => new TextDecoder().decode(Buffer.concat([...chunks]))),
  );

test.provider(
  "one Action binding S3, SQS and DynamoDB routes every client to the emulator",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const outputs = yield* stack.deploy(
        Effect.gen(function* () {
          const bucket = yield* AWS.S3.Bucket("ActionsBucket", {
            forceDestroy: true,
          });
          const queue = yield* AWS.SQS.Queue("ActionsQueue");
          const table = yield* AWS.DynamoDB.Table("ActionsTable", {
            partitionKey: "id",
            attributes: { id: "S" },
          });

          // A realistic "ingest" Action: write the object, record it, and
          // enqueue its key — three services behind one body.
          const Ingest = Action(
            "Ingest",
            Effect.gen(function* () {
              const putObject = yield* AWS.S3.PutObject(bucket);
              const getObject = yield* AWS.S3.GetObject(bucket);
              const sendMessage = yield* AWS.SQS.SendMessage(queue);
              const putItem = yield* AWS.DynamoDB.PutItem(table);
              return Effect.fn(function* (input: { key: string }) {
                yield* putObject({ Key: input.key, Body: "ingested" });
                const object = yield* getObject({ Key: input.key });
                const body = yield* readBody(object.Body!);
                yield* putItem({
                  Item: { id: { S: input.key }, body: { S: body } },
                });
                const sent = yield* sendMessage({ MessageBody: input.key });
                return { body, messageId: sent.MessageId };
              });
            }).pipe(
              Effect.provide(
                Layer.mergeAll(
                  AWS.S3.PutObjectHttp,
                  AWS.S3.GetObjectHttp,
                  AWS.SQS.SendMessageHttp,
                  AWS.DynamoDB.PutItemHttp,
                ),
              ),
            ),
          );
          const ingested = yield* Ingest({ key: "uploads/hello.txt" });
          return {
            bucketName: bucket.bucketName,
            queueUrl: queue.queueUrl,
            tableName: table.tableName,
            ingested,
          };
        }),
      );

      // The Action read back what it wrote — through the emulator.
      expect(outputs.ingested.body).toBe("ingested");
      expect(outputs.ingested.messageId).toBeTruthy();

      // Every side effect landed on the emulator…
      const head = yield* S3.headObject({
        Bucket: outputs.bucketName,
        Key: "uploads/hello.txt",
      }).pipe(Effect.provide(flociServices()));
      expect(head.ContentLength).toBe("ingested".length);

      const item = yield* DynamoDB.getItem({
        TableName: outputs.tableName,
        Key: { id: { S: "uploads/hello.txt" } },
      }).pipe(Effect.provide(flociServices()));
      expect(item.Item?.body).toEqual({ S: "ingested" });

      const received = yield* SQS.receiveMessage({
        QueueUrl: outputs.queueUrl,
        MaxNumberOfMessages: 1,
        WaitTimeSeconds: 5,
      }).pipe(Effect.provide(flociServices()));
      expect(received.Messages?.[0]?.Body).toBe("uploads/hello.txt");

      // …and the bucket never existed on the real cloud. The ambient
      // environment in a dev run is the emulator, so the real cloud is
      // reached EXPLICITLY via the live environment chain.
      const live = yield* S3.headBucket({ Bucket: outputs.bucketName }).pipe(
        Effect.map(() => "found" as const),
        Effect.catchTag("NotFound", () => Effect.succeed("not-found" as const)),
        Effect.provide(liveContext),
      );
      expect(live).toBe("not-found");

      yield* stack.destroy();
    }),
  {
    tags: ["provider:aws", "provider:aws:dynamodb", "provider:aws:s3", "provider:aws:sqs", "live"],
    timeout: 300_000,
  },
);

test.provider(
  "an Action's output feeds a downstream resource",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const outputs = yield* stack.deploy(
        Effect.gen(function* () {
          const source = yield* AWS.SSM.Parameter("ActionsSource", {
            value: "region-a",
          });
          // Read one parameter through its binding, derive a value, and
          // hand the Action's Output to a second resource's props.
          const Derive = Action(
            "Derive",
            Effect.gen(function* () {
              const getParameter = yield* AWS.SSM.GetParameter(source);
              return Effect.fn(function* () {
                const current = yield* getParameter({ WithDecryption: true });
                const raw = current.Parameter?.Value;
                const value = typeof raw === "string" ? raw : Redacted.value(raw!);
                return { derived: `${value}:derived` };
              });
            }).pipe(Effect.provide(AWS.SSM.GetParameterHttp)),
          );
          const derived = yield* Derive({});
          const target = yield* AWS.SSM.Parameter("ActionsTarget", {
            value: derived.derived,
          });
          return { sourceArn: source.parameterArn, target };
        }),
      );

      expect(outputs.sourceArn).toContain(":000000000000:");
      expect(outputs.target.parameterArn).toContain(":000000000000:");

      // The downstream parameter carries the Action-derived value — on the
      // emulator, where the Action's GetParameter read from.
      const stored = yield* SSM.getParameter({
        Name: outputs.target.parameterName,
      }).pipe(Effect.provide(flociServices()));
      const value = stored.Parameter?.Value;
      expect(typeof value === "string" ? value : Redacted.value(value!)).toBe("region-a:derived");

      yield* stack.destroy();
    }),
  { tags: ["provider:aws", "provider:aws:ssm", "local"], timeout: 300_000 },
);

test.provider(
  "InvokeFunction(fn) Action invokes the dev Lambda on the emulator",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const outputs = yield* stack.deploy(
        Effect.gen(function* () {
          const fn = yield* AWS.Lambda.Function("ActionsEcho", {
            main: echoHandlerPath,
            handler: "handler",
            bundle: false,
            functionUrl: false,
          });
          // A single-resource binding on a hand-written floci dual. Before
          // Lambda.Function declared its data plane this client was left
          // unrouted and the invoke went to the real cloud.
          const Ping = Action(
            "Ping",
            Effect.gen(function* () {
              const invoke = yield* AWS.Lambda.InvokeFunction(fn);
              return Effect.fn(function* (input: { message: string }) {
                const response = yield* invoke({
                  Payload: new TextEncoder().encode(JSON.stringify(input)),
                });
                const result = JSON.parse(yield* readBody(response.Payload!)) as {
                  echoed: { message: string };
                  from: string;
                };
                return { statusCode: response.StatusCode, result };
              });
            }).pipe(Effect.provide(AWS.Lambda.InvokeFunctionHttp)),
          );
          return {
            functionArn: fn.functionArn,
            ping: yield* Ping({ message: "hello" }),
          };
        }),
      );

      expect(outputs.functionArn).toContain(":000000000000:");
      expect(outputs.ping.statusCode).toBe(200);
      expect(outputs.ping.result.from).toBe("floci-echo");
      expect(outputs.ping.result.echoed).toEqual({ message: "hello" });

      yield* stack.destroy();
    }),
  // First invoke pulls the Lambda runtime image on a cold machine.
  { tags: ["provider:aws", "provider:aws:lambda", "local"], timeout: 600_000 },
);

test.provider(
  "RunTask(cluster, task) Action launches the task on the emulator",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const outputs = yield* stack.deploy(
        Effect.gen(function* () {
          const cluster = yield* AWS.ECS.Cluster("ActionsCluster");
          const task = yield* AWS.ECS.Task("ActionsTask", {
            image: "busybox:stable",
            command: ["true"],
            cpu: 256,
            memory: 512,
            requiresCompatibilities: ["EC2"],
            // awsvpc (the default) needs a network configuration on RunTask,
            // which the emulator enforces like ECS does; bridge needs none.
            networkMode: "bridge",
            runtimePlatform: hostRuntimePlatform,
          });
          // A multi-resource binding spanning a `flociDual` (Cluster) and a
          // hand-written dual (Task). The reported bug: with Task
          // undeclared this bind died with "mixed data planes".
          const Launch = Action(
            "Launch",
            Effect.gen(function* () {
              const runTask = yield* AWS.ECS.RunTask(cluster, task);
              return () =>
                runTask({ launchType: "EC2", count: 1 }).pipe(
                  Effect.map((response) => ({
                    taskArn: response.tasks?.[0]?.taskArn,
                    failures: response.failures ?? [],
                  })),
                );
            }).pipe(Effect.provide(AWS.ECS.RunTaskHttp)),
          );
          return {
            clusterArn: cluster.clusterArn,
            launched: yield* Launch({}),
          };
        }),
      );

      expect(outputs.clusterArn).toContain(":000000000000:");
      expect(outputs.launched.failures).toEqual([]);
      expect(outputs.launched.taskArn).toContain(":000000000000:");

      yield* stack.destroy();
    }),
  { tags: ["provider:aws", "provider:aws:ecs", "local"], timeout: 300_000 },
);

test.provider(
  "a binding spanning a remote() resource and a local one fails at bind with a per-resource explanation",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const exit = yield* Effect.exit(
        stack.deploy(
          Effect.gen(function* () {
            // Pinned live: its clients belong to the real cloud…
            const cluster = yield* AWS.ECS.Cluster("MixedCluster").pipe(Alchemy.remote());
            // …while the task is emulated. One API call cannot span both.
            const task = yield* AWS.ECS.Task("MixedTask", {
              image: "busybox:stable",
              command: ["true"],
              cpu: 256,
              memory: 512,
              requiresCompatibilities: ["EC2"],
              runtimePlatform: hostRuntimePlatform,
            });
            const Launch = Action(
              "MixedLaunch",
              Effect.gen(function* () {
                const runTask = yield* AWS.ECS.RunTask(cluster, task);
                return () => runTask({ launchType: "EC2", count: 1 });
              }).pipe(Effect.provide(AWS.ECS.RunTaskHttp)),
            );
            return { launched: yield* Launch({}) };
          }),
        ),
      );

      expect(Exit.isFailure(exit)).toBe(true);
      const message = Exit.isFailure(exit) ? Cause.pretty(exit.cause) : "";
      // Each resource is named with WHERE it lands and WHY — never the old
      // "(some local, some live)" that hid which one and for what reason.
      expect(message).toContain("Binding client spans mixed data planes");
      expect(message).toContain("MixedCluster → real cloud (live mode)");
      expect(message).toContain("MixedTask → local emulator");

      yield* stack.destroy();
    }),
  { tags: ["provider:aws", "provider:aws:ecs", "live"], timeout: 300_000 },
);