@antelopejs/dms 0.9.1 → 0.9.3

package/frontend-vue/tests/table-view-sortable-columns.test.ts

@@ -1,338 +0,0 @@
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { describe, expect, it, vi } from "vitest";
-import enGB from "../layers/dms-ui/i18n/locales/ui-en-GB.json";
-import frFR from "../layers/dms-ui/i18n/locales/ui-fr-FR.json";
-import {
-  defaultSortingState,
-  headerSortCue,
-  isColumnSortable,
-  isDefaultSorting,
-  isSameSorting,
-  isUnsortableFieldError,
-  resolveDefaultSort,
-  resolveDefaultSortConfig,
-  sanitizeSorting,
-  sortableColumnIds,
-  sortDirectionLabelKey,
-  sortingOrDefault,
-  sortValueKind,
-} from "../layers/dms-ui/app/build/composables/table-view/utils/sortableColumns";
-
-// The Drawer demo's task columns: only `due_date` and
-// `completion_percentage` are `@Sortable()` on `/api/task`.
-const columns = [
-  { id: "name", accessorKey: "name", enableSorting: false },
-  { id: "email", accessorKey: "email", enableSorting: false },
-  { id: "due_date", accessorKey: "due_date", enableSorting: true },
-  { id: "price", accessorKey: "price", enableSorting: false },
-  {
-    id: "completion_percentage",
-    accessorKey: "completion_percentage",
-    enableSorting: true,
-  },
-];
-const sortable = sortableColumnIds(columns);
-
-describe("sortable column gating", () => {
-  it("keeps only the columns the backend marks sortable", () => {
-    expect([...sortable]).toEqual(["due_date", "completion_percentage"]);
-  });
-
-  it("treats a hand-built column without the flag as sortable", () => {
-    expect(isColumnSortable({ id: "x" })).toBe(true);
-    expect(isColumnSortable({ id: "x", enableSorting: false })).toBe(false);
-    expect([...sortableColumnIds([{ accessorKey: "x" }])]).toEqual(["x"]);
-  });
-});
-
-describe("sanitizeSorting", () => {
-  it("keeps a sort on a sortable column", () => {
-    expect(sanitizeSorting([{ id: "due_date", desc: true }], sortable)).toEqual(
-      [{ id: "due_date", desc: true }],
-    );
-  });
-
-  it("drops a saved or pasted sort on a non-sortable column", () => {
-    expect(sanitizeSorting([{ id: "price", desc: false }], sortable)).toEqual(
-      [],
-    );
-    expect(sanitizeSorting([{ id: "gone", desc: false }], sortable)).toEqual(
-      [],
-    );
-  });
-
-  it("sends a single column: the route sorts on one key", () => {
-    expect(
-      sanitizeSorting(
-        [
-          { id: "completion_percentage", desc: false },
-          { id: "due_date", desc: true },
-        ],
-        sortable,
-      ),
-    ).toEqual([{ id: "completion_percentage", desc: false }]);
-  });
-
-  it("survives malformed preferences", () => {
-    expect(sanitizeSorting(undefined, sortable)).toEqual([]);
-    expect(sanitizeSorting(null, sortable)).toEqual([]);
-    expect(sanitizeSorting("due_date" as unknown as never[], sortable)).toEqual(
-      [],
-    );
-    expect(sanitizeSorting([{ id: 3 } as unknown as never], sortable)).toEqual(
-      [],
-    );
-  });
-
-  it("drops a sort on a column the route refused since", () => {
-    const afterRefusal = new Set(
-      [...sortable].filter((id) => id !== "due_date"),
-    );
-    expect(
-      sanitizeSorting([{ id: "due_date", desc: false }], afterRefusal),
-    ).toEqual([]);
-  });
-});
-
-describe("sortingOrDefault", () => {
-  const byDueDate = [{ id: "due_date", desc: true }];
-
-  it("keeps a sort the route serves", () => {
-    const sorting = [{ id: "completion_percentage", desc: false }];
-    expect(sortingOrDefault(sorting, sortable, byDueDate)).toEqual(sorting);
-  });
-
-  // Clearing the sort (a third click on a header) used to be remembered as
-  // `[]`: the table then listed in the database's natural order for good.
-  it("goes back to the default sort once the user clears theirs", () => {
-    expect(sortingOrDefault([], sortable, byDueDate)).toEqual(byDueDate);
-    expect(sortingOrDefault(null, sortable, byDueDate)).toEqual(byDueDate);
-    expect(
-      sortingOrDefault([{ id: "name", desc: false }], sortable, byDueDate),
-    ).toEqual(byDueDate);
-  });
-
-  it("stays unsorted without a default, or when the route refuses it", () => {
-    expect(sortingOrDefault([], sortable, [])).toEqual([]);
-    expect(
-      sortingOrDefault([], new Set(["completion_percentage"]), byDueDate),
-    ).toEqual([]);
-  });
-
-  it("is what the table view restores, and corrects, its sort with", () => {
-    const tableView = readFileSync(
-      resolve(
-        __dirname,
-        "../layers/dms-ui/app/components/table-view/TableView.vue",
-      ),
-      "utf8",
-    );
-    expect(tableView).toMatch(
-      /const sorting = ref<SortingState>\(\s*sortingOrDefault\(/,
-    );
-    expect(tableView).toMatch(
-      /const sanitized = sortingOrDefault\(\s*next,\s*sortableIds\.value,\s*defaultSortState,\s*\);/,
-    );
-  });
-});
-
-describe("resolveDefaultSort", () => {
-  it("uses a sortable default sort", () => {
-    expect(
-      resolveDefaultSort({ field: "due_date", desc: true }, sortable),
-    ).toEqual([{ id: "due_date", desc: true }]);
-    expect(resolveDefaultSort({ field: "due_date" }, sortable)).toEqual([
-      { id: "due_date", desc: false },
-    ]);
-  });
-
-  it("ignores a non-sortable default sort with a warning", () => {
-    const warn = vi.fn();
-    expect(resolveDefaultSort({ field: "name" }, sortable, warn)).toEqual([]);
-    expect(warn).toHaveBeenCalledOnce();
-    expect(warn.mock.calls[0]?.[0]).toContain('"name"');
-  });
-
-  it("has nothing to resolve without a default sort", () => {
-    expect(resolveDefaultSort(undefined, sortable)).toEqual([]);
-  });
-});
-
-describe("isSameSorting", () => {
-  it("compares column and direction", () => {
-    expect(
-      isSameSorting([{ id: "a", desc: false }], [{ id: "a", desc: false }]),
-    ).toBe(true);
-    expect(
-      isSameSorting([{ id: "a", desc: false }], [{ id: "a", desc: true }]),
-    ).toBe(false);
-    expect(isSameSorting([], [{ id: "a", desc: false }])).toBe(false);
-    expect(isSameSorting([], [])).toBe(true);
-  });
-});
-
-describe("isUnsortableFieldError (recovery trigger)", () => {
-  it("recognises the data API's refusal of a sort key", () => {
-    expect(
-      isUnsortableFieldError({
-        name: "FetchError",
-        statusCode: 400,
-        data: "Field is not sortable.",
-      }),
-    ).toBe(true);
-    expect(
-      isUnsortableFieldError({
-        statusCode: 400,
-        data: { message: "Field is not sortable." },
-      }),
-    ).toBe(true);
-    expect(
-      isUnsortableFieldError({
-        response: { status: 400 },
-        message: '[GET] "/api/task/list": 400 Field is not sortable.',
-      }),
-    ).toBe(true);
-  });
-
-  it("leaves every other failure to the error panel", () => {
-    expect(
-      isUnsortableFieldError({ statusCode: 400, data: "Invalid filter." }),
-    ).toBe(false);
-    expect(
-      isUnsortableFieldError({
-        statusCode: 500,
-        data: "Field is not sortable.",
-      }),
-    ).toBe(false);
-    expect(isUnsortableFieldError({ statusCode: 403, data: "Forbidden" })).toBe(
-      false,
-    );
-    expect(isUnsortableFieldError(undefined)).toBe(false);
-    expect(isUnsortableFieldError("Field is not sortable.")).toBe(false);
-  });
-});
-
-describe("stable default sort", () => {
-  it("falls back to a sortable creation date, newest first", () => {
-    const withCreated = new Set(["createdAt", "due_date"]);
-    expect(resolveDefaultSortConfig(undefined, withCreated)).toEqual({
-      field: "createdAt",
-      desc: true,
-    });
-    expect(
-      resolveDefaultSortConfig(undefined, new Set(["created_at"])),
-    ).toEqual({ field: "created_at", desc: true });
-  });
-
-  it("invents nothing without a sortable creation date", () => {
-    // The task demos list `created_at`, but not as @Sortable.
-    expect(resolveDefaultSortConfig(undefined, sortable)).toBeUndefined();
-  });
-
-  it("never replaces a declared default sort, even an ignored one", () => {
-    const warn = vi.fn();
-    expect(
-      resolveDefaultSortConfig({ field: "name" }, new Set(["createdAt"]), warn),
-    ).toBeUndefined();
-    expect(warn).toHaveBeenCalledOnce();
-  });
-});
-
-describe("header sort cue", () => {
-  it("draws nothing on a column that cannot be sorted", () => {
-    expect(
-      headerSortCue({ canSort: false, sorted: false, isDefaultSorting: false }),
-    ).toBe("none");
-    // Even a stale sort state on it never shows.
-    expect(
-      headerSortCue({ canSort: false, sorted: "asc", isDefaultSorting: true }),
-    ).toBe("none");
-  });
-
-  it("draws the neutral cue on an unsorted sortable column", () => {
-    expect(
-      headerSortCue({ canSort: true, sorted: false, isDefaultSorting: true }),
-    ).toBe("idle");
-  });
-
-  it("tells the default sort from the user's", () => {
-    expect(
-      headerSortCue({ canSort: true, sorted: "desc", isDefaultSorting: true }),
-    ).toBe("default");
-    expect(
-      headerSortCue({ canSort: true, sorted: "desc", isDefaultSorting: false }),
-    ).toBe("active");
-  });
-});
-
-describe("default sort indicator", () => {
-  const defaultSort = { field: "due_date", desc: true };
-
-  it("is on while the list keeps its default sort", () => {
-    expect(
-      isDefaultSorting([{ id: "due_date", desc: true }], defaultSort),
-    ).toBe(true);
-  });
-
-  it("is off once the user sorts, reverses or clears the sort", () => {
-    expect(
-      isDefaultSorting(
-        [{ id: "completion_percentage", desc: false }],
-        defaultSort,
-      ),
-    ).toBe(false);
-    expect(
-      isDefaultSorting([{ id: "due_date", desc: false }], defaultSort),
-    ).toBe(false);
-    expect(isDefaultSorting([], defaultSort)).toBe(false);
-  });
-
-  it("never shows without a default sort", () => {
-    expect(isDefaultSorting([], undefined)).toBe(false);
-    expect(isDefaultSorting([{ id: "due_date", desc: true }], undefined)).toBe(
-      false,
-    );
-  });
-
-  it("resets to the default sort, or to none without one", () => {
-    expect(defaultSortingState(defaultSort)).toEqual([
-      { id: "due_date", desc: true },
-    ]);
-    expect(defaultSortingState({ field: "name" })).toEqual([
-      { id: "name", desc: false },
-    ]);
-    expect(defaultSortingState(undefined)).toEqual([]);
-  });
-});
-
-describe("sort direction labels", () => {
-  it("fit the column's data type", () => {
-    expect(sortValueKind("percentage")).toBe("number");
-    expect(sortValueKind("price")).toBe("number");
-    expect(sortValueKind("date")).toBe("date");
-    expect(sortValueKind("string")).toBe("text");
-    expect(sortValueKind(undefined)).toBe("text");
-  });
-
-  it("are translated in English and French", () => {
-    const lookup = (messages: unknown, key: string) =>
-      key
-        .split(".")
-        .reduce<unknown>(
-          (node, part) => (node as Record<string, unknown>)?.[part],
-          messages,
-        );
-    for (const kind of ["number", "date", "text"] as const) {
-      for (const desc of [false, true]) {
-        const key = sortDirectionLabelKey(kind, desc);
-        expect(typeof lookup(enGB, key), key).toBe("string");
-        expect(typeof lookup(frFR, key), key).toBe("string");
-      }
-    }
-    expect(lookup(enGB, "dms.sort.direction.date.desc")).toBe(
-      "newest → oldest",
-    );
-    expect(lookup(frFR, "dms.sort.default_sort")).toBe("Tri par défaut");
-  });
-});

package/frontend-vue/tests/table-view-sources.test.ts

@@ -1,222 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { reactive } from "vue";
-import {
-  processSourceRows,
-  sourceRouteQuery,
-  useTableRows,
-} from "../layers/dms-ui/app/build/composables/table-view/useTableRows";
-import type { TableViewColumn } from "../layers/dms-ui/app/composables/table-view/types";
-
-interface LogRow extends Record<string, unknown> {
-  _id: string;
-  path: string;
-  duration: number;
-}
-
-const ROWS: LogRow[] = [
-  { _id: "a", path: "/api/orders", duration: 40 },
-  { _id: "b", path: "/api/health", duration: 300 },
-  { _id: "c", path: "/api/orders/42", duration: 120 },
-];
-
-const COLUMNS = [
-  { id: "path", accessorKey: "path" },
-  { id: "duration", accessorKey: "duration" },
-] as TableViewColumn[];
-
-type Api = Parameters<typeof useTableRows>[0]["api"];
-
-interface PageRoute {
-  params: Record<string, string>;
-  query: Record<string, unknown>;
-}
-
-describe("source tables", () => {
-  it("sends the route only the part of the query it handles", () => {
-    const query = {
-      search: "orders",
-      sortKey: "duration",
-      sortDirection: "desc",
-      offset: 10,
-      limit: 10,
-      filter_method: "is:GET",
-      ids: "x",
-    };
-    expect(sourceRouteQuery(query, { filter: true })).toEqual({
-      filter_method: "is:GET",
-    });
-    expect(sourceRouteQuery(query, { paginate: true, sort: true })).toEqual({
-      sortKey: "duration",
-      sortDirection: "desc",
-      offset: 10,
-      limit: 10,
-    });
-    expect(
-      sourceRouteQuery(
-        { ...query, showArchived: false },
-        { filter: true, search: true, sort: true, paginate: true },
-      ),
-    ).not.toHaveProperty("showArchived");
-  });
-
-  it("searches, sorts and pages in the browser what the route left to it", () => {
-    const page = processSourceRows(
-      ROWS,
-      {
-        search: "ORDERS",
-        sortKey: "duration",
-        sortDirection: "desc",
-        limit: 1,
-      },
-      {},
-      COLUMNS,
-    );
-    expect(page.total).toBe(2);
-    expect(page.results.map((row) => row._id)).toEqual(["c"]);
-  });
-
-  it("takes a paging route's page and total as they are", async () => {
-    const api = vi.fn(async () => ({ results: ROWS.slice(0, 1), total: 120 }));
-    const rows = useTableRows<LogRow>({
-      api: api as unknown as Api,
-      location: "/api/log",
-      source: { fetchUrl: "/api/log", capabilities: { paginate: true } },
-      columns: COLUMNS,
-    });
-    const page = await rows.list({ offset: 20, limit: 10, search: "x" });
-    expect(api).toHaveBeenCalledWith("/api/log", {
-      query: { offset: 20, limit: 10 },
-    });
-    expect(page).toMatchObject({ total: 120, offset: 20, limit: 10 });
-    expect(await rows.getRow("a")).toBeUndefined();
-  });
-
-  it("counts a source's tabs one list at a time, and a controller's in one batch", async () => {
-    const sourceApi = vi.fn(async () => ({ results: ROWS, total: 3 }));
-    const source = useTableRows<LogRow>({
-      api: sourceApi as unknown as Api,
-      location: "/api/log",
-      source: { fetchUrl: "/api/log", capabilities: {} },
-      columns: COLUMNS,
-    });
-    expect(
-      await source.countBatch([
-        { id: "all", query: {} },
-        { id: "orders", query: { search: "orders" } },
-      ]),
-    ).toEqual({ all: 3, orders: 2 });
-
-    const controllerApi = vi.fn(async () => ({ all: 7 }));
-    const controller = useTableRows<LogRow>({
-      api: controllerApi as unknown as Api,
-      location: "/api/runs",
-      columns: COLUMNS,
-    });
-    await controller.countBatch([{ id: "all", query: {} }]);
-    expect(controllerApi).toHaveBeenCalledWith("/api/runs/count/batch", {
-      method: "POST",
-      body: { queries: [{ id: "all", query: {} }] },
-    });
-  });
-
-  describe("with a templated fetchUrl", () => {
-    const FETCH_URL = "/api/ws/{{params.id}}/requests?route={{query.route}}";
-
-    function sourceRows(route: PageRoute) {
-      const api = vi.fn(async (_url: string) => ({ results: ROWS, total: 3 }));
-      const rows = useTableRows<LogRow>({
-        api: api as unknown as Api,
-        location: FETCH_URL,
-        source: { fetchUrl: FETCH_URL, capabilities: {} },
-        columns: COLUMNS,
-        route: () => ({ routeParams: route.params, routeQuery: route.query }),
-      });
-      return { api, rows };
-    }
-
-    it("requests the page's URL, its values encoded", async () => {
-      const { api, rows } = sourceRows({
-        params: { id: "ws-1" },
-        query: { route: "GET /api/a?b=c" },
-      });
-      await rows.list({});
-      expect(api).toHaveBeenCalledWith(
-        "/api/ws/ws-1/requests?route=GET%20%2Fapi%2Fa%3Fb%3Dc",
-        { query: {} },
-      );
-    });
-
-    it("requests nothing, and lists nothing, while a token has no value", async () => {
-      const { api, rows } = sourceRows({ params: { id: "ws-1" }, query: {} });
-      expect(rows.sourceUrl.value).toBe(undefined);
-      expect(await rows.list({ offset: 10, limit: 10 })).toEqual({
-        results: [],
-        total: 0,
-        offset: 10,
-        limit: 10,
-      });
-      expect(
-        await rows.countBatch([{ id: "orders", query: { search: "orders" } }]),
-      ).toEqual({ orders: 0 });
-      expect(api).not.toHaveBeenCalled();
-    });
-
-    it("follows the page URL, tab counters included", async () => {
-      const route = reactive<PageRoute>({
-        params: { id: "ws-1" },
-        query: { route: "GET /a" },
-      });
-      const { api, rows } = sourceRows(route);
-      await rows.list({});
-      route.query = { route: "POST /b" };
-      expect(rows.sourceUrl.value).toBe(
-        "/api/ws/ws-1/requests?route=POST%20%2Fb",
-      );
-      await rows.countBatch([{ id: "all", query: {} }]);
-      expect(api.mock.calls.map(([url]) => url)).toEqual([
-        "/api/ws/ws-1/requests?route=GET%20%2Fa",
-        "/api/ws/ws-1/requests?route=POST%20%2Fb",
-      ]);
-    });
-  });
-
-  describe("reading one row (fetchRowUrl)", () => {
-    const FETCH_URL = "/api/ws/{{params.ws}}/requests";
-    const ROW_URL = "/api/ws/{{params.ws}}/requests/{{row.id}}";
-
-    function rowsWith(
-      api: (url: string) => Promise<unknown>,
-      fetchRowUrl?: string,
-    ) {
-      return useTableRows<LogRow>({
-        api: api as unknown as Api,
-        location: FETCH_URL,
-        source: { fetchUrl: FETCH_URL, fetchRowUrl, capabilities: {} },
-        columns: COLUMNS,
-        route: () => ({ routeParams: { ws: "ws-1" }, routeQuery: {} }),
-      });
-    }
-
-    it("reads a row by id, its id and the page's tokens filled", async () => {
-      const api = vi.fn(async () => ROWS[2]);
-      const rows = rowsWith(api, ROW_URL);
-      expect(await rows.getRow("c/42")).toBe(ROWS[2]);
-      expect(api).toHaveBeenCalledWith("/api/ws/ws-1/requests/c%2F42");
-    });
-
-    it("rejects as the route does on a missing row", async () => {
-      const api = vi.fn(async () => {
-        throw Object.assign(new Error("Not Found"), { statusCode: 404 });
-      });
-      await expect(rowsWith(api, ROW_URL).getRow("gone")).rejects.toThrow(
-        "Not Found",
-      );
-    });
-
-    it("requests nothing without fetchRowUrl", async () => {
-      const api = vi.fn(async () => ROWS[0]);
-      expect(await rowsWith(api).getRow("a")).toBeUndefined();
-      expect(api).not.toHaveBeenCalled();
-    });
-  });
-});