@nocobase/client-v2 2.2.0-alpha.1 → 2.2.0-alpha.3

package/src/flow/models/base/__tests__/transformRowsToSingleColumn.test.ts

@@ -35,6 +35,36 @@ describe('transformRowsToSingleColumn', () => {
     expect(all).toEqual([['a'], ['b', 'c'], ['d'], ['e']]);
   });
 
+  it('should preserve row ids for ordinary single-column mobile rows', () => {
+    const rows = {
+      row_a: [['a']],
+      row_b: [['b']],
+    };
+
+    expect(transformRowsToSingleColumn(rows)).toEqual(rows);
+  });
+
+  it('should avoid adding another mobile prefix to ordinary single-column projected rows', () => {
+    const rows = {
+      'mobile:row_a:0': [['a']],
+    };
+
+    expect(Object.keys(transformRowsToSingleColumn(rows))).toEqual(['mobile:row_a:0']);
+  });
+
+  it('should keep split multi-column row keys stable and unique', () => {
+    const rows = {
+      row_a: [['a'], ['b']],
+    };
+    const result = transformRowsToSingleColumn(rows);
+    const keys = Object.keys(result);
+
+    expect(keys).toHaveLength(2);
+    expect(new Set(keys).size).toBe(2);
+    expect(keys.every((key) => key.startsWith('mobile:'))).toBe(true);
+    expect(Object.values(result).map((row) => row[0])).toEqual([['a'], ['b']]);
+  });
+
   it('should skip columns that only contain EMPTY_COLUMN_UID', () => {
     const rows = buildRows([[[EMPTY_COLUMN_UID], ['a']]]);
     const result = transformRowsToSingleColumn(rows);
@@ -55,4 +85,22 @@ describe('transformRowsToSingleColumn', () => {
     const all = Object.values(result).map((r) => r[0]);
     expect(all).toEqual([['x'], ['y']]);
   });
+
+  it('should keep generated row keys stable for the same input', () => {
+    const rows = buildRows([
+      [['a'], ['b']],
+      [['c'], ['d']],
+    ]);
+
+    expect(Object.keys(transformRowsToSingleColumn(rows))).toEqual(Object.keys(transformRowsToSingleColumn(rows)));
+  });
+
+  it('should keep existing row keys stable when appending new mobile rows', () => {
+    const before = buildRows([[['a'], ['b']]]);
+    const after = buildRows([[['a'], ['b']], [['c']]]);
+    const beforeKeys = Object.keys(transformRowsToSingleColumn(before));
+    const afterKeys = Object.keys(transformRowsToSingleColumn(after));
+
+    expect(afterKeys.slice(0, beforeKeys.length)).toEqual(beforeKeys);
+  });
 });

package/src/flow/models/blocks/filter-form/FilterFormBlockModel.tsx

@@ -17,7 +17,6 @@ import {
   Droppable,
   isRunJSValue,
   normalizeRunJSValue,
-  runjsWithSafeGlobals,
   tExpr,
   FlowModelRenderer,
   FlowSettingsButton,
@@ -231,6 +230,7 @@ export class FilterFormBlockModel extends FilterBlockModel<{
   private initialDefaultsPromise?: Promise<void>;
   private initialRefreshHandledTargetIds = new Set<string>();
   private lastDefaultValueByFieldName = new Map<string, any>();
+  private userEditedFieldNames = new Set<string>();
   private defaultValuesRefreshSeq = 0;
 
   get form() {
@@ -436,6 +436,28 @@ export class FilterFormBlockModel extends FilterBlockModel<{
     return isEqual(current, this.lastDefaultValueByFieldName.get(name));
   }
 
+  private canApplyFormOverrideValue(name: string, force?: boolean) {
+    if (force) return true;
+    return !this.userEditedFieldNames.has(name);
+  }
+
+  private normalizeFieldValueMode(mode: unknown): 'default' | 'assign' | 'override' {
+    if (mode === 'assign') return 'assign';
+    if (mode === 'override') return 'override';
+    return 'default';
+  }
+
+  private markFilterFormUserEditedFields(changedValues: any) {
+    if (!changedValues || typeof changedValues !== 'object' || Array.isArray(changedValues)) return;
+    for (const name of Object.keys(changedValues)) {
+      this.userEditedFieldNames.add(String(name));
+    }
+  }
+
+  private resetFilterFormUserEditedFields() {
+    this.userEditedFieldNames.clear();
+  }
+
   private async matchDefaultValueCondition(condition: any) {
     if (!condition) return true;
 
@@ -458,6 +480,10 @@ export class FilterFormBlockModel extends FilterBlockModel<{
     if (!form) return appliedValues;
 
     const force = options?.force === true;
+    if (force) {
+      this.resetFilterFormUserEditedFields();
+    }
+
     const params = this.getStepParams?.('formFilterBlockModelSettings', 'defaultValues');
     const rules = (params?.value || []) as any[];
     if (!Array.isArray(rules) || rules.length === 0) return appliedValues;
@@ -466,7 +492,7 @@ export class FilterFormBlockModel extends FilterBlockModel<{
       // RunJS support
       if (isRunJSValue(raw)) {
         const { code, version } = normalizeRunJSValue(raw);
-        const ret = await runjsWithSafeGlobals(this.context, code, { version });
+        const ret = await this.context.runjs(code, undefined, { version });
         return ret?.success ? ret.value : undefined;
       }
 
@@ -499,8 +525,9 @@ export class FilterFormBlockModel extends FilterBlockModel<{
 
       const operator = getDefaultOperator(itemModel as any);
       const normalized = normalizeFilterValueByOperator(operator, resolved);
-      const mode = String(rule.mode || 'default') === 'assign' ? 'assign' : 'default';
+      const mode = this.normalizeFieldValueMode(rule.mode);
       if (mode === 'default' && !this.canApplyFormDefaultValue(String(name), current, force)) continue;
+      if (mode === 'override' && !this.canApplyFormOverrideValue(String(name), force)) continue;
       if (isEqual(current, normalized)) {
         if (mode === 'default') {
           this.lastDefaultValueByFieldName.set(String(name), normalized);
@@ -527,6 +554,7 @@ export class FilterFormBlockModel extends FilterBlockModel<{
   }
 
   private handleFilterFormValuesChange(changedValues: any, allValues: any) {
+    this.markFilterFormUserEditedFields(changedValues);
     const refreshSeq = ++this.defaultValuesRefreshSeq;
     void (async () => {
       const appliedValues = await this.applyFormDefaultValues({ refreshSeq });

package/src/flow/models/blocks/filter-form/FilterFormJSActionModel.tsx

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { createSafeDocument, createSafeWindow, createSafeNavigator, tExpr } from '@nocobase/flow-engine';
+import { tExpr } from '@nocobase/flow-engine';
 import { CodeEditor } from '../../../components/code-editor';
 import { FilterFormActionModel } from './FilterFormActionModel';
 import { resolveRunJsParams } from '../../utils/resolveRunJsParams';
@@ -60,12 +60,7 @@ FilterFormJSActionModel.registerFlow({
       },
       async handler(ctx, params) {
         const { code, version } = resolveRunJsParams(ctx, params);
-        const navigator = createSafeNavigator();
-        await ctx.runjs(
-          code,
-          { window: createSafeWindow({ navigator }), document: createSafeDocument(), navigator },
-          { version },
-        );
+        await ctx.runjs(code, undefined, { version });
       },
     },
   },

package/src/flow/models/blocks/filter-form/__tests__/defaultValues.wiring.test.ts

@@ -50,6 +50,7 @@ function createFilterFormDefaultValuesModel(rules: any[], initialValues: Record<
   const model = {
     defaultValuesRefreshSeq: 0,
     lastDefaultValueByFieldName: new Map<string, any>(),
+    userEditedFieldNames: new Set<string>(),
     form: {
       getFieldsValue: () => ({ ...values }),
       getFieldValue: (name: string) => values[name],
@@ -86,6 +87,10 @@ function createFilterFormDefaultValuesModel(rules: any[], initialValues: Record<
       return undefined;
     }),
     canApplyFormDefaultValue: (FilterFormBlockModel.prototype as any).canApplyFormDefaultValue,
+    canApplyFormOverrideValue: (FilterFormBlockModel.prototype as any).canApplyFormOverrideValue,
+    normalizeFieldValueMode: (FilterFormBlockModel.prototype as any).normalizeFieldValueMode,
+    markFilterFormUserEditedFields: (FilterFormBlockModel.prototype as any).markFilterFormUserEditedFields,
+    resetFilterFormUserEditedFields: (FilterFormBlockModel.prototype as any).resetFilterFormUserEditedFields,
     matchDefaultValueCondition: (FilterFormBlockModel.prototype as any).matchDefaultValueCondition,
     applyFormDefaultValues: FilterFormBlockModel.prototype.applyFormDefaultValues,
     handleFilterFormValuesChange: (FilterFormBlockModel.prototype as any).handleFilterFormValuesChange,
@@ -315,6 +320,78 @@ describe('filter-form defaultValues wiring', () => {
     expect(values.username_user).toBe('Bob');
   });
 
+  it('applies override values until the target filter field is changed by user', async () => {
+    const { model, values } = createFilterFormDefaultValuesModel(
+      [
+        {
+          key: 'username-override',
+          enable: true,
+          targetPath: 'username',
+          mode: 'override',
+          value: '{{ ctx.formValues.nickname_nick }}',
+        },
+      ],
+      { nickname_nick: 'Bob', username_user: 'Manual' },
+    );
+
+    await FilterFormBlockModel.prototype.applyFormDefaultValues.call(model as any);
+    expect(values.username_user).toBe('Bob');
+
+    values.nickname_nick = 'Carol';
+    model.defaultValuesRefreshSeq += 1;
+    await FilterFormBlockModel.prototype.applyFormDefaultValues.call(model as any, {
+      refreshSeq: model.defaultValuesRefreshSeq,
+    });
+    expect(values.username_user).toBe('Carol');
+
+    values.username_user = 'User value';
+    (model as any).handleFilterFormValuesChange(
+      { username_user: 'User value' },
+      { nickname_nick: 'Carol', username_user: 'User value' },
+    );
+
+    await waitFor(() => {
+      expect(values.username_user).toBe('User value');
+    });
+
+    values.nickname_nick = 'Dora';
+    model.defaultValuesRefreshSeq += 1;
+    await FilterFormBlockModel.prototype.applyFormDefaultValues.call(model as any, {
+      refreshSeq: model.defaultValuesRefreshSeq,
+    });
+    expect(values.username_user).toBe('User value');
+  });
+
+  it('clears filter form user-edited override state on forced apply', async () => {
+    const { model, values } = createFilterFormDefaultValuesModel(
+      [
+        {
+          key: 'username-override',
+          enable: true,
+          targetPath: 'username',
+          mode: 'override',
+          condition: {
+            logic: '$and',
+            items: [{ path: '{{ ctx.formValues.nickname_nick }}', operator: '$eq', value: 'allow' }],
+          },
+          value: '{{ ctx.formValues.nickname_nick }}',
+        },
+      ],
+      { nickname_nick: 'deny', username_user: 'User value' },
+    );
+
+    model.userEditedFieldNames.add('username_user');
+
+    await FilterFormBlockModel.prototype.applyFormDefaultValues.call(model as any, { force: true });
+    expect(values.username_user).toBe('User value');
+    expect(model.userEditedFieldNames.has('username_user')).toBe(false);
+
+    values.nickname_nick = 'allow';
+    await FilterFormBlockModel.prototype.applyFormDefaultValues.call(model as any);
+
+    expect(values.username_user).toBe('allow');
+  });
+
   it('skips filter form field values when the rule condition does not match', async () => {
     const { model, values } = createFilterFormDefaultValuesModel(
       [

package/src/flow/models/blocks/filter-form/fields/FilterFormCustomFieldModel.tsx

@@ -210,7 +210,7 @@ FilterFormCustomFieldModel.registerFlow({
           'x-decorator': 'FormItem',
           required: true,
           description:
-            '{{t("Randomly generated and can be modified. Support letters, numbers and underscores, must start with an letter.")}}',
+            '{{t("Randomly generated and can be modified. Support letters, numbers and underscores, must start with a letter.")}}',
         },
         source: {
           type: 'array',

package/src/flow/models/blocks/filter-manager/flow-actions/__tests__/customizeFilterRender.test.tsx

@@ -18,12 +18,23 @@ type TestFieldModel = {
   setupReactiveRender: ReturnType<typeof vi.fn>;
   _reactiveWrapperCache?: unknown;
   __originalRender?: () => React.ReactNode;
+  translate?: (text: string) => string;
 };
 
 const MultipleKeywordsInput = (props: Record<string, unknown>) => {
   return <div data-testid="multiple-keywords-input" {...props} />;
 };
 
+const Select = (props: Record<string, unknown>) => {
+  return <div data-testid="select" {...props} />;
+};
+
+function mockT(text: string) {
+  if (text === '{{t("Yes")}}') return '是';
+  if (text === '{{t("No")}}') return '否';
+  return text;
+}
+
 function createFieldModel() {
   return {
     props: {
@@ -52,7 +63,10 @@ function createFilterItemModel({
     collectionField,
     context: {
       app: {
-        getComponent: (name: string) => (name === 'MultipleKeywordsInput' ? MultipleKeywordsInput : undefined),
+        getComponent: (name: string) => {
+          if (name === 'MultipleKeywordsInput') return MultipleKeywordsInput;
+          if (name === 'Select') return Select;
+        },
       },
       collectionField,
     },
@@ -112,6 +126,47 @@ describe('customizeFilterRender action', () => {
     expect((rerenderedElement as React.ReactElement).props.placeholder).toBe('updated runtime placeholder');
   });
 
+  it('translates operator schema select options', () => {
+    const fieldModel = {
+      ...createFieldModel(),
+      translate: mockT,
+    };
+    const model = createFilterItemModel({
+      fieldModel,
+      operator: '$isTruly',
+      collectionField: {
+        interface: 'checkbox',
+        type: 'boolean',
+        filterable: {
+          operators: [
+            {
+              label: '{{t("Yes")}}',
+              value: '$isTruly',
+              schema: {
+                'x-component': 'Select',
+                'x-component-props': {
+                  options: [
+                    { label: '{{t("Yes")}}', value: true },
+                    { label: '{{t("No")}}', value: false },
+                  ],
+                },
+              },
+            },
+          ],
+        },
+      },
+    });
+
+    customizeFilterRender.handler?.({ model } as any);
+
+    const element = fieldModel.render();
+    expect((element as React.ReactElement).type).toBe(Select);
+    expect((element as React.ReactElement).props.options).toEqual([
+      { label: '是', value: true },
+      { label: '否', value: false },
+    ]);
+  });
+
   it('restores original render when switching to an operator without a schema component', () => {
     const fieldModel = createFieldModel();
     const originalRender = fieldModel.render;

package/src/flow/models/blocks/form/EditFormModel.tsx

@@ -239,6 +239,7 @@ EditFormModel.registerFlow({
           // 切换记录（翻页等）时，清理“用户改动标记”，避免把上一条记录的编辑状态带到下一条
           if (recordChanged) {
             ctx.model.resetUserModifiedFields?.();
+            ctx.model.resetRuntimeUserEditedState?.();
           }
 
           ctx.form.setFieldsValue(currentRecord);

package/src/flow/models/blocks/form/FormActionModel.tsx

@@ -117,7 +117,7 @@ FormSubmitActionModel.registerFlow({
         try {
           ctx.model.setProps('loading', true);
           const { submitHandler } = await import('./submitHandler');
-          await submitHandler(ctx, params);
+          return await submitHandler(ctx, params);
         } catch (error) {
           ctx.model.setProps('loading', false);
           if (error instanceof FlowExitAllException) {

package/src/flow/models/blocks/form/FormBlockModel.tsx

@@ -166,6 +166,13 @@ export class FormBlockModel<
     this.userModifiedTopLevelFields.clear();
   }
 
+  /**
+   * @internal
+   */
+  resetRuntimeUserEditedState(): void {
+    this.formValueRuntime?.resetUserEditedState?.();
+  }
+
   public async onDispatchEventStart(eventName: string, options?: any, inputArgs?: Record<string, any>): Promise<void> {
     if (eventName === 'beforeRender') {
       const grid = this.subModels.grid;

package/src/flow/models/blocks/form/JSFormActionModel.tsx

@@ -10,7 +10,7 @@
 /**
  * JS Form Action：表单工具栏按钮点击执行 JS。
  */
-import { tExpr, createSafeWindow, createSafeDocument, createSafeNavigator } from '@nocobase/flow-engine';
+import { tExpr } from '@nocobase/flow-engine';
 import { CodeEditor } from '../../../components/code-editor';
 import { FormActionModel } from './FormActionModel';
 import { resolveRunJsParams } from '../../utils/resolveRunJsParams';
@@ -73,12 +73,7 @@ ctx.message.success('Current form values: ' + JSON.stringify(values));
             await ctx.resource.refresh();
           }
         });
-        const navigator = createSafeNavigator();
-        await ctx.runjs(
-          code,
-          { window: createSafeWindow({ navigator }), document: createSafeDocument(), navigator },
-          { version },
-        );
+        await ctx.runjs(code, undefined, { version });
       },
     },
   },

package/src/flow/models/blocks/form/__tests__/FormBlockModel.test.tsx

@@ -420,6 +420,23 @@ describe('FormBlockModel (form/formValues injection & server resolve anchors)',
     expect(savedUids).toContain('grid-1');
   });
 
+  it('keeps dirty reset separate from runtime user-edited reset', async () => {
+    const model = await setupFormModel();
+    const resetUserEditedState = vi.fn();
+    model.formValueRuntime = { resetUserEditedState } as any;
+
+    model.markUserModifiedFields({ status: 'draft' });
+    expect(model.getUserModifiedFields().has('status')).toBe(true);
+
+    model.resetUserModifiedFields();
+
+    expect(model.getUserModifiedFields().size).toBe(0);
+    expect(resetUserEditedState).not.toHaveBeenCalled();
+
+    model.resetRuntimeUserEditedState();
+    expect(resetUserEditedState).toHaveBeenCalledTimes(1);
+  });
+
   it('re-syncs delegated assignRules when grid submodel is added after block init', async () => {
     const model = await setupFormModel();
     const syncAssignRules = vi.fn();

package/src/flow/models/blocks/form/__tests__/submitHandler.test.ts

@@ -9,6 +9,7 @@
 
 import { SingleRecordResource } from '@nocobase/flow-engine';
 import { describe, expect, it, vi } from 'vitest';
+import { EditFormModel } from '../EditFormModel';
 import { submitHandler } from '../submitHandler';
 
 describe('submitHandler', () => {
@@ -52,13 +53,14 @@ describe('submitHandler', () => {
       t: (value: string) => value,
     };
 
-    await submitHandler(ctx, {
+    const responseRecord = await submitHandler(ctx, {
       assignedValues: {
         status: 'published',
         reviewer: 'Alice',
       },
     });
 
+    expect(responseRecord).toEqual({ id: 1 });
     expect(resource.save).toHaveBeenCalledWith(
       {
         title: 'Draft title',
@@ -68,4 +70,55 @@ describe('submitHandler', () => {
       undefined,
     );
   });
+
+  it('returns the refreshed record for edit forms when the save response is empty', async () => {
+    const refreshedRecord = { id: 2, title: 'Updated title' };
+    const resource = Object.create(SingleRecordResource.prototype);
+    resource.getMeta = vi.fn((key: string) => (key === 'currentFilterByTk' ? 2 : undefined));
+    resource.setFilterByTk = vi.fn(() => resource);
+    resource.save = vi.fn(async () => undefined);
+    resource.refresh = vi.fn(async () => undefined);
+    resource.getData = vi.fn(() => refreshedRecord);
+
+    const blockModel = Object.create(EditFormModel.prototype);
+    const form = {
+      validateFields: vi.fn(async () => undefined),
+      getFieldsValue: vi.fn(() => ({
+        title: 'Updated title',
+      })),
+    };
+    Object.defineProperty(blockModel, 'context', { value: { form } });
+    Object.defineProperty(blockModel, 'collection', {
+      value: {
+        name: 'posts',
+        getFilterByTK: (record: { id?: number }) => record.id,
+      },
+    });
+    blockModel.resetUserModifiedFields = vi.fn();
+
+    const responseRecord = await submitHandler(
+      {
+        resource,
+        blockModel,
+        model: {
+          getStepParams: vi.fn(),
+        },
+        message: {
+          error: vi.fn(),
+        },
+        t: (value: string) => value,
+      },
+      {},
+    );
+
+    expect(responseRecord).toBe(refreshedRecord);
+    expect(resource.setFilterByTk).toHaveBeenCalledWith(2);
+    expect(resource.save).toHaveBeenCalledWith(
+      {
+        title: 'Updated title',
+      },
+      undefined,
+    );
+    expect(resource.refresh).toHaveBeenCalled();
+  });
 });

package/src/flow/models/blocks/form/submitHandler.ts

@@ -12,6 +12,16 @@ import { mergeAssignFieldValues, resolveAssignFieldValues } from '../assign-form
 import type { FormBlockModel } from './FormBlockModel';
 import { omitHiddenModelValuesFromSubmit, shouldSkipSubmitValidation, validateSubmitForm } from './submitValues';
 
+function getResponseRecord(response: unknown) {
+  if (!response || typeof response !== 'object') {
+    return response;
+  }
+  if ('data' in response) {
+    return (response as { data?: unknown }).data;
+  }
+  return response;
+}
+
 export async function submitHandler(ctx, params, cb?: (values?: any, filterByTk?: any) => void) {
   const resource = ctx.resource;
   const blockModel = ctx.blockModel as FormBlockModel;
@@ -41,30 +51,34 @@ export async function submitHandler(ctx, params, cb?: (values?: any, filterByTk?
         resource.setFilterByTk(currentFilterByTk);
       }
     }
-    const data: any = cb ? await cb(values) : await resource.save(values, params.requestConfig);
+    const data: unknown = cb ? await cb(values) : await resource.save(values, params.requestConfig);
+    let responseRecord = getResponseRecord(data);
     if (isEditFormModel) {
       resource.isNewRecord = false;
       // 编辑表单保存成功后，表单应回到“已同步”状态：下一次刷新应允许覆盖为服务端值
       blockModel.resetUserModifiedFields?.();
       await resource.refresh();
+      responseRecord = responseRecord ?? resource.getData?.();
     } else {
       blockModel.form.resetFields();
       blockModel.emitter.emit('onFieldReset');
       blockModel.resetUserModifiedFields?.();
       blockModel.formValueRuntime?.resetAfterFormReset?.();
       if (ctx.view.inputArgs.collectionName === blockModel.collection.name && ctx.view.inputArgs.onChange) {
-        ctx.view.inputArgs.onChange(data?.data);
+        ctx.view.inputArgs.onChange(responseRecord);
       }
     }
+    return responseRecord;
   } else if (resource instanceof MultiRecordResource) {
     const currentFilterByTk = resource.getMeta('currentFilterByTk');
     if (!currentFilterByTk) {
       ctx.message.error(ctx.t('No filterByTk found for multi-record resource.'));
       return;
     }
-    (await cb)
+    const data = cb
       ? await cb(values, currentFilterByTk)
       : await resource.update(currentFilterByTk, values, params.requestConfig);
     blockModel.resetUserModifiedFields?.();
+    return getResponseRecord(data) ?? blockModel.getCurrentRecord?.();
   }
 }