sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ Fly/ Website/ CustomDomainDns.test.ts

import { resolve4, resolveNs, Resolver } from "node:dns/promises";
/**
 * `domain.dns` on a Fly website, deployed for real: the DNS adapter
 * publishes the Fly Certificate's ACME challenge `CNAME` and the site's
 * `A` / `AAAA` records, Fly issues the certificate, and the custom hostname
 * serves over HTTPS.
 */
import * as AWS from "@alchemy.run/aws";
import * as Cloudflare from "@alchemy.run/cloudflare";
import { CloudflareEnvironment } from "@alchemy.run/cloudflare/CloudflareEnvironment";
import { findZoneByName } from "@alchemy.run/cloudflare/Zone/lookup";
import * as Fly from "@alchemy.run/fly";
import { expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as route53 from "@distilled.cloud/aws/route-53";
import * as dns from "@distilled.cloud/cloudflare/dns";
import * as machines from "@distilled.cloud/fly-io/machines";
import * as Output from "alchemy/Output";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Path from "effect/Path";
import { MinimumLogLevel } from "effect/References";
import * as Schedule from "effect/Schedule";
import * as Stream from "effect/Stream";
import { cloneFixture } from "../../Cloudflare/Utils/Fixture.ts";
import { assertAppGone, getText } from "./fixtures/deployment.ts";

const { test } = Test.make({
  providers: Layer.mergeAll(Fly.providers(), Cloudflare.providers(), AWS.providers()),
});

const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");

const ZONE = process.env.CLOUDFLARE_TEST_DNS_ZONE_NAME ?? "alchemy-test-2.us";
const CLOUDFLARE_HOST = `fly-dns.${ZONE}`;
const ROUTE53_ZONE = `fly-dns-r53.${ZONE}`;
const ROUTE53_HOST = ROUTE53_ZONE;
/** Route 53 always assigns four name servers to a public hosted zone. */
const ROUTE53_NAME_SERVER_COUNT = 4;

const normalize = (name: string | null | undefined) =>
  (name ?? "").replace(/\.$/, "").toLowerCase();

class NotPublished extends Data.TaggedError("NotPublished")<{
  readonly server: string;
  readonly name: string;
}> {}

class CertificateNotIssued extends Data.TaggedError("CertificateNotIssued")<{
  readonly hostname: string;
  readonly status: string | undefined;
}> {}

const cloudflareZoneId = Effect.gen(function* () {
  const { accountId } = yield* yield* CloudflareEnvironment;
  const zone = yield* findZoneByName({ accountId, name: ZONE });
  if (!zone) {
    return yield* Effect.die(new Error(`zone "${ZONE}" not found in account`));
  }
  return zone.id;
});

const cloudflareRecords = (zoneId: string, name: string, type: "A" | "AAAA" | "CNAME" | "NS") =>
  dns.listRecords.items({ zoneId, name: { exact: name }, type }).pipe(
    Stream.runCollect,
    Effect.map((chunk) => Array.from(chunk)),
  );

const route53Records = (hostedZoneId: string) =>
  route53
    .listResourceRecordSets({ HostedZoneId: hostedZoneId, MaxItems: 100 })
    .pipe(Effect.map((response) => response.ResourceRecordSets ?? []));

const assertHostedZoneGone = (hostedZoneId: string) =>
  route53.getHostedZone({ Id: hostedZoneId }).pipe(
    Effect.as(false),
    Effect.catchTag("NoSuchHostedZone", () => Effect.succeed(true)),
    Effect.repeat({
      until: (gone) => gone,
      times: 10,
      schedule: Schedule.spaced("2 seconds"),
    }),
    Effect.tap((gone) => Effect.sync(() => expect(gone).toBe(true))),
  );

/**
 * Wait until every authoritative name server answers `name` with the
 * `expected` A records, so the first HTTPS request never resolves (and
 * negatively caches) the hostname before it exists.
 */
const waitForAuthoritativeA = (
  nameServers: readonly string[],
  name: string,
  expected: readonly string[],
) =>
  Effect.gen(function* () {
    const servers = (yield* Effect.forEach(nameServers, (ns) =>
      Effect.tryPromise(() => resolve4(normalize(ns))).pipe(Effect.orDie),
    )).flat();
    yield* Effect.forEach(servers, (server) =>
      Effect.gen(function* () {
        const resolver = yield* Effect.sync(() => {
          const r = new Resolver();
          r.setServers([server]);
          return r;
        });
        const answers = yield* Effect.tryPromise(() => resolver.resolve4(name)).pipe(
          Effect.orElseSucceed(() => [] as string[]),
        );
        if (!expected.every((ip) => answers.includes(ip))) {
          return yield* Effect.fail(new NotPublished({ server, name }));
        }
      }).pipe(Effect.retry({ schedule: Schedule.spaced("3 seconds"), times: 20 })),
    );
  });

/**
 * Fly issues the ACME certificate once its challenge `CNAME` resolves;
 * `checkAppCertificate` re-runs validation on each poll.
 */
const waitForIssuedCertificate = (appName: string, hostname: string) =>
  machines.checkAppCertificate({ app_name: appName, hostname }).pipe(
    Effect.flatMap((checked) =>
      (checked.certificates ?? []).some(
        (certificate) => certificate.source === "fly" && certificate.status === "active",
      )
        ? Effect.succeed(checked)
        : Effect.fail(new CertificateNotIssued({ hostname, status: checked.status })),
    ),
    Effect.retry({
      while: (error) => error._tag === "CertificateNotIssued",
      schedule: Schedule.spaced("10 seconds"),
      times: 30,
    }),
  );

const serveOverHttps = (hostname: string) =>
  getText(`https://${hostname}/`).pipe(
    Effect.retry({ schedule: Schedule.spaced("5 seconds"), times: 24 }),
  );

const cloneSite = Effect.gen(function* () {
  const path = yield* Path.Path;
  return yield* cloneFixture(
    path.resolve(import.meta.dirname, "../../Cloudflare/Website/staticsite-fixture"),
    {
      prefix: "alchemy-fly-dns-",
      tempRoot: path.resolve(import.meta.dirname, "../../../.tmp"),
      entries: ["src", "build.sh"],
    },
  );
});

const siteProps = (path: string) => ({
  path,
  build: { command: "bash build.sh", output: "dist" },
  memo: { include: ["src/**", "build.sh"] },
});

const tags = [
  "provider:fly",
  "provider:fly:certificate",
  "provider:fly:website",
  "provider:cloudflare",
  "provider:cloudflare:dns",
  "live",
];

test.provider(
  "Cloudflare DNS: ACME challenge CNAME + A/AAAA published, certificate issued, HTTPS 200, records removed on destroy",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const zoneId = yield* cloudflareZoneId;
      const cwd = yield* cloneSite;

      yield* Effect.gen(function* () {
        const { site } = yield* stack.deploy(
          Effect.gen(function* () {
            const site = yield* Fly.Website.StaticSite("Site", {
              ...siteProps(cwd),
              domain: {
                name: CLOUDFLARE_HOST,
                dns: Cloudflare.DNS.Adapter(),
              },
            });
            return { site };
          }),
        );
        const appName = site.app!.appName;
        expect(site.url).toBe(`https://${CLOUDFLARE_HOST}`);
        const requirements = site.certificate!.dnsRequirements;
        const challenge = requirements?.acmeChallenge;
        expect(challenge?.target).toEqual(expect.any(String));
        const ip = site.ip!.ip;

        // The ACME challenge CNAME Fly lists, DNS-only.
        const [cname] = yield* cloudflareRecords(
          zoneId,
          `_acme-challenge.${CLOUDFLARE_HOST}`,
          "CNAME",
        );
        expect(normalize(cname?.content)).toBe(normalize(challenge!.target));
        expect(cname?.proxied).toBe(false);

        // A at the shared IPv4, AAAA at every IPv6 Fly lists.
        const a = yield* cloudflareRecords(zoneId, CLOUDFLARE_HOST, "A");
        expect(a.map((record) => record.content)).toEqual([ip]);
        const aaaa = yield* cloudflareRecords(zoneId, CLOUDFLARE_HOST, "AAAA");
        expect(aaaa.map((record) => record.content).sort()).toEqual(
          [...(requirements?.aaaa ?? [])].sort(),
        );

        yield* waitForIssuedCertificate(appName, CLOUDFLARE_HOST);

        const nameServers = yield* Effect.tryPromise(() => resolveNs(ZONE)).pipe(Effect.orDie);
        yield* waitForAuthoritativeA(nameServers, CLOUDFLARE_HOST, [ip]);
        expect(yield* serveOverHttps(CLOUDFLARE_HOST)).toContain("StaticSite fixture v1");

        yield* stack.destroy();
        expect(
          yield* cloudflareRecords(zoneId, `_acme-challenge.${CLOUDFLARE_HOST}`, "CNAME"),
        ).toEqual([]);
        expect(yield* cloudflareRecords(zoneId, CLOUDFLARE_HOST, "A")).toEqual([]);
        expect(yield* cloudflareRecords(zoneId, CLOUDFLARE_HOST, "AAAA")).toEqual([]);
        yield* assertAppGone(appName);
      }).pipe(Effect.ensuring(stack.destroy().pipe(Effect.orDie)));
    }).pipe(logLevel),
  // Image build + Machine boot + ACME issuance through public DNS.
  { tags, timeout: 900_000 },
);

test.provider(
  "Route 53 DNS: records published in a delegated hosted zone, certificate issued, HTTPS 200",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const zoneId = yield* cloudflareZoneId;
      const cwd = yield* cloneSite;

      yield* Effect.gen(function* () {
        const { site, zone } = yield* stack.deploy(
          Effect.gen(function* () {
            const zone = yield* AWS.Route53.HostedZone("Zone", {
              name: ROUTE53_ZONE,
              forceDestroy: true,
            });
            // Delegate the hosted zone from the Cloudflare zone.
            for (let index = 0; index < ROUTE53_NAME_SERVER_COUNT; index++) {
              yield* Cloudflare.DNS.Record(`Delegation${index}`, {
                zoneId,
                name: ROUTE53_ZONE,
                type: "NS",
                content: Output.map(zone.nameServers, (nameServers) => nameServers[index]!),
              });
            }
            const site = yield* Fly.Website.StaticSite("Site", {
              ...siteProps(cwd),
              domain: {
                name: ROUTE53_HOST,
                dns: AWS.Route53.Adapter({ hostedZoneId: zone.id }),
              },
            });
            return { site, zone };
          }),
        );
        const appName = site.app!.appName;
        expect(site.url).toBe(`https://${ROUTE53_HOST}`);
        expect(zone.nameServers).toHaveLength(ROUTE53_NAME_SERVER_COUNT);
        const requirements = site.certificate!.dnsRequirements;
        const challenge = requirements?.acmeChallenge;
        expect(challenge?.target).toEqual(expect.any(String));
        const ip = site.ip!.ip;

        // The delegation is live in Cloudflare.
        const delegation = yield* cloudflareRecords(zoneId, ROUTE53_ZONE, "NS");
        expect(delegation.map((record) => normalize(record.content)).sort()).toEqual(
          zone.nameServers.map(normalize).sort(),
        );

        // The records live in Route 53, not Cloudflare.
        const sets = yield* route53Records(zone.id);
        const find = (name: string, type: string) =>
          sets.find((set) => normalize(set.Name) === name && set.Type === type);
        expect(
          find(`_acme-challenge.${ROUTE53_HOST}`, "CNAME")?.ResourceRecords?.map((record) =>
            normalize(record.Value),
          ),
        ).toEqual([normalize(challenge!.target)]);
        expect(find(ROUTE53_HOST, "A")?.ResourceRecords?.map((record) => record.Value)).toEqual([
          ip,
        ]);
        expect(yield* cloudflareRecords(zoneId, ROUTE53_HOST, "A")).toEqual([]);

        yield* waitForIssuedCertificate(appName, ROUTE53_HOST);

        yield* waitForAuthoritativeA(zone.nameServers, ROUTE53_HOST, [ip]);
        expect(yield* serveOverHttps(ROUTE53_HOST)).toContain("StaticSite fixture v1");

        yield* stack.destroy();
        yield* assertHostedZoneGone(zone.id);
        expect(yield* cloudflareRecords(zoneId, ROUTE53_ZONE, "NS")).toEqual([]);
        yield* assertAppGone(appName);
      }).pipe(Effect.ensuring(stack.destroy().pipe(Effect.orDie)));
    }).pipe(logLevel),
  // Image build + Machine boot + ACME issuance through a delegated zone.
  { tags: [...tags, "provider:aws", "provider:aws:route53"], timeout: 900_000 },
);