ding-react-admin 1.0.4 → 2.0.4

package/src/data/createMemoryResourceHandlers.ts

@@ -1,78 +1,78 @@
-import { applyInMemoryListParams, getById, rowIdMatches } from "./inMemoryList";
-import type {
-  CreateResult,
-  DeleteResult,
-  GetListParams,
-  GetListResult,
-  GetOneResult,
-  UpdateResult,
-} from "./dataProviderTypes";
-import type { ResourceHandlers } from "./resourceHandlers";
-
-type Row = Record<string, unknown>;
-
-export type MemoryResourceHandlersConfig<
-  T extends Record<string, unknown> & { id: string | number },
-> = {
-  getRows: () => T[];
-  nextId: () => string | number;
-  /** Defaults to `{ ...data, id }` from form field sources. */
-  mapCreate?: (data: Row, id: string | number) => T;
-  /** Defaults to spread patch over current row. */
-  applyUpdate?: (current: T, patch: Row) => T;
-  scopeList?: (rows: T[], params: GetListParams) => T[];
-  afterDelete?: (removed: T) => void;
-};
-
-/**
- * Generic in-memory CRUD for demos and tests. Override hooks for entity-specific rules.
- */
-export function createMemoryResourceHandlers<
-  T extends Record<string, unknown> & { id: string | number },
->(config: MemoryResourceHandlersConfig<T>): ResourceHandlers<T> {
-  const asRows = (xs: T[]) => xs as unknown as Row[];
-
-  const mapCreate =
-    config.mapCreate ??
-    ((data: Row, id: string | number) => ({ ...data, id }) as T);
-
-  const applyUpdate =
-    config.applyUpdate ??
-    ((current: T, patch: Row) => ({ ...current, ...patch, id: current.id }) as T);
-
-  return {
-    async getList(params): Promise<GetListResult<T>> {
-      const base = config.scopeList
-        ? config.scopeList(config.getRows(), params)
-        : config.getRows();
-      return applyInMemoryListParams(asRows(base), params) as GetListResult<T>;
-    },
-
-    async getOne(id, _params?): Promise<GetOneResult<T>> {
-      return { data: getById(config.getRows(), id) as T };
-    },
-
-    async create(data): Promise<CreateResult<T>> {
-      const row = mapCreate(data as Row, config.nextId());
-      config.getRows().push(row);
-      return { data: row };
-    },
-
-    async update({ id, data }): Promise<UpdateResult<T>> {
-      const current = getById(config.getRows(), id);
-      const patch = data as Row;
-      const next = applyUpdate(current, patch);
-      Object.assign(current, next);
-      return { data: current };
-    },
-
-    async delete(id): Promise<DeleteResult<T>> {
-      const rows = config.getRows();
-      const idx = rows.findIndex((r) => rowIdMatches(r.id, id));
-      if (idx < 0) return { data: null };
-      const [removed] = rows.splice(idx, 1);
-      config.afterDelete?.(removed);
-      return { data: removed };
-    },
-  };
-}
+import { applyInMemoryListParams, getById, rowIdMatches } from "./inMemoryList";
+import type {
+  CreateResult,
+  DeleteResult,
+  GetListParams,
+  GetListResult,
+  GetOneResult,
+  UpdateResult,
+} from "./dataProviderTypes";
+import type { ResourceHandlers } from "./resourceHandlers";
+
+type Row = Record<string, unknown>;
+
+export type MemoryResourceHandlersConfig<
+  T extends Record<string, unknown> & { id: string | number },
+> = {
+  getRows: () => T[];
+  nextId: () => string | number;
+  /** Defaults to `{ ...data, id }` from form field sources. */
+  mapCreate?: (data: Row, id: string | number) => T;
+  /** Defaults to spread patch over current row. */
+  applyUpdate?: (current: T, patch: Row) => T;
+  scopeList?: (rows: T[], params: GetListParams) => T[];
+  afterDelete?: (removed: T) => void;
+};
+
+/**
+ * Generic in-memory CRUD for demos and tests. Override hooks for entity-specific rules.
+ */
+export function createMemoryResourceHandlers<
+  T extends Record<string, unknown> & { id: string | number },
+>(config: MemoryResourceHandlersConfig<T>): ResourceHandlers<T> {
+  const asRows = (xs: T[]) => xs as unknown as Row[];
+
+  const mapCreate =
+    config.mapCreate ??
+    ((data: Row, id: string | number) => ({ ...data, id }) as T);
+
+  const applyUpdate =
+    config.applyUpdate ??
+    ((current: T, patch: Row) => ({ ...current, ...patch, id: current.id }) as T);
+
+  return {
+    async getList(params): Promise<GetListResult<T>> {
+      const base = config.scopeList
+        ? config.scopeList(config.getRows(), params)
+        : config.getRows();
+      return applyInMemoryListParams(asRows(base), params) as GetListResult<T>;
+    },
+
+    async getOne(id, _params?): Promise<GetOneResult<T>> {
+      return { data: getById(config.getRows(), id) as T };
+    },
+
+    async create(data): Promise<CreateResult<T>> {
+      const row = mapCreate(data as Row, config.nextId());
+      config.getRows().push(row);
+      return { data: row };
+    },
+
+    async update({ id, data }): Promise<UpdateResult<T>> {
+      const current = getById(config.getRows(), id);
+      const patch = data as Row;
+      const next = applyUpdate(current, patch);
+      Object.assign(current, next);
+      return { data: current };
+    },
+
+    async delete(id): Promise<DeleteResult<T>> {
+      const rows = config.getRows();
+      const idx = rows.findIndex((r) => rowIdMatches(r.id, id));
+      if (idx < 0) return { data: null };
+      const [removed] = rows.splice(idx, 1);
+      config.afterDelete?.(removed);
+      return { data: removed };
+    },
+  };
+}

package/src/data/createRestResourceHandlers.ts

@@ -1,57 +1,63 @@
-import type { GetListParams, GetOneParams, Identifier } from "./dataProviderTypes";
-import type { ResourceHandlers } from "./resourceHandlers";
-
-export type RestResourceHandlersConfig<
-  T extends Record<string, unknown> = Record<string, unknown>,
-> = {
-  list: (params: GetListParams) => Promise<{ data: T[]; total: number }>;
-  retrieve: (id: Identifier, params?: GetOneParams) => Promise<T>;
-  create: (data: Record<string, unknown>) => Promise<T>;
-  update: (id: Identifier, data: Record<string, unknown>) => Promise<T>;
-  destroy: (id: Identifier) => Promise<void>;
-  /** When API create body differs from form `source` paths. */
-  transformCreate?: (data: Record<string, unknown>) => unknown;
-  /** When API update body differs from form `source` paths. */
-  transformUpdate?: (data: Record<string, unknown>) => unknown;
-};
-
-/**
- * Thin CRUD glue for REST backends. Form payload comes from field `source` paths;
- * wire your fetch or API client in the five functions below.
- */
-export function createRestResourceHandlers<
-  T extends Record<string, unknown> = Record<string, unknown>,
->(config: RestResourceHandlersConfig<T>): ResourceHandlers<T> {
-  return {
-    async getList(params) {
-      return config.list(params);
-    },
-
-    async getOne(id, params) {
-      return { data: await config.retrieve(id, params) };
-    },
-
-    async create(data) {
-      const body = config.transformCreate
-        ? config.transformCreate(data as Record<string, unknown>)
-        : data;
-      return {
-        data: await config.create(body as Record<string, unknown>),
-      };
-    },
-
-    async update({ id, data }) {
-      const body = config.transformUpdate
-        ? config.transformUpdate(data as Record<string, unknown>)
-        : data;
-      return {
-        data: await config.update(id, body as Record<string, unknown>),
-      };
-    },
-
-    async delete(id) {
-      await config.destroy(id);
-      return { data: null };
-    },
-  };
-}
+import type { GetListParams, GetOneParams, Identifier, FormMutationBody } from "./dataProviderTypes";
+import type { ResourceHandlers } from "./resourceHandlers";
+
+export type RestResourceHandlersConfig<
+  T extends Record<string, unknown> = Record<string, unknown>,
+> = {
+  list: (params: GetListParams) => Promise<{ data: T[]; total: number }>;
+  retrieve: (id: Identifier, params?: GetOneParams) => Promise<T>;
+  create: (data: FormMutationBody) => Promise<T>;
+  update: (id: Identifier, data: FormMutationBody) => Promise<T>;
+  destroy: (id: Identifier) => Promise<void>;
+  /** When API create body differs from form `source` paths. Not applied when body is already `FormData`. */
+  transformCreate?: (data: Record<string, unknown>) => unknown;
+  /** When API update body differs from form `source` paths. Not applied when body is already `FormData`. */
+  transformUpdate?: (data: Record<string, unknown>) => unknown;
+};
+
+/**
+ * Thin CRUD glue for REST backends. Form payload comes from field `source` paths;
+ * wire your fetch or API client in the five functions below.
+ */
+export function createRestResourceHandlers<
+  T extends Record<string, unknown> = Record<string, unknown>,
+>(config: RestResourceHandlersConfig<T>): ResourceHandlers<T> {
+  return {
+    async getList(params) {
+      return config.list(params);
+    },
+
+    async getOne(id, params) {
+      return { data: await config.retrieve(id, params) };
+    },
+
+    async create(data) {
+      const body =
+        data instanceof FormData
+          ? data
+          : config.transformCreate
+            ? config.transformCreate(data as Record<string, unknown>)
+            : data;
+      return {
+        data: await config.create(body as FormMutationBody),
+      };
+    },
+
+    async update({ id, data }) {
+      const body =
+        data instanceof FormData
+          ? data
+          : config.transformUpdate
+            ? config.transformUpdate(data as Record<string, unknown>)
+            : data;
+      return {
+        data: await config.update(id, body as FormMutationBody),
+      };
+    },
+
+    async delete(id) {
+      await config.destroy(id);
+      return { data: null };
+    },
+  };
+}

package/src/data/dataProviderTypes.ts

@@ -43,7 +43,7 @@ export type CreateResult<RecordType extends Record<string, unknown>> = {
 
 export type UpdateParams<RecordType extends Record<string, unknown>> = {
   id: Identifier;
-  data: Partial<RecordType>;
+  data: Partial<RecordType> | FormData;
 };
 
 export type UpdateResult<RecordType extends Record<string, unknown>> = {
@@ -54,14 +54,16 @@ export type DeleteResult<RecordType extends Record<string, unknown>> = {
   data: RecordType | null;
 };
 
+/** Save body from forms — plain JSON object or multipart `FormData` when uploads are present. */
+export type FormMutationBody = Record<string, unknown> | FormData;
+
 export type FormMutation = "create" | "update";
 
 export type ParseFormErrorContext = {
   resource: string;
   mutation: FormMutation;
-  /** Set when saving an inline row — prefix field paths for that row. */
-  inlineArrayName?: string;
-  rowIndex?: number;
+  /** Top-level inline field-array paths on the form, e.g. `["lines"]`. */
+  inlineFieldPaths?: string[];
 };
 
 /** Field paths match react-hook-form `name` (form `source` or inline `arrayName.index.source`). */
@@ -94,7 +96,7 @@ export type DataProvider<
   ) => Promise<GetOneResult<RecordType>>;
   create: (
     resource: string,
-    data: Partial<RecordType>,
+    data: Partial<RecordType> | FormData,
   ) => Promise<CreateResult<RecordType>>;
   update: (
     resource: string,

package/src/data/dataUtils.test.ts

@@ -1,108 +1,228 @@
-import { describe, expect, it, vi } from "vitest";
-import { pickBySources } from "../crud/utils/pickBySources";
-import { createRestResourceHandlers } from "./createRestResourceHandlers";
-import {
-  toDjangoRestOrdering,
-  toJsonApiSort,
-  toODataOrderBy,
-} from "./sortHelpers";
-
-describe("pickBySources", () => {
-  it("picks flat fields", () => {
-    const values = {
-      username: "jane",
-      email: "jane@example.com",
-      tenants: [{ id: 1 }],
-    };
-    expect(pickBySources(values, ["username", "email"])).toEqual({
-      username: "jane",
-      email: "jane@example.com",
-    });
-  });
-
-  it("picks nested fields", () => {
-    const values = {
-      invoiceLine: { product: "SKU-1", quantity: 2 },
-      extra: "ignored",
-    };
-    expect(pickBySources(values, ["invoiceLine.product", "invoiceLine.quantity"])).toEqual({
-      invoiceLine: { product: "SKU-1", quantity: 2 },
-    });
-  });
-
-  it("returns all values when no sources registered", () => {
-    const values = { a: 1, b: 2 };
-    expect(pickBySources(values, [])).toEqual(values);
-  });
-});
-
-describe("sort helpers", () => {
-  it("toDjangoRestOrdering", () => {
-    expect(toDjangoRestOrdering({ field: "username", order: "ASC" })).toBe(
-      "username",
-    );
-    expect(toDjangoRestOrdering({ field: "username", order: "DESC" })).toBe(
-      "-username",
-    );
-    expect(
-      toDjangoRestOrdering([
-        { field: "username", order: "ASC" },
-        { field: "date_joined", order: "DESC" },
-      ]),
-    ).toBe("username,-date_joined");
-  });
-
-  it("toODataOrderBy", () => {
-    expect(toODataOrderBy({ field: "username", order: "DESC" })).toBe(
-      "username desc",
-    );
-  });
-
-  it("toJsonApiSort", () => {
-    expect(toJsonApiSort({ field: "username", order: "DESC" })).toBe(
-      "-username",
-    );
-  });
-});
-
-describe("createRestResourceHandlers", () => {
-  it("passes form payload through on create/update", async () => {
-    const create = vi.fn(async (data) => ({ id: "1", ...data }));
-    const update = vi.fn(async (_id, data) => ({ id: "1", ...data }));
-
-    const handlers = createRestResourceHandlers({
-      list: async () => ({ data: [], total: 0 }),
-      retrieve: async () => ({ id: "1" }),
-      create,
-      update,
-      destroy: async () => {},
-    });
-
-    await handlers.create({ username: "jane" });
-    expect(create).toHaveBeenCalledWith({ username: "jane" });
-
-    await handlers.update({ id: "1", data: { email: "a@b.c" } });
-    expect(update).toHaveBeenCalledWith("1", { email: "a@b.c" });
-  });
-
-  it("applies transformCreate and transformUpdate when provided", async () => {
-    const create = vi.fn(async (data) => data);
-    const update = vi.fn(async (_id, data) => data);
-
-    const handlers = createRestResourceHandlers({
-      list: async () => ({ data: [], total: 0 }),
-      retrieve: async () => ({}),
-      create,
-      update,
-      destroy: async () => {},
-      transformCreate: (data) => ({ user: data }),
-      transformUpdate: (data) => ({ patch: data }),
-    });
-
-    await handlers.create({ username: "jane" });
-    expect(create).toHaveBeenCalledWith({ user: { username: "jane" } });
-
-    await handlers.update({ id: "1", data: { username: "bob" } });
-    expect(update).toHaveBeenCalledWith("1", { patch: { username: "bob" } });
-  });
-});
+import { describe, expect, it, vi } from "vitest";
+import { buildFormPayload } from "../crud/utils/buildFormPayload";
+import { buildInlineRowsPayload } from "../crud/utils/buildInlineRowsPayload";
+import { nestedFieldPath } from "../crud/utils/nestedFieldPath";
+import { hasUploadValues } from "../crud/utils/hasUploadValues";
+import { prepareFormSubmitBody } from "../crud/utils/prepareFormSubmitBody";
+import { toFormData } from "../crud/utils/toFormData";
+import { createRestResourceHandlers } from "./createRestResourceHandlers";
+import {
+  toDjangoRestOrdering,
+  toJsonApiSort,
+  toODataOrderBy,
+} from "./sortHelpers";
+
+describe("buildFormPayload", () => {
+  it("picks flat fields", () => {
+    const values = {
+      username: "jane",
+      email: "jane@example.com",
+      tenants: [{ id: 1 }],
+    };
+    expect(buildFormPayload(values, ["username", "email"])).toEqual({
+      username: "jane",
+      email: "jane@example.com",
+    });
+  });
+
+  it("picks nested fields", () => {
+    const values = {
+      invoiceLine: { product: "SKU-1", quantity: 2 },
+      extra: "ignored",
+    };
+    expect(
+      buildFormPayload(values, ["invoiceLine.product", "invoiceLine.quantity"]),
+    ).toEqual({
+      invoiceLine: { product: "SKU-1", quantity: 2 },
+    });
+  });
+
+  it("returns all values when no field paths registered", () => {
+    const values = { a: 1, b: 2 };
+    expect(buildFormPayload(values, [])).toEqual(values);
+  });
+});
+
+describe("buildInlineRowsPayload", () => {
+  it("picks sources and keeps record id", () => {
+    const rows = [
+      { rowKey: "a", id: 10, label: "A", quantity: 2, extra: "x" },
+      { rowKey: "b", label: "B", quantity: 1 },
+    ];
+    expect(buildInlineRowsPayload(rows, ["label", "quantity"])).toEqual([
+      { label: "A", quantity: 2, id: 10 },
+      { label: "B", quantity: 1 },
+    ]);
+  });
+
+  it("applies transformRows", () => {
+    const rows = [{ rowKey: "a", label: "A" }];
+    const result = buildInlineRowsPayload(rows, ["label"], {
+      transformRows: (cleaned) => cleaned.map((r) => ({ ...r, kind: "line" })),
+    });
+    expect(result).toEqual([{ label: "A", kind: "line" }]);
+  });
+});
+
+describe("nestedFieldPath", () => {
+  it("builds dot paths", () => {
+    expect(nestedFieldPath("lines", 0, "label")).toBe("lines.0.label");
+  });
+});
+
+describe("hasUploadValues", () => {
+  it("detects File in nested payload", () => {
+    const file = new File(["x"], "a.png", { type: "image/png" });
+    expect(hasUploadValues({ name: "x" })).toBe(false);
+    expect(hasUploadValues({ photo: file })).toBe(true);
+    expect(hasUploadValues({ lines: [{ photo: file }] })).toBe(true);
+  });
+});
+
+describe("toFormData", () => {
+  it("encodes flat scalars and files", () => {
+    const file = new File(["x"], "photo.png", { type: "image/png" });
+    const fd = toFormData({ name: "Widget", active: true, count: 2, photo: file });
+
+    expect(fd.get("name")).toBe("Widget");
+    expect(fd.get("active")).toBe("true");
+    expect(fd.get("count")).toBe("2");
+    expect(fd.get("photo")).toBe(file);
+  });
+
+  it("encodes null as empty string and skips unchanged upload URLs", () => {
+    const fd = toFormData({
+      photo: null,
+      avatar: "https://cdn.example.com/a.jpg",
+      title: "Hello",
+    });
+
+    expect(fd.get("photo")).toBe("");
+    expect(fd.get("avatar")).toBeNull();
+    expect(fd.get("title")).toBe("Hello");
+  });
+
+  it("encodes inline rows with bracket notation", () => {
+    const file = new File(["x"], "line.png", { type: "image/png" });
+    const fd = toFormData({
+      lines: [{ id: 10, label: "A", photo: file }],
+    });
+
+    expect(fd.get("lines[0][id]")).toBe("10");
+    expect(fd.get("lines[0][label]")).toBe("A");
+    expect(fd.get("lines[0][photo]")).toBe(file);
+  });
+});
+
+describe("prepareFormSubmitBody", () => {
+  it("returns plain object when no uploads", () => {
+    const payload = { name: "Widget" };
+    expect(prepareFormSubmitBody(payload)).toEqual(payload);
+  });
+
+  it("omits unchanged upload references from JSON payloads", () => {
+    const body = prepareFormSubmitBody({
+      name: "Widget",
+      photo: "/media/employee_pictures/default.png",
+    });
+    expect(body).toEqual({ name: "Widget" });
+  });
+
+  it("returns FormData when uploads are present", () => {
+    const file = new File(["x"], "a.png", { type: "image/png" });
+    const body = prepareFormSubmitBody({ name: "Widget", photo: file });
+    expect(body).toBeInstanceOf(FormData);
+    expect((body as FormData).get("photo")).toBe(file);
+  });
+});
+
+describe("sort helpers", () => {
+  it("toDjangoRestOrdering", () => {
+    expect(toDjangoRestOrdering({ field: "username", order: "ASC" })).toBe(
+      "username",
+    );
+    expect(toDjangoRestOrdering({ field: "username", order: "DESC" })).toBe(
+      "-username",
+    );
+    expect(
+      toDjangoRestOrdering([
+        { field: "username", order: "ASC" },
+        { field: "date_joined", order: "DESC" },
+      ]),
+    ).toBe("username,-date_joined");
+  });
+
+  it("toODataOrderBy", () => {
+    expect(toODataOrderBy({ field: "username", order: "DESC" })).toBe(
+      "username desc",
+    );
+  });
+
+  it("toJsonApiSort", () => {
+    expect(toJsonApiSort({ field: "username", order: "DESC" })).toBe(
+      "-username",
+    );
+  });
+});
+
+describe("createRestResourceHandlers", () => {
+  it("passes form payload through on create/update", async () => {
+    const create = vi.fn(async (data) => ({ id: "1", ...data }));
+    const update = vi.fn(async (_id, data) => ({ id: "1", ...data }));
+
+    const handlers = createRestResourceHandlers({
+      list: async () => ({ data: [], total: 0 }),
+      retrieve: async () => ({ id: "1" }),
+      create,
+      update,
+      destroy: async () => {},
+    });
+
+    await handlers.create({ username: "jane" });
+    expect(create).toHaveBeenCalledWith({ username: "jane" });
+
+    await handlers.update({ id: "1", data: { email: "a@b.c" } });
+    expect(update).toHaveBeenCalledWith("1", { email: "a@b.c" });
+  });
+
+  it("applies transformCreate and transformUpdate when provided", async () => {
+    const create = vi.fn(async (data) => data);
+    const update = vi.fn(async (_id, data) => data);
+
+    const handlers = createRestResourceHandlers({
+      list: async () => ({ data: [], total: 0 }),
+      retrieve: async () => ({}),
+      create,
+      update,
+      destroy: async () => {},
+      transformCreate: (data) => ({ user: data }),
+      transformUpdate: (data) => ({ patch: data }),
+    });
+
+    await handlers.create({ username: "jane" });
+    expect(create).toHaveBeenCalledWith({ user: { username: "jane" } });
+
+    await handlers.update({ id: "1", data: { username: "bob" } });
+    expect(update).toHaveBeenCalledWith("1", { patch: { username: "bob" } });
+  });
+
+  it("passes FormData through without transform", async () => {
+    const create = vi.fn(async (data) => data);
+    const transformCreate = vi.fn((data) => data);
+
+    const handlers = createRestResourceHandlers({
+      list: async () => ({ data: [], total: 0 }),
+      retrieve: async () => ({}),
+      create,
+      update: async (_id, data) => data,
+      destroy: async () => {},
+      transformCreate,
+    });
+
+    const fd = new FormData();
+    fd.append("name", "Widget");
+    await handlers.create(fd);
+    expect(transformCreate).not.toHaveBeenCalled();
+    expect(create).toHaveBeenCalledWith(fd);
+  });
+});