sailfork / t3code-github / .repos/ alchemy-effect/ packages/ frontend-frameworks/ src/ nuxt/ test/ UserConfig.test.ts

import { describe, expect, it } from "vitest";
import {
  enforceNitroConfig,
  findPresetConflict,
  isSamePreset,
  makeNuxtOverrides,
  normalizePresetName,
  presetConflictMessage,
  type NitroConfigSlice,
} from "../UserConfig.ts";

describe("normalizePresetName / isSamePreset", () => {
  it("treats snake, kebab, and camel spellings as the same preset", () => {
    expect(normalizePresetName("cloudflare_module")).toBe("cloudflare-module");
    expect(normalizePresetName("cloudflare-module")).toBe("cloudflare-module");
    expect(normalizePresetName("cloudflareModule")).toBe("cloudflare-module");
    expect(isSamePreset("cloudflare_module", "cloudflare-module")).toBe(true);
    expect(isSamePreset("cloudflareModule", "cloudflare_module")).toBe(true);
  });

  it("distinguishes genuinely different presets", () => {
    expect(isSamePreset("cloudflare_module", "cloudflare_pages")).toBe(false);
    expect(isSamePreset("cloudflare_module", "cloudflare_durable")).toBe(false);
    expect(isSamePreset("cloudflare_module", "vercel")).toBe(false);
  });
});

describe("makeNuxtOverrides", () => {
  it("injects the target preset into the nitro overrides", () => {
    const overrides = makeNuxtOverrides({ nitroPreset: "cloudflare_module" });
    expect(overrides).toEqual({
      vite: { logLevel: "warn" },
      nitro: { preset: "cloudflare_module" },
    });
  });

  it("lets integration-level vite config override the reporter-safe defaults", () => {
    const overrides = makeNuxtOverrides({
      nuxtConfig: { vite: { logLevel: "info", clearScreen: false } },
    });
    expect(overrides["vite"]).toEqual({ logLevel: "info", clearScreen: false });
  });

  it("merges integration-level nuxt config, with the preset winning over its nitro slice", () => {
    const overrides = makeNuxtOverrides({
      nitroPreset: "cloudflare_module",
      nuxtConfig: {
        ssr: true,
        nitro: { preset: "vercel", minify: false },
      },
    });
    expect(overrides["ssr"]).toBe(true);
    expect(overrides["nitro"]).toEqual({
      preset: "cloudflare_module",
      minify: false,
    });
  });

  it("appends nitro plugins after integration-declared ones", () => {
    const overrides = makeNuxtOverrides({
      nitroPreset: "cloudflare_module",
      nuxtConfig: { nitro: { plugins: ["a-plugin.ts"] } },
      nitroPlugins: ["/abs/dev-bridge.ts"],
    });
    expect((overrides["nitro"] as { plugins: Array<string> }).plugins).toEqual([
      "a-plugin.ts",
      "/abs/dev-bridge.ts",
    ]);
  });

  it("omits the preset for dev-shaped overrides (no nitroPreset) while still appending plugins", () => {
    const overrides = makeNuxtOverrides({
      nuxtConfig: { telemetry: false },
      nitroPlugins: ["/abs/dev-bridge.ts"],
    });
    expect(overrides["telemetry"]).toBe(false);
    expect(overrides["nitro"]).toEqual({ plugins: ["/abs/dev-bridge.ts"] });
  });

  it("merges injected runtimeConfig over the integration overrides' runtimeConfig", () => {
    const overrides = makeNuxtOverrides({
      nuxtConfig: { runtimeConfig: { keep: "user", clobbered: "user" } },
      runtimeConfig: {
        clobbered: "platform",
        injected: { url: "http://127.0.0.1:1", token: "t" },
      },
    });
    expect(overrides["runtimeConfig"]).toEqual({
      keep: "user",
      clobbered: "platform",
      injected: { url: "http://127.0.0.1:1", token: "t" },
    });
  });

  it("adds no runtimeConfig key when none is injected", () => {
    const overrides = makeNuxtOverrides({ nitroPreset: "cloudflare_module" });
    expect("runtimeConfig" in overrides).toBe(false);
  });

  it("adds no plugins key when none are given", () => {
    const overrides = makeNuxtOverrides({ nitroPreset: "cloudflare_module" });
    expect("plugins" in (overrides["nitro"] as Record<string, unknown>)).toBe(false);
  });
});

describe("findPresetConflict", () => {
  const layer = (preset: string | undefined, cwd = "/project") => ({
    cwd,
    config: preset !== undefined ? { nitro: { preset } } : {},
  });

  it("returns undefined when no layer sets a preset", () => {
    expect(findPresetConflict([layer(undefined)], "cloudflare_module")).toBeUndefined();
    expect(findPresetConflict([], "cloudflare_module")).toBeUndefined();
    expect(findPresetConflict(undefined, "cloudflare_module")).toBeUndefined();
  });

  it("accepts the target preset and its spelling aliases", () => {
    expect(findPresetConflict([layer("cloudflare_module")], "cloudflare_module")).toBeUndefined();
    expect(findPresetConflict([layer("cloudflare-module")], "cloudflare_module")).toBeUndefined();
    expect(findPresetConflict([layer("cloudflareModule")], "cloudflare_module")).toBeUndefined();
  });

  it("surfaces a foreign preset from any layer", () => {
    expect(findPresetConflict([layer("vercel")], "cloudflare_module")).toBe("vercel");
    expect(
      findPresetConflict(
        [layer(undefined), layer("cloudflare_pages", "/project/base")],
        "cloudflare_module",
      ),
    ).toBe("cloudflare_pages");
  });

  it("ignores empty-string presets", () => {
    expect(findPresetConflict([layer("")], "cloudflare_module")).toBeUndefined();
  });
});

describe("presetConflictMessage", () => {
  it("names both presets and the fix", () => {
    const message = presetConflictMessage("vercel", "cloudflare_module");
    expect(message).toContain('"vercel"');
    expect(message).toContain('"cloudflare_module"');
    expect(message).toContain("nitro.preset");
  });
});

describe("enforceNitroConfig", () => {
  it("enforces the preset as the last word", () => {
    const config: NitroConfigSlice = { preset: "node-server" };
    enforceNitroConfig(config, { preset: "cloudflare_module" });
    expect(config.preset).toBe("cloudflare_module");
  });

  it("runs the target's configure pass after the preset is set", () => {
    const config: NitroConfigSlice = {};
    const seen: Array<string | undefined> = [];
    enforceNitroConfig(config, {
      preset: "cloudflare_module",
      configure: (nitroConfig) => {
        seen.push(nitroConfig.preset);
        nitroConfig.cloudflare = { deployConfig: false };
      },
    });
    expect(seen).toEqual(["cloudflare_module"]);
    expect(config.cloudflare).toEqual({ deployConfig: false });
  });
});