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

import * as Cloudflare from "@alchemy.run/cloudflare";
import { CloudflareEnvironment } from "@alchemy.run/cloudflare/CloudflareEnvironment";
import { describe, expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as Alchemy from "alchemy";
import * as Effect from "effect/Effect";
import { MinimumLogLevel } from "effect/References";
import * as pathe from "pathe";
import { cloneFixture } from "../Utils/Fixture.ts";
import { expectUrlContains } from "../Utils/Http.ts";
import { expectWorkerExists, waitForWorkerToBeDeleted } from "../Utils/Worker.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");

// Same rationale as Vite.test.ts: Vite's `vite:build-html` plugin expresses
// emitted asset paths relative to `cwd`, so the temp clone has to live under
// the same workspace root.
const tempRoot = pathe.resolve(import.meta.dirname, "../../../.tmp");

const ssrFixtureDir = pathe.resolve(import.meta.dirname, "foldkit-ssr-fixture");

const fixtureEntries = ["package.json", "vite.config.ts", "src"];

// Restrict the input memo to fixture sources so the test isn't re-hashing
// the whole monorepo on every deploy.
const memoInclude = ["index.html", "src/**", "package.json", "vite.config.ts"];

// Tests are independent (per-test scratch stacks, private fixture clones),
// so run them concurrently; suites are sequential by default.
describe.concurrent(
  "Foldkit dev",
  {
    tags: ["provider:cloudflare", "provider:cloudflare:website", "provider:cloudflare:worker"],
  },
  () => {
    // A server-rendered app names no Worker entry of its own, so workerd
    // serves assets alone in dev and Vite's `ssr` environment stays runnable:
    // the Foldkit plugin renders through it exactly as under the app's own
    // `vite dev`. Each page stamps the `count` query into its markup, which
    // is what tells a render from a served template.
    test.provider(
      "Foldkit dev: a server-rendered app renders through the local dev server",
      (stack) =>
        Effect.gen(function* () {
          yield* stack.destroy();

          const rootDir = yield* cloneFixture(ssrFixtureDir, {
            prefix: "alchemy-foldkit-dev-ssr-",
            tempRoot,
            entries: fixtureEntries,
          });

          const site = yield* stack.deploy(
            Cloudflare.Website.Foldkit("FoldkitSsrLocal", {
              rootDir,
              dev: { port: 0 },
              memo: { include: memoInclude },
            }),
          );

          // 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 front page renders on request — a served template would
          // carry an empty `<div id="root">` and no count at all.
          yield* expectUrlContains(`${site.url!}/?count=7`, ">7<", {
            timeout: "30 seconds",
            label: "foldkit dev ssr front page",
          });
          // A deep link is rendered too; nothing is prerendered in dev.
          yield* expectUrlContains(`${site.url!}/counter/42?count=3`, ">3<", {
            timeout: "15 seconds",
            label: "foldkit dev ssr deep link",
          });

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

    /**
     * `Alchemy.remote()` opts the whole site OUT of local emulation: even under
     * `alchemy dev` the build runs, the fetch handler it emits deploys to real
     * Cloudflare, and destroy deletes the cloud Worker (the state row is
     * stamped live).
     */
    test.provider(
      "Foldkit dev: Alchemy.remote() deploys the real Worker and destroy removes it",
      (stack) =>
        Effect.gen(function* () {
          const { accountId } = yield* yield* CloudflareEnvironment;

          yield* stack.destroy();

          const rootDir = yield* cloneFixture(ssrFixtureDir, {
            prefix: "alchemy-foldkit-dev-remote-",
            tempRoot,
            entries: fixtureEntries,
          });

          const site = yield* stack.deploy(
            Cloudflare.Website.Foldkit("FoldkitRemoteSite", {
              rootDir,
              workersDev: true,
              compatibility: {
                date: "2024-09-23",
                flags: ["nodejs_compat"],
              },
              memo: { include: memoInclude },
            }).pipe(Alchemy.remote()),
          );

          // Real identity: a non-local URL and a Worker that exists on
          // Cloudflare.
          expect(site.url).toBeDefined();
          expect(site.url).not.toMatch(/^http:\/\/localhost/);
          yield* expectWorkerExists(site.workerName, accountId);

          // The deployed handler renders the front page on request.
          yield* expectUrlContains(`${site.url!}/?count=7`, ">7<", {
            timeout: "30 seconds",
            label: "remote() foldkit ssr front page in dev mode",
          });
          // The route the fixture prerenders is a file: the query never
          // reaches a render.
          yield* expectUrlContains(`${site.url!}/about/?count=7`, ">0<", {
            timeout: "15 seconds",
            label: "remote() foldkit prerendered page in dev mode",
          });

          yield* stack.destroy();

          // The stamped-live row deletes the real Worker even in a dev run.
          yield* waitForWorkerToBeDeleted(site.workerName, accountId);
        }).pipe(logLevel),
      { tags: ["live"], timeout: 120_000 },
    );
  },
);