ding-react-admin 2.0.0 → 2.0.5

package/src/crud/utils/buildResourceFormSubmitBody.ts

@@ -1,29 +1,29 @@
-import type { InlineFieldRegistration } from "../context/InlineFieldsRegistry";
-import { buildFormPayload } from "./buildFormPayload";
-import { buildInlineRowsPayload } from "./buildInlineRowsPayload";
-import {
-  prepareFormSubmitBody,
-  type PrepareFormSubmitBodyOptions,
-} from "./prepareFormSubmitBody";
-
-/** Build the create/update body from form values, auto-switching to multipart when needed. */
-export function buildResourceFormSubmitBody(
-  raw: Record<string, unknown>,
-  payloadFieldPaths: string[],
-  inlineRegistry?: Iterable<InlineFieldRegistration>,
-  options?: PrepareFormSubmitBodyOptions,
-): Record<string, unknown> | FormData {
-  const payload = buildFormPayload(raw, payloadFieldPaths);
-
-  if (inlineRegistry) {
-    for (const inline of inlineRegistry) {
-      const rows = raw[inline.field];
-      const key = inline.payloadKey ?? inline.field;
-      payload[key] = buildInlineRowsPayload(rows, inline.sources, {
-        transformRows: inline.transformRows,
-      });
-    }
-  }
-
-  return prepareFormSubmitBody(payload, options);
-}
+import type { InlineFieldRegistration } from "../context/InlineFieldsRegistry";
+import { buildFormPayload } from "./buildFormPayload";
+import { buildInlineRowsPayload } from "./buildInlineRowsPayload";
+import {
+  prepareFormSubmitBody,
+  type PrepareFormSubmitBodyOptions,
+} from "./prepareFormSubmitBody";
+
+/** Build the create/update body from form values, auto-switching to multipart when needed. */
+export function buildResourceFormSubmitBody(
+  raw: Record<string, unknown>,
+  payloadFieldPaths: string[],
+  inlineRegistry?: Iterable<InlineFieldRegistration>,
+  options?: PrepareFormSubmitBodyOptions,
+): Record<string, unknown> | FormData {
+  const payload = buildFormPayload(raw, payloadFieldPaths);
+
+  if (inlineRegistry) {
+    for (const inline of inlineRegistry) {
+      const rows = raw[inline.field];
+      const key = inline.payloadKey ?? inline.field;
+      payload[key] = buildInlineRowsPayload(rows, inline.sources, {
+        transformRows: inline.transformRows,
+      });
+    }
+  }
+
+  return prepareFormSubmitBody(payload, options);
+}

package/src/crud/utils/choiceSelectionUtils.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import {
+  collectSelectedRecords,
+  isRecordObject,
+  normalizeSelectedIds,
+  recordsToOptions,
+  valueAsId,
+  valuesAsIds,
+} from "./choiceSelectionUtils";
+
+describe("choiceSelectionUtils", () => {
+  it("detects nested record objects", () => {
+    expect(isRecordObject({ id: 1, name: "Branch 1" }, "id")).toBe(true);
+    expect(isRecordObject("1", "id")).toBe(false);
+  });
+
+  it("extracts ids from primitive or nested values", () => {
+    expect(valueAsId("abc", "id")).toBe("abc");
+    expect(valueAsId({ id: 2, name: "Two" }, "id")).toBe(2);
+    expect(valuesAsIds([{ id: 1, name: "One" }, "2"], "id")).toEqual([1, "2"]);
+    expect(normalizeSelectedIds([{ id: 3, name: "Three" }], "id")).toEqual([3]);
+  });
+
+  it("collects embedded records from value and recordSource data", () => {
+    const records = collectSelectedRecords(
+      [{ id: 1, name: "One" }, "2"],
+      { id: 3, name: "Three" },
+      "id",
+    );
+    expect(records).toHaveLength(2);
+    expect(records.map((record) => record.id).sort()).toEqual([1, 3]);
+  });
+
+  it("maps records to select options", () => {
+    expect(
+      recordsToOptions([{ id: 1, name: "Branch 1" }], "name", "id"),
+    ).toEqual([
+      {
+        label: "Branch 1",
+        value: 1,
+        record: { id: 1, name: "Branch 1" },
+      },
+    ]);
+  });
+});

package/src/crud/utils/choiceSelectionUtils.ts

@@ -0,0 +1,116 @@
+import type { ChoiceOption } from "../types";
+
+export function isRecordObject(
+  value: unknown,
+  optionValue: string,
+): value is Record<string, unknown> {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    optionValue in value
+  );
+}
+
+export function valueAsId(
+  value: unknown,
+  optionValue: string,
+): string | number | undefined {
+  if (value == null || value === "") return undefined;
+  if (isRecordObject(value, optionValue)) {
+    const id = value[optionValue];
+    if (typeof id === "string" || typeof id === "number") return id;
+    return undefined;
+  }
+  if (typeof value === "string" || typeof value === "number") return value;
+  return undefined;
+}
+
+export function valuesAsIds(
+  values: unknown,
+  optionValue: string,
+): (string | number)[] {
+  if (!Array.isArray(values)) return [];
+  return values
+    .map((value) => valueAsId(value, optionValue))
+    .filter((value): value is string | number => value != null);
+}
+
+export function normalizeSelectedIds(
+  selectedValues: unknown | unknown[] | undefined,
+  optionValue: string,
+): unknown[] {
+  if (selectedValues == null) return [];
+  const values = Array.isArray(selectedValues)
+    ? selectedValues
+    : [selectedValues];
+  return values
+    .filter((value) => value != null && value !== "")
+    .map((value) =>
+      isRecordObject(value, optionValue) ? value[optionValue] : value,
+    );
+}
+
+export function collectSelectedRecords(
+  selectedValues: unknown | unknown[] | undefined,
+  selectedRecords: Record<string, unknown> | Record<string, unknown>[] | undefined,
+  optionValue: string,
+): Record<string, unknown>[] {
+  const records: Record<string, unknown>[] = [];
+
+  if (selectedRecords != null) {
+    if (Array.isArray(selectedRecords)) {
+      records.push(
+        ...selectedRecords.filter(
+          (record): record is Record<string, unknown> =>
+            isRecordObject(record, optionValue),
+        ),
+      );
+    } else if (isRecordObject(selectedRecords, optionValue)) {
+      records.push(selectedRecords);
+    }
+  }
+
+  if (selectedValues == null) return records;
+
+  const values = Array.isArray(selectedValues)
+    ? selectedValues
+    : [selectedValues];
+  for (const value of values) {
+    if (isRecordObject(value, optionValue)) {
+      records.push(value);
+    }
+  }
+
+  return records;
+}
+
+export function resolveOptionLabel(
+  record: Record<string, unknown>,
+  optionLabel: string | ((record: Record<string, unknown>) => string),
+): string {
+  if (typeof optionLabel === "function") return optionLabel(record);
+  return String(record[optionLabel] ?? "");
+}
+
+export function recordsToOptions(
+  records: Record<string, unknown>[],
+  optionLabel: string | ((record: Record<string, unknown>) => string),
+  optionValue: string,
+): ChoiceOption[] {
+  return records.map((record) => ({
+    label: resolveOptionLabel(record, optionLabel),
+    value: record[optionValue],
+    record,
+  }));
+}
+
+export function mergeOptions(
+  existing: ChoiceOption[],
+  incoming: ChoiceOption[],
+): ChoiceOption[] {
+  const byValue = new Map<unknown, ChoiceOption>();
+  for (const option of existing) byValue.set(option.value, option);
+  for (const option of incoming) byValue.set(option.value, option);
+  return Array.from(byValue.values());
+}

package/src/crud/utils/formErrors.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, it, vi } from "vitest";
+import type { UseFormReturn } from "react-hook-form";
+
+import type { DataProvider } from "../../data/dataProviderTypes";
+import type { InlineFieldRegistration } from "../context/InlineFieldsRegistry";
+import {
+  applyApiErrorsToForm,
+  isKnownFormFieldPath,
+  partitionFormErrors,
+} from "./formErrors";
+
+const inlineRegistry = new Map<string, InlineFieldRegistration>([
+  [
+    "lines",
+    {
+      field: "lines",
+      sources: ["label", "quantity"],
+    },
+  ],
+]);
+
+describe("isKnownFormFieldPath", () => {
+  it("matches top-level payload fields", () => {
+    const payloadFields = new Set(["name", "email"]);
+    expect(isKnownFormFieldPath("name", payloadFields, inlineRegistry)).toBe(
+      true,
+    );
+    expect(
+      isKnownFormFieldPath("unknown", payloadFields, inlineRegistry),
+    ).toBe(false);
+  });
+
+  it("matches inline nested paths", () => {
+    const payloadFields = new Set(["lines"]);
+    expect(
+      isKnownFormFieldPath("lines.0.quantity", payloadFields, inlineRegistry),
+    ).toBe(true);
+    expect(
+      isKnownFormFieldPath("lines.2.label", payloadFields, inlineRegistry),
+    ).toBe(true);
+    expect(
+      isKnownFormFieldPath("lines.0.missing", payloadFields, inlineRegistry),
+    ).toBe(false);
+  });
+});
+
+describe("partitionFormErrors", () => {
+  it("keeps known fields and promotes unknown keys to global", () => {
+    const payloadFields = new Set(["name"]);
+    const { fieldErrors, globalErrors } = partitionFormErrors(
+      {
+        fields: {
+          name: "Required",
+          internal_code: "Already used",
+        },
+        global: ["Cannot save while locked"],
+      },
+      payloadFields,
+      inlineRegistry,
+    );
+
+    expect(fieldErrors).toEqual({ name: "Required" });
+    expect(globalErrors).toEqual([
+      "Cannot save while locked",
+      "Already used",
+    ]);
+  });
+
+  it("routes inline errors to fields when the column exists", () => {
+    const payloadFields = new Set(["lines"]);
+    const { fieldErrors, globalErrors } = partitionFormErrors(
+      {
+        fields: {
+          "lines.0.quantity": "Must be positive",
+          "lines.1.unknown": "Bad value",
+        },
+      },
+      payloadFields,
+      inlineRegistry,
+    );
+
+    expect(fieldErrors).toEqual({
+      "lines.0.quantity": "Must be positive",
+    });
+    expect(globalErrors).toEqual(["Bad value"]);
+  });
+});
+
+describe("applyApiErrorsToForm", () => {
+  const context = { resource: "users", mutation: "create" as const };
+  const options = {
+    payloadFields: new Set(["email"]),
+    inlineRegistry: [] as InlineFieldRegistration[],
+  };
+
+  function createForm() {
+    return {
+      setError: vi.fn(),
+    } as unknown as UseFormReturn<{ email: string }>;
+  }
+
+  it("maps standard validation bodies to field errors", async () => {
+    const form = createForm();
+    const dp = {
+      parseFormError: vi.fn().mockReturnValue({
+        fields: { email: "Already taken" },
+      }),
+    } as unknown as DataProvider;
+
+    const result = await applyApiErrorsToForm(
+      dp,
+      form,
+      {
+        body: { email: ["Already taken"] },
+      },
+      context,
+      options,
+    );
+
+    expect(result.handled).toBe(true);
+    expect(result.globalErrors).toEqual([]);
+    expect(form.setError).toHaveBeenCalledWith("email", {
+      type: "server",
+      message: "Already taken",
+    });
+  });
+
+  it("returns a non-standard format warning when the parser cannot map the body", async () => {
+    const form = createForm();
+    const dp = {
+      parseFormError: vi.fn().mockReturnValue(null),
+    } as unknown as DataProvider;
+
+    const result = await applyApiErrorsToForm(
+      dp,
+      form,
+      { body: { message: "Unexpected shape" } },
+      context,
+      options,
+    );
+
+    expect(result.handled).toBe(true);
+    expect(result.globalErrors[0]).toContain("Non-standard validation response.");
+    expect(result.globalErrors[0]).toContain('{"message":"Unexpected shape"}');
+    expect(form.setError).not.toHaveBeenCalled();
+  });
+
+  it("returns a non-standard format warning for HTTP 400 without JSON", async () => {
+    const form = createForm();
+    const dp = {} as DataProvider;
+    const response = new Response("bad request", {
+      status: 400,
+      headers: { "Content-Type": "text/plain" },
+    });
+
+    const result = await applyApiErrorsToForm(
+      dp,
+      form,
+      { response },
+      context,
+      options,
+    );
+
+    expect(result.handled).toBe(true);
+    expect(result.globalErrors[0]).toContain("Non-standard validation response.");
+    expect(result.globalErrors[0]).toContain("text/plain");
+  });
+});

package/src/crud/utils/formErrors.ts

@@ -1,42 +1,138 @@
-import type { MessageInstance } from "antd/es/message/interface";
-import type { FieldPath, FieldValues, UseFormReturn } from "react-hook-form";
-import type { DataProvider, ParseFormErrorContext } from "../../data/dataProviderTypes";
-import { resolveErrorBody } from "../../data/parseFormErrorHelpers";
-
-function toMessages(value: string | string[] | undefined): string[] {
-  if (!value) return [];
-  return Array.isArray(value) ? value : [value];
-}
-
-export function applyFormErrors<T extends FieldValues>(
-  form: UseFormReturn<T>,
-  parsed: { fields?: Record<string, string | string[]>; global?: string | string[] },
-  message: MessageInstance,
-) {
-  for (const msg of toMessages(parsed.global)) {
-    message.error(msg);
-  }
-  for (const [path, msg] of Object.entries(parsed.fields ?? {})) {
-    const text = Array.isArray(msg) ? msg.join(", ") : msg;
-    form.setError(path as FieldPath<T>, { type: "server", message: text });
-  }
-}
-
-export async function applyApiErrorsToForm<T extends FieldValues>(
-  dp: DataProvider,
-  form: UseFormReturn<T>,
-  message: MessageInstance,
-  error: unknown,
-  context: ParseFormErrorContext,
-): Promise<boolean> {
-  const body = await resolveErrorBody(error);
-  const normalizedError = body != null ? { body } : error;
-  const parsed = dp.parseFormError?.(normalizedError, context);
-  if (!parsed) return false;
-  const hasFields = Object.keys(parsed.fields ?? {}).length > 0;
-  const hasGlobal = toMessages(parsed.global).length > 0;
-  if (!hasFields && !hasGlobal) return false;
-  applyFormErrors(form, parsed, message);
-  return true;
-}
-
+import type { FieldPath, FieldValues, UseFormReturn } from "react-hook-form";
+
+import type {
+  DataProvider,
+  FormValidationErrors,
+  ParseFormErrorContext,
+} from "../../data/dataProviderTypes";
+import type { InlineFieldRegistration } from "../context/InlineFieldsRegistry";
+import {
+  describeNonStandardValidationBody,
+  getErrorResponseContentType,
+  getValidationErrorStatus,
+  resolveErrorBody,
+} from "../../data/parseFormErrorHelpers";
+
+export type ApplyApiErrorsResult = {
+  handled: boolean;
+  globalErrors: string[];
+};
+
+export type ApplyApiErrorsOptions = {
+  payloadFields: Iterable<string>;
+  inlineRegistry: Iterable<InlineFieldRegistration>;
+};
+
+function toMessages(value: string | string[] | undefined): string[] {
+  if (!value) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+function messageText(msg: string | string[]): string {
+  return Array.isArray(msg) ? msg.join(", ") : msg;
+}
+
+/** Top-level `source` or inline cell path such as `lines.0.quantity`. */
+export function isKnownFormFieldPath(
+  path: string,
+  payloadFields: Set<string>,
+  inlineRegistry: Map<string, InlineFieldRegistration>,
+): boolean {
+  if (payloadFields.has(path)) return true;
+
+  const match = path.match(/^([^.]+)\.(\d+)\.([^.]+)$/);
+  if (!match) return false;
+
+  const [, arrayName, , source] = match;
+  return inlineRegistry.get(arrayName)?.sources.includes(source) ?? false;
+}
+
+export function partitionFormErrors(
+  parsed: FormValidationErrors,
+  payloadFields: Set<string>,
+  inlineRegistry: Map<string, InlineFieldRegistration>,
+): { fieldErrors: Record<string, string | string[]>; globalErrors: string[] } {
+  const fieldErrors: Record<string, string | string[]> = {};
+  const globalErrors = [...toMessages(parsed.global)];
+
+  for (const [path, msg] of Object.entries(parsed.fields ?? {})) {
+    if (isKnownFormFieldPath(path, payloadFields, inlineRegistry)) {
+      fieldErrors[path] = msg;
+    } else {
+      globalErrors.push(messageText(msg));
+    }
+  }
+
+  return { fieldErrors, globalErrors };
+}
+
+export function applyFormErrors<T extends FieldValues>(
+  form: UseFormReturn<T>,
+  fieldErrors: Record<string, string | string[]>,
+) {
+  for (const [path, msg] of Object.entries(fieldErrors)) {
+    form.setError(path as FieldPath<T>, {
+      type: "server",
+      message: messageText(msg),
+    });
+  }
+}
+
+function nonStandardValidationHint(error: unknown): string | undefined {
+  const contentType = getErrorResponseContentType(error);
+  if (contentType && !/application\/json/i.test(contentType)) {
+    return `non-JSON response (Content-Type: ${contentType})`;
+  }
+  return undefined;
+}
+
+export async function applyApiErrorsToForm<T extends FieldValues>(
+  dp: DataProvider,
+  form: UseFormReturn<T>,
+  error: unknown,
+  context: ParseFormErrorContext,
+  options: ApplyApiErrorsOptions,
+): Promise<ApplyApiErrorsResult> {
+  const body = await resolveErrorBody(error);
+
+  if (body != null) {
+    const parsed = dp.parseFormError?.({ body }, context);
+
+    if (parsed) {
+      const payloadFields = new Set(options.payloadFields);
+      const inlineRegistry = new Map<string, InlineFieldRegistration>();
+      for (const inline of options.inlineRegistry) {
+        inlineRegistry.set(inline.field, inline);
+      }
+
+      const { fieldErrors, globalErrors } = partitionFormErrors(
+        parsed,
+        payloadFields,
+        inlineRegistry,
+      );
+
+      if (Object.keys(fieldErrors).length || globalErrors.length) {
+        applyFormErrors(form, fieldErrors);
+        return { handled: true, globalErrors };
+      }
+    }
+
+    return {
+      handled: true,
+      globalErrors: [describeNonStandardValidationBody(body)],
+    };
+  }
+
+  if (getValidationErrorStatus(error) != null) {
+    return {
+      handled: true,
+      globalErrors: [
+        describeNonStandardValidationBody(null, {
+          hint: nonStandardValidationHint(error),
+        }),
+      ],
+    };
+  }
+
+  return { handled: false, globalErrors: [] };
+}