siftlode/frontend/src/lib/uiBoundary.contract.test.ts

import { describe, expect, it } from "vitest";

import { eslint } from "./lintProbe.testkit";

// `components/ui/` is a platform layer, and the rule that makes it one — no feature components,
// no domain API slices — lives in eslint.config.js rather than prose. This asserts the rule
// actually FIRES, because a `no-restricted-imports` pattern that matches nothing is indistinguishable
// from a clean codebase: the first cut wrote its regexes in plain "..." literals, where `\.` collapses
// to the any-char `.`, and it silently let through both `../../lib/api` (the barrel every feature
// component imports) and `../../components/Feed` (the same file `../Feed` names). Eight green lanes
// said nothing. A rule stated in a comment must also be enforced in code — and a
// rule meant to enforce something must itself be tested.
const BOUNDARY = "no-restricted-imports";

// Linted as if it were this file, so eslint.config.js's `files: ["src/components/ui/**"]` block applies.
const AS_UI = "src/components/ui/__boundary_probe.tsx";

// fileURLToPath, not URL.pathname: on Windows the latter yields "/D:/…", which eslint cannot resolve
// a config from. Anchored to this file rather than process.cwd() so the test holds wherever it is run.

async function restrictedIn(source: string, filePath: string): Promise<string[]> {
  const [result] = await eslint.lintText(source, { filePath });
  return (result?.messages ?? []).filter((m) => m.ruleId === BOUNDARY).map((m) => m.message);
}

describe("components/ui/ boundary rule", () => {
  it("refuses a feature component by BOTH of its spellings", async () => {
    const found = await restrictedIn(
      `import A from "../Sidebar";\nimport B from "../../components/Feed";\nexport default [A, B];\n`,
      AS_UI,
    );
    expect(found).toHaveLength(2);
    expect(found.every((m) => m.includes("may not import a feature component"))).toBe(true);
  });

  it("refuses a domain API slice AND the barrel that re-exports every slice", async () => {
    const found = await restrictedIn(
      `import { api } from "../../lib/api";\nimport * as p from "../../lib/api/playlists";\nexport default [api, p];\n`,
      AS_UI,
    );
    expect(found).toHaveLength(2);
    expect(found.every((m) => m.includes("may not call a domain API slice"))).toBe(true);
  });

  it("allows what the layer is FOR — sibling primitives and generic lib helpers", async () => {
    const found = await restrictedIn(
      `import B from "./Button";\nimport M from "../../components/ui/Modal";\nimport { qk } from "../../lib/queryKeys";\nexport default [B, M, qk];\n`,
      AS_UI,
    );
    expect(found).toEqual([]);
  });

  it("binds only inside ui/ — a feature component may still import its neighbours", async () => {
    const found = await restrictedIn(
      `import { api } from "../lib/api";\nimport S from "./Sidebar";\nexport default [api, S];\n`,
      "src/components/__boundary_probe.tsx",
    );
    expect(found).toEqual([]);
  });
});

// One layer down, `lib/` may not import from `components/` at all. The type-only and the
// re-export spellings are in here on purpose — both are how a lib helper most easily leans on a
// component (`lib/sortOptions` imported `Column` from `ui/tableHeader` as a type).
describe("lib/ boundary rule", () => {
  const AS_LIB = "src/lib/__boundary_probe.ts";

  it("refuses components/ by every spelling: value, type-only, re-export, and from a nested lib dir", async () => {
    const source =
      `import F from "../components/Feed";\n` +
      `import type { Column } from "../components/ui/tableHeader";\n` +
      `export type { FilterMap } from "../components/ui/tableHeader";\n` +
      `export default F;\n`;
    const found = await restrictedIn(source, AS_LIB);
    const nested = await restrictedIn(
      `import M from "../../components/ui/Modal";\nexport default M;\n`,
      "src/lib/api/__boundary_probe.ts",
    );
    expect(found).toHaveLength(3);
    expect(nested).toHaveLength(1);
    expect([...found, ...nested].every((m) => m.includes("may not import from components/"))).toBe(
      true,
    );
  });

  it("allows lib's own modules and the i18n setup", async () => {
    const found = await restrictedIn(
      `import { qk } from "./queryKeys";\nimport { api } from "./api";\nimport i18n from "../i18n";\nexport default [qk, api, i18n];\n`,
      AS_LIB,
    );
    expect(found).toEqual([]);
  });
});