sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ AWS/ RDSData/ Bindings.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 Core from "@alchemy.run/test/Core";
import * as rds from "@distilled.cloud/aws/rds";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as HttpClient from "effect/http/HttpClient";
import * as HttpClientRequest from "effect/http/HttpClientRequest";
import * as Layer from "effect/Layer";
import * as Schedule from "effect/Schedule";
import RDSDrizzleIamFunctionLive, { RDSDrizzleIamFunction } from "./drizzle-iam-handler";
import RDSDataTestFunctionLive, { RDSDataTestFunction } from "./handler";
import { reapRDSDataOrphans } from "./reap";

// Aurora Serverless v2 cluster + writer-instance provisioning takes 5-15
// minutes — far beyond the speed doctrine's budget — so the ENTIRE live suite
// (deploy hook, every test, destroy hook) skipped under `--fast`.
// A run without the env var is skip-clean: no AWS calls, no side effects.
const SLOW = !process.env.FAST;

const testOptions = { providers: AWS.providers() };
const { test, beforeAll, afterAll } = Test.make(testOptions);
const sharedStack = Core.scratchStack(testOptions, "RDSDataBindings");

let baseUrl: string;
let drizzleUrl: string;
let clusterIdentifier: string | undefined;

class TransientUpstream extends Data.TaggedError("TransientUpstream")<{
  readonly status: number;
  readonly body: string;
}> {}

class ClusterStillPresent extends Data.TaggedError("ClusterStillPresent")<{
  readonly clusterIdentifier: string;
}> {}

// The fixture surfaces every failure as a 500 (handler-level `Effect.orDie`).
// A 5xx from this Lambda is either a cold re-init or an rds-data transient
// (DatabaseResumingException / DatabaseUnavailableException while the
// serverless cluster scales from idle) — retry those on a generous bounded
// schedule; a 4xx/assertion failure is surfaced immediately.
const send = (request: HttpClientRequest.HttpClientRequest) =>
  HttpClient.execute(request).pipe(
    Effect.flatMap((response) =>
      response.status >= 500
        ? response.text.pipe(
            Effect.flatMap((body) =>
              Effect.fail(new TransientUpstream({ status: response.status, body })),
            ),
          )
        : Effect.succeed(response),
    ),
    Effect.retry({
      while: (e) => e._tag === "TransientUpstream",
      schedule: Schedule.max([Schedule.spaced("5 seconds"), Schedule.recurs(8)]),
    }),
  );

const postJson = (url: string, body: unknown) =>
  send(HttpClientRequest.bodyJsonUnsafe(HttpClientRequest.post(url), body)).pipe(
    Effect.flatMap((r) => r.json),
  );

// The scratch stack's state store is IN MEMORY, so `sharedStack.destroy()`
// can only see resources deployed by THIS process. A previous run killed
// mid-deploy/mid-destroy (Aurora provisioning + teardown run 10+ minutes)
// leaves the whole VPC/RDS fixture orphaned with no state to destroy from.
// The reaper deletes fixture leftovers out-of-band by deterministic
// name-prefix / ownership tag; it runs as a pre-clean before deploy and as
// an `ensuring` finalizer after destroy.
const reapOrphans = Core.withProviders(reapRDSDataOrphans, testOptions, sharedStack.name);

describe(
  "RDSData Bindings",
  {
    tags: [
      "provider:aws",
      "provider:aws:batch",
      "provider:aws:ec2",
      "provider:aws:iam",
      "provider:aws:lambda",
      "provider:aws:rds",
      "provider:aws:rdsdata",
      "provider:aws:secretsmanager",
      "live",
    ],
  },
  () => {
    beforeAll(
      SLOW
        ? Effect.gen(function* () {
            yield* Effect.logInfo("RDSData test setup: destroying previous resources");
            yield* sharedStack.destroy();

            yield* Effect.logInfo(
              "RDSData test setup: reaping orphans from prior interrupted runs",
            );
            yield* reapOrphans;

            yield* Effect.logInfo(
              "RDSData test setup: deploying Aurora SV2 + Lambda fixture (5-15 min)",
            );
            const { dataApiUrl, drizzleIamUrl } = yield* sharedStack.deploy(
              Effect.gen(function* () {
                const dataApi = yield* RDSDataTestFunction;
                const drizzleIam = yield* RDSDrizzleIamFunction;
                return { dataApiUrl: dataApi.functionUrl, drizzleIamUrl: drizzleIam.functionUrl };
              }).pipe(
                Effect.provide(Layer.mergeAll(RDSDataTestFunctionLive, RDSDrizzleIamFunctionLive)),
              ),
            );

            expect(dataApiUrl).toBeTruthy();
            expect(drizzleIamUrl).toBeTruthy();
            baseUrl = dataApiUrl!.replace(/\/+$/, "");
            drizzleUrl = drizzleIamUrl!.replace(/\/+$/, "");

            // Bounded readiness poll (gated-suite only): the cluster is already
            // `available` when deploy returns (the DBCluster/DBInstance
            // reconcilers wait for it), so this covers Lambda URL cold start
            // plus first Data API connection setup. Generous spaced schedule:
            // 10s x 42 ≈ 7 min ceiling.
            yield* HttpClient.get(`${baseUrl}/health`).pipe(
              Effect.flatMap((response) =>
                response.status === 200
                  ? Effect.succeed(response)
                  : Effect.fail(new Error(`Fixture not ready: ${response.status}`)),
              ),
              Effect.tapError((error) =>
                Effect.logWarning(`RDSData test setup: fixture not ready yet (${String(error)})`),
              ),
              Effect.retry({
                schedule: Schedule.max([Schedule.spaced("10 seconds"), Schedule.recurs(42)]),
              }),
            );

            // Capture the cluster identifier so afterAll can verify deletion
            // out-of-band after destroy.
            const meta = (yield* HttpClient.get(`${baseUrl}/meta`).pipe(
              Effect.flatMap((r) => r.json),
            )) as { clusterIdentifier: string };
            clusterIdentifier = meta.clusterIdentifier;
            yield* Effect.logInfo(
              `RDSData test setup: fixture ready (cluster ${clusterIdentifier})`,
            );

            // Create the shared table once for all binding tests.
            yield* postJson(`${baseUrl}/setup`, {});

            // Bootstrap the IAM-auth DB user (rds_iam + table grants) via the
            // Data API — the VPC-attached Drizzle fixture can't reach the Data
            // API itself.
            yield* postJson(`${baseUrl}/setup-iam-user`, {});
          })
        : Effect.void,
      { timeout: 1_500_000 },
    );

    afterAll(
      SLOW
        ? Effect.gen(function* () {
            yield* sharedStack.destroy();

            // Out-of-band deletion check via distilled: the DBCluster provider
            // already waits until the cluster is gone, so this is a bounded
            // confirmation, not a long poll.
            if (clusterIdentifier) {
              yield* Core.withProviders(
                rds.describeDBClusters({ DBClusterIdentifier: clusterIdentifier }).pipe(
                  Effect.flatMap((response) =>
                    (response.DBClusters ?? []).length === 0
                      ? Effect.void
                      : Effect.fail(
                          new ClusterStillPresent({ clusterIdentifier: clusterIdentifier! }),
                        ),
                  ),
                  Effect.catchTag("DBClusterNotFoundFault", () => Effect.void),
                  Effect.retry({
                    schedule: Schedule.max([Schedule.spaced("15 seconds"), Schedule.recurs(8)]),
                  }),
                ),
                testOptions,
                sharedStack.name,
              );
            }
          }).pipe(
            // Always sweep out-of-band leftovers — even when destroy itself
            // fails partway (e.g. a lingering Lambda ENI blocking SG deletion).
            // Once this process exits, the in-memory state is gone and nothing
            // else can ever find these resources again.
            Effect.ensuring(reapOrphans.pipe(Effect.orDie)),
          )
        : Effect.void,
      { timeout: 1_500_000 },
    );

    describe("ExecuteStatement", () => {
      test.provider.skipIf(!SLOW)(
        "inserts and selects a row with typed parameters",
        (_stack) =>
          Effect.gen(function* () {
            const insert = (yield* postJson(`${baseUrl}/insert`, { id: 1, title: "first" })) as {
              success: boolean;
              numberOfRecordsUpdated: number;
            };
            expect(insert.success).toBe(true);
            expect(insert.numberOfRecordsUpdated).toBe(1);

            const select = (yield* send(HttpClientRequest.get(`${baseUrl}/select?id=1`)).pipe(
              Effect.flatMap((r) => r.json),
            )) as { records: { longValue?: number; stringValue?: string }[][] };
            expect(select.records).toHaveLength(1);
            expect(select.records[0]![0]!.longValue).toBe(1);
            expect(select.records[0]![1]!.stringValue).toBe("first");
          }),
        { timeout: 120_000 },
      );

      test.provider.skipIf(!SLOW)(
        "returns no records for a missing row",
        (_stack) =>
          Effect.gen(function* () {
            const select = (yield* send(HttpClientRequest.get(`${baseUrl}/select?id=999999`)).pipe(
              Effect.flatMap((r) => r.json),
            )) as { records: unknown[] };
            expect(select.records).toHaveLength(0);
          }),
        { timeout: 120_000 },
      );
    });

    describe("BatchExecuteStatement", () => {
      test.provider.skipIf(!SLOW)(
        "inserts multiple rows via parameterSets",
        (_stack) =>
          Effect.gen(function* () {
            const batch = (yield* postJson(`${baseUrl}/batch-insert`, {
              rows: [
                { id: 10, title: "batch-a" },
                { id: 11, title: "batch-b" },
              ],
            })) as { updateResults: unknown[] };
            expect(batch.updateResults).toHaveLength(2);

            const select = (yield* send(HttpClientRequest.get(`${baseUrl}/select?id=11`)).pipe(
              Effect.flatMap((r) => r.json),
            )) as { records: { longValue?: number; stringValue?: string }[][] };
            expect(select.records[0]![1]!.stringValue).toBe("batch-b");
          }),
        { timeout: 120_000 },
      );
    });

    describe("BeginTransaction", () => {
      test.provider.skipIf(!SLOW)(
        "returns a transaction id",
        (_stack) =>
          Effect.gen(function* () {
            const result = (yield* postJson(`${baseUrl}/tx-commit`, {
              id: 20,
              title: "begin",
            })) as { transactionId: string };
            expect(result.transactionId).toBeTruthy();
          }),
        { timeout: 120_000 },
      );
    });

    describe("CommitTransaction", () => {
      test.provider.skipIf(!SLOW)(
        "commits an insert so it is visible afterwards",
        (_stack) =>
          Effect.gen(function* () {
            const result = (yield* postJson(`${baseUrl}/tx-commit`, {
              id: 30,
              title: "committed",
            })) as { transactionId: string; transactionStatus: string };
            expect(result.transactionId).toBeTruthy();

            const select = (yield* send(HttpClientRequest.get(`${baseUrl}/select?id=30`)).pipe(
              Effect.flatMap((r) => r.json),
            )) as { records: { longValue?: number; stringValue?: string }[][] };
            expect(select.records).toHaveLength(1);
            expect(select.records[0]![1]!.stringValue).toBe("committed");
          }),
        { timeout: 120_000 },
      );
    });

    describe("RollbackTransaction", () => {
      test.provider.skipIf(!SLOW)(
        "rolls back an insert so it never becomes visible",
        (_stack) =>
          Effect.gen(function* () {
            const result = (yield* postJson(`${baseUrl}/tx-rollback`, {
              id: 40,
              title: "rolled-back",
            })) as { transactionId: string; transactionStatus: string };
            expect(result.transactionId).toBeTruthy();

            const select = (yield* send(HttpClientRequest.get(`${baseUrl}/select?id=40`)).pipe(
              Effect.flatMap((r) => r.json),
            )) as { records: unknown[] };
            expect(select.records).toHaveLength(0);
          }),
        { timeout: 120_000 },
      );
    });

    // RDS.Connect is not a Data API binding, but it targets the same cluster
    // and only resolves connection settings (endpoint + secret credentials), so
    // it shares this fixture instead of provisioning a second Aurora cluster.
    describe("RDS.Connect", () => {
      test.provider.skipIf(!SLOW)(
        "resolves host, port, database and credentials from the secret",
        (_stack) =>
          Effect.gen(function* () {
            const info = (yield* send(HttpClientRequest.get(`${baseUrl}/connect-info`)).pipe(
              Effect.flatMap((r) => r.json),
            )) as {
              host: string;
              port: number;
              database?: string;
              username?: string;
              hasPassword: boolean;
              ssl: boolean;
            };
            expect(info.host).toMatch(/\.rds\.amazonaws\.com$/);
            expect(info.port).toBe(5432);
            expect(info.database).toBe("app");
            expect(info.username).toBe("app");
            expect(info.hasPassword).toBe(true);
            expect(info.ssl).toBe(true);
          }),
        { timeout: 120_000 },
      );
    });

    // IAM database authentication (db-drivers §3 "RDS/Aurora"): the deploy
    // half binds `rds-db:connect` on `dbuser:{resourceId}/app_iam` and attaches
    // the Lambda to the fixture VPC through the binding contract's `vpc`
    // channel (DECISION #5); the runtime half presigns a 15-minute token as the
    // password and `Drizzle.Postgres` consumes `ConnectionInfo.url` directly.
    describe("RDS.Connect (IAM auth)", () => {
      test.provider.skipIf(!SLOW)(
        "mints an IAM auth token as the password and can re-mint via refreshPassword",
        (_stack) =>
          Effect.gen(function* () {
            const info = (yield* send(HttpClientRequest.get(`${drizzleUrl}/connect-info`)).pipe(
              Effect.flatMap((r) => r.json),
            )) as {
              host: string;
              port: number;
              database?: string;
              username?: string;
              hasToken: boolean;
              ssl: boolean;
              canRefresh: boolean;
            };
            expect(info.host).toMatch(/\.rds\.amazonaws\.com$/);
            expect(info.port).toBe(5432);
            expect(info.database).toBe("app");
            expect(info.username).toBe("app_iam");
            expect(info.hasToken).toBe(true);
            expect(info.ssl).toBe(true);
            expect(info.canRefresh).toBe(true);
          }),
        { timeout: 120_000 },
      );

      test.provider.skipIf(!SLOW)(
        "Drizzle round-trips over the IAM-auth connection URL",
        (_stack) =>
          Effect.gen(function* () {
            // Socket sanity check first — TLS + token auth + in-VPC route.
            const health = (yield* send(HttpClientRequest.get(`${drizzleUrl}/drizzle-health`)).pipe(
              Effect.flatMap((r) => r.json),
            )) as { rows: { one: number }[] };
            expect(health.rows[0]?.one).toBe(1);

            // Cross-path consistency: write via the Data API Lambda, read over
            // the wire protocol from the VPC-attached Lambda.
            yield* postJson(`${baseUrl}/insert`, { id: 60, title: "written-via-data-api" });
            const todos = (yield* send(HttpClientRequest.get(`${drizzleUrl}/drizzle-todos`)).pipe(
              Effect.flatMap((r) => r.json),
            )) as { rows: { count: number }[] };
            expect(todos.rows[0]!.count).toBeGreaterThanOrEqual(1);
          }),
        { timeout: 180_000 },
      );
    });

    // `ExecuteSql` is deprecated (Aurora Serverless v1 era API) — implemented
    // for completeness but intentionally not exercised against live AWS.
  },
);