@goplusvn/core 0.1.71 → 0.1.72

package/src/crud/server-service.ts

@@ -7,16 +7,15 @@
 // lives here so every app stops re-implementing it.
 //
 // Usage (app side):
-//   import { createServerCrudService, getModelName } from "@goerp/core/crud/server";
+//   import { createServerCrudService } from "@goerp/core/crud/server";
 //   import { prisma } from "@/lib/prisma";
-//   const MODEL_MAP = { customers: "customer", "fee-schedules": "feeSchedule" };
-//   export const crudService = createServerCrudService({
-//     prisma,
-//     getModelName: (e) => getModelName(e, MODEL_MAP),
-//   });
+//   export const crudService = createServerCrudService({ prisma });
+// Tên model Prisma khai ngay trong EntityConfig (`modelName: "feeSchedule"`),
+// không cần MODEL_MAP riêng; thiếu modelName thì fallback convention getModelName.
 
 import { buildListQuery } from "./lib/query-builder";
 import { prepareMutationData } from "./lib/mutation-builder";
+import { CrudRequestError } from "./lib/errors";
 import type { CrudQueryParams, CrudResponse, EntityConfig } from "../types";
 import { serializeDecimalFields } from "../utils/serialize";
 
@@ -24,14 +23,16 @@ type PrismaLike = Record<string, any>;
 
 export interface ServerCrudService {
   list(entity: string, config: EntityConfig, params: CrudQueryParams): Promise<CrudResponse>;
-  /** `config` (tùy chọn) để áp cùng `include` như list — detail không hiện raw FK id. */
+  /** `config` (tùy chọn) để áp cùng `include` như list — detail không hiện raw FK id.
+   *  Mọi method nhận id dạng chuỗi thô từ URL; entity `idKind: "int"` được ép
+   *  Number bên trong (sai định dạng → {@link CrudRequestError} 400). */
   getById(entity: string, id: string, config?: EntityConfig): Promise<any>;
   /** `tx` (tùy chọn) để app chạy create CÙNG transaction với sinh số phiếu
    *  advisory-lock (document-number yêu cầu cùng tx với insert). */
   create(entity: string, data: any, config?: EntityConfig, tx?: PrismaLike): Promise<any>;
   update(entity: string, id: string, data: any, config?: EntityConfig, tx?: PrismaLike): Promise<any>;
-  delete(entity: string, id: string): Promise<any>;
-  deleteMany(entity: string, ids: string[]): Promise<any>;
+  delete(entity: string, id: string, config?: EntityConfig): Promise<any>;
+  deleteMany(entity: string, ids: string[], config?: EntityConfig): Promise<any>;
 }
 
 export interface ServerCrudLogger {
@@ -79,13 +80,31 @@ const DEFAULT_SYSTEM_FIELDS = [
 
 const MAX_PAGE_SIZE = 200;
 
-// Default plural→model resolver: strip trailing "s", camelCase kebab. Apps with
-// irregular names pass a map: getModelName(entity, { "fee-schedules": "feeSchedule" }).
+// Default plural→model resolver: strip trailing "s", camelCase kebab. Ưu tiên
+// khai `modelName` ngay trong EntityConfig; map ở đây chỉ còn cho chỗ gọi cũ
+// chưa có config trong tay.
 export function getModelName(entity: string, map?: Record<string, string>): string {
   if (map && map[entity]) return map[entity];
   return entity.replace(/s$/, "").replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 }
 
+// Ép id từ URL theo idKind của entity — "abc" vào cột Int phải trả 400 rõ
+// ràng thay vì để Prisma nổ 500.
+function coerceIdParam(
+  entity: string,
+  config: EntityConfig | undefined,
+  id: string,
+): string | number {
+  if (config?.idKind !== "int") return id;
+  const num = Number(id);
+  if (!Number.isInteger(num)) {
+    throw new CrudRequestError(
+      `Id không hợp lệ cho "${entity}": "${id}" (idKind=int cần số nguyên)`,
+    );
+  }
+  return num;
+}
+
 // Opt-in audit-name resolver. Overwrites createdByName/updatedByName from a User
 // model. `nameField` handles schema drift (vinhhoa: "name", wu: "fullName").
 export function createAuditUserNameResolver(opts: {
@@ -130,18 +149,18 @@ export function createServerCrudService(deps: ServerCrudDeps): ServerCrudService
 
   const systemFields = deps.systemFields ?? DEFAULT_SYSTEM_FIELDS;
 
-  const model = (entity: string, client: PrismaLike = prisma) => {
-    const name = resolveModel(entity);
+  // config.modelName thắng convention/MODEL_MAP — một registry duy nhất ở
+  // entity config, app không phải nuôi map song song.
+  const model = (entity: string, config?: EntityConfig, client: PrismaLike = prisma) => {
+    const name = config?.modelName ?? resolveModel(entity);
     const m = client[name];
     if (!m) throw new Error(`Prisma model not found for entity: ${entity} (${name})`);
     return m;
   };
 
-
-
   return {
     async list(entity, config, params) {
-      const prismaModel = model(entity);
+      const prismaModel = model(entity, config);
       
       const {
         where,
@@ -174,12 +193,13 @@ export function createServerCrudService(deps: ServerCrudDeps): ServerCrudService
     },
 
     async getById(entity, id, config) {
-      const prismaModel = model(entity);
+      const prismaModel = model(entity, config);
       // Áp cùng include như list — detail dialog hiện label relation thay raw FK id.
       const include: any = {};
       if (config?.include?.length) config.include.forEach((inc) => (include[inc] = true));
       const includeOption = Object.keys(include).length ? { include } : {};
-      const result = await prismaModel.findUnique({ where: { id }, ...includeOption });
+      const where = { [config?.idField ?? "id"]: coerceIdParam(entity, config, id) };
+      const result = await prismaModel.findUnique({ where, ...includeOption });
       if (!result) return null;
       const serialized = serializeDecimalFields(result);
       const [resolved] = await resolveAuditNames([serialized]);
@@ -187,7 +207,7 @@ export function createServerCrudService(deps: ServerCrudDeps): ServerCrudService
     },
 
     async create(entity, data, config, tx) {
-      const prismaModel = model(entity, tx ?? prisma);
+      const prismaModel = model(entity, config, tx ?? prisma);
       try {
         const prismaData = prepareMutationData({
           data,
@@ -206,7 +226,8 @@ export function createServerCrudService(deps: ServerCrudDeps): ServerCrudService
     },
 
     async update(entity, id, data, config, tx) {
-      const prismaModel = model(entity, tx ?? prisma);
+      const prismaModel = model(entity, config, tx ?? prisma);
+      const where = { [config?.idField ?? "id"]: coerceIdParam(entity, config, id) };
       try {
         const prismaData = prepareMutationData({
           data,
@@ -216,27 +237,31 @@ export function createServerCrudService(deps: ServerCrudDeps): ServerCrudService
           relationFieldSkip: deps.relationFieldSkip,
           logger: log,
         });
-        return serializeDecimalFields(await prismaModel.update({ where: { id }, data: prismaData }));
+        return serializeDecimalFields(await prismaModel.update({ where, data: prismaData }));
       } catch (error) {
         log.error(`Error updating ${entity}:`, error);
         throw error;
       }
     },
 
-    async delete(entity, id) {
-      const prismaModel = model(entity);
+    async delete(entity, id, config) {
+      const prismaModel = model(entity, config);
+      const where = { [config?.idField ?? "id"]: coerceIdParam(entity, config, id) };
       try {
-        return await prismaModel.delete({ where: { id } });
+        return await prismaModel.delete({ where });
       } catch (error) {
         log.error(`Error deleting ${entity}:`, error);
         throw error;
       }
     },
 
-    async deleteMany(entity, ids) {
-      const prismaModel = model(entity);
+    async deleteMany(entity, ids, config) {
+      const prismaModel = model(entity, config);
+      // Ép cả mảng — một phần tử sai định dạng là 400 cả request, không xóa nửa vời.
+      const idField = config?.idField ?? "id";
+      const where = { [idField]: { in: ids.map((id) => coerceIdParam(entity, config, id)) } };
       try {
-        return await prismaModel.deleteMany({ where: { id: { in: ids } } });
+        return await prismaModel.deleteMany({ where });
       } catch (error) {
         log.error(`Error deleting many ${entity}:`, error);
         throw error;

package/src/crud/server.ts

@@ -22,6 +22,16 @@ export type {
 export {
   createCrudCollectionHandlers,
   createCrudItemHandlers,
+  createCrudExportHandler,
+  createCrudImportHandler,
 } from './crud-route-handlers'
-export type { CrudHandlerDeps } from './crud-route-handlers'
+export type {
+  CrudHandlerDeps,
+  CrudExportHandlerDeps,
+  CrudImportHandlerDeps,
+} from './crud-route-handlers'
+export { readImportRows, coerceBooleanCell } from './lib/import-request'
 export { compileFilterTree, conditionForOperator, type FilterTreeLeaf, type FilterTreeNode } from "./lib/filter-tree";
+export { CrudRequestError } from "./lib/errors";
+export { coerceFieldValue } from "./lib/coerce";
+export { getEntityEndpoints } from "./lib/entity-endpoints";

package/src/guardrails/rules/design.ts

@@ -72,12 +72,13 @@ export const designRules: GuardrailRule[] = [
 
   {
     id: "design/list-table-uses-kit",
-    title: "bảng mới trong app/ dùng DataTableWrapper, không tự dựng <Table>",
+    title:
+      "bảng mới trong app/ dùng DataTable (@goerp/core/ui — import { DataTable }), không tự dựng <Table>",
     why:
       "Bảng tự dựng lại thiếu một trong: header dính, phân trang, trạng thái " +
       "rỗng, hàng bấm được, footer tổng. Mỗi bảng thiếu một thứ khác nhau, và " +
       "người dùng học lại thao tác ở mỗi trang.",
-    fix: "Dùng `DataTableWrapper` + cột tanstack trong `*-columns.tsx`. Thật sự phải tự dựng thì thêm vào allowlist kèm lý do.",
+    fix: "Dùng `DataTable` (@goerp/core/ui — `import { DataTable }`) + cột tanstack trong `*-columns.tsx`. Thật sự phải tự dựng thì thêm vào allowlist kèm lý do.",
     run(ctx) {
       const allowed = new Set(ctx.options.allowlists["design/list-table-uses-kit"] ?? []);
       const handRolled = ctx.files

package/src/types/index.ts

@@ -302,7 +302,28 @@ export interface EntityConfig {
    */
   permissionResource?: string;
   apiEndpoint: string;
+  /**
+   * Endpoint import/export. Không khai thì suy từ apiEndpoint theo CÙNG MỘT
+   * quy tắc: `${base}/import|/export` (giữ nguyên query params nếu có) —
+   * xem getEntityEndpoints ở crud/lib/entity-endpoints.
+   */
+  endpoints?: {
+    import?: string;
+    export?: string;
+  };
+  /**
+   * Tên model Prisma (camelCase, vd "jobTitle"). Không khai thì engine suy
+   * theo convention từ entity key (bỏ "s" cuối + camelCase kebab) — khai ở
+   * đây thay cho MODEL_MAP riêng phía app.
+   */
+  modelName?: string;
   idField: string;
+  /**
+   * Kiểu khóa chính. "string" (default): create thiếu id sẽ tự sinh UUID.
+   * "int": KHÔNG BAO GIỜ tự sinh (DB autoincrement), id trên URL được ép
+   * Number — sai định dạng trả 400.
+   */
+  idKind?: "string" | "int";
   displayField: string;
   fields: FieldConfig[];
   filters?: FilterConfig[];
@@ -345,19 +366,32 @@ export interface FormModeConfig {
   sheetSide?: "top" | "right" | "bottom" | "left";
 }
 
+/** Các action built-in có icon + hành vi mặc định trong CrudPage/CrudRowActions. */
+export type BuiltinRowActionKind =
+  | "copy"
+  | "duplicate"
+  | "view"
+  | "archive"
+  | "custom"
+  | "approve"
+  | "reject"
+  | "set-default"
+  | "view-history";
+
 export interface RowAction {
   label: string;
   icon?: string;
-  action:
-    | "copy"
-    | "duplicate"
-    | "view"
-    | "archive"
-    | "custom"
-    | "approve"
-    | "reject"
-    | "set-default"
-    | "view-history";
+  /**
+   * Built-in giữ hành vi/icon cũ; chuỗi tự do = action tự khai — đi kèm
+   * `urlTemplate` (dispatcher HTTP của CrudPage) hoặc handler app-side.
+   * `(string & {})` để vẫn gợi ý được literal built-in.
+   */
+  action: BuiltinRowActionKind | (string & {});
+  /**
+   * handler/visibleWhen/transformData KHÔNG sống sót qua serializeConfig
+   * (RSC → client) — chỉ dùng khi config đi thẳng vào CrudPage phía client.
+   * Cần action serialize an toàn thì dùng bộ urlTemplate/method bên dưới.
+   */
   handler?: (
     rowId: string,
     rowData: Record<string, unknown>,
@@ -372,6 +406,24 @@ export interface RowAction {
     | "link";
   excludeFields?: string[];
   transformData?: (rowData: Record<string, unknown>) => Record<string, unknown>;
+
+  // ── Biến thể HTTP thuần data (serialize qua RSC được) ──
+  /** URL gọi khi bấm — "{id}" được thay bằng id dòng, vd "/api/employees/{id}/reset-password". */
+  urlTemplate?: string;
+  /** Method cho urlTemplate. Default: POST. */
+  method?: "POST" | "PATCH" | "DELETE";
+  /** Có khai thì window.confirm trước khi gọi. */
+  confirmMessage?: string;
+  /** Toast khi thành công. Không khai thì dùng message "updated" chung. */
+  successMessage?: string;
+  /**
+   * Gate hiển thị + thực thi theo action code trong quyền. Nhận cả 8 action
+   * CRUD chuẩn ("update", "approve"…) lẫn CUSTOM ACTION khai trong registry
+   * ("reset-password", "resync"…) — EntityCrudPage tự gom các permissionAction
+   * custom trong rowActions và hỏi checkPermission cho từng cái. Fail-closed:
+   * action không có trong map quyền thì nút bị chặn.
+   */
+  permissionAction?: string;
 }
 
 // ============================================================================
@@ -402,6 +454,13 @@ export interface FieldConfig {
   name: string;
   label: string;
   type: FieldType;
+  /**
+   * Kiểu GIÁ TRỊ thô của field khi kiểu cột không suy được từ `type` — cột FK
+   * Int autoincrement hiện qua select/multiselect/relation: form và URL chở
+   * chuỗi "3", khai `valueType: "int"` để coercion tập trung (coerceFieldValue)
+   * ép Number trước khi vào Prisma. Default: "string" (giữ nguyên).
+   */
+  valueType?: "string" | "int";
   required?: boolean;
   defaultValue?: unknown;
   placeholder?: string;
@@ -658,6 +717,12 @@ export interface CrudPermissions {
   import?: boolean;
   approve?: boolean;
   reject?: boolean;
+  /**
+   * Custom action từ registry (vd "reset-password") — getCrudPermissions nhận
+   * danh sách extraActions và điền vào đây; RowAction.permissionAction tra
+   * thẳng map này, thiếu key = false (fail-closed).
+   */
+  [action: string]: boolean | undefined;
 }
 
 export interface CrudFeatures {

package/src/ui/data-display/__tests__/use-client-pagination.test.ts

@@ -0,0 +1,59 @@
+/**
+ * Hợp đồng useClientPagination: trang 1-BASED, đổi cỡ trang tự về trang 1,
+ * và page tự clamp khi items co lại (xoá/lọc) — không có render trung gian
+ * với trang rỗng.
+ */
+import { act, renderHook } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+
+import { useClientPagination } from "../use-client-pagination";
+
+const items = (n: number) => Array.from({ length: n }, (_, i) => i + 1);
+
+describe("useClientPagination", () => {
+  it("khởi tạo: trang 1, cắt đúng lát đầu", () => {
+    const { result } = renderHook(() => useClientPagination(items(25), 10));
+    expect(result.current.page).toBe(1);
+    expect(result.current.pageSize).toBe(10);
+    expect(result.current.total).toBe(25);
+    expect(result.current.pageCount).toBe(3);
+    expect(result.current.pageItems).toEqual(items(10));
+  });
+
+  it("setPage cắt đúng lát (1-based), trang cuối là phần dư", () => {
+    const { result } = renderHook(() => useClientPagination(items(25), 10));
+    act(() => result.current.setPage(3));
+    expect(result.current.page).toBe(3);
+    expect(result.current.pageItems).toEqual([21, 22, 23, 24, 25]);
+  });
+
+  it("setPageSize tự về trang 1", () => {
+    const { result } = renderHook(() => useClientPagination(items(25), 10));
+    act(() => result.current.setPage(3));
+    act(() => result.current.setPageSize(5));
+    expect(result.current.page).toBe(1);
+    expect(result.current.pageSize).toBe(5);
+    expect(result.current.pageItems).toEqual([1, 2, 3, 4, 5]);
+  });
+
+  it("items co lại thì page clamp vào pageCount, không rơi ra trang rỗng", () => {
+    const { result, rerender } = renderHook(
+      ({ data }: { data: number[] }) => useClientPagination(data, 10),
+      { initialProps: { data: items(25) } },
+    );
+    act(() => result.current.setPage(3));
+    expect(result.current.page).toBe(3);
+
+    rerender({ data: items(12) }); // còn 2 trang
+    expect(result.current.page).toBe(2);
+    expect(result.current.pageItems).toEqual([11, 12]);
+  });
+
+  it("danh sách rỗng: total 0 nhưng pageCount tối thiểu 1, không chia cho 0", () => {
+    const { result } = renderHook(() => useClientPagination([] as number[], 10));
+    expect(result.current.total).toBe(0);
+    expect(result.current.pageCount).toBe(1);
+    expect(result.current.page).toBe(1);
+    expect(result.current.pageItems).toEqual([]);
+  });
+});

package/src/ui/data-display/data-table/__tests__/data-table-row-memo.test.tsx

@@ -0,0 +1,96 @@
+/**
+ * Chốt hợp đồng memo từng hàng của DataTable:
+ * - mặc định memo theo identity `row.original` → cell đọc state NGOÀI row data
+ *   bị ĐƠ (baseline, đã cắn ở bảng ma trận tanloc-spartronics);
+ * - `rowMemo={false}` tắt memo; `rowMemo={(row) => key}` mở memo khi key đổi;
+ * - `cellClassName` đổi phải re-render (bug cũ: không nằm trong comparator).
+ */
+import { render } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+
+import { DataTable } from "../data-table";
+import type { ColumnDef } from "../data-table";
+
+type RowData = { id: string; name: string };
+
+const DATA: RowData[] = [{ id: "1", name: "x" }];
+
+// Cột đọc state NGOÀI row data qua closure — đúng kịch bản Input controlled /
+// cờ busy per-cell. Identity mảng cột phải GIỮ NGUYÊN giữa các lần render.
+function makeColumns(getExternal: () => string): ColumnDef<RowData>[] {
+  return [
+    {
+      id: "name",
+      header: "Tên",
+      cell: ({ row }) => (
+        <span data-testid="cell">
+          {row.original.name}-{getExternal()}
+        </span>
+      ),
+    },
+  ];
+}
+
+describe("DataTable rowMemo", () => {
+  it("mặc định: memo theo identity row.original — state ngoài KHÔNG tới cell (baseline)", () => {
+    let external = "A";
+    const columns = makeColumns(() => external);
+    const { rerender, getByTestId } = render(
+      <DataTable data={DATA} columns={columns} />,
+    );
+    expect(getByTestId("cell").textContent).toBe("x-A");
+
+    external = "B";
+    rerender(<DataTable data={DATA} columns={columns} />);
+    // row.original không đổi identity → memo chặn, cell vẫn hiện giá trị cũ
+    expect(getByTestId("cell").textContent).toBe("x-A");
+  });
+
+  it("rowMemo={false}: tắt memo — hàng re-render theo cha, state ngoài tới cell", () => {
+    let external = "A";
+    const columns = makeColumns(() => external);
+    const { rerender, getByTestId } = render(
+      <DataTable data={DATA} columns={columns} rowMemo={false} />,
+    );
+    expect(getByTestId("cell").textContent).toBe("x-A");
+
+    external = "B";
+    rerender(<DataTable data={DATA} columns={columns} rowMemo={false} />);
+    expect(getByTestId("cell").textContent).toBe("x-B");
+  });
+
+  it("rowMemo={(row) => key}: key đổi thì re-render, key giữ nguyên thì vẫn chặn", () => {
+    let external = "A";
+    let version = 0;
+    const columns = makeColumns(() => external);
+    const rowMemo = () => version;
+    const { rerender, getByTestId } = render(
+      <DataTable data={DATA} columns={columns} rowMemo={rowMemo} />,
+    );
+    expect(getByTestId("cell").textContent).toBe("x-A");
+
+    // key đổi → comparator thấy khác → re-render
+    external = "B";
+    version = 1;
+    rerender(<DataTable data={DATA} columns={columns} rowMemo={rowMemo} />);
+    expect(getByTestId("cell").textContent).toBe("x-B");
+
+    // key GIỮ NGUYÊN → memo vẫn chặn dù closure đã đổi
+    external = "C";
+    rerender(<DataTable data={DATA} columns={columns} rowMemo={rowMemo} />);
+    expect(getByTestId("cell").textContent).toBe("x-B");
+  });
+
+  it("cellClassName đổi phải ăn xuống <td> (bug cũ: thiếu trong comparator)", () => {
+    const columns = makeColumns(() => "A");
+    const { rerender, container } = render(
+      <DataTable data={DATA} columns={columns} cellClassName="text-xs" />,
+    );
+    expect(container.querySelector("td")?.className).toContain("text-xs");
+
+    rerender(
+      <DataTable data={DATA} columns={columns} cellClassName="text-sm" />,
+    );
+    expect(container.querySelector("td")?.className).toContain("text-sm");
+  });
+});

package/src/ui/data-display/data-table/data-table-context.tsx

@@ -18,7 +18,12 @@ export interface ActiveFilter {
   operator: string;
 }
 
+/**
+ * Trạng thái phân trang của core: `page` là 1-BASED (trang đầu = 1),
+ * KHÁC `pageIndex` 0-BASED của tanstack. Convert tay: pageIndex = page - 1.
+ */
 export interface PaginationState {
+  /** Trang hiện tại, 1-based (tanstack pageIndex = page - 1). */
   page: number;
   pageSize: number;
 }

package/src/ui/data-display/data-table/data-table.tsx

@@ -35,6 +35,7 @@ import type { SortingState, PaginationState } from "./data-table-context";
 // ============================================================================
 
 export interface DataTablePaginationConfig {
+  /** Trang hiện tại, 1-BASED — KHÁC `pageIndex` 0-based của tanstack (pageIndex = page - 1). */
   page: number;
   pageSize: number;
   total: number;
@@ -155,6 +156,16 @@ export interface DataTableProps<TData> {
   headerCellClassName?: string;
   /** Cỡ chữ cho ô <td> (TableCell primitive vốn cứng "text-xs"). CRUD truyền "text-sm". */
   cellClassName?: string;
+
+  /**
+   * Escape hatch cho memo từng hàng. Mặc định hàng được memo theo identity
+   * `row.original` — cell đọc state NGOÀI row data (Input controlled, cờ busy
+   * per-cell, closure ngoài) sẽ ĐƠ vì identity không đổi. Khi đó:
+   * - `false`: tắt memo, hàng luôn re-render theo cha.
+   * - `(row) => key`: memo vẫn bật, comparator so sánh THÊM key trả về
+   *   (Object.is) — trả về version/chuỗi gộp các state ngoài mà cell phụ thuộc.
+   */
+  rowMemo?: false | ((row: TData) => unknown);
 }
 
 // ============================================================================
@@ -184,6 +195,7 @@ export function DataTable<TData extends Record<string, unknown>>({
   tableClassName,
   headerCellClassName,
   cellClassName,
+  rowMemo,
 }: DataTableProps<TData>) {
   // Build final columns with selection and row number if enabled
   const columns = useMemo<ColumnDef<TData>[]>(() => {
@@ -350,12 +362,18 @@ export function DataTable<TData extends Record<string, unknown>>({
     getFilteredRowModel: getFilteredRowModel(),
     state: {
       sorting: tanstackSorting,
-      pagination: pagination
+      // CHỈ đưa key `pagination` vào state khi controlled: `pagination: undefined`
+      // vẫn đè initialState của tanstack → getPaginationRowModel crash
+      // ("Cannot destructure 'pageSize'") và bảng uncontrolled render RỖNG im lặng.
+      ...(pagination
         ? {
-            pageIndex: pagination.page - 1,
-            pageSize: pagination.pageSize,
+            pagination: {
+              // page của core 1-based, pageIndex của tanstack 0-based
+              pageIndex: pagination.page - 1,
+              pageSize: pagination.pageSize,
+            },
           }
-        : undefined,
+        : {}),
     },
     onPaginationChange: handlePaginationChange,
     manualPagination: !!pagination,
@@ -442,16 +460,30 @@ export function DataTable<TData extends Record<string, unknown>>({
                 />
               </>
             ) : rows.length > 0 ? (
-              rows.map((row) => (
-                <MemoizedTableRow
-                  key={row.id}
-                  row={row}
-                  isSelected={row.getIsSelected()}
-                  visibleCellsCount={row.getVisibleCells().length}
-                  onRowClick={onRowClick}
-                  cellClassName={cellClassName}
-                />
-              ))
+              rows.map((row) =>
+                rowMemo === false ? (
+                  // rowMemo={false}: render thẳng, không memo — hàng theo kịp mọi
+                  // state ngoài row data (Input controlled, cờ busy per-cell).
+                  <DataTableRowInner
+                    key={row.id}
+                    row={row}
+                    isSelected={row.getIsSelected()}
+                    visibleCellsCount={row.getVisibleCells().length}
+                    onRowClick={onRowClick}
+                    cellClassName={cellClassName}
+                  />
+                ) : (
+                  <MemoizedTableRow
+                    key={row.id}
+                    row={row}
+                    isSelected={row.getIsSelected()}
+                    visibleCellsCount={row.getVisibleCells().length}
+                    onRowClick={onRowClick}
+                    cellClassName={cellClassName}
+                    memoKey={rowMemo ? rowMemo(row.original) : undefined}
+                  />
+                ),
+              )
             ) : null}
           </TableBody>
         </table>
@@ -504,14 +536,20 @@ interface MemoizedTableRowProps<TData> {
   visibleCellsCount: number;
   onRowClick?: (row: TData) => void;
   cellClassName?: string;
+  /** Key từ `rowMemo(row.original)` — comparator so bằng Object.is. */
+  memoKey?: unknown;
 }
 
-// Ensure TData is maintained by making it a generic memo component, or casting it
-const MemoizedTableRow = memo(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  ({ row, isSelected, onRowClick, cellClassName }: MemoizedTableRowProps<any>) => {
-    return (
-      <TableRow
+// Thân hàng KHÔNG memo — dùng trực tiếp khi rowMemo={false}, và là inner của
+// MemoizedTableRow ở dưới.
+function DataTableRowInner<TData>({
+  row,
+  isSelected,
+  onRowClick,
+  cellClassName,
+}: MemoizedTableRowProps<TData>) {
+  return (
+    <TableRow
         data-state={isSelected && "selected"}
         className={`transition-colors duration-100 even:bg-muted/30 hover:bg-accent/50 dark:hover:bg-slate-800/40 data-[state=selected]:bg-primary/5 border-b border-border/40 dark:border-slate-800 relative hover:border-l-[3px] hover:border-l-primary ${
           onRowClick ? "cursor-pointer" : ""
@@ -549,8 +587,11 @@ const MemoizedTableRow = memo(
           </TableCell>
         ))}
       </TableRow>
-    );
-  },
+  );
+}
+
+const MemoizedTableRow = memo(
+  DataTableRowInner,
   (prevProps, nextProps) => {
     // Basic checks
     if (
@@ -558,7 +599,11 @@ const MemoizedTableRow = memo(
       prevProps.isSelected !== nextProps.isSelected ||
       prevProps.onRowClick !== nextProps.onRowClick ||
       prevProps.visibleCellsCount !== nextProps.visibleCellsCount ||
-      prevProps.row.original !== nextProps.row.original
+      prevProps.row.original !== nextProps.row.original ||
+      // cellClassName đổi phải re-render (trước đây bị bỏ sót — đổi class không ăn)
+      prevProps.cellClassName !== nextProps.cellClassName ||
+      // Key từ rowMemo(row.original): state ngoài row data mà cell phụ thuộc
+      !Object.is(prevProps.memoKey, nextProps.memoKey)
     ) {
       return false;
     }