sailfork / t3code-github / .repos/ alchemy-effect/ packages/ frontend-frameworks/ src/ waku/ test/ cloudflare.test.ts

import * as NodePath from "node:path";
import * as Effect from "effect/Effect";
import type * as ViteModule from "vite";
import { describe, expect, it } from "vitest";
import { isDeployTarget } from "../../core/index.ts";
import cloudflareTargetFactory, {
  makeWakuCloudflareTarget,
  makeWakuPluginOptions,
} from "../cloudflare.ts";
import { WAKU_SERVER_ENTRY_PATH } from "../index.ts";

const WAKU_DIR = "/project/node_modules/waku";

const context = {
  root: "/project",
  wakuDirectory: WAKU_DIR,
  phase: "build",
} as const;

const flatten = (plugins: ReadonlyArray<ViteModule.PluginOption>): Array<ViteModule.Plugin> =>
  (plugins as Array<unknown>)
    .flat(8)
    .filter(
      (plugin): plugin is ViteModule.Plugin =>
        typeof plugin === "object" && plugin !== null && "name" in plugin,
    );

describe("makeWakuPluginOptions", () => {
  it("defaults main to waku's rsc worker entry and pins the rsc/ssr topology", () => {
    const options = makeWakuPluginOptions({
      root: "/project",
      wakuDirectory: WAKU_DIR,
    });
    expect(options.main).toBe(NodePath.join(WAKU_DIR, WAKU_SERVER_ENTRY_PATH));
    expect(options.viteEnvironments).toEqual({
      entry: "rsc",
      children: ["ssr"],
    });
  });

  it("preserves user cloudflare options but overrides viteEnvironments", () => {
    const options = makeWakuPluginOptions({
      root: "/project",
      wakuDirectory: WAKU_DIR,
      pluginOptions: {
        compatibilityDate: "2026-03-10",
        compatibilityFlags: ["nodejs_als"],
        worker: { name: "fixtures-waku", bindings: [] },
        viteEnvironments: { entry: "ssr" },
      },
    });
    expect(options.compatibilityDate).toBe("2026-03-10");
    expect(options.compatibilityFlags).toEqual(["nodejs_als"]);
    expect(options.worker?.name).toBe("fixtures-waku");
    // The environment topology always wins: the worker must run in the rsc
    // environment.
    expect(options.main).toBe(NodePath.join(WAKU_DIR, WAKU_SERVER_ENTRY_PATH));
    expect(options.viteEnvironments).toEqual({
      entry: "rsc",
      children: ["ssr"],
    });
  });

  it("lets a user main (the user-entry seam) take precedence over waku's entry", () => {
    const absolute = makeWakuPluginOptions({
      root: "/project",
      wakuDirectory: WAKU_DIR,
      pluginOptions: { main: "/project/src/worker-entry.ts" },
    });
    expect(absolute.main).toBe("/project/src/worker-entry.ts");

    // A relative main resolves against the project root, not process.cwd().
    const relative = makeWakuPluginOptions({
      root: "/project",
      wakuDirectory: WAKU_DIR,
      pluginOptions: { main: "./src/worker-entry.ts" },
    });
    expect(relative.main).toBe(NodePath.resolve("/project", "src/worker-entry.ts"));
    // The topology stays pinned even with a user main.
    expect(relative.viteEnvironments).toEqual({
      entry: "rsc",
      children: ["ssr"],
    });
  });

  it("defaults compatibilityFlags to nodejs_als (waku needs AsyncLocalStorage)", () => {
    expect(
      makeWakuPluginOptions({ root: "/project", wakuDirectory: WAKU_DIR }).compatibilityFlags,
    ).toEqual(["nodejs_als"]);
    expect(
      makeWakuPluginOptions({
        root: "/project",
        wakuDirectory: WAKU_DIR,
        pluginOptions: { compatibilityFlags: [] },
      }).compatibilityFlags,
    ).toEqual(["nodejs_als"]);
    expect(
      makeWakuPluginOptions({
        root: "/project",
        wakuDirectory: WAKU_DIR,
        pluginOptions: { compatibilityFlags: ["global_fetch_strictly_public"] },
      }).compatibilityFlags,
    ).toEqual(["global_fetch_strictly_public", "nodejs_als"]);
  });

  it("keeps user compatibilityFlags that already provide AsyncLocalStorage", () => {
    expect(
      makeWakuPluginOptions({
        root: "/project",
        wakuDirectory: WAKU_DIR,
        pluginOptions: { compatibilityFlags: ["nodejs_als"] },
      }).compatibilityFlags,
    ).toEqual(["nodejs_als"]);
    expect(
      makeWakuPluginOptions({
        root: "/project",
        wakuDirectory: WAKU_DIR,
        pluginOptions: { compatibilityFlags: ["nodejs_compat"] },
      }).compatibilityFlags,
    ).toEqual(["nodejs_compat"]);
    expect(
      makeWakuPluginOptions({
        root: "/project",
        wakuDirectory: WAKU_DIR,
        pluginOptions: { compatibilityFlags: ["nodejs_compat_v2"] },
      }).compatibilityFlags,
    ).toEqual(["nodejs_compat_v2"]);
  });
});

describe("makeWakuCloudflareTarget", () => {
  it("default-exports the target factory", () => {
    expect(cloudflareTargetFactory).toBe(makeWakuCloudflareTarget);
    expect(isDeployTarget(cloudflareTargetFactory({}))).toBe(true);
  });

  it("is a cloudflare DeployTarget carrying the config opaquely", () => {
    const config = { compatibilityDate: "2026-03-10" };
    const target = makeWakuCloudflareTarget(config);
    expect(target.platform).toBe("cloudflare");
    expect(target.config).toBe(config);
    expect(isDeployTarget(target)).toBe(true);
    // `config` must be an own property even when undefined — `isDeployTarget`
    // checks for its presence.
    expect(isDeployTarget(makeWakuCloudflareTarget())).toBe(true);
  });

  it("declares the workerd bundle conditions and cloudflare: externals", () => {
    const target = makeWakuCloudflareTarget();
    expect(target.bundle?.conditions).toEqual(["workerd", "worker", "module", "browser"]);
    expect(target.bundle?.external).toEqual(["cloudflare:"]);
  });

  it("does not take over the framework build (no wholesale build hook)", () => {
    const target = makeWakuCloudflareTarget();
    expect(target.build).toBeUndefined();
    expect(target.finish).toBeUndefined();
  });

  it("resolves the adapter hook to this package's wrangler-free fork", () => {
    const target = makeWakuCloudflareTarget();
    const adapterPath = Effect.runSync(target.adapter(context));
    expect(NodePath.isAbsolute(adapterPath)).toBe(true);
    expect(adapterPath).toMatch(/adapter\.(ts|js)$/);
  });

  it("produces the cloudflare vite plugin with the pinned waku options", () => {
    const target = makeWakuCloudflareTarget({
      compatibilityDate: "2026-03-10",
    });
    const plugins = flatten(Effect.runSync(target.vitePlugins(context)));
    expect(plugins.length).toBeGreaterThan(0);
    expect(plugins.some((plugin) => plugin.name.startsWith("distilled-cloudflare"))).toBe(true);
  });

  it("surfaces the config's main as the generic user-entry carriage", () => {
    expect(makeWakuCloudflareTarget().entry).toBeUndefined();
    expect(makeWakuCloudflareTarget({ compatibilityDate: "2026-03-10" }).entry).toBeUndefined();
    expect(makeWakuCloudflareTarget({ main: "./src/worker-entry.ts" }).entry).toEqual({
      main: "./src/worker-entry.ts",
    });
  });
});