@multiplatform.one/backoffice 6.4.2 → 6.6.0

package/src/report/reportShapes.spec.ts

@@ -0,0 +1,101 @@
+// Normalizer specs pinned to PROBED bench payloads (see reportShapes.ts
+// header): v15 dict columns/rows from frappe.desk.query_report.run plus the
+// defensive old-style string-column / positional-array-row forms.
+import { describe, expect, it } from "vitest";
+import {
+  normalizeQueryReportColumns,
+  normalizeQueryReportRows,
+  scrubFieldname,
+  stripHtml,
+} from "./reportShapes";
+
+describe("normalizeQueryReportColumns", () => {
+  it("normalizes v15 dict columns (probed ToDo report shape)", () => {
+    const columns = normalizeQueryReportColumns([
+      { fieldtype: "Link", options: "ToDo", width: "90", label: "ID", fieldname: "id" },
+      { fieldtype: "", width: "60", label: "Priority", fieldname: "priority" },
+      { fieldtype: "Date", label: "Date", fieldname: "date" },
+      {
+        fieldtype: "Data",
+        width: "120",
+        label: "Assigned To/Owner",
+        fieldname: "assigned_to/owner",
+      },
+    ]);
+    expect(columns).toEqual([
+      { fieldname: "id", label: "ID", fieldtype: "Link", options: "ToDo", width: 90 },
+      { fieldname: "priority", label: "Priority", fieldtype: "", options: undefined, width: 60 },
+      { fieldname: "date", label: "Date", fieldtype: "Date", options: undefined, width: undefined },
+      {
+        fieldname: "assigned_to/owner",
+        label: "Assigned To/Owner",
+        fieldtype: "Data",
+        options: undefined,
+        width: 120,
+      },
+    ]);
+  });
+
+  it("normalizes old-style SQL alias strings", () => {
+    const columns = normalizeQueryReportColumns([
+      "ID:Link/ToDo:120",
+      "Status::100",
+      "Modified On:Date:110",
+    ]);
+    expect(columns).toEqual([
+      { fieldname: "id", label: "ID", fieldtype: "Link", options: "ToDo", width: 120 },
+      { fieldname: "status", label: "Status", fieldtype: "", options: undefined, width: 100 },
+      {
+        fieldname: "modified_on",
+        label: "Modified On",
+        fieldtype: "Date",
+        options: undefined,
+        width: 110,
+      },
+    ]);
+  });
+
+  it("dedupes colliding fieldnames and skips junk entries", () => {
+    const columns = normalizeQueryReportColumns(["Total::80", "Total::80", null, 42]);
+    expect(columns.map((column) => column.fieldname)).toEqual(["total", "total_1"]);
+  });
+});
+
+describe("normalizeQueryReportRows", () => {
+  const columns = normalizeQueryReportColumns(["ID:Link/ToDo:120", "Status::100"]);
+
+  it("passes dict rows through (probed v15 shape)", () => {
+    const rows = normalizeQueryReportRows([{ id: "TD-1", status: "Open" }], columns);
+    expect(rows).toEqual([{ id: "TD-1", status: "Open" }]);
+  });
+
+  it("zips positional array rows onto column fieldnames", () => {
+    const rows = normalizeQueryReportRows([["TD-1", "Open"]], columns);
+    expect(rows).toEqual([{ id: "TD-1", status: "Open" }]);
+  });
+
+  it("drops scalar/null separator entries", () => {
+    expect(normalizeQueryReportRows([null, "sep", 3, ["TD-1", "Open"]], columns)).toHaveLength(1);
+  });
+});
+
+describe("scrubFieldname", () => {
+  it("matches frappe.scrub semantics", () => {
+    expect(scrubFieldname("Modified On")).toBe("modified_on");
+    expect(scrubFieldname("Assigned To/Owner")).toBe("assigned_to_owner");
+    expect(scrubFieldname("  Total (USD) ")).toBe("total_usd");
+  });
+});
+
+describe("stripHtml", () => {
+  it("flattens desk anchor markup (probed ToDo reference cell)", () => {
+    expect(stripHtml('<a href="/app/Form/ToDo/oftgr5usq3">ToDo: oftgr5usq3</a>')).toBe(
+      "ToDo: oftgr5usq3",
+    );
+  });
+
+  it("decodes basic entities and leaves plain text alone", () => {
+    expect(stripHtml("A &amp; B")).toBe("A & B");
+    expect(stripHtml("plain")).toBe("plain");
+  });
+});

package/src/report/reportShapes.ts

@@ -0,0 +1,233 @@
+// Pure (dependency-free) query-report wire-shape normalization — kept apart
+// from useQueryReport so the node-environment specs can import it without
+// dragging in react/frappe packages.
+//
+// PROBED response shapes (bench v15 — reports "ToDo", "Permitted Documents
+// For User", and the SQL query report "Backoffice QR Probe"):
+//   POST /api/method/frappe.desk.query_report.run {report_name, filters}
+//   → {message: {columns, result, message, chart, report_summary,
+//      add_total_row, skip_total_row, execution_time, status}}
+//   - columns: [{label, fieldname, fieldtype, width?, options?}] — width is
+//     a STRING ("90"), fieldtype may be "". v15 normalizes even old-style
+//     SQL alias columns ("Label:Fieldtype/Options:Width") into this dict
+//     shape server-side; the string + positional-array-row forms are still
+//     handled here defensively (older benches / custom reports).
+//   - result: array of objects keyed by fieldname; values may embed HTML
+//     (e.g. desk anchor tags). The totals row is appended SERVER-side when
+//     add_total_row=1, so no client aggregation happens here.
+//   - errors: {exc_type, _server_messages} where _server_messages is a
+//     JSON-encoded array of JSON-encoded {message} — humanized below.
+
+export interface QueryReportColumn {
+  fieldname: string;
+  label: string;
+  /** Frappe fieldtype ("Link", "Date", "Currency", … or "" when untyped). */
+  fieldtype: string;
+  /** Link target doctype (fieldtype "Link"). */
+  options?: string;
+  /** Desk pixel width hint (server sends strings like "90"). */
+  width?: number;
+}
+
+export type QueryReportRow = Record<string, unknown>;
+export type QueryReportFilters = Record<string, unknown>;
+
+/** Report doc `filters` child row (Report Filter) — trivially derivable filter meta. */
+export interface QueryReportFilterMeta {
+  fieldname: string;
+  label?: string;
+  fieldtype?: string;
+  options?: string;
+  default?: string;
+  mandatory?: 0 | 1;
+}
+
+/** Report doc bits the screen cares about (loose — server owns the schema). */
+export interface QueryReportMeta {
+  name: string;
+  report_name?: string;
+  ref_doctype?: string;
+  report_type?: string;
+  disabled?: 0 | 1;
+  prepared_report?: 0 | 1;
+  add_total_row?: 0 | 1;
+  filters?: QueryReportFilterMeta[];
+  [key: string]: unknown;
+}
+
+/** Static data for stories/tests — skips every bench RPC. */
+export interface QueryReportFixture {
+  meta?: Partial<QueryReportMeta>;
+  /** Raw column shapes (dicts or "Label:Fieldtype/Options:Width" strings). */
+  columns: unknown[];
+  /** Raw rows (dicts or positional arrays). */
+  rows: unknown[];
+  message?: string;
+}
+
+export interface QueryReportRunMessage {
+  columns?: unknown[];
+  result?: unknown[];
+  message?: string | null;
+  chart?: unknown;
+  report_summary?: unknown;
+  add_total_row?: 0 | 1;
+  skip_total_row?: 0 | 1;
+  execution_time?: number;
+  status?: string | null;
+}
+
+/** frappe.scrub equivalent: "Modified On" → "modified_on". */
+export function scrubFieldname(label: string): string {
+  return label
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "_")
+    .replace(/^_+|_+$/g, "");
+}
+
+/** Best-effort HTML → text for report cell values and server messages. */
+export function stripHtml(value: string): string {
+  if (!value.includes("<") && !value.includes("&")) return value;
+  return value
+    .replace(/<[^>]*>/g, "")
+    .replace(/&nbsp;/g, " ")
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function parseWidth(raw: unknown): number | undefined {
+  if (typeof raw === "number") return raw > 0 ? raw : undefined;
+  if (typeof raw === "string" && raw) {
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isNaN(parsed) && parsed > 0) return parsed;
+  }
+  return undefined;
+}
+
+/**
+ * Normalize run() columns: v15 sends dicts, older/custom reports may send
+ * "Label:Fieldtype/Options:Width" alias strings. Fieldnames are deduped so
+ * positional rows always land somewhere addressable.
+ */
+export function normalizeQueryReportColumns(
+  raw: readonly unknown[] | undefined,
+): QueryReportColumn[] {
+  const used = new Set<string>();
+  const columns: QueryReportColumn[] = [];
+  (raw ?? []).forEach((entry, index) => {
+    let label = "";
+    let fieldname = "";
+    let fieldtype = "";
+    let options: string | undefined;
+    let width: number | undefined;
+    if (typeof entry === "string") {
+      const [labelPart = "", typePart = "", widthPart = ""] = entry.split(":");
+      label = labelPart.trim();
+      const [typeBit = "", optionsBit = ""] = typePart.split("/");
+      fieldtype = typeBit.trim();
+      options = optionsBit.trim() || undefined;
+      width = parseWidth(widthPart.trim());
+    } else if (entry && typeof entry === "object") {
+      const column = entry as Record<string, unknown>;
+      label = typeof column.label === "string" ? column.label : "";
+      fieldname = typeof column.fieldname === "string" ? column.fieldname : "";
+      fieldtype = typeof column.fieldtype === "string" ? column.fieldtype : "";
+      options = typeof column.options === "string" && column.options ? column.options : undefined;
+      width = parseWidth(column.width);
+    } else {
+      return;
+    }
+    let id = fieldname || scrubFieldname(label) || `col_${index}`;
+    if (used.has(id)) id = `${id}_${index}`;
+    used.add(id);
+    columns.push({ fieldname: id, label: label || id, fieldtype, options, width });
+  });
+  return columns;
+}
+
+/** Normalize run() rows: positional arrays are zipped onto column fieldnames. */
+export function normalizeQueryReportRows(
+  raw: readonly unknown[] | undefined,
+  columns: readonly QueryReportColumn[],
+): QueryReportRow[] {
+  const rows: QueryReportRow[] = [];
+  for (const entry of raw ?? []) {
+    if (Array.isArray(entry)) {
+      const row: QueryReportRow = {};
+      columns.forEach((column, index) => {
+        row[column.fieldname] = entry[index];
+      });
+      rows.push(row);
+    } else if (entry && typeof entry === "object") {
+      rows.push(entry as QueryReportRow);
+    }
+  }
+  return rows;
+}
+
+export function normalizeFilterMeta(raw: unknown): QueryReportFilterMeta[] {
+  if (!Array.isArray(raw)) return [];
+  const filters: QueryReportFilterMeta[] = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object") continue;
+    const row = entry as Record<string, unknown>;
+    const fieldname =
+      typeof row.fieldname === "string" && row.fieldname
+        ? row.fieldname
+        : typeof row.label === "string" && row.label
+          ? scrubFieldname(row.label)
+          : "";
+    if (!fieldname) continue;
+    filters.push({
+      fieldname,
+      label: typeof row.label === "string" ? row.label : undefined,
+      fieldtype: typeof row.fieldtype === "string" ? row.fieldtype : undefined,
+      options: typeof row.options === "string" ? row.options : undefined,
+      default: typeof row.default === "string" ? row.default : undefined,
+      mandatory: row.mandatory === 1 || row.mandatory === "1" ? 1 : 0,
+    });
+  }
+  return filters;
+}
+
+export function isEmptyFilterValue(value: unknown): boolean {
+  return value === undefined || value === null || value === "";
+}
+
+/** `_server_messages` is a JSON array of JSON-encoded {message} objects. */
+function decodeServerMessages(raw: unknown): string | undefined {
+  if (typeof raw !== "string" || !raw.startsWith("[")) return undefined;
+  try {
+    const entries: unknown = JSON.parse(raw);
+    if (!Array.isArray(entries)) return undefined;
+    const parts = entries
+      .map((entry) => {
+        try {
+          const decoded: unknown = typeof entry === "string" ? JSON.parse(entry) : entry;
+          const message = (decoded as { message?: unknown } | null)?.message;
+          return typeof message === "string" ? stripHtml(message) : String(entry);
+        } catch {
+          return String(entry);
+        }
+      })
+      .filter(Boolean);
+    return parts.length > 0 ? parts.join("\n") : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function humanizeFrappeError(err: unknown): Error {
+  if (err instanceof Error) {
+    const data = (err as { data?: unknown }).data as Record<string, unknown> | undefined;
+    const decoded =
+      decodeServerMessages(data?._server_messages) ?? decodeServerMessages(err.message);
+    return decoded ? new Error(decoded) : err;
+  }
+  return new Error(String(err));
+}

package/src/report/reportViewModel.spec.ts

@@ -0,0 +1,338 @@
+import { describe, expect, it } from "vitest";
+import type { DoctypeMeta } from "../shared/useDoctypeMeta";
+import {
+  buildGridRows,
+  buildReportCsv,
+  columnFilterTuple,
+  columnFilterTuples,
+  computeTotals,
+  defaultReportFieldnames,
+  fromDeskReportSettings,
+  orderReportRows,
+  parseDeskOrderBy,
+  parseReportFiltersParam,
+  reportColumnsFromMeta,
+  resolveSelectedColumns,
+  toDeskReportSettings,
+  type ReportColumnDef,
+  type ReportRow,
+} from "./reportViewModel";
+
+const userMeta: DoctypeMeta = {
+  name: "User",
+  title_field: "full_name",
+  sort_field: "modified",
+  sort_order: "DESC",
+  fields: [
+    { fieldname: "basic_section", fieldtype: "Section Break" },
+    { fieldname: "email", label: "Email", fieldtype: "Data", in_list_view: 1 },
+    { fieldname: "first_name", label: "First Name", fieldtype: "Data", in_standard_filter: 1 },
+    { fieldname: "full_name", label: "Full Name", fieldtype: "Data", in_list_view: 1 },
+    { fieldname: "enabled", label: "Enabled", fieldtype: "Check", in_standard_filter: 1 },
+    {
+      fieldname: "user_type",
+      label: "User Type",
+      fieldtype: "Select",
+      options: "System User\nWebsite User",
+      in_list_view: 1,
+      in_standard_filter: 1,
+    },
+    {
+      fieldname: "api_secret",
+      label: "API Secret",
+      fieldtype: "Data",
+      in_list_view: 1,
+      report_hide: 1,
+    },
+    {
+      fieldname: "roles",
+      label: "Roles",
+      fieldtype: "Table",
+      options: "Has Role",
+      in_list_view: 1,
+    },
+    { fieldname: "bio", label: "Bio", fieldtype: "Small Text" },
+    { fieldname: "points", label: "Points", fieldtype: "Int" },
+    {
+      fieldname: "role_profile",
+      label: "Role Profile",
+      fieldtype: "Link",
+      options: "Role Profile",
+    },
+  ],
+};
+
+function column(fieldname: string, overrides: Partial<ReportColumnDef> = {}): ReportColumnDef {
+  return {
+    fieldname,
+    label: fieldname,
+    fieldtype: "Data",
+    kind: "text",
+    width: 160,
+    align: "left",
+    ...overrides,
+  };
+}
+
+describe("defaultReportFieldnames", () => {
+  it("seeds desk defaults: name, title field, in_list_view/in_standard_filter, modified", () => {
+    expect(defaultReportFieldnames(userMeta)).toEqual([
+      "name",
+      "full_name",
+      "email",
+      "first_name",
+      "enabled",
+      "user_type",
+      "modified",
+    ]);
+  });
+
+  it("excludes report_hide, layout and table fields, dedupes the title field", () => {
+    const fields = defaultReportFieldnames(userMeta);
+    expect(fields).not.toContain("api_secret");
+    expect(fields).not.toContain("roles");
+    expect(fields).not.toContain("basic_section");
+    expect(fields.filter((field) => field === "full_name")).toHaveLength(1);
+  });
+
+  it("degrades to name + modified without meta", () => {
+    expect(defaultReportFieldnames(undefined)).toEqual(["name", "modified"]);
+  });
+});
+
+describe("reportColumnsFromMeta", () => {
+  it("offers ID first, all value-type meta fields, then standard doc fields", () => {
+    const columns = reportColumnsFromMeta(userMeta);
+    expect(columns[0].fieldname).toBe("name");
+    const names = columns.map((entry) => entry.fieldname);
+    expect(names).toContain("bio");
+    expect(names).toContain("points");
+    expect(names).toContain("owner");
+    expect(names).toContain("modified");
+    expect(names).not.toContain("roles");
+    expect(names).not.toContain("basic_section");
+  });
+
+  it("derives kind, width and alignment from the fieldtype", () => {
+    const columns = reportColumnsFromMeta(userMeta);
+    const points = columns.find((entry) => entry.fieldname === "points");
+    expect(points).toMatchObject({ kind: "number", align: "right" });
+    const enabled = columns.find((entry) => entry.fieldname === "enabled");
+    expect(enabled).toMatchObject({ kind: "check", align: "center" });
+    const userType = columns.find((entry) => entry.fieldname === "user_type");
+    expect(userType).toMatchObject({ kind: "select", options: "System User\nWebsite User" });
+  });
+});
+
+describe("resolveSelectedColumns", () => {
+  it("keeps selection order and drops unknown fieldnames", () => {
+    const all = reportColumnsFromMeta(userMeta);
+    const resolved = resolveSelectedColumns(all, ["user_type", "nope", "name"]);
+    expect(resolved.map((entry) => entry.fieldname)).toEqual(["user_type", "name"]);
+  });
+});
+
+describe("columnFilterTuple", () => {
+  it("wraps text in contains-like (user wildcards win)", () => {
+    expect(columnFilterTuple(column("email"), "test")).toEqual(["email", "like", "%test%"]);
+    expect(columnFilterTuple(column("email"), "test%")).toEqual(["email", "like", "test%"]);
+    expect(columnFilterTuple(column("email"), "  ")).toBeNull();
+  });
+
+  it("equals exact select options (case-insensitive), likes partials", () => {
+    const select = column("user_type", {
+      fieldtype: "Select",
+      kind: "select",
+      options: "System User\nWebsite User",
+    });
+    expect(columnFilterTuple(select, "system user")).toEqual(["user_type", "=", "System User"]);
+    expect(columnFilterTuple(select, "Sys")).toEqual(["user_type", "like", "%Sys%"]);
+  });
+
+  it("parses check values, rejects unparseable input", () => {
+    const check = column("enabled", { fieldtype: "Check", kind: "check" });
+    expect(columnFilterTuple(check, "yes")).toEqual(["enabled", "=", 1]);
+    expect(columnFilterTuple(check, "0")).toEqual(["enabled", "=", 0]);
+    expect(columnFilterTuple(check, "maybe")).toBeNull();
+  });
+
+  it("supports comparison prefixes on numbers and dates", () => {
+    const points = column("points", { fieldtype: "Int", kind: "number" });
+    expect(columnFilterTuple(points, ">= 10")).toEqual(["points", ">=", "10"]);
+    expect(columnFilterTuple(points, "5")).toEqual(["points", "=", "5"]);
+    expect(columnFilterTuple(points, ">")).toBeNull();
+    const modified = column("modified", { fieldtype: "Datetime", kind: "date" });
+    expect(columnFilterTuple(modified, ">2026-01-01")).toEqual(["modified", ">", "2026-01-01"]);
+  });
+});
+
+describe("columnFilterTuples", () => {
+  it("collects only parseable inputs, keyed by fieldname", () => {
+    const columns = [column("email"), column("enabled", { fieldtype: "Check", kind: "check" })];
+    expect(columnFilterTuples(columns, { email: "a", enabled: "??", other: "x" })).toEqual([
+      ["email", "like", "%a%"],
+    ]);
+  });
+});
+
+describe("desk report settings round trip", () => {
+  it("serializes fields/filters/order_by/group_by in desk shape", () => {
+    const settings = toDeskReportSettings("User", {
+      fieldnames: ["name", "email"],
+      filters: [["enabled", "=", 1]],
+      sort: { field: "creation", order: "asc" },
+      pageSize: 100,
+      groupBy: "user_type",
+      addTotals: true,
+    });
+    expect(settings.fields).toEqual([
+      ["name", "User"],
+      ["email", "User"],
+    ]);
+    expect(settings.filters).toEqual([["User", "enabled", "=", 1]]);
+    expect(settings.order_by).toBe("`tabUser`.`creation` asc");
+    expect(settings.add_totals_row).toBe(1);
+    expect(settings.page_length).toBe(100);
+    expect(settings.group_by).toEqual({
+      group_by: "`tabUser`.`user_type`",
+      aggregate_function: "count",
+      aggregate_on: null,
+    });
+  });
+
+  it("parses desk json back (dropping child-doctype fields and filters)", () => {
+    const parsed = fromDeskReportSettings("User", {
+      fields: [["name", "User"], ["role", "Has Role"], "email"],
+      filters: [
+        ["User", "enabled", "=", 1],
+        ["Has Role", "role", "=", "System Manager"],
+        ["user_type", "=", "System User"],
+      ],
+      order_by: "`tabUser`.`modified` desc",
+      add_totals_row: 1,
+      page_length: 500,
+      group_by: { group_by: "`tabUser`.`user_type`", aggregate_function: "count" },
+    });
+    expect(parsed).toEqual({
+      fieldnames: ["name", "email"],
+      filters: [
+        ["enabled", "=", 1],
+        ["user_type", "=", "System User"],
+      ],
+      sort: { field: "modified", order: "desc" },
+      pageSize: 500,
+      groupBy: "user_type",
+      addTotals: true,
+    });
+  });
+
+  it("round-trips through its own serialization", () => {
+    const config = {
+      fieldnames: ["name", "points"],
+      filters: [["points", ">", "5"]] as Array<[string, string, unknown]>,
+      sort: { field: "points", order: "asc" as const },
+      pageSize: 20,
+      groupBy: null,
+      addTotals: false,
+    };
+    const parsed = fromDeskReportSettings("User", toDeskReportSettings("User", config));
+    expect(parsed).toEqual(config);
+  });
+
+  it("tolerates garbage", () => {
+    expect(fromDeskReportSettings("User", null)).toBeUndefined();
+    expect(fromDeskReportSettings("User", "{}")).toBeUndefined();
+    expect(fromDeskReportSettings("User", {})).toMatchObject({ fieldnames: [], filters: [] });
+  });
+});
+
+describe("parseDeskOrderBy", () => {
+  it("parses backticked and bare expressions", () => {
+    expect(parseDeskOrderBy("`tabUser`.`modified` desc")).toEqual({
+      field: "modified",
+      order: "desc",
+    });
+    expect(parseDeskOrderBy("creation asc")).toEqual({ field: "creation", order: "asc" });
+    expect(parseDeskOrderBy("")).toBeUndefined();
+    expect(parseDeskOrderBy(42)).toBeUndefined();
+  });
+});
+
+describe("orderReportRows / buildGridRows", () => {
+  const rows: ReportRow[] = [
+    { name: "c", status: "Open", points: 3 },
+    { name: "a", status: "Closed", points: 1 },
+    { name: "b", status: "Open", points: 2 },
+    { name: "d", status: "Open", points: null },
+  ];
+
+  it("orders by sort field with name tiebreak, nulls last", () => {
+    const ordered = orderReportRows(rows, { field: "points", order: "desc" });
+    expect(ordered.map((row) => row.name)).toEqual(["c", "b", "a", "d"]);
+  });
+
+  it("groups first when grouping, then sorts inside groups", () => {
+    const ordered = orderReportRows(rows, { field: "points", order: "asc" }, "status");
+    expect(ordered.map((row) => row.name)).toEqual(["a", "b", "c", "d"]);
+  });
+
+  it("injects group headers with full-result counts inside the page", () => {
+    const ordered = orderReportRows(rows, { field: "points", order: "asc" }, "status");
+    const page = buildGridRows(ordered, 0, 2, "status");
+    expect(page).toHaveLength(4);
+    expect(page[0]).toMatchObject({ kind: "group", value: "Closed", count: 1 });
+    expect(page[1]).toMatchObject({ kind: "row", key: "a", index: 1 });
+    expect(page[2]).toMatchObject({ kind: "group", value: "Open", count: 3 });
+    expect(page[3]).toMatchObject({ kind: "row", key: "b", index: 2 });
+  });
+
+  it("numbers rows across pages without grouping", () => {
+    const ordered = orderReportRows(rows, { field: "name", order: "asc" });
+    const page = buildGridRows(ordered, 2, 2);
+    expect(page).toEqual([
+      { kind: "row", key: "c", row: ordered[2], index: 3 },
+      { kind: "row", key: "d", row: ordered[3], index: 4 },
+    ]);
+  });
+});
+
+describe("computeTotals", () => {
+  it("sums numeric visible columns over all rows", () => {
+    const columns = [column("name"), column("points", { fieldtype: "Int", kind: "number" })];
+    const totals = computeTotals(columns, [
+      { name: "a", points: 1 },
+      { name: "b", points: 2 },
+      { name: "c", points: "x" },
+    ]);
+    expect(totals).toEqual([{ fieldname: "points", fieldtype: "Int", value: 3 }]);
+  });
+
+  it("is empty without rows", () => {
+    expect(computeTotals([column("points", { fieldtype: "Int", kind: "number" })], [])).toEqual([]);
+  });
+});
+
+describe("buildReportCsv", () => {
+  it("escapes quotes, commas and newlines", () => {
+    const csv = buildReportCsv(
+      [column("name", { label: "ID" }), column("bio", { label: "Bio, or so" })],
+      [{ name: "a", bio: 'say "hi"\nplease' }],
+    );
+    expect(csv).toBe('ID,"Bio, or so"\na,"say ""hi""\nplease"');
+  });
+});
+
+describe("parseReportFiltersParam", () => {
+  it("parses raw and urlencoded JSON tuples", () => {
+    expect(parseReportFiltersParam('[["enabled","=",1]]')).toEqual([["enabled", "=", 1]]);
+    expect(
+      parseReportFiltersParam(encodeURIComponent('[["user_type","=","System User"]]')),
+    ).toEqual([["user_type", "=", "System User"]]);
+  });
+
+  it("degrades to undefined on malformed input", () => {
+    expect(parseReportFiltersParam("not json")).toBeUndefined();
+    expect(parseReportFiltersParam("")).toBeUndefined();
+    expect(parseReportFiltersParam(42)).toBeUndefined();
+  });
+});