sailfork / t3code-github / .repos/ alchemy-effect/ packages/ cloudflare-runtime/ src/ rolldown/ test/ options.test.ts

import path from "node:path";
import type { MinimalPluginContext } from "rolldown";
import type * as vite from "vite";
import { assert, describe, expect, it } from "vitest";
import { optionsPlugin } from "../plugins/options.ts";

const callViteConfig = async (
  plugin: vite.Plugin | null,
  userConfig: vite.UserConfig,
): Promise<vite.UserConfig> => {
  assert(plugin, "plugin is not defined");
  const hook = plugin.config;
  assert(typeof hook === "function", "plugin.config is not a function");
  const result = await hook.call({ meta: {} } as never, userConfig, {
    command: "build",
    mode: "production",
  } as never);
  assert(result, "config hook returned nothing");
  return result as vite.UserConfig;
};

const NO_HTML_ROOT = path.resolve("test/fixtures");
const HTML_ROOT = path.resolve("test/fixtures/client-html");

interface FakeEnvironment {
  name: string;
  isBuilt?: boolean;
  /** Defaults to a directory with no `index.html`. */
  root?: string;
  build?: {
    rollupOptions?: { input?: unknown };
    rolldownOptions?: { input?: unknown };
  };
}

/** Records the environments the resolved `buildApp` actually builds. */
const runBuildApp = async (
  config: vite.UserConfig,
  environments: Array<FakeEnvironment>,
): Promise<Array<string>> => {
  const buildApp = config.builder?.buildApp;
  assert(typeof buildApp === "function", "buildApp is not a function");
  const built: Array<string> = [];
  await buildApp({
    config: { root: NO_HTML_ROOT, publicDir: false },
    environments: Object.fromEntries(
      environments.map(({ name, isBuilt = false, root = NO_HTML_ROOT, build = {} }) => [
        name,
        { name, isBuilt, config: { root, build: { outDir: `dist/${name}`, ...build } } },
      ]),
    ),
    build: async (environment: { name: string }) => {
      built.push(environment.name);
    },
  } as never);
  return built;
};

describe("options plugin", () => {
  it("preserves dependency discovery settings for each Worker environment", async () => {
    const plugin = optionsPlugin.vite({
      viteEnvironments: { entry: "rsc", children: ["ssr"] },
    });
    const result = await callViteConfig(plugin, {
      optimizeDeps: { noDiscovery: true },
      environments: { ssr: { optimizeDeps: { noDiscovery: false } } },
    });
    expect(result.environments?.rsc?.optimizeDeps?.noDiscovery).toBe(true);
    expect(result.environments?.ssr?.optimizeDeps?.noDiscovery).toBe(false);

    const explicit = await callViteConfig(optionsPlugin.vite({ main: "./worker.ts" }), {
      environments: { ssr: { optimizeDeps: { noDiscovery: true } } },
    });
    expect(explicit.environments?.ssr?.optimizeDeps?.noDiscovery).toBe(true);

    const defaults = await callViteConfig(optionsPlugin.vite({ main: "./worker.ts" }), {});
    expect(defaults.environments?.ssr?.optimizeDeps?.noDiscovery).toBe(false);
  });

  it("applies the Cloudflare defaults", () => {
    const plugin = optionsPlugin.rolldown({});
    const input = {};
    assert(typeof plugin.options === "function", "plugin.options is not a function");
    const output = plugin.options.call({} as MinimalPluginContext, input);
    assert(output, "output is not defined");
    assert(!(output instanceof Promise), "output is a promise");

    expect(output.platform).toBe("neutral");
    expect(output.resolve?.conditionNames).toEqual([
      "workerd",
      "worker",
      "module",
      "browser",
      "production",
    ]);
    expect(output.resolve?.mainFields).toEqual([
      "browser",
      "module",
      "jsnext:main",
      "jsnext",
      "main",
    ]);
    expect(output.resolve?.extensions).toEqual([
      ".mjs",
      ".js",
      ".mts",
      ".ts",
      ".jsx",
      ".tsx",
      ".json",
      ".cjs",
      ".cts",
      ".ctx",
    ]);
    expect(output.transform?.target).toBe("es2026");
  });

  it("defines production node env values and stubs process.env without nodejs_compat", () => {
    const plugin = optionsPlugin.rolldown({});
    const input = {};
    assert(typeof plugin.options === "function", "plugin.options is not a function");
    const output = plugin.options!.call({} as MinimalPluginContext, input);
    assert(output, "output is not defined");
    assert(!(output instanceof Promise), "output is a promise");

    expect(output.transform?.define).toMatchObject({
      "process.env.NODE_ENV": '"production"',
      "global.process.env.NODE_ENV": '"production"',
      "globalThis.process.env.NODE_ENV": '"production"',
      "process.env": "{}",
      "global.process.env": "{}",
      "globalThis.process.env": "{}",
    });
  });

  it.each([{ compatibilityFlags: ["nodejs_compat"] }, { compatibilityDate: "2026-08-31" }])(
    "preserves runtime process.env with Node compatibility: %j",
    (options) => {
      const plugin = optionsPlugin.rolldown(options);
      const input = {};
      assert(typeof plugin.options === "function", "plugin.options is not a function");
      const output = plugin.options!.call({} as MinimalPluginContext, input);
      assert(output, "output is not defined");
      assert(!(output instanceof Promise), "output is a promise");

      expect(output.transform?.define).toMatchObject({
        "process.env.NODE_ENV": '"production"',
        "global.process.env.NODE_ENV": '"production"',
        "globalThis.process.env.NODE_ENV": '"production"',
      });
      expect(output.transform?.define?.["process.env"]).toBeUndefined();
      expect(output.transform?.define?.["global.process.env"]).toBeUndefined();
      expect(output.transform?.define?.["globalThis.process.env"]).toBeUndefined();
    },
  );

  it("defines navigator.userAgent only when the compatibility date supports it", () => {
    const withNavigator = optionsPlugin.rolldown({
      compatibilityDate: "2022-03-21",
    });
    const withoutNavigator = optionsPlugin.rolldown({
      compatibilityDate: "2022-03-20",
    });

    assert(typeof withNavigator.options === "function", "withNavigator.options is not a function");
    assert(
      typeof withoutNavigator.options === "function",
      "withoutNavigator.options is not a function",
    );

    const withNavigatorOutput = withNavigator.options!.call({} as MinimalPluginContext, {});
    const withoutNavigatorOutput = withoutNavigator.options.call({} as MinimalPluginContext, {});

    assert(withNavigatorOutput, "withNavigatorOutput is not defined");
    assert(!(withNavigatorOutput instanceof Promise), "withNavigatorOutput is a promise");
    assert(withoutNavigatorOutput, "withoutNavigatorOutput is not defined");
    assert(!(withoutNavigatorOutput instanceof Promise), "withoutNavigatorOutput is a promise");

    expect(withNavigatorOutput.transform?.define?.["navigator.userAgent"]).toBe(
      '"Cloudflare-Workers"',
    );
    expect(withoutNavigatorOutput.transform?.define?.["navigator.userAgent"]).toBeUndefined();
  });

  it("normalizes Windows backslashes in worker entry ids", () => {
    const plugin = optionsPlugin.rolldown({});
    assert(typeof plugin.options === "function", "plugin.options is not a function");
    const output = plugin.options.call({} as MinimalPluginContext, {
      input: { worker: "D:\\src\\app\\entry-server.ts" },
    });
    assert(output, "output is not defined");
    assert(!(output instanceof Promise), "output is a promise");

    // The virtual worker-entry id must use POSIX separators so it round-trips
    // through Rolldown/Vite id handling and resolves on Windows.
    expect(output.input).toEqual({
      worker: "\0distilled:worker-entry:D:/src/app/entry-server.ts",
    });
  });

  it("defaults builder.buildApp when the user config does not define one", async () => {
    const plugin = optionsPlugin.vite({ main: "./worker.ts" });
    const result = await callViteConfig(plugin, {});
    expect(typeof result.builder?.buildApp).toBe("function");
  });

  it("does not clobber a framework-provided builder.buildApp", async () => {
    // Vite merges plugin `config` results over the user config, so returning a
    // default here would replace the framework's orchestrator (e.g. Astro's
    // prerender -> ssr -> client pipeline).
    const buildApp = async () => {};
    const plugin = optionsPlugin.vite({ main: "./worker.ts" });
    const result = await callViteConfig(plugin, { builder: { buildApp } });
    expect(result.builder).toBeUndefined();
  });

  it("builds only the client in SPA mode", async () => {
    const plugin = optionsPlugin.vite({});
    const result = await callViteConfig(plugin, { root: HTML_ROOT });
    // `custom`, as `@cloudflare/vite-plugin` sets it: HTML is served through
    // the Worker's router, never Vite's SPA middleware.
    expect(result.appType).toBe("custom");
    // An assets-only site declares no Worker environments.
    expect(result.environments).toBeUndefined();
    const built = await runBuildApp(result, [
      { name: "client", root: HTML_ROOT },
      { name: "ssr", root: HTML_ROOT },
    ]);
    expect(built).toEqual(["client"]);
  });

  it("builds an assets-only site with only public/ through a fallback client entry", async () => {
    // As `@cloudflare/vite-plugin` does: the client still builds, from an
    // empty entry, so its output holds the `public/` files.
    const plugin = optionsPlugin.vite({});
    const result = await callViteConfig(plugin, { root: NO_HTML_ROOT });
    const environments = {
      client: {
        name: "client",
        isBuilt: false,
        config: { root: NO_HTML_ROOT, build: { outDir: "dist" } as Record<string, unknown> },
      },
    };
    const built: Array<string> = [];
    await result.builder?.buildApp?.({
      config: { root: NO_HTML_ROOT, publicDir: path.join(NO_HTML_ROOT, "client-html") },
      environments,
      build: async (environment: { name: string }) => {
        built.push(environment.name);
      },
    } as never);
    expect(built).toEqual(["client"]);
    expect(environments.client.config.build.rollupOptions).toMatchObject({
      input: "virtual:cloudflare/client-fallback-entry",
    });
  });

  it("skips skipEnvironments in the default buildApp", async () => {
    const plugin = optionsPlugin.vite({
      main: "./worker.ts",
      skipEnvironments: ["prerender"],
    });
    const result = await callViteConfig(plugin, {});

    const built = await runBuildApp(result, [
      { name: "ssr" },
      { name: "client", build: { rollupOptions: { input: "./src/main.tsx" } } },
      // Framework-owned environment with no build input of its own.
      { name: "prerender" },
      { name: "already", isBuilt: true },
    ]);
    expect(built).toEqual(["ssr", "client"]);
  });

  it("skips the entry-less client environment in the default buildApp", async () => {
    // Vite creates `client` for every app. A pure Worker app never configures
    // it, so building it would fall back to a nonexistent `index.html`.
    const plugin = optionsPlugin.vite({ main: "./worker.ts" });
    const result = await callViteConfig(plugin, {});

    const built = await runBuildApp(result, [{ name: "ssr" }, { name: "client" }]);
    expect(built).toEqual(["ssr"]);
  });

  it("builds a client environment that has a configured input", async () => {
    const plugin = optionsPlugin.vite({ main: "./worker.ts" });
    const result = await callViteConfig(plugin, {});

    const withRollupInput = await runBuildApp(result, [
      { name: "client", build: { rollupOptions: { input: "./src/main.tsx" } } },
    ]);
    expect(withRollupInput).toEqual(["client"]);

    const withRolldownInput = await runBuildApp(result, [
      {
        name: "client",
        build: { rolldownOptions: { input: "./src/main.tsx" } },
      },
    ]);
    expect(withRolldownInput).toEqual(["client"]);
  });

  it("builds a client environment whose root has an index.html", async () => {
    const plugin = optionsPlugin.vite({ main: "./worker.ts" });
    const result = await callViteConfig(plugin, {});

    const built = await runBuildApp(result, [{ name: "client", root: HTML_ROOT }]);
    expect(built).toEqual(["client"]);
  });
});