fix(grid): inline-edit toggle takes effect immediately + staged editor closes on save (#2151)

* fix(grid): keep lookup inline-edit value after clicking another row

Two independent defects made an inline-edited lookup/reference value
disappear (falling back to the raw id) once the user clicked another row:

1. data-table `startEdit` had no re-entry guard. A lookup option renders in
   a Portal, but React synthetic events still bubble through the component
   tree back to the cell onClick, re-invoking startEdit for the same cell;
   that reset editValue from a not-yet-flushed pendingChanges and clobbered
   the freshly picked value. Guard against re-entering the same cell.

2. ObjectGrid's column-building paths dropped reference_to (they copied only
   label/currency/precision/scale/format/options) so the read-only
   LookupCellRenderer/useLookupName could not resolve the staged id to a
   display name. Add applyRelationalMeta() and call it in every path to
   forward reference_to/display_field/id_field/etc.

Adds a reproduction test; both fixes are individually load-bearing.

Closes #2150

* fix(grid): inline-edit toggle takes effect immediately + staged editor closes on save

Bug A: toggling 行内编辑 needed a second click to actually make the grid
editable. ListView's memoized grid schema (which sets editable: inlineEdit)
omitted inlineEdit from its deps, so it served the stale value for one toggle.
Add inlineEdit to the dep array so the toggle propagates on the same interaction.

Bug B: after inline-editing a lookup cell and clicking 全部保存, the cell stayed
stuck showing the picker widget. Relational editors (lookup/master_detail/
user/owner) stage their value and deliberately keep the editor open; saveRow/
saveBatch cleared pendingChanges but never cleared editingCell, so the persisted
cell never reverted to its resolved display value. Close any open editor once the
row/batch is saved.

Also: ListView refetches on dataSource.onMutation even when an external
refreshTrigger is present (inline-edit saves go straight through dataSource.update
and only signal via onMutation), and the lookup cell derives its reference key
correctly.

Regression tests: data-table-inline-edit (E), ListView toggle/mutationRefresh,
onMutation, lookupCellReferenceKey.

* fix(grid): refresh list after a bulk/row action succeeds (#2159)

The bottom BulkActionBar's string bulk actions (e.g. 下推 / 派工) and the row
action menu both dispatched via executeAction but never bumped refreshKey, so
the grid kept showing stale data after the server mutation completed — and the
selection toolbar stayed stuck. Only the delete branch (onBulkDelete) and the
rich BulkActionDialog (handleBulkDialogClose) refreshed.

ObjectGrid self-fetches on refreshKey and has no onMutation subscription, and
custom bulk APIs bypass dataSource.update, so nothing else signals a refetch.
On a successful action, reset the selection and bump refreshKey so the list
reflects the server state (mirrors the delete + dialog branches).

Adds bulkActionRefresh.test.tsx driving the full path (header checkbox →
BulkActionBar → dispatchBulkAction → runner handler) against an in-memory fake
server, asserting a refetch + selection reset on success and neither on failure.

* fix(grid): guard inline-edit re-entry with a ref (flaky CI #2150)

The startEdit re-entry guard read the editingCell React state, which can
observe a stale value under batching/contention. Picking a lookup/select
option (rendered in a Portal) bubbles its click back to the cell onClick,
re-invoking startEdit for the same cell; when the guard missed, editValue
was reset from not-yet-flushed pendingChanges and the freshly picked value
was clobbered — the intermittent 'Dev Admin' failure in CI.

Track the active cell in a synchronously-mutated ref and guard on it, so the
re-entrant call within the same event is always caught. Keep the ref in sync
at every edit-exit site.

Also lands the bulkActionDefs-path refresh regression test (#2159).

* fix(fields): cache picked lookup option so its label resolves synchronously

handleSelect now stores the chosen option in pickerResolvedRecords, so
selectedOptions/findOption can resolve the just-picked foreign-key id to
its display label without depending on the popover's transient
fetchedOptions or an async findOne hydration. Fixes the intermittent CI
failure where a freshly-picked lookup value showed no label (#2150).

Author: baozhoutao

packages/components/src/__tests__/data-table-inline-edit.test.tsx

@@ -179,4 +179,40 @@ describe('data-table — inline edit is per-row usable', () => {
 
     expect(container.textContent).not.toContain('Save failed');
   });
+
+  it('E) a staged editor (e.g. a lookup picker) exits edit mode after Save All', async () => {
+    // Regression: relational pickers (lookup/master_detail/user/owner) keep their
+    // widget open on pick — they `stage` the value rather than commit-and-close.
+    // saveBatch cleared pendingChanges but never cleared `editingCell`, so after
+    // 全部保存 the saved cell stayed stuck showing the picker widget instead of
+    // reverting to the resolved display value. Save All must close any open editor.
+    const onBatchSave = vi.fn().mockResolvedValue(undefined);
+    // A host-injected editor that mimics a lookup: picking a value STAGES it and
+    // deliberately keeps the editor open (no commit/close).
+    const renderCellEditor = ({ column, stage }: any) =>
+      column.accessorKey === 'qty' ? (
+        <button data-testid="picker" onClick={() => stage('picked')}>
+          picker
+        </button>
+      ) : null;
+
+    const { container, getByText, getByTestId, queryByTestId } = renderComponent({
+      ...editableSchema,
+      onBatchSave,
+      renderCellEditor,
+    });
+
+    const cells = container.querySelectorAll('tbody td');
+    const qtyCell = cells[2] as HTMLElement; // uses the injected picker editor
+    fireEvent.click(qtyCell);
+
+    // Editor is open; pick a value — it stages and stays open (no close).
+    fireEvent.click(getByTestId('picker'));
+    expect(queryByTestId('picker')).toBeInTheDocument();
+
+    // Save All persists the staged value AND must exit edit mode.
+    fireEvent.click(getByText(/Save All/i));
+    await waitFor(() => expect(onBatchSave).toHaveBeenCalledTimes(1));
+    await waitFor(() => expect(queryByTestId('picker')).not.toBeInTheDocument());
+  });
 });

packages/components/src/renderers/complex/data-table.tsx

@@ -363,6 +363,16 @@ const DataTableRenderer = ({ schema }: { schema: DataTableSchema }) => {
   const [draggedColumn, setDraggedColumn] = useState<number | null>(null);
   const [dragOverColumn, setDragOverColumn] = useState<number | null>(null);
   const [editingCell, setEditingCell] = useState<{ rowIndex: number; columnKey: string } | null>(null);
+  // Mirror of `editingCell` that is mutated synchronously, so the `startEdit`
+  // re-entry guard can't be defeated by a stale closure. A lookup/select option
+  // renders in a Portal; picking it fires the option's onChange (which stages
+  // the value) and — because React synthetic events still bubble through the
+  // component tree — the cell's onClick, re-invoking `startEdit` for the SAME
+  // cell within one event. Reading `editingCell` state there can observe a stale
+  // (pre-edit) value under batching/contention, so the guard misses and the
+  // just-picked value is reset from empty `pendingChanges`. The ref always
+  // reflects the latest edit target within the same tick, so re-entry is caught.
+  const editingCellRef = useRef<{ rowIndex: number; columnKey: string } | null>(null);
   const [editValue, setEditValue] = useState<any>('');
   // Track pending changes for multi-cell editing: rowIndex -> { columnKey -> newValue }
   const [pendingChanges, setPendingChanges] = useState<Map<number, Record<string, any>>>(new Map());
@@ -662,10 +672,22 @@ const DataTableRenderer = ({ schema }: { schema: DataTableSchema }) => {
   // Cell editing handlers
   const startEdit = (rowIndex: number, columnKey: string) => {
     if (!editable) return;
-    
+
+    // Already editing THIS cell — do nothing. Re-entering would reset `editValue`
+    // from `pendingChanges`, and when a widget-injected editor commits via an
+    // overlay (a lookup/select popover renders in a Portal, but React events
+    // still bubble through the component tree to this cell's onClick), that reset
+    // reads a stale `pendingChanges` — before the just-staged value has flushed —
+    // and clobbers the freshly picked value. Guard on the synchronous ref (not
+    // the `editingCell` state, which can read stale under batching/contention —
+    // the intermittent CI failure #2150) so the re-entrant call is always caught.
+    const active = editingCellRef.current;
+    if (active?.rowIndex === rowIndex && active?.columnKey === columnKey) return;
+
     const column = columns.find(col => col.accessorKey === columnKey);
     if (column?.editable === false) return;
-    
+
+    editingCellRef.current = { rowIndex, columnKey };
     setEditingCell({ rowIndex, columnKey });
 
     // Check if there's a pending change for this cell, otherwise use current data value
@@ -703,12 +725,14 @@ const DataTableRenderer = ({ schema }: { schema: DataTableSchema }) => {
       schema.onCellChange(globalIndex, columnKey, valueToStage, row);
     }
 
+    editingCellRef.current = null;
     setEditingCell(null);
     setEditValue('');
   };
 
   const cancelEdit = () => {
     skipBlurSaveRef.current = true;
+    editingCellRef.current = null;
     setEditingCell(null);
     setEditValue('');
   };
@@ -757,6 +781,14 @@ const DataTableRenderer = ({ schema }: { schema: DataTableSchema }) => {
       const newPendingChanges = new Map(pendingChanges);
       newPendingChanges.delete(rowIndex);
       setPendingChanges(newPendingChanges);
+      // A staged editor (e.g. a lookup picker, which keeps its widget open on
+      // pick rather than committing) must exit edit mode once its value is
+      // persisted — otherwise the saved cell stays stuck showing the editor.
+      if (editingCell?.rowIndex === rowIndex) {
+        editingCellRef.current = null;
+        setEditingCell(null);
+        setEditValue('');
+      }
       // Saved — drop any prior error for this row, and clear the banner once
       // no errored rows remain.
       setErroredRows((prev) => {
@@ -807,6 +839,12 @@ const DataTableRenderer = ({ schema }: { schema: DataTableSchema }) => {
 
       // Clear all pending changes
       setPendingChanges(new Map());
+      // Any staged editor left open (e.g. a lookup picker that keeps its widget
+      // open on pick) must exit edit mode now that every row is persisted —
+      // otherwise the edited cell stays stuck showing the editor after 全部保存.
+      editingCellRef.current = null;
+      setEditingCell(null);
+      setEditValue('');
       // Saved — clear any prior errors.
       setErroredRows(new Set());
       setSaveError(null);

packages/data-objectstack/src/index.ts

@@ -9,6 +9,7 @@
 import { ObjectStackClient, type QueryOptions as ObjectStackQueryOptions } from '@objectstack/client';
 import type {
   DataSource,
+  MutationEvent,
   QueryParams,
   QueryResult,
   FileUploadResult,
@@ -403,6 +404,11 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
   // so optional collections like sys_presence don't hammer the server with
   // failing requests on every record open / panel render.
   private missingResources = new Set<string>();
+  // Subscribers registered via onMutation(). Emitted after each successful
+  // create/update/delete so data-bound views (ListView, ObjectView, kanban,
+  // calendar) auto-refresh — the interface ListView relies on to reflect
+  // inline-edit "Save All" writes without a manual reload.
+  private mutationListeners = new Set<(event: MutationEvent<T>) => void>();
 
   constructor(config: {
     baseUrl: string;
@@ -706,9 +712,37 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
   /**
    * Create a new record.
    */
+  /**
+   * Notify all mutation subscribers. A throwing listener must not break the
+   * mutation or starve the other subscribers, so each is isolated.
+   */
+  private emitMutation(event: MutationEvent<T>): void {
+    for (const listener of this.mutationListeners) {
+      try {
+        listener(event);
+      } catch (err) {
+        console.warn('ObjectStackAdapter: mutation listener error', err);
+      }
+    }
+  }
+
+  /**
+   * Subscribe to create/update/delete events on any resource. Returns an
+   * unsubscribe function. Data-bound views use this to auto-refresh after a
+   * mutation (e.g. inline-edit "Save All", which writes through `update` and
+   * must repaint the list without a manual reload).
+   */
+  onMutation(callback: (event: MutationEvent<T>) => void): () => void {
+    this.mutationListeners.add(callback);
+    return () => {
+      this.mutationListeners.delete(callback);
+    };
+  }
+
   async create(resource: string, data: Partial<T>): Promise<T> {
     await this.connect();
     const result = await this.client.data.create<T>(resource, data);
+    this.emitMutation({ type: 'create', resource, record: { ...result.record } });
     return result.record;
   }
 
@@ -737,6 +771,7 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
         data,
         opts?.ifMatch ? { ifMatch: opts.ifMatch } : undefined,
       );
+      this.emitMutation({ type: 'update', resource, id, record: { ...result.record } });
       return result.record;
     } catch (err) {
       throw normaliseClientError(err);
@@ -762,6 +797,9 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
         String(id),
         opts?.ifMatch ? { ifMatch: opts.ifMatch } : undefined,
       );
+      if (result.deleted) {
+        this.emitMutation({ type: 'delete', resource, id });
+      }
       return result.deleted;
     } catch (err) {
       throw normaliseClientError(err);
@@ -792,6 +830,13 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
     if (!ids || ids.length === 0) return 0;
     const records = ids.map((id) => ({ id: String(id), data: patch as any }));
 
+    // Notify subscribers once for the whole batch (not per-id) so a single
+    // "mark all read"/"archive selected" refreshes bound views exactly once.
+    const emitBulk = (count: number): number => {
+      if (count > 0) this.emitMutation({ type: 'update', resource });
+      return count;
+    };
+
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const updateMany = (this.client.data as any).updateMany;
     if (typeof updateMany === 'function') {
@@ -800,10 +845,10 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
         // The server returns BatchUpdateResponse { succeeded, failed, ... };
         // fall back to ids.length on adapters that return a bare array.
         if (res && typeof res === 'object' && typeof (res as any).succeeded === 'number') {
-          return (res as any).succeeded as number;
+          return emitBulk((res as any).succeeded as number);
         }
-        if (Array.isArray(res)) return (res as any[]).length;
-        return ids.length;
+        if (Array.isArray(res)) return emitBulk((res as any[]).length);
+        return emitBulk(ids.length);
       } catch (err) {
         throw normaliseClientError(err);
       }
@@ -819,7 +864,7 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
         // continueOnError semantics — swallow per-row errors
       }
     }
-    return succeeded;
+    return emitBulk(succeeded);
   }
 
   /**
@@ -837,17 +882,23 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
     if (!ids || ids.length === 0) return 0;
     const strIds = ids.map((id) => String(id));
 
+    // Notify subscribers once for the whole batch (see bulkUpdate).
+    const emitBulk = (count: number): number => {
+      if (count > 0) this.emitMutation({ type: 'delete', resource });
+      return count;
+    };
+
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const deleteMany = (this.client.data as any).deleteMany;
     if (typeof deleteMany === 'function') {
       try {
         const res = await deleteMany(resource, strIds, { continueOnError: true });
         if (res && typeof res === 'object' && typeof (res as any).succeeded === 'number') {
-          return (res as any).succeeded as number;
+          return emitBulk((res as any).succeeded as number);
         }
-        if (Array.isArray(res)) return (res as any[]).length;
+        if (Array.isArray(res)) return emitBulk((res as any[]).length);
         // deleteMany historically returns void on success — assume all hit.
-        return strIds.length;
+        return emitBulk(strIds.length);
       } catch (err) {
         throw normaliseClientError(err);
       }
@@ -863,7 +914,7 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
         // continueOnError semantics — swallow per-row errors
       }
     }
-    return succeeded;
+    return emitBulk(succeeded);
   }
 
   /**