sailfork / t3code-github / .repos/ alchemy-effect/ examples/ aws-aurora-drizzle/ test/ integ.test.ts

import { describe, expect } from "bun:test";
import * as AWS from "@alchemy.run/aws";
import * as Test from "@alchemy.run/test/Bun";
import { Credentials } from "@distilled.cloud/aws/Credentials";
import { sign } from "@distilled.cloud/aws/SigV4";
import * as Alchemy from "alchemy";
import * as Effect from "effect/Effect";
import * as HttpClient from "effect/http/HttpClient";
import * as HttpClientRequest from "effect/http/HttpClientRequest";
import * as Redacted from "effect/Redacted";
import Stack from "../alchemy.run.ts";

// Aurora provisioning/deletion is opt-in, as in the RDSData integration suite.
describe.skipIf(!!process.env.FAST)("Drizzle + Aurora PostgreSQL", () => {
  const { test, beforeAll, afterAll, deploy, destroy } = Test.make({
    providers: AWS.providers(),
    state: Alchemy.localState(),
    profile: process.env.ALCHEMY_PROFILE,
  });
  const stack = beforeAll(
    Effect.gen(function* () {
      yield* destroy(Stack);
      const outputs = yield* deploy(Stack);
      yield* deploy(Stack);
      return outputs;
    }),
    { timeout: 1_500_000 },
  );
  afterAll(destroy(Stack), { timeout: 1_500_000 });

  test.provider(
    "CRUD, TLS, least privilege, and repeated invocations",
    () =>
      Effect.gen(function* () {
        const { url } = yield* stack;
        if (!url) return yield* Effect.fail(new Error("Missing Function URL"));
        const client = yield* HttpClient.HttpClient;
        const getCredentials = yield* Credentials;
        expect((yield* client.get(`${url}health`)).status).toBe(403);
        const request = Effect.fn(function* (
          method: "GET" | "POST" | "PATCH" | "DELETE",
          path: string,
          body?: object,
        ) {
          const credentials = yield* getCredentials;
          const payload = body === undefined ? undefined : JSON.stringify(body);
          const signed = yield* sign({
            method,
            url: new URL(path, url).toString(),
            body: payload,
            service: "lambda",
            region: credentials.region,
            accessKeyId: Redacted.value(credentials.accessKeyId),
            secretAccessKey: credentials.secretAccessKey,
            sessionToken: credentials.sessionToken,
          });
          const base = HttpClientRequest.make(method)(signed.url).pipe(
            HttpClientRequest.setHeaders(signed.headers),
          );
          const response = yield* client.execute(
            payload === undefined
              ? base
              : base.pipe(HttpClientRequest.bodyText(payload, "application/json")),
          );
          return { statusCode: response.status, body: yield* response.text };
        });
        const health = yield* request("GET", "/health");
        expect(health.statusCode).toBe(200);
        expect(JSON.parse(health.body).rows).toEqual([
          {
            username: "app_iam",
            tls: true,
            can_insert: true,
            can_create: false,
          },
        ]);
        const id = "aaaaaaaa-0000-4000-8000-000000000001";
        yield* request("DELETE", `/todos/${id}`);
        expect((yield* request("GET", "/todos")).body).toBe("[]");
        const created = yield* request("POST", "/todos", {
          id,
          title: "Ship Aurora guide",
        });
        expect(created.statusCode).toBe(201);
        expect(JSON.parse(created.body)).toEqual([{ id, title: "Ship Aurora guide", done: false }]);
        const updated = yield* request("PATCH", `/todos/${id}`, {
          done: true,
        });
        expect(updated.statusCode).toBe(200);
        expect(JSON.parse(updated.body)[0].done).toBe(true);
        for (let i = 0; i < 3; i++) {
          const listed = yield* request("GET", "/todos");
          expect(listed.statusCode).toBe(200);
          expect(JSON.parse(listed.body)).toEqual([{ id, title: "Ship Aurora guide", done: true }]);
        }
        expect((yield* request("POST", "/todos", { id: "invalid", title: "" })).statusCode).toBe(
          400,
        );
        expect((yield* request("GET", "/setup")).statusCode).toBe(404);
        expect((yield* request("DELETE", `/todos/${id}`)).statusCode).toBe(204);
        expect((yield* request("GET", "/todos")).body).toBe("[]");
      }),
    { timeout: 120_000 },
  );
});