@goplusvn/core 0.1.71 → 0.1.73

package/src/crud/index.ts

@@ -28,8 +28,11 @@ export * from "./components/crud-virtual-table";
 export { EntityCrudPage } from "./pages/entity-crud-page";
 
 // Re-export lib logic
+export * from "./lib/coerce";
 export * from "./lib/crud-service";
 export * from "./lib/crud-utils";
+export * from "./lib/entity-endpoints";
+export * from "./lib/errors";
 export * from "./lib/crud-validator";
 export * from "./lib/data-loader";
 export * from "./lib/field-calculator";

package/src/crud/lib/coerce.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect } from "vitest";
+import { coerceFieldValue } from "./coerce";
+import type { FieldConfig } from "../../types";
+
+const field = (over: Partial<FieldConfig>): FieldConfig => ({
+  name: "f",
+  label: "F",
+  type: "text",
+  ...over,
+});
+
+describe("coerceFieldValue", () => {
+  it("giữ nguyên undefined/null", () => {
+    const f = field({ type: "number" });
+    expect(coerceFieldValue(f, undefined)).toBeUndefined();
+    expect(coerceFieldValue(f, null)).toBeNull();
+  });
+
+  it("number: chuỗi số → number, chuỗi rỗng → null, chuỗi rác giữ nguyên", () => {
+    const f = field({ type: "number" });
+    expect(coerceFieldValue(f, "5")).toBe(5);
+    expect(coerceFieldValue(f, "5.5")).toBe(5.5);
+    expect(coerceFieldValue(f, "")).toBeNull();
+    expect(coerceFieldValue(f, "  ")).toBeNull();
+    expect(coerceFieldValue(f, "abc")).toBe("abc");
+    expect(coerceFieldValue(f, 7)).toBe(7);
+  });
+
+  it("boolean: các chuỗi truthy quy ước → true", () => {
+    const f = field({ type: "boolean" });
+    expect(coerceFieldValue(f, "true")).toBe(true);
+    expect(coerceFieldValue(f, "active")).toBe(true);
+    expect(coerceFieldValue(f, "1")).toBe(true);
+    expect(coerceFieldValue(f, "on")).toBe(true);
+    expect(coerceFieldValue(f, "false")).toBe(false);
+    expect(coerceFieldValue(f, "inactive")).toBe(false);
+  });
+
+  it("switch có cặp option → map về value của option, không phải boolean", () => {
+    const f = field({
+      type: "switch",
+      options: [
+        { label: "Hoạt động", value: "active" },
+        { label: "Vô hiệu", value: "inactive" },
+      ],
+    });
+    expect(coerceFieldValue(f, "active")).toBe("active");
+    expect(coerceFieldValue(f, "inactive")).toBe("inactive");
+    expect(coerceFieldValue(f, true)).toBe("active");
+    expect(coerceFieldValue(f, false)).toBe("inactive");
+  });
+
+  it("date/datetime: chuỗi ISO → Date, chuỗi rỗng → null, chuỗi rác giữ nguyên", () => {
+    const f = field({ type: "datetime" });
+    const out = coerceFieldValue(f, "2026-01-02T00:00:00.000Z");
+    expect(out).toBeInstanceOf(Date);
+    expect((out as Date).toISOString()).toBe("2026-01-02T00:00:00.000Z");
+    expect(coerceFieldValue(f, "")).toBeNull();
+    expect(coerceFieldValue(f, "not-a-date")).toBe("not-a-date");
+  });
+
+  it('FK: "" → undefined cho relation và *Id dạng select', () => {
+    expect(
+      coerceFieldValue(field({ name: "department", type: "relation" }), ""),
+    ).toBeUndefined();
+    expect(
+      coerceFieldValue(field({ name: "departmentId", type: "select" }), ""),
+    ).toBeUndefined();
+  });
+
+  it('*Id scalar (kiểu text, không phải FK) giữ nguyên ""', () => {
+    expect(
+      coerceFieldValue(field({ name: "citizenId", type: "text" }), ""),
+    ).toBe("");
+  });
+
+  it("mảng: ép từng phần tử (giá trị filter in/notIn)", () => {
+    const f = field({ type: "integer" });
+    expect(coerceFieldValue(f, ["1", "2", 3])).toEqual([1, 2, 3]);
+  });
+
+  it('FK snake_case: "" → undefined cho *_id/*_ids dạng select', () => {
+    expect(
+      coerceFieldValue(field({ name: "meal_time_id", type: "select" }), ""),
+    ).toBeUndefined();
+    expect(
+      coerceFieldValue(
+        field({ name: "default_meal_time_ids", type: "multiselect" }),
+        "",
+      ),
+    ).toBeUndefined();
+  });
+
+  it('valueType "int": select/multiselect chở chuỗi → number (FK Int autoincrement)', () => {
+    const f = field({
+      name: "meal_time_id",
+      type: "select",
+      valueType: "int",
+    });
+    expect(coerceFieldValue(f, "3")).toBe(3);
+    expect(coerceFieldValue(f, 3)).toBe(3);
+    expect(coerceFieldValue(f, "")).toBeUndefined(); // FK "" = bỏ trống
+    expect(coerceFieldValue(f, "abc")).toBe("abc"); // rác giữ nguyên cho validate
+
+    const multi = field({
+      name: "default_meal_time_ids",
+      type: "multiselect",
+      valueType: "int",
+    });
+    expect(coerceFieldValue(multi, ["1", "2", 3])).toEqual([1, 2, 3]);
+  });
+
+  it('valueType "int" trên select KHÔNG phải FK: "" → null (cột Int nullable)', () => {
+    const f = field({ name: "level", type: "select", valueType: "int" });
+    expect(coerceFieldValue(f, "2")).toBe(2);
+    expect(coerceFieldValue(f, "")).toBeNull();
+  });
+});

package/src/crud/lib/coerce.ts

@@ -0,0 +1,95 @@
+import type { FieldConfig } from "../../types";
+
+function optionValue(option: unknown): unknown {
+  return typeof option === "object" && option !== null && "value" in option
+    ? (option as { value: unknown }).value
+    : option;
+}
+
+/**
+ * Ép kiểu MỘT giá trị theo FieldConfig — điểm coercion tập trung, dùng chung
+ * cho body create/update (mutation-builder) và giá trị filter từ query string
+ * (route-handlers). Client gửi chuỗi (form/URL) là chuyện thường; không ép thì
+ * Prisma nổ type mismatch với cột Int/Boolean/DateTime.
+ *
+ * Trả `undefined` nghĩa là "coi như bỏ trống" — với cột FK, chuỗi rỗng ""
+ * phải thành undefined chứ không được lọt xuống DB (nổ P2003).
+ */
+export function coerceFieldValue(field: FieldConfig, value: unknown): unknown {
+  if (value === undefined || value === null) return value;
+  if (Array.isArray(value)) {
+    return value.map((v) => coerceFieldValue(field, v));
+  }
+
+  // BẪY empty-string FK: "" vào cột FK là "bỏ trống", không phải giá trị —
+  // trả undefined để mutation disconnect/bỏ key, filter thì bỏ qua điều kiện.
+  // CHỈ áp cho field thực sự là FK (relation, hoặc *Id/*_id dạng select) —
+  // nhận CẢ HAI convention camelCase (`branchId`) và snake_case
+  // (`meal_time_id`, `default_meal_time_ids`); *Id scalar kiểu text
+  // (citizenId, targetId…) giữ nguyên "".
+  const fkName =
+    (field.name.endsWith("Id") && field.name.length > 2) ||
+    /_ids?$/.test(field.name);
+  const isForeignKey =
+    field.type === "relation" ||
+    Boolean(field.relation) ||
+    (fkName && (field.type === "select" || field.type === "multiselect"));
+  if (value === "" && isForeignKey) {
+    return undefined;
+  }
+
+  // Cột Int đứng sau select/multiselect/relation (FK autoincrement): `type`
+  // không nói lên kiểu cột nên phải khai `valueType: "int"` trong FieldConfig.
+  // Chuỗi không phải số giữ nguyên cho tầng validate/Prisma báo.
+  if (field.valueType === "int" && typeof value === "string") {
+    if (value.trim() === "") return null;
+    const num = Number(value);
+    return Number.isNaN(num) ? value : num;
+  }
+
+  switch (field.type) {
+    case "number":
+    case "integer": {
+      if (typeof value !== "string") return value;
+      if (value.trim() === "") return null;
+      const num = Number(value);
+      // Chuỗi không phải số: giữ nguyên cho tầng validate/Prisma báo, không âm thầm NaN.
+      return Number.isNaN(num) ? value : num;
+    }
+
+    case "boolean":
+    case "switch": {
+      let isTrue: boolean;
+      if (typeof value === "string") {
+        const lv = value.toLowerCase();
+        isTrue =
+          lv === "true" || lv === "active" || value === "1" || value === "on";
+      } else {
+        isTrue = Boolean(value);
+      }
+      // switch có cặp option = cột string 2 trạng thái (active/inactive…),
+      // map về value của option chứ không phải boolean.
+      if (
+        field.type === "switch" &&
+        field.options &&
+        field.options.length >= 2
+      ) {
+        return isTrue
+          ? optionValue(field.options[0])
+          : optionValue(field.options[1]);
+      }
+      return isTrue;
+    }
+
+    case "date":
+    case "datetime": {
+      if (typeof value !== "string") return value;
+      if (value.trim() === "") return null;
+      const date = new Date(value);
+      return Number.isNaN(date.getTime()) ? value : date;
+    }
+
+    default:
+      return value;
+  }
+}

package/src/crud/lib/crud-utils.ts

@@ -31,6 +31,10 @@ export function buildQueryString(params: CrudQueryParams): string {
     searchParams.append("filters", JSON.stringify(params.filters));
   }
 
+  if (params.filterTree) {
+    searchParams.append("filterTree", JSON.stringify(params.filterTree));
+  }
+
   return searchParams.toString();
 }
 

package/src/crud/lib/entity-endpoints.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect } from "vitest";
+import { getEntityEndpoints } from "./entity-endpoints";
+import type { EntityConfig } from "../../types";
+
+const base: EntityConfig = {
+  name: "job-title",
+  label: "Chức danh",
+  pluralLabel: "Chức danh",
+  apiEndpoint: "/api/crud/job-titles",
+  idField: "id",
+  displayField: "name",
+  fields: [],
+};
+
+describe("getEntityEndpoints", () => {
+  it("default: suy từ apiEndpoint theo cùng một quy tắc", () => {
+    expect(getEntityEndpoints(base)).toEqual({
+      import: "/api/crud/job-titles/import",
+      export: "/api/crud/job-titles/export",
+    });
+  });
+
+  it("apiEndpoint có query params: giữ query sau path import/export", () => {
+    const config = { ...base, apiEndpoint: "/api/stocks?type=in" };
+    expect(getEntityEndpoints(config)).toEqual({
+      import: "/api/stocks/import?type=in",
+      export: "/api/stocks/export?type=in",
+    });
+  });
+
+  it("config.endpoints override từng endpoint riêng lẻ", () => {
+    const config = {
+      ...base,
+      endpoints: { export: "/api/reports/job-titles/xlsx" },
+    };
+    expect(getEntityEndpoints(config)).toEqual({
+      import: "/api/crud/job-titles/import",
+      export: "/api/reports/job-titles/xlsx",
+    });
+  });
+});

package/src/crud/lib/entity-endpoints.ts

@@ -0,0 +1,23 @@
+import type { EntityConfig } from "../../types";
+
+/**
+ * Endpoint import/export của entity — MỘT quy tắc duy nhất cho cả ImportDialog
+ * lẫn CrudExportButton (trước đây hai nơi tự build hai kiểu khác nhau → 404).
+ *
+ * Default: `${base}/import|/export` với base = apiEndpoint bỏ query string,
+ * query params (nếu có) được giữ lại nối sau path. Override từng cái qua
+ * `config.endpoints`.
+ */
+export function getEntityEndpoints(config: EntityConfig): {
+  import: string;
+  export: string;
+} {
+  const [base, query] = config.apiEndpoint.split("?");
+  const derive = (suffix: string) =>
+    `${base}/${suffix}${query ? `?${query}` : ""}`;
+
+  return {
+    import: config.endpoints?.import ?? derive("import"),
+    export: config.endpoints?.export ?? derive("export"),
+  };
+}

package/src/crud/lib/errors.ts

@@ -0,0 +1,14 @@
+/**
+ * Lỗi request CRUD do client gửi sai (id sai kiểu, filters/filterTree hỏng…).
+ * Route-handler bắt instanceof để trả đúng status (mặc định 400) thay vì rơi
+ * xuống onError/500 chung.
+ */
+export class CrudRequestError extends Error {
+  readonly status: number;
+
+  constructor(message: string, status = 400) {
+    super(message);
+    this.name = "CrudRequestError";
+    this.status = status;
+  }
+}

package/src/crud/lib/import-request.ts

@@ -0,0 +1,99 @@
+import type { EntityConfig, FieldConfig, ImportOptions } from "../../types";
+
+import { parseFile } from "./import-export-service";
+
+/**
+ * Đọc body của một route import ở CẢ HAI dạng client đang tồn tại:
+ *
+ *  - multipart FormData `{file, format}` — ImportDialog của core gửi lên
+ *    (file xlsx/csv/json parse ngay tại server bằng parseFile);
+ *  - JSON array — đường cũ: client tự parse Excel rồi POST thẳng mảng dòng.
+ *
+ * Sau khi parse, header mỗi dòng được dịch về TÊN CỘT DB, nhận cả 3 kiểu:
+ * header legacy khai tường minh (`legacyHeaders`, vd tiếng Việt của file mẫu
+ * hệ cũ), label khai trong EntityConfig (file mẫu do ImportDialog sinh dùng
+ * label) và tên cột máy. Cột không khớp mapping nào bị bỏ qua.
+ *
+ * Trả `null` khi body không đọc được thành mảng dòng (thiếu file, JSON không
+ * phải array…) — caller trả 400.
+ */
+export async function readImportRows(
+  req: Request,
+  config: EntityConfig,
+  legacyHeaders: Record<string, string> = {},
+): Promise<Record<string, unknown>[] | null> {
+  const contentType = req.headers.get("content-type") ?? "";
+  let rawRows: unknown;
+
+  if (contentType.includes("multipart/form-data")) {
+    const form = await req.formData();
+    // Duck-type thay vì `instanceof File` — File có thể đến từ realm khác
+    // (undici vs jsdom/global) và instanceof xuyên realm luôn false.
+    const file = form.get("file") as File | string | null;
+    if (file === null || typeof file === "string") return null;
+    const formatField = form.get("format");
+    const format =
+      formatField === "csv" || formatField === "json" || formatField === "xlsx"
+        ? formatField
+        : inferFormat(file.name);
+    rawRows = await parseFile(file, format);
+  } else {
+    try {
+      rawRows = await req.json();
+    } catch {
+      return null;
+    }
+  }
+
+  if (!Array.isArray(rawRows)) return null;
+
+  // Header legacy khai tường minh thắng trước; label/tên cột từ config bù sau.
+  const headerToColumn: Record<string, string> = { ...legacyHeaders };
+  for (const field of config.fields) {
+    headerToColumn[field.name] ??= field.name;
+    headerToColumn[field.label] ??= field.name;
+  }
+
+  return rawRows.map((row) => {
+    const out: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(row as Record<string, unknown>)) {
+      const column = headerToColumn[key.trim()];
+      if (column) out[column] = value;
+    }
+    return out;
+  });
+}
+
+function inferFormat(fileName: string): ImportOptions["format"] {
+  const name = fileName.toLowerCase();
+  if (name.endsWith(".csv")) return "csv";
+  if (name.endsWith(".json")) return "json";
+  return "xlsx";
+}
+
+/**
+ * Ép ô boolean từ file import: nhận boolean thật (đường JSON cũ), chuỗi
+ * true/false/1/0/x…, và cả LABEL của option boolean trong config ("Đang làm
+ * việc", "Ngừng bán"…). Không nhận diện được → undefined (để zod default lo).
+ */
+export function coerceBooleanCell(
+  value: unknown,
+  field?: FieldConfig,
+): boolean | undefined {
+  if (typeof value === "boolean") return value;
+  if (value === undefined || value === null || value === "") return undefined;
+  const v = String(value).trim().toLowerCase();
+  if (["true", "1", "yes", "y", "x", "có", "co"].includes(v)) return true;
+  if (["false", "0", "no", "n", "không", "khong"].includes(v)) return false;
+  for (const opt of field?.options ?? []) {
+    if (
+      typeof opt === "object" &&
+      opt !== null &&
+      typeof opt.value === "boolean" &&
+      String(opt.label).trim().toLowerCase() === v
+    ) {
+      return opt.value;
+    }
+  }
+  return undefined;
+}

package/src/crud/lib/mutation-builder.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, vi } from "vitest";
+import { prepareMutationData } from "./mutation-builder";
+import type { EntityConfig } from "../../types";
+
+const logger = { warn: vi.fn(), error: vi.fn() };
+const SYSTEM_FIELDS = ["id", "createdAt", "updatedAt", "createdBy", "updatedBy"];
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+const makeConfig = (over: Partial<EntityConfig> = {}): EntityConfig => ({
+  name: "job-title",
+  label: "Chức danh",
+  pluralLabel: "Chức danh",
+  apiEndpoint: "/api/crud/job-titles",
+  idField: "id",
+  displayField: "name",
+  fields: [
+    { name: "id", label: "ID", type: "text" },
+    { name: "name", label: "Tên", type: "text" },
+    { name: "level", label: "Cấp", type: "number" },
+    { name: "active", label: "Kích hoạt", type: "boolean" },
+    { name: "departmentId", label: "Phòng ban", type: "select" },
+  ],
+  ...over,
+});
+
+const prepare = (
+  data: Record<string, unknown>,
+  mode: "create" | "update",
+  config?: EntityConfig,
+) => prepareMutationData({ data, config, mode, systemFields: SYSTEM_FIELDS, logger });
+
+describe("prepareMutationData", () => {
+  describe("id theo idKind", () => {
+    it('idKind mặc định ("string"): create thiếu id thì sinh UUID', () => {
+      const out = prepare({ name: "A" }, "create", makeConfig());
+      expect(out.id).toMatch(UUID_RE);
+    });
+
+    it("không có config: giữ hành vi cũ, vẫn sinh UUID", () => {
+      const out = prepare({ name: "A" }, "create");
+      expect(out.id).toMatch(UUID_RE);
+    });
+
+    it("idKind int: KHÔNG BAO GIỜ sinh id (DB autoincrement)", () => {
+      const out = prepare({ name: "A" }, "create", makeConfig({ idKind: "int" }));
+      expect("id" in out).toBe(false);
+    });
+
+    it('idKind int: id rỗng "" từ form bị bỏ hẳn key', () => {
+      const out = prepare({ id: "", name: "A" }, "create", makeConfig({ idKind: "int" }));
+      expect("id" in out).toBe(false);
+    });
+
+    it("idKind int: id chuỗi số được ép Number", () => {
+      const out = prepare({ id: "12", name: "A" }, "create", makeConfig({ idKind: "int" }));
+      expect(out.id).toBe(12);
+    });
+
+    it("idField tùy biến: sinh UUID vào đúng cột id của entity", () => {
+      const config = makeConfig({
+        idField: "code",
+        fields: [
+          { name: "code", label: "Mã", type: "text" },
+          { name: "name", label: "Tên", type: "text" },
+        ],
+      });
+      const out = prepare({ name: "A" }, "create", config);
+      expect(out.code).toMatch(UUID_RE);
+      expect("id" in out).toBe(false);
+    });
+  });
+
+  describe("coercion theo config.fields", () => {
+    it("ép number/boolean từ chuỗi form", () => {
+      const out = prepare(
+        { name: "A", level: "5", active: "true" },
+        "create",
+        makeConfig(),
+      );
+      expect(out.level).toBe(5);
+      expect(out.active).toBe(true);
+    });
+
+    it("lọc field ngoài config kèm cảnh báo", () => {
+      const out = prepare({ name: "A", hacker: "x" }, "create", makeConfig());
+      expect("hacker" in out).toBe(false);
+      expect(logger.warn).toHaveBeenCalled();
+    });
+  });
+
+  describe("empty-string FK", () => {
+    it('create: departmentId "" bị bỏ, không connect', () => {
+      const out = prepare({ name: "A", departmentId: "" }, "create", makeConfig());
+      expect("departmentId" in out).toBe(false);
+      expect("department" in out).toBe(false);
+    });
+
+    it('update: departmentId "" → disconnect relation', () => {
+      const out = prepare({ name: "A", departmentId: "" }, "update", makeConfig());
+      expect("departmentId" in out).toBe(false);
+      expect(out.department).toEqual({ disconnect: true });
+    });
+
+    it("departmentId có giá trị → connect", () => {
+      const out = prepare(
+        { name: "A", departmentId: "dep-1" },
+        "create",
+        makeConfig(),
+      );
+      expect(out.department).toEqual({ connect: { id: "dep-1" } });
+      expect("departmentId" in out).toBe(false);
+    });
+  });
+});

package/src/crud/lib/mutation-builder.ts

@@ -1,5 +1,7 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import type { EntityConfig } from "../../types";
 import type { ServerCrudLogger } from "../server-service";
+import { coerceFieldValue } from "./coerce";
 
 export interface PrepareMutationDataOptions {
   data: any;
@@ -14,12 +16,16 @@ export interface PrepareMutationDataOptions {
 export function prepareMutationData(options: PrepareMutationDataOptions) {
   const { data, config, mode, systemFields, relationFieldSkip, logger, touchUpdatedAtOnCreate } = options;
 
+  const idField = config?.idField ?? "id";
+  const idKind = config?.idKind ?? "string";
+
   let filtered = data;
-  
+
   if (config) {
     // 1. Filter valid fields
     const valid = new Set(config.fields.filter((f) => !(f as any).isDisplayOnly).map((f) => f.name));
     for (const f of systemFields) valid.add(f);
+    valid.add(idField);
     filtered = {};
     for (const [k, v] of Object.entries(data)) {
       if (valid.has(k)) {
@@ -29,42 +35,28 @@ export function prepareMutationData(options: PrepareMutationDataOptions) {
       }
     }
 
-    // 2. Cast field values (boolean, number)
+    // 2. Ép kiểu tập trung theo config.fields (number/boolean/switch/date,
+    // "" cho FK → undefined) — xem coerceFieldValue.
     for (const field of config.fields) {
-      const value = filtered[field.name];
-      if (value === undefined || value === null) continue;
-      
-      if (field.type === "boolean" || field.type === "switch") {
-        let isTrue: boolean;
-        if (typeof value === "string") {
-          const lv = value.toLowerCase();
-          isTrue = lv === "true" || lv === "active" || value === "1" || value === "on";
-        } else {
-          isTrue = Boolean(value);
-        }
-        
-        if (field.type === "switch" && field.options && field.options.length >= 2) {
-          filtered[field.name] = isTrue ? (field.options[0] as any).value : (field.options[1] as any).value;
-        } else {
-          filtered[field.name] = isTrue;
-        }
-      } else if (field.type === "number" || (field.type as string) === "integer") {
-        if (typeof value === "string") {
-          if (value.trim() === "") {
-            filtered[field.name] = null;
-          } else {
-            const num = Number(value);
-            if (!isNaN(num)) filtered[field.name] = num;
-          }
-        }
-      }
+      if (!(field.name in filtered)) continue;
+      filtered[field.name] = coerceFieldValue(field, filtered[field.name]);
     }
   }
 
   // 3. System defaults for create
   if (mode === "create") {
-    if (!filtered.id) {
-      filtered.id = crypto.randomUUID();
+    if (idKind === "int") {
+      // DB autoincrement — KHÔNG BAO GIỜ tự sinh id; id rỗng từ form thì bỏ
+      // hẳn key, id chuỗi số thì ép Number cho Prisma Int.
+      const raw = filtered[idField];
+      if (raw === undefined || raw === null || raw === "") {
+        delete filtered[idField];
+      } else if (typeof raw === "string") {
+        const num = Number(raw);
+        if (Number.isInteger(num)) filtered[idField] = num;
+      }
+    } else if (!filtered[idField]) {
+      filtered[idField] = crypto.randomUUID();
     }
     if (touchUpdatedAtOnCreate && !filtered.updatedAt) {
       filtered.updatedAt = new Date();
@@ -74,21 +66,22 @@ export function prepareMutationData(options: PrepareMutationDataOptions) {
   // 4. Transform relation fields (*Id -> connect/disconnect)
   const skip = new Set([
     "id",
+    idField,
     "createdBy",
     "updatedBy",
     "citizenId",
     "targetId",
     ...(relationFieldSkip ?? []),
   ]);
-  
+
   const prismaData = { ...filtered };
   for (const key of Object.keys(prismaData)) {
     if (skip.has(key)) continue;
-    
+
     if (key.endsWith("Id") && key.length > 2) {
       const rel = key.slice(0, -2);
       const value = prismaData[key];
-      
+
       if (value && typeof value === "string" && value.trim() !== "") {
         prismaData[rel] = { connect: { id: value } };
         delete prismaData[key];