ding-react-admin 1.0.4 → 2.0.4

package/src/data/inMemoryList.ts

@@ -1,97 +1,97 @@
-import type { GetListParams, Identifier, SortSpec } from "./dataProviderTypes";
-
-export function rowIdMatches(
-  rowId: string | number,
-  id: Identifier,
-): boolean {
-  return rowId === id || String(rowId) === String(id);
-}
-
-export function getById<T extends { id: string | number }>(
-  rows: T[],
-  id: Identifier,
-): T {
-  const row = rows.find((r) => rowIdMatches(r.id, id));
-  if (!row) throw new Error("Not found");
-  return row;
-}
-
-function sortRows<T extends Record<string, unknown>>(
-  rows: T[],
-  specs: SortSpec[],
-): T[] {
-  if (specs.length === 0) return rows;
-  const mul = (order: "ASC" | "DESC") => (order === "DESC" ? -1 : 1);
-  return [...rows].sort((a, b) => {
-    for (const { field, order } of specs) {
-      const av = a[field];
-      const bv = b[field];
-      if (av === bv) continue;
-      if (av == null) return -1 * mul(order);
-      if (bv == null) return 1 * mul(order);
-      if (typeof av === "number" && typeof bv === "number") {
-        return av < bv ? -mul(order) : mul(order);
-      }
-      const cmp = String(av).localeCompare(String(bv));
-      if (cmp !== 0) return cmp * mul(order);
-    }
-    return 0;
-  });
-}
-
-function matchFilterValue(rowVal: unknown, filterVal: unknown): boolean {
-  if (filterVal === undefined || filterVal === null || filterVal === "") {
-    return true;
-  }
-  if (Array.isArray(filterVal)) {
-    if (filterVal.length === 0) return true;
-    if (Array.isArray(rowVal)) {
-      return filterVal.some((fv) => rowVal.includes(fv));
-    }
-    return filterVal.includes(rowVal);
-  }
-  if (Array.isArray(rowVal)) {
-    return rowVal.includes(filterVal);
-  }
-  if (typeof filterVal === "string" && typeof rowVal === "string") {
-    return rowVal.toLowerCase().includes(filterVal.toLowerCase());
-  }
-  return rowVal === filterVal;
-}
-
-export function filterRows<T extends Record<string, unknown>>(
-  rows: T[],
-  filter?: Record<string, unknown>,
-): T[] {
-  if (!filter) return rows;
-  return rows.filter((row) =>
-    Object.entries(filter).every(([k, v]) => matchFilterValue(row[k], v)),
-  );
-}
-
-function paginate<T>(rows: T[], page: number, perPage: number) {
-  const start = (page - 1) * perPage;
-  return {
-    data: rows.slice(start, start + perPage),
-    total: rows.length,
-  };
-}
-
-/** Apply CRUD list filters, sort, and pagination to an in-memory row array. */
-export function applyInMemoryListParams<T extends Record<string, unknown>>(
-  rows: T[],
-  params: GetListParams,
-): { data: T[]; total: number } {
-  const { pagination, sort, filter } = params;
-  let out = filterRows(rows, filter);
-  if (sort) {
-    const specs = Array.isArray(sort) ? sort : [sort];
-    if (specs.length > 0 && specs[0]?.field) {
-      out = sortRows(out, specs);
-    }
-  }
-  if (pagination) {
-    return paginate(out, pagination.page, pagination.perPage);
-  }
-  return { data: out, total: out.length };
-}
+import type { GetListParams, Identifier, SortSpec } from "./dataProviderTypes";
+
+export function rowIdMatches(
+  rowId: string | number,
+  id: Identifier,
+): boolean {
+  return rowId === id || String(rowId) === String(id);
+}
+
+export function getById<T extends { id: string | number }>(
+  rows: T[],
+  id: Identifier,
+): T {
+  const row = rows.find((r) => rowIdMatches(r.id, id));
+  if (!row) throw new Error("Not found");
+  return row;
+}
+
+function sortRows<T extends Record<string, unknown>>(
+  rows: T[],
+  specs: SortSpec[],
+): T[] {
+  if (specs.length === 0) return rows;
+  const mul = (order: "ASC" | "DESC") => (order === "DESC" ? -1 : 1);
+  return [...rows].sort((a, b) => {
+    for (const { field, order } of specs) {
+      const av = a[field];
+      const bv = b[field];
+      if (av === bv) continue;
+      if (av == null) return -1 * mul(order);
+      if (bv == null) return 1 * mul(order);
+      if (typeof av === "number" && typeof bv === "number") {
+        return av < bv ? -mul(order) : mul(order);
+      }
+      const cmp = String(av).localeCompare(String(bv));
+      if (cmp !== 0) return cmp * mul(order);
+    }
+    return 0;
+  });
+}
+
+function matchFilterValue(rowVal: unknown, filterVal: unknown): boolean {
+  if (filterVal === undefined || filterVal === null || filterVal === "") {
+    return true;
+  }
+  if (Array.isArray(filterVal)) {
+    if (filterVal.length === 0) return true;
+    if (Array.isArray(rowVal)) {
+      return filterVal.some((fv) => rowVal.includes(fv));
+    }
+    return filterVal.includes(rowVal);
+  }
+  if (Array.isArray(rowVal)) {
+    return rowVal.includes(filterVal);
+  }
+  if (typeof filterVal === "string" && typeof rowVal === "string") {
+    return rowVal.toLowerCase().includes(filterVal.toLowerCase());
+  }
+  return rowVal === filterVal;
+}
+
+export function filterRows<T extends Record<string, unknown>>(
+  rows: T[],
+  filter?: Record<string, unknown>,
+): T[] {
+  if (!filter) return rows;
+  return rows.filter((row) =>
+    Object.entries(filter).every(([k, v]) => matchFilterValue(row[k], v)),
+  );
+}
+
+function paginate<T>(rows: T[], page: number, perPage: number) {
+  const start = (page - 1) * perPage;
+  return {
+    data: rows.slice(start, start + perPage),
+    total: rows.length,
+  };
+}
+
+/** Apply CRUD list filters, sort, and pagination to an in-memory row array. */
+export function applyInMemoryListParams<T extends Record<string, unknown>>(
+  rows: T[],
+  params: GetListParams,
+): { data: T[]; total: number } {
+  const { pagination, sort, filter } = params;
+  let out = filterRows(rows, filter);
+  if (sort) {
+    const specs = Array.isArray(sort) ? sort : [sort];
+    if (specs.length > 0 && specs[0]?.field) {
+      out = sortRows(out, specs);
+    }
+  }
+  if (pagination) {
+    return paginate(out, pagination.page, pagination.perPage);
+  }
+  return { data: out, total: out.length };
+}

package/src/data/parseFormErrorHelpers.test.ts

@@ -1,84 +1,201 @@
-import { describe, expect, it } from "vitest";
-import {
-  parseDjangoDRFFormErrors,
-  parseDotNetFormErrors,
-  parseNodeFormErrors,
-} from "./parseFormErrorHelpers";
-
-const mainCtx = { resource: "users", mutation: "create" as const };
-const inlineCtx = {
-  resource: "invoice-lines",
-  mutation: "create" as const,
-  inlineArrayName: "__inline_invoice_lines",
-  rowIndex: 1,
-};
-
-describe("parseDjangoDRFFormErrors", () => {
-  it("maps field and non_field_errors", () => {
-    const parsed = parseDjangoDRFFormErrors(
-      {
-        body: {
-          email: ["Enter a valid email."],
-          non_field_errors: ["Cannot save"],
-        },
-      },
-      mainCtx,
-    );
-    expect(parsed).toEqual({
-      fields: { email: "Enter a valid email." },
-      global: ["Cannot save"],
-    });
-  });
-
-  it("prefixes inline row fields", () => {
-    const parsed = parseDjangoDRFFormErrors(
-      { body: { quantity: ["Must be positive"] } },
-      inlineCtx,
-    );
-    expect(parsed?.fields).toEqual({
-      "__inline_invoice_lines.1.quantity": "Must be positive",
-    });
-  });
-});
-
-describe("parseDotNetFormErrors", () => {
-  it("maps errors object with camelCase", () => {
-    const parsed = parseDotNetFormErrors(
-      {
-        body: {
-          errors: { Email: ["The Email field is required."] },
-        },
-      },
-      mainCtx,
-    );
-    expect(parsed?.fields).toEqual({
-      email: "The Email field is required.",
-    });
-  });
-});
-
-describe("parseNodeFormErrors", () => {
-  it("maps express-validator array", () => {
-    const parsed = parseNodeFormErrors(
-      {
-        body: {
-          errors: [{ path: "email", msg: "Invalid email" }],
-        },
-      },
-      mainCtx,
-    );
-    expect(parsed?.fields).toEqual({ email: "Invalid email" });
-  });
-
-  it("maps Joi details", () => {
-    const parsed = parseNodeFormErrors(
-      {
-        body: {
-          details: [{ message: "Required", path: ["email"] }],
-        },
-      },
-      mainCtx,
-    );
-    expect(parsed?.fields).toEqual({ email: "Required" });
-  });
-});
+import { describe, expect, it } from "vitest";
+
+import {
+  describeNonStandardValidationBody,
+  parseDjangoDRFFormErrors,
+  parseDotNetFormErrors,
+  parseNodeFormErrors,
+  flattenNestedArrayErrors,
+  resolveErrorBody,
+} from "./parseFormErrorHelpers";
+
+const mainCtx = { resource: "users", mutation: "create" as const };
+
+describe("parseDjangoDRFFormErrors", () => {
+  it("maps field and non_field_errors", () => {
+    const parsed = parseDjangoDRFFormErrors(
+      {
+        body: {
+          email: ["Enter a valid email."],
+          non_field_errors: ["Cannot save"],
+        },
+      },
+      mainCtx,
+    );
+
+    expect(parsed).toEqual({
+      fields: { email: "Enter a valid email." },
+      global: ["Cannot save"],
+    });
+  });
+
+  it("flattens nested inline row errors", () => {
+    const parsed = parseDjangoDRFFormErrors(
+      {
+        body: {
+          lines: [
+            { quantity: ["Must be positive"] },
+            {},
+            { label: ["Required"] },
+          ],
+        },
+      },
+      mainCtx,
+    );
+
+    expect(parsed?.fields).toEqual({
+      "lines.0.quantity": "Must be positive",
+      "lines.2.label": "Required",
+    });
+  });
+
+  it("returns null when no field messages can be extracted", () => {
+    const parsed = parseDjangoDRFFormErrors(
+      { body: { code: 123, nested: { foo: "bar" } } },
+      mainCtx,
+    );
+
+    expect(parsed).toBeNull();
+  });
+});
+
+describe("describeNonStandardValidationBody", () => {
+  it("includes expected shape and received JSON", () => {
+    const message = describeNonStandardValidationBody({ message: "Oops" });
+
+    expect(message).toContain("Non-standard validation response.");
+    expect(message).toContain('"field_name"');
+    expect(message).toContain('Received: {"message":"Oops"}');
+  });
+
+  it("truncates long received bodies", () => {
+    const longValue = "x".repeat(400);
+    const message = describeNonStandardValidationBody({ detail: longValue });
+
+    expect(message).toContain("…");
+    expect(message).not.toContain(longValue);
+  });
+
+  it("supports explicit hints for non-json responses", () => {
+    const message = describeNonStandardValidationBody(null, {
+      hint: "non-JSON response (Content-Type: text/plain)",
+    });
+
+    expect(message).toContain(
+      "Received: non-JSON response (Content-Type: text/plain)",
+    );
+  });
+});
+
+describe("resolveErrorBody", () => {
+  it("reads axios-style response.data", async () => {
+    const body = await resolveErrorBody({
+      response: { data: { email: ["Invalid"] } },
+    });
+
+    expect(body).toEqual({ email: ["Invalid"] });
+  });
+
+  it("reads fetch ResponseError response.json()", async () => {
+    const response = new Response(
+      JSON.stringify({ email: ["Enter a valid email address."] }),
+      {
+        status: 400,
+        headers: { "Content-Type": "application/json" },
+      },
+    );
+
+    const body = await resolveErrorBody({
+      name: "ResponseError",
+      message: "Response returned an error code",
+      response,
+    });
+
+    expect(body).toEqual({ email: ["Enter a valid email address."] });
+  });
+
+  it("normalizes top-level JSON array bodies", async () => {
+    const response = new Response(
+      JSON.stringify(["This code is already in use."]),
+      {
+        status: 400,
+        headers: { "Content-Type": "application/json" },
+      },
+    );
+
+    const body = await resolveErrorBody({ response });
+
+    expect(body).toEqual({ non_field_errors: "This code is already in use." });
+  });
+
+  it("returns null for non-json fetch responses", async () => {
+    const response = new Response("bad request", {
+      status: 400,
+      headers: { "Content-Type": "text/plain" },
+    });
+
+    const body = await resolveErrorBody({ response });
+
+    expect(body).toBeNull();
+  });
+});
+
+describe("flattenNestedArrayErrors", () => {
+  it("maps row errors to RHF paths", () => {
+    const fields: Record<string, string | string[]> = {};
+    flattenNestedArrayErrors("lines", [
+      { label: ["Required"] },
+      { quantity: ["Too small", "Invalid"] },
+    ], fields);
+
+    expect(fields).toEqual({
+      "lines.0.label": "Required",
+      "lines.1.quantity": ["Too small", "Invalid"],
+    });
+  });
+});
+
+describe("parseDotNetFormErrors", () => {
+  it("maps errors object with camelCase", () => {
+    const parsed = parseDotNetFormErrors(
+      {
+        body: {
+          errors: { Email: ["The Email field is required."] },
+        },
+      },
+      mainCtx,
+    );
+
+    expect(parsed?.fields).toEqual({
+      email: "The Email field is required.",
+    });
+  });
+});
+
+describe("parseNodeFormErrors", () => {
+  it("maps express-validator array", () => {
+    const parsed = parseNodeFormErrors(
+      {
+        body: {
+          errors: [{ path: "email", msg: "Invalid email" }],
+        },
+      },
+      mainCtx,
+    );
+
+    expect(parsed?.fields).toEqual({ email: "Invalid email" });
+  });
+
+  it("maps Joi details", () => {
+    const parsed = parseNodeFormErrors(
+      {
+        body: {
+          details: [{ message: "Required", path: ["email"] }],
+        },
+      },
+      mainCtx,
+    );
+
+    expect(parsed?.fields).toEqual({ email: "Required" });
+  });
+});