@nocobase/client-v2 2.1.33 → 2.1.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.1.33",
+  "version": "2.1.35",
   "license": "Apache-2.0",
   "main": "lib/index.js",
   "module": "es/index.mjs",
@@ -27,11 +27,11 @@
     "@formily/antd-v5": "1.2.3",
     "@formily/react": "^2.2.27",
     "@formily/shared": "^2.2.27",
-    "@nocobase/evaluators": "2.1.33",
-    "@nocobase/flow-engine": "2.1.33",
-    "@nocobase/sdk": "2.1.33",
-    "@nocobase/shared": "2.1.33",
-    "@nocobase/utils": "2.1.33",
+    "@nocobase/evaluators": "2.1.35",
+    "@nocobase/flow-engine": "2.1.35",
+    "@nocobase/sdk": "2.1.35",
+    "@nocobase/shared": "2.1.35",
+    "@nocobase/utils": "2.1.35",
     "ahooks": "^3.7.2",
     "antd": "5.24.2",
     "antd-style": "3.7.1",
@@ -48,5 +48,5 @@
     "react-i18next": "^11.15.1",
     "react-router-dom": "^6.30.1"
   },
-  "gitHead": "3b69db294250fc91f08f1ca8140ff5df997d1c2f"
+  "gitHead": "d844133f9bd61a3506a3be1af25a1cb06dafbc6f"
 }

package/src/flow/models/actions/UpdateRecordActionModel.tsx

@@ -22,6 +22,11 @@ import { applyUpdateRecordAction } from './UpdateRecordActionUtils';
 // import { RemoteFlowModelRenderer } from '../../FlowPage';
 
 const SETTINGS_FLOW_KEY = 'assignSettings';
+const AFTER_SUCCESS_DEFAULT_PARAMS = {
+  successMessage: tExpr('Saved successfully'),
+  manualClose: false,
+  actionAfterSuccess: 'stay',
+};
 
 function Info() {
   const ctx = useFlowSettingsContext();
@@ -101,6 +106,10 @@ UpdateRecordActionModel.registerFlow({
       tipComponent: Info,
       validateBeforeSave: true,
     }),
+    afterSuccess: {
+      use: 'afterSuccess',
+      defaultParams: AFTER_SUCCESS_DEFAULT_PARAMS,
+    },
   },
 });
 
@@ -113,7 +122,15 @@ UpdateRecordActionModel.registerFlow({
         return getAssignFieldValuesDefaultParams(ctx, SETTINGS_FLOW_KEY);
       },
       async handler(ctx, params) {
-        await applyUpdateRecordAction(ctx, params, { settingsFlowKey: SETTINGS_FLOW_KEY });
+        const updated = await applyUpdateRecordAction(ctx, params, { settingsFlowKey: SETTINGS_FLOW_KEY });
+        if (!updated) {
+          return;
+        }
+        const savedAfterSuccess = ctx.model.getStepParams(SETTINGS_FLOW_KEY, 'afterSuccess') || {};
+        await ctx.runAction('afterSuccess', {
+          ...AFTER_SUCCESS_DEFAULT_PARAMS,
+          ...savedAfterSuccess,
+        });
       },
     },
   },

package/src/flow/models/actions/UpdateRecordActionUtils.ts

@@ -8,9 +8,15 @@
  */
 
 import { MultiRecordResource, SingleRecordResource } from '@nocobase/flow-engine';
+import type { AxiosRequestConfig } from 'axios';
 import { dispatchEventDeep } from '../../utils';
 import { resolveAssignFieldValues } from '../blocks/assign-form/assignFieldValuesFlow';
 
+type UpdateRecordActionParams = {
+  assignedValues?: unknown;
+  requestConfig?: AxiosRequestConfig;
+};
+
 export async function refreshLinkageRulesAfterUpdate(ctx: any) {
   const blockModel = ctx?.blockModel || ctx?.model?.context?.blockModel || ctx?.model;
   const actionModel = ctx?.model;
@@ -48,11 +54,11 @@ export async function refreshLinkageRulesAfterUpdate(ctx: any) {
 
 export async function applyUpdateRecordAction(
   ctx: any,
-  params: any,
+  params: UpdateRecordActionParams,
   options?: {
     settingsFlowKey?: string;
   },
-) {
+): Promise<boolean> {
   const settingsFlowKey = options?.settingsFlowKey || 'assignSettings';
 
   // 统一接入二次确认：如果启用则弹窗；未配置时默认不启用
@@ -62,25 +68,31 @@ export async function applyUpdateRecordAction(
 
   const assignedValues = await resolveAssignFieldValues(ctx, params?.assignedValues, 'UpdateRecordAction');
   if (!assignedValues) {
-    return;
+    return false;
   }
 
   if (!assignedValues || typeof assignedValues !== 'object' || !Object.keys(assignedValues).length) {
     ctx.message.warning(ctx.t('No assigned fields configured'));
-    return;
+    return false;
   }
   const collection = ctx.collection?.name;
   const filterByTk = ctx.collection?.getFilterByTK?.(ctx.record);
   if (!collection || typeof filterByTk === 'undefined' || filterByTk === null) {
     ctx.message.error(ctx.t('Record is required to perform this action'));
-    return;
+    return false;
   }
+  let updated = false;
   if (ctx.resource instanceof SingleRecordResource) {
     await ctx.resource.save(assignedValues, params.requestConfig);
+    updated = true;
   } else if (ctx.resource instanceof MultiRecordResource) {
     await ctx.resource.update(filterByTk, assignedValues, params.requestConfig);
+    updated = true;
+  }
+  if (!updated) {
+    return false;
   }
 
   await refreshLinkageRulesAfterUpdate(ctx);
-  ctx.message.success(ctx.t('Saved successfully'));
+  return true;
 }

package/src/flow/models/actions/__tests__/UpdateRecordActionModel.test.ts

@@ -8,8 +8,9 @@
  */
 
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { MultiRecordResource } from '@nocobase/flow-engine';
+import { FlowEngine, MultiRecordResource } from '@nocobase/flow-engine';
 import { applyUpdateRecordAction } from '../UpdateRecordActionUtils';
+import { UpdateRecordActionModel } from '../UpdateRecordActionModel';
 import { dispatchEventDeep } from '../../../utils';
 
 vi.mock('../../../utils', () => ({
@@ -21,7 +22,7 @@ describe('UpdateRecordActionModel apply action', () => {
     vi.clearAllMocks();
   });
 
-  it('dispatches paginationChange for action and block after successful update', async () => {
+  it('dispatches paginationChange and returns success after updating the record', async () => {
     const resource: any = Object.create(MultiRecordResource.prototype);
     resource.update = vi.fn(async () => ({}));
     resource.refresh = vi.fn(async () => {});
@@ -52,12 +53,13 @@ describe('UpdateRecordActionModel apply action', () => {
       t: (value: string) => value,
     };
 
-    await applyUpdateRecordAction(ctx, {
+    const updated = await applyUpdateRecordAction(ctx, {
       assignedValues: {
         marital_status: '已婚',
       },
     });
 
+    expect(updated).toBe(true);
     expect(resource.update).toHaveBeenCalledWith(1, { marital_status: '已婚' }, undefined);
     expect(resource.refresh).not.toHaveBeenCalled();
 
@@ -67,6 +69,76 @@ describe('UpdateRecordActionModel apply action', () => {
     expect(paginationCalls.length).toBeGreaterThan(0);
     expect(paginationCalls.some(([model]: [any]) => model === ctx.model)).toBe(true);
     expect(paginationCalls.some(([model]: [any]) => model === blockModel)).toBe(true);
-    expect(ctx.message.success).toHaveBeenCalledWith('Saved successfully');
+    expect(ctx.message.success).not.toHaveBeenCalled();
+  });
+
+  it('runs the configured after-success action only after a successful update', async () => {
+    const engine = new FlowEngine();
+    const action = new UpdateRecordActionModel({ uid: 'update-record-action', flowEngine: engine } as any);
+    action.setStepParams('assignSettings', 'confirm', { enable: false });
+    action.setStepParams('assignSettings', 'afterSuccess', {
+      successMessage: 'Record updated',
+    });
+
+    const resource: any = Object.create(MultiRecordResource.prototype);
+    resource.update = vi.fn(async () => ({}));
+    const blockModel: any = { uid: 'details-block' };
+    const runAction = vi.fn(async () => {});
+    const ctx: any = {
+      model: action,
+      blockModel,
+      runAction,
+      collection: {
+        name: 'users',
+        getFilterByTK: vi.fn(() => 1),
+      },
+      record: { id: 1 },
+      resource,
+      message: {
+        success: vi.fn(),
+        warning: vi.fn(),
+        error: vi.fn(),
+      },
+      t: (value: string) => value,
+    };
+    const handler = action.getFlow('apply')?.getStep('apply')?.serialize().handler;
+
+    await handler(ctx, { assignedValues: { status: 'active' } });
+
+    expect(runAction).toHaveBeenNthCalledWith(1, 'confirm', { enable: false });
+    expect(runAction).toHaveBeenNthCalledWith(2, 'afterSuccess', {
+      successMessage: 'Record updated',
+      manualClose: false,
+      actionAfterSuccess: 'stay',
+    });
+  });
+
+  it('does not run the after-success action when no fields are assigned', async () => {
+    const engine = new FlowEngine();
+    const action = new UpdateRecordActionModel({ uid: 'update-record-action-empty', flowEngine: engine } as any);
+    const runAction = vi.fn(async () => {});
+    const ctx: any = {
+      model: action,
+      runAction,
+      collection: {
+        name: 'users',
+        getFilterByTK: vi.fn(() => 1),
+      },
+      record: { id: 1 },
+      resource: Object.create(MultiRecordResource.prototype),
+      message: {
+        success: vi.fn(),
+        warning: vi.fn(),
+        error: vi.fn(),
+      },
+      t: (value: string) => value,
+    };
+    const handler = action.getFlow('apply')?.getStep('apply')?.serialize().handler;
+
+    await handler(ctx, { assignedValues: {} });
+
+    expect(runAction).toHaveBeenCalledTimes(1);
+    expect(runAction).toHaveBeenCalledWith('confirm', { enable: false });
+    expect(ctx.message.warning).toHaveBeenCalledWith('No assigned fields configured');
   });
 });

package/src/flow/models/base/CollectionBlockModel.tsx

@@ -82,6 +82,15 @@ export class CollectionBlockModel<T = DefaultStructure> extends DataBlockModel<T
     const engine = this.context.engine as FlowEngine;
     const currentVersion = this.getDirtyTrackingVersion(engine, dataSourceKey, resource, params);
 
+    if (resource instanceof MultiRecordResource && this.getDataLoadingMode() === 'manual' && !this.hasActiveFilters()) {
+      resource.setData([]);
+      resource.setMeta({ count: 0, hasNext: false });
+      resource.setPage(1);
+      resource.loading = false;
+      this.lastSeenDirtyVersion = currentVersion;
+      return;
+    }
+
     if (forceRefresh) {
       if (this.dirtyRefreshing) return;
       this.dirtyRefreshing = true;

package/src/flow/models/base/__tests__/CollectionBlockModel.initialBeforeRenderRefresh.test.ts

@@ -128,4 +128,64 @@ describe('CollectionBlockModel initial beforeRender refresh', () => {
     expect(resource.getData()).toEqual([]);
     expect(resource.getMeta('count')).toBe(0);
   });
+
+  it('skips forced active refresh in manual mode when filters are empty', async () => {
+    const { model, resource } = setupModelWithManualMode();
+    const refreshSpy = vi.spyOn(resource, 'refresh');
+
+    resource.setData([{ id: 2, name: 'Stale' }]);
+    resource.setMeta({ count: 1, hasNext: true });
+    resource.setPage(2);
+    resource.loading = true;
+
+    model.onActive(true);
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(refreshSpy).not.toHaveBeenCalled();
+    expect(resource.getData()).toEqual([]);
+    expect(resource.getMeta('count')).toBe(0);
+    expect(resource.getMeta('hasNext')).toBe(false);
+    expect(resource.getMeta('page')).toBe(1);
+    expect(resource.getRequestParameter('page')).toBe(1);
+    expect(resource.loading).toBe(false);
+  });
+
+  it('keeps forced active refresh in manual mode when filters are active', async () => {
+    const { model, resource } = setupModelWithManualMode();
+    const refreshSpy = vi.spyOn(resource, 'refresh').mockResolvedValue();
+
+    resource.setData([{ id: 2, name: 'Stale' }]);
+    resource.setMeta({ count: 1, hasNext: true, page: 2 });
+    model.setFilterActive('filter-form-item', true);
+
+    model.onActive(true);
+    await Promise.resolve();
+
+    expect(refreshSpy).toHaveBeenCalledTimes(1);
+    expect(resource.getData()).toEqual([{ id: 2, name: 'Stale' }]);
+    expect(resource.getMeta('count')).toBe(1);
+  });
+
+  it('skips forced active refresh in manual mode when only resource filters are active', async () => {
+    const { model, resource } = setupModelWithManualMode();
+    const refreshSpy = vi.spyOn(resource, 'refresh');
+
+    resource.setData([{ id: 2, name: 'Stale' }]);
+    resource.setMeta({ count: 1, hasNext: true });
+    resource.setPage(2);
+    resource.loading = true;
+    resource.addFilterGroup('data-scope', { status: { $eq: 'active' } });
+
+    model.onActive(true);
+    await Promise.resolve();
+
+    expect(refreshSpy).not.toHaveBeenCalled();
+    expect(resource.getData()).toEqual([]);
+    expect(resource.getMeta('count')).toBe(0);
+    expect(resource.getMeta('hasNext')).toBe(false);
+    expect(resource.getMeta('page')).toBe(1);
+    expect(resource.getRequestParameter('page')).toBe(1);
+    expect(resource.loading).toBe(false);
+  });
 });

package/src/flow/models/blocks/table/JSColumnModel.tsx

@@ -9,13 +9,14 @@
 
 import { LockOutlined, QuestionCircleOutlined } from '@ant-design/icons';
 import { css } from '@emotion/css';
-import type { PropertyMetaFactory } from '@nocobase/flow-engine';
+import type { FlowModelOptions, PropertyMetaFactory } from '@nocobase/flow-engine';
 import {
   Droppable,
   tExpr,
   FlowsFloatContextMenu,
   DragHandler,
   MemoFlowModelRenderer,
+  createCurrentRecordMetaFactory,
   createRecordMetaFactory,
   createRecordResolveOnServerWithLocal,
   ElementProxy,
@@ -54,6 +55,14 @@ function getRecordRenderSignature(record: any) {
 export class JSColumnModel extends TableCustomColumnModel {
   // Stable per‑instance render component to avoid remounts across re-renders
   private _RenderComponent?: React.ComponentType;
+
+  onInit(options: FlowModelOptions): void {
+    super.onInit(options);
+    this.context.defineProperty('record', {
+      meta: createCurrentRecordMetaFactory(this.context, () => this.context.collection),
+    });
+  }
+
   renderHiddenInConfig() {
     return (
       <Tooltip

package/src/flow/models/blocks/table/__tests__/JSColumnModel.test.tsx

@@ -11,17 +11,62 @@ import { FlowEngine } from '@nocobase/flow-engine';
 import { describe, expect, it, vi } from 'vitest';
 import { JSColumnModel } from '../JSColumnModel';
 
-describe('JSColumnModel row refresh', () => {
+describe('JSColumnModel', () => {
+  it('declares current record metadata before rendering any row', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ JSColumnModel });
+    const model = engine.createModel<JSColumnModel>({
+      use: 'JSColumnModel',
+      uid: 'js-column-record-meta',
+      props: {
+        width: 200,
+        title: 'JS column',
+      },
+    });
+
+    engine.context.dataSourceManager.getDataSource('main').addCollection({
+      name: 'users',
+      filterTargetKey: 'id',
+      fields: [
+        { name: 'id', type: 'integer', interface: 'number' },
+        { name: 'age', type: 'integer', interface: 'integer' },
+      ],
+    });
+
+    const collection = engine.context.dataSourceManager.getCollection('main', 'users');
+    model.context.defineProperty('collection', {
+      value: collection,
+    });
+
+    const recordNode = model.context.getPropertyMetaTree().find((node) => node.name === 'record');
+    const recordFields =
+      typeof recordNode?.children === 'function' ? await recordNode.children() : recordNode?.children || [];
+
+    expect(model.context.record).toBeUndefined();
+    expect(recordNode).toMatchObject({
+      name: 'record',
+      title: 'Current record',
+      paths: ['record'],
+    });
+    expect(recordFields).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ name: 'id', paths: ['record', 'id'] }),
+        expect.objectContaining({ name: 'age', paths: ['record', 'age'] }),
+      ]),
+    );
+  });
+
   it('changes renderer key and invalidates beforeRender cache when row content changes', () => {
     const engine = new FlowEngine();
-    const model = new JSColumnModel({
+    engine.registerModels({ JSColumnModel });
+    const model = engine.createModel<JSColumnModel>({
+      use: 'JSColumnModel',
       uid: 'js-column-row-refresh',
-      flowEngine: engine,
       props: {
         width: 200,
         title: 'JS column',
       },
-    } as any);
+    });
 
     engine.context.dataSourceManager.getDataSource('main').addCollection({
       name: 'users',
@@ -39,12 +84,14 @@ describe('JSColumnModel row refresh', () => {
     });
 
     const column = model.getColumnProps();
-    const first = column.render(null, { id: 1, age: 3, workyears: 39.2 }, 0) as any;
+    const firstRecord = { id: 1, age: 3, workyears: 39.2 };
+    const first = column.render(null, firstRecord, 0) as any;
     const fork = model.getFork('1') as any;
     const invalidateFlowCache = vi.fn();
     fork.invalidateFlowCache = invalidateFlowCache;
     const second = column.render(null, { id: 1, age: 37, workyears: 39.2 }, 0) as any;
 
+    expect(fork.context.record).toEqual({ id: 1, age: 37, workyears: 39.2 });
     expect(first.key).not.toBe(second.key);
     expect(invalidateFlowCache).toHaveBeenCalledWith('beforeRender');
   });