sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ Cloudflare/ Website/ Astro.local.test.ts

import * as Cloudflare from "@alchemy.run/cloudflare";
import { CloudflareEnvironment } from "@alchemy.run/cloudflare/CloudflareEnvironment";
import { isLocalId } from "@alchemy.run/cloudflare/LocalRuntime";
import { describe, expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as kv from "@distilled.cloud/cloudflare/kv";
import * as Alchemy from "alchemy";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import { MinimumLogLevel } from "effect/References";
import * as Schedule from "effect/Schedule";
import * as Stream from "effect/Stream";
import * as pathe from "pathe";
import { cloneFixture } from "../Utils/Fixture.ts";
import { expectUrlContains } from "../Utils/Http.ts";

// `dev: true` runs local providers behind the RPC sidecar proxy by default,
// matching the process topology of the real `alchemy dev` command.
const { test } = Test.make({ providers: Cloudflare.providers(), dev: true });

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

const fixtureDir = pathe.resolve(import.meta.dirname, "fixtures", "astro-app");
const staticFixtureDir = pathe.resolve(import.meta.dirname, "fixtures", "astro-static-app");
const tempRoot = pathe.resolve(import.meta.dirname, "../../../.tmp");

class DevResponseMismatch extends Data.TaggedError("DevResponseMismatch")<{
  url: string;
  detail: string;
}> {
  override get message() {
    return `${this.url} :: ${this.detail}`;
  }
}

const devRetry = Effect.retry({
  schedule: Schedule.min([Schedule.exponential("500 millis", 1.5), Schedule.spaced("4 seconds")]),
  times: 10,
});

/**
 * Cookie-aware fetch for the dev session round-trip: returns the body plus
 * the `astro-session` cookie pair from `set-cookie` (if any).
 */
const fetchSession = (url: string, cookie?: string) =>
  Effect.tryPromise({
    try: async (signal) => {
      const res = await fetch(url, {
        signal,
        cache: "no-store",
        headers: { "cache-control": "no-cache", accept: "*/*", ...(cookie ? { cookie } : {}) },
      });
      const body = await res.text();
      const sessionCookie = res.headers.get("set-cookie")?.match(/astro-session=[^;,\s]+/)?.[0];
      return { status: res.status, body, sessionCookie };
    },
    catch: (e) =>
      new DevResponseMismatch({ url, detail: e instanceof Error ? e.message : String(e) }),
  });

/**
 * Fetch `url` and assert the exact `status` with a body containing
 * `marker` — used for the dev 404 page, which `expectUrlContains` can't
 * assert (it requires `res.ok`).
 */
const expectStatusBody = (url: string, status: number, marker: string) =>
  Effect.tryPromise({
    try: async (signal) => {
      const res = await fetch(url, {
        signal,
        cache: "no-store",
        headers: { "cache-control": "no-cache", accept: "*/*" },
      });
      return { status: res.status, body: await res.text() };
    },
    catch: (e) =>
      new DevResponseMismatch({ url, detail: e instanceof Error ? e.message : String(e) }),
  }).pipe(
    Effect.filterOrFail(
      (r) => r.status === status && r.body.includes(marker),
      (r) =>
        new DevResponseMismatch({
          url,
          detail: `expected ${status} with "${marker}", got ${r.status} ${r.body.slice(0, 240)}`,
        }),
    ),
    devRetry,
  );

// Tests are independent (per-test scratch stacks, private fixture clones),
// so run them concurrently; suites are sequential by default.
describe.concurrent(
  "Astro dev",
  { tags: ["provider:cloudflare", "provider:cloudflare:website"] },
  () => {
    test.provider(
      "Astro dev: local dev server renders SSR with bindings and local sessions",
      (stack) =>
        Effect.gen(function* () {
          yield* stack.destroy();

          const rootDir = yield* cloneFixture(fixtureDir, {
            prefix: "alchemy-astro-dev-",
            tempRoot,
            entries: ["astro.config.mjs", "package.json", "public", "src"],
          });

          const marker = "astro-dev-marker";

          const { site, sessions } = yield* stack.deploy(
            Effect.gen(function* () {
              const site = yield* Cloudflare.Website.Astro("AstroLocal", {
                rootDir,
                dev: { port: 0 },
                memo: { include: ["src/**", "public/**", "astro.config.mjs", "package.json"] },
                env: { TEST_MARKER: marker },
              });
              // Dedupes by logical id — a handle on the session namespace the
              // Astro resource auto-provisioned, for the dev-identity assertion.
              const sessions = yield* Cloudflare.KV.Namespace("AstroLocalSession");
              return { site, sessions };
            }),
          );

          // Local identity: the url points at the alchemy dev proxy — no
          // cloud Worker exists.
          expect(site.url).toBeDefined();
          expect(site.url).toMatch(/^http:\/\/localhost:\d+/);

          // The auto-provisioned session namespace is emulated locally — a
          // `dev:` id is proof no cloud call ran.
          expect(isLocalId(sessions.namespaceId)).toBe(true);

          // SSR page rendered by astro's dev server (ssr environment runs
          // in workerd behind the proxy) — reads the TEST_MARKER binding.
          yield* expectUrlContains(`${site.url!}/`, marker, {
            timeout: "120 seconds",
            label: "astro dev SSR home with env binding",
          });

          // Prerendered route renders on demand in dev.
          yield* expectUrlContains(`${site.url!}/about/`, "prerendered-page", {
            timeout: "60 seconds",
            label: "astro dev prerender route",
          });

          // Static asset from `public/` through the dev server.
          yield* expectUrlContains(`${site.url!}/static.txt`, "astro-static-asset", {
            timeout: "60 seconds",
            label: "astro dev static asset",
          });

          // The same `public/` file read by a server route through the
          // Worker's `ASSETS` binding.
          yield* expectUrlContains(`${site.url!}/api/asset`, "astro-static-asset", {
            timeout: "60 seconds",
            label: "astro dev ASSETS binding",
          });

          // ── sessions round-trip against the LOCAL simulator ────────────────
          const first = yield* fetchSession(`${site.url!}/session`).pipe(
            Effect.filterOrFail(
              (r) => r.status === 200 && r.body.includes("session-count=1"),
              (r) =>
                new DevResponseMismatch({
                  url: `${site.url!}/session`,
                  detail: `${r.status} ${r.body.slice(0, 240)}`,
                }),
            ),
            devRetry,
          );
          expect(first.sessionCookie).toBeDefined();

          const second = yield* fetchSession(`${site.url!}/session`, first.sessionCookie).pipe(
            Effect.filterOrFail(
              (r) => r.body.includes("session-count=2"),
              (r) =>
                new DevResponseMismatch({
                  url: `${site.url!}/session`,
                  detail: `expected session-count=2, got ${r.body.slice(0, 240)}`,
                }),
            ),
            devRetry,
          );
          expect(second.body).toContain("session-count=2");

          // Out-of-band: NO real cloud namespace was created for the
          // auto-provisioned session KV. (Physical titles embed the logical id
          // verbatim: `{stack}-AstroLocalSession-{stage}-{suffix}`.)
          const { accountId } = yield* yield* CloudflareEnvironment;
          const cloudNamespace = yield* kv.listNamespaces.items({ accountId }).pipe(
            Stream.filter((ns) => ns.title.includes("AstroLocalSession")),
            Stream.runHead,
            Effect.map(Option.getOrUndefined),
          );
          expect(cloudNamespace).toBeUndefined();

          yield* stack.destroy();
        }).pipe(logLevel),
      { tags: ["provider:cloudflare:kv", "live"], timeout: 300_000 },
    );

    // ─────────────────────────────────────────────────────────────────────
    // Declared-static app in dev: `output: "static"` produces no
    // server modules — the dev server must still answer every route from the
    // assets-only dispatch, including the custom 404 page.
    // ─────────────────────────────────────────────────────────────────────

    test.provider(
      "Astro dev: declared-static app serves pages and the 404 page assets-only",
      (stack) =>
        Effect.gen(function* () {
          yield* stack.destroy();

          const rootDir = yield* cloneFixture(staticFixtureDir, {
            prefix: "alchemy-astro-static-dev-",
            tempRoot,
            entries: ["package.json", "public", "src"],
          });

          const site = yield* stack.deploy(
            Effect.gen(function* () {
              return yield* Cloudflare.Website.Astro("AstroStaticLocal", {
                rootDir,
                dev: { port: 0 },
                memo: { include: ["src/**", "public/**", "package.json"] },
                astro: { output: "static" },
                assets: { notFoundHandling: "404-page" },
              });
            }),
          );

          expect(site.url).toBeDefined();
          expect(site.url).toMatch(/^http:\/\/localhost:\d+/);

          yield* expectUrlContains(`${site.url!}/`, "static-home", {
            timeout: "120 seconds",
            label: "astro dev static home",
          });
          yield* expectUrlContains(`${site.url!}/about/`, "static-about", {
            timeout: "60 seconds",
            label: "astro dev static about",
          });
          // Unknown routes serve the custom 404 page with a real 404 status.
          yield* expectStatusBody(`${site.url!}/definitely-not-a-page`, 404, "static-404");

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

    // ─────────────────────────────────────────────────────────────────────
    // `Alchemy.remote()` opt-out: the SITE_KV namespace runs LIVE even in a
    // dev run — the local dev server's binding proxies to the real cloud
    // namespace, and destroy deletes it from the cloud (stamped-mode delete).
    // ─────────────────────────────────────────────────────────────────────

    test.provider(
      "Astro dev: Alchemy.remote() SITE_KV binds the real namespace from the local server",
      (stack) =>
        Effect.gen(function* () {
          yield* stack.destroy();

          const rootDir = yield* cloneFixture(fixtureDir, {
            prefix: "alchemy-astro-remote-",
            tempRoot,
            entries: ["astro.config.mjs", "package.json", "public", "src"],
          });

          const marker = "astro-remote-marker";

          const { site, liveKv } = yield* stack.deploy(
            Effect.gen(function* () {
              const liveKv = yield* Cloudflare.KV.Namespace("AstroRemoteSiteKV").pipe(
                Alchemy.remote(),
              );
              const site = yield* Cloudflare.Website.Astro("AstroRemoteLocal", {
                rootDir,
                dev: { port: 0 },
                memo: { include: ["src/**", "public/**", "astro.config.mjs", "package.json"] },
                env: { TEST_MARKER: marker, SITE_KV: liveKv },
              });
              return { site, liveKv };
            }),
          );

          // The site itself is local; the remote() namespace is REAL.
          expect(site.url).toMatch(/^http:\/\/localhost:\d+/);
          expect(isLocalId(liveKv.namespaceId)).toBe(false);

          // Wait for the dev server before driving the binding.
          yield* expectUrlContains(`${site.url!}/`, marker, {
            timeout: "120 seconds",
            label: "astro dev home (remote kv stack)",
          });

          // Write through the remote-proxied binding via the fixture's
          // /api/kv route, then read it back through the same binding.
          yield* Effect.tryPromise({
            try: async (signal) => {
              const res = await fetch(`${site.url!}/api/kv?key=remote-key&value=${marker}`, {
                signal,
                method: "PUT",
                cache: "no-store",
              });
              return { status: res.status, body: await res.text() };
            },
            catch: (e) =>
              new DevResponseMismatch({
                url: `${site.url!}/api/kv`,
                detail: e instanceof Error ? e.message : String(e),
              }),
          }).pipe(
            Effect.filterOrFail(
              (r) => r.status === 200,
              (r) =>
                new DevResponseMismatch({
                  url: `${site.url!}/api/kv`,
                  detail: `PUT ${r.status} ${r.body.slice(0, 240)}`,
                }),
            ),
            devRetry,
          );

          yield* expectStatusBody(`${site.url!}/api/kv?key=remote-key`, 200, `"value":"${marker}"`);

          // Out-of-band: the write landed in the REAL cloud namespace.
          const { accountId } = yield* yield* CloudflareEnvironment;
          const observed = yield* kv
            .getNamespaceValue({
              accountId,
              namespaceId: liveKv.namespaceId,
              keyName: "remote-key",
            })
            .pipe(
              Effect.flatMap((res) =>
                Effect.tryPromise(() =>
                  new Response(Stream.toReadableStream(res.body) as BodyInit).text(),
                ),
              ),
              Effect.retry({ schedule: Schedule.exponential("1 second", 1.5), times: 8 }),
            );
          expect(observed).toBe(marker);

          yield* stack.destroy();

          // The live namespace was deleted from the cloud on destroy (its
          // state row is stamped live, so the live provider handles the
          // delete even in a dev run).
          const gone = yield* kv.getNamespace({ accountId, namespaceId: liveKv.namespaceId }).pipe(
            Effect.as(false),
            Effect.catchTag("NamespaceNotFound", () => Effect.succeed(true)),
          );
          expect(gone).toBe(true);
        }).pipe(logLevel),
      { tags: ["provider:cloudflare:kv", "live"], timeout: 300_000 },
    );
  },
);