@nocobase/client-v2 2.1.0-beta.27 → 2.1.0-beta.29

package/src/flow/actions/__tests__/pattern.test.ts

@@ -0,0 +1,190 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+import { FlowEngine, FlowModel } from '@nocobase/flow-engine';
+import { FieldModel } from '../../models/base/FieldModel';
+import { JSEditableFieldModel } from '../../models/fields/JSEditableFieldModel';
+import { DetailsItemModel } from '../../models/blocks/details/DetailsItemModel';
+import { pattern } from '../pattern';
+
+class DummyDisplayFieldModel extends FieldModel {}
+
+class DummyFormItemModel extends FlowModel<{ subModels: { field?: FieldModel } }> {
+  collectionField: any;
+
+  static getDefaultBindingByField() {
+    return { modelName: 'FieldModel' };
+  }
+
+  getFieldSettingsInitParams() {
+    return { mock: true };
+  }
+}
+
+function makeCollectionField() {
+  return {
+    targetCollection: undefined,
+    isAssociationField: () => false,
+  };
+}
+
+function makeCtx(parent: DummyFormItemModel) {
+  const collectionField = makeCollectionField();
+  parent.collectionField = collectionField;
+  return {
+    model: parent,
+    collectionField,
+    engine: parent.flowEngine,
+  } as any;
+}
+
+describe('pattern action', () => {
+  it('keeps JS editable field model when switching to display only', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({
+      DummyFormItemModel,
+      FieldModel,
+      JSEditableFieldModel,
+      DummyDisplayFieldModel,
+    });
+
+    const parent = engine.createModel<DummyFormItemModel>({
+      use: DummyFormItemModel,
+      uid: 'form-item-js',
+      subModels: {
+        field: {
+          use: FieldModel,
+          uid: 'field-js',
+          stepParams: {
+            fieldBinding: {
+              use: 'JSEditableFieldModel',
+            },
+            jsSettings: {
+              runJs: {
+                code: 'ctx.render("hello")',
+              },
+            },
+          },
+        },
+      },
+    });
+    const field = parent.subModels.field;
+    const saveSpy = vi.spyOn(engine, 'saveModel');
+    const applyJsSettingsSpy = vi.spyOn(field as JSEditableFieldModel, 'scheduleApplyJsSettings');
+
+    await pattern.afterParamsSave?.(makeCtx(parent), { pattern: 'readPretty' }, { pattern: 'editable' });
+
+    expect(parent.subModels.field).toBe(field);
+    expect(parent.subModels.field).toBeInstanceOf(JSEditableFieldModel);
+    expect(parent.subModels.field?.uid).toBe('field-js');
+    expect(parent.subModels.field?.getStepParams('jsSettings', 'runJs')).toMatchObject({
+      code: 'ctx.render("hello")',
+    });
+    expect(saveSpy).not.toHaveBeenCalled();
+    expect(applyJsSettingsSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('keeps JS editable field model when leaving display only', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({
+      DummyFormItemModel,
+      FieldModel,
+      JSEditableFieldModel,
+      DummyDisplayFieldModel,
+    });
+
+    const parent = engine.createModel<DummyFormItemModel>({
+      use: DummyFormItemModel,
+      uid: 'form-item-js-leave',
+      subModels: {
+        field: {
+          use: FieldModel,
+          uid: 'field-js-leave',
+          stepParams: {
+            fieldBinding: {
+              use: 'JSEditableFieldModel',
+            },
+          },
+        },
+      },
+    });
+    const field = parent.subModels.field;
+    const saveSpy = vi.spyOn(engine, 'saveModel');
+    const applyJsSettingsSpy = vi.spyOn(field as JSEditableFieldModel, 'scheduleApplyJsSettings');
+
+    await pattern.afterParamsSave?.(makeCtx(parent), { pattern: 'editable' }, { pattern: 'readPretty' });
+
+    expect(parent.subModels.field).toBe(field);
+    expect(parent.subModels.field).toBeInstanceOf(JSEditableFieldModel);
+    expect(saveSpy).not.toHaveBeenCalled();
+    expect(applyJsSettingsSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not reapply JS settings when pattern is unchanged', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({
+      DummyFormItemModel,
+      FieldModel,
+      JSEditableFieldModel,
+    });
+
+    const parent = engine.createModel<DummyFormItemModel>({
+      use: DummyFormItemModel,
+      uid: 'form-item-js-unchanged',
+      subModels: {
+        field: {
+          use: FieldModel,
+          uid: 'field-js-unchanged',
+          stepParams: {
+            fieldBinding: {
+              use: 'JSEditableFieldModel',
+            },
+          },
+        },
+      },
+    });
+    const applyJsSettingsSpy = vi.spyOn(parent.subModels.field as JSEditableFieldModel, 'scheduleApplyJsSettings');
+
+    await pattern.afterParamsSave?.(makeCtx(parent), { pattern: 'readPretty' }, { pattern: 'readPretty' });
+
+    expect(applyJsSettingsSpy).not.toHaveBeenCalled();
+  });
+
+  it('still rebuilds regular fields when switching to display only', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({
+      DummyFormItemModel,
+      FieldModel,
+      DummyDisplayFieldModel,
+    });
+
+    const parent = engine.createModel<DummyFormItemModel>({
+      use: DummyFormItemModel,
+      uid: 'form-item-regular',
+      subModels: {
+        field: {
+          use: FieldModel,
+          uid: 'field-regular',
+        },
+      },
+    });
+    const ctx = makeCtx(parent);
+    const displayBinding = { modelName: 'DummyDisplayFieldModel', defaultProps: { display: true } } as any;
+    const getDisplayBindingSpy = vi.spyOn(DetailsItemModel, 'getDefaultBindingByField').mockReturnValue(displayBinding);
+
+    await pattern.afterParamsSave?.(ctx, { pattern: 'readPretty' }, { pattern: 'editable' });
+
+    expect(parent.subModels.field).toBeInstanceOf(DummyDisplayFieldModel);
+    expect(parent.subModels.field?.uid).toBe('field-regular');
+    expect(parent.subModels.field?.props).toMatchObject({ display: true });
+
+    getDisplayBindingSpy.mockRestore();
+  });
+});

package/src/flow/actions/dateRangeLimit.tsx

@@ -0,0 +1,66 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { defineAction, tExpr } from '@nocobase/flow-engine';
+import { FieldAssignValueInput } from '../components/FieldAssignValueInput';
+
+function normalizeDateRangeValue(value: any) {
+  if (value === '' || value === null || typeof value === 'undefined') {
+    return undefined;
+  }
+  return value;
+}
+
+export const dateRangeLimit = defineAction({
+  name: 'dateRangeLimit',
+  title: tExpr('Date range limit'),
+  uiMode: {
+    type: 'dialog',
+    props: {
+      width: 720,
+    },
+  },
+  uiSchema(ctx: any) {
+    const targetPath = ctx.model.context?.collectionField?.name || '';
+    const dateLimitInputProps = {
+      targetPath,
+      enableDateVariableAsConstant: true,
+    };
+
+    return {
+      _minDate: {
+        type: 'string',
+        title: tExpr('MinDate'),
+        'x-decorator': 'FormItem',
+        'x-component': FieldAssignValueInput,
+        'x-component-props': dateLimitInputProps,
+      },
+      _maxDate: {
+        type: 'string',
+        title: tExpr('MaxDate'),
+        'x-decorator': 'FormItem',
+        'x-component': FieldAssignValueInput,
+        'x-component-props': dateLimitInputProps,
+      },
+    };
+  },
+  defaultParams(ctx: any) {
+    return {
+      _minDate: normalizeDateRangeValue(ctx.model.props?._minDate),
+      _maxDate: normalizeDateRangeValue(ctx.model.props?._maxDate),
+    };
+  },
+  useRawParams: true,
+  async handler(ctx: any, params) {
+    ctx.model.setProps({
+      _minDate: normalizeDateRangeValue(params?._minDate),
+      _maxDate: normalizeDateRangeValue(params?._maxDate),
+    });
+  },
+});

package/src/flow/actions/index.ts

@@ -20,6 +20,7 @@ export * from './refreshTargetBlocks';
 export * from './setTargetDataScope';
 export { titleField } from './titleField';
 export * from './dateTimeFormat';
+export * from './dateRangeLimit';
 export * from './sortingRules';
 export * from './dataLoadingMode';
 export * from './renderMode';

package/src/flow/actions/linkageRules.tsx

@@ -51,11 +51,7 @@ import {
   getCollectionFromModel,
   isToManyAssociationField,
 } from '../internal/utils/modelUtils';
-import {
-  namePathToPathKey,
-  parsePathString,
-  resolveDynamicNamePath,
-} from '../models/blocks/form/value-runtime/path';
+import { namePathToPathKey, parsePathString, resolveDynamicNamePath } from '../models/blocks/form/value-runtime/path';
 import { ensureFormValueDrivenLinkageRefresh } from './linkageRulesFormValueRefresh';
 
 interface LinkageRule {
@@ -1759,7 +1755,7 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
 
   const linkageRules: LinkageRule[] = params.value as LinkageRule[];
   const allModels: FlowModel[] = ctx.model.__allModels || (ctx.model.__allModels = []);
-  const directValuePatches: Array<{ path: any; value: any }> = [];
+  const directValuePatches: Array<{ path: Array<string | number>; value: any; whenEmpty?: boolean }> = [];
   const rootCollection = getCollectionFromModel((ctx.model as any)?.context?.blockModel ?? ctx.model);
   const isSafeToWriteAssociationSubpath = (namePath: any): boolean => {
     if (!Array.isArray(namePath) || !namePath.length) return true;
@@ -1800,6 +1796,24 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
     const fieldIndex = (ctx.model as any)?.context?.fieldIndex;
     return resolveDynamicNamePath(path, fieldIndex);
   };
+  const getDefaultPatchRuntime = () => {
+    const blockModel = (ctx.model as any)?.context?.blockModel ?? ctx.model;
+    return blockModel?.formValueRuntime ?? (ctx as any)?.formValueRuntime;
+  };
+  const rememberAppliedDefaultPatches = (patches: typeof directValuePatches) => {
+    const runtime = getDefaultPatchRuntime();
+    if (typeof runtime?.recordDefaultValuePatch !== 'function') return;
+
+    const lastPatchByPathKey = new Map<string, (typeof directValuePatches)[number]>();
+    for (const patch of patches) {
+      lastPatchByPathKey.set(namePathToPathKey(patch.path), patch);
+    }
+
+    for (const patch of lastPatchByPathKey.values()) {
+      if (!patch.whenEmpty) continue;
+      runtime.recordDefaultValuePatch(patch.path, patch.value);
+    }
+  };
   const addFormValuePatch = (patch: { path: any; value: any; whenEmpty?: boolean }) => {
     if (!patch) return;
     const path = (patch as any)?.path;
@@ -1823,20 +1837,33 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
       return;
     }
     const whenEmpty = !!(patch as any)?.whenEmpty;
+    const value = (patch as any)?.value;
     try {
       const form = ctx.model?.context?.form;
       const current = form?.getFieldValue?.(resolvedPath);
-      if (whenEmpty && typeof current !== 'undefined' && current !== null && current !== '') {
-        return;
+      if (whenEmpty) {
+        const runtime = getDefaultPatchRuntime();
+        if (typeof runtime?.canApplyDefaultValuePatch === 'function') {
+          const canApply = runtime.canApplyDefaultValuePatch(resolvedPath, value);
+          if (!canApply) {
+            return;
+          }
+        } else if (typeof current !== 'undefined' && current !== null && current !== '') {
+          return;
+        }
       }
-      if (_.isEqual(current, (patch as any)?.value)) {
+      if (_.isEqual(current, value)) {
         return;
       }
     } catch {
       // ignore
     }
 
-    directValuePatches.push({ path: resolvedPath, value: (patch as any)?.value });
+    directValuePatches.push({
+      path: resolvedPath,
+      value,
+      ...(whenEmpty ? { whenEmpty: true } : {}),
+    });
   };
 
   const getModelTargetPathForPatch = (model: any): string | null => {
@@ -2018,6 +2045,7 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
   if (typeof directSetter === 'function') {
     try {
       await trySetFormValues(directSetter, directCtx, 'linkage');
+      rememberAppliedDefaultPatches(allPatches);
       return;
     } catch (error) {
       console.warn('[linkageRules] Failed to set form values via setFormValues', {
@@ -2034,6 +2062,7 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
   if (typeof blockSetter === 'function') {
     try {
       await trySetFormValues(blockSetter, blockCtx, 'linkage');
+      rememberAppliedDefaultPatches(allPatches);
       return;
     } catch (error) {
       console.warn('[linkageRules] Failed to set form values via setFormValues', {
@@ -2063,6 +2092,7 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
       console.warn('[linkageRules] Failed to set form field value (fallback setFieldValue)', { path }, error);
     }
   });
+  rememberAppliedDefaultPatches(allPatches);
 };
 
 export const blockLinkageRules = defineAction({
@@ -2348,33 +2378,95 @@ export const fieldLinkageRules = defineAction({
       return;
     }
 
-    const getRowScopeKeyFromModel = (model: any): string | null => {
+    const getRowFieldIndexInfoFromModel = (model: any) => {
       const fieldIndex = model?.context?.fieldIndex;
       const arr = Array.isArray(fieldIndex) ? fieldIndex : [];
-      if (!arr.length) return null;
+      const normalized = arr.filter((it): it is string => typeof it === 'string');
       const entries: Array<{ name: string; index: number }> = [];
-      for (const it of arr) {
-        if (typeof it !== 'string') continue;
+      const path: Array<string | number> = [];
+      for (const it of normalized) {
         const [name, indexStr] = it.split(':');
         const index = Number(indexStr);
         if (!name || Number.isNaN(index)) continue;
         entries.push({ name, index });
+        path.push(name, index);
       }
+      return { normalized, entries, path };
+    };
+
+    const getRowScopeKeyFromModel = (model: any): string | null => {
+      const { entries } = getRowFieldIndexInfoFromModel(model);
       if (!entries.length) return null;
       const deepest = entries[entries.length - 1].name;
       const occurrence = entries.reduce((count, e) => (e.name === deepest ? count + 1 : count), 0);
       return `${deepest}#${occurrence}`;
     };
 
+    const getRowFieldIndexKeyFromModel = (model: any): string | null => {
+      const { normalized } = getRowFieldIndexInfoFromModel(model);
+      if (!normalized.length) return null;
+      return JSON.stringify(normalized);
+    };
+
+    const getRowPathFromModel = (model: any): Array<string | number> | null => {
+      const { path } = getRowFieldIndexInfoFromModel(model);
+      return path.length ? path : null;
+    };
+
+    const getFormForRowFork = (model: any) => {
+      return (
+        model?.context?.form ??
+        model?.context?.blockModel?.context?.form ??
+        ctx.model?.context?.form ??
+        ctx.model?.context?.blockModel?.context?.form
+      );
+    };
+
+    const isRowForkMountedInCurrentValue = (model: any): boolean => {
+      const rowPath = getRowPathFromModel(model);
+      if (!rowPath) return true;
+      const form = getFormForRowFork(model);
+      if (!form || typeof form.getFieldValue !== 'function') return true;
+      return typeof form.getFieldValue(rowPath as any) !== 'undefined';
+    };
+
+    const hasRowItemContext = (model: any): boolean => {
+      const itemOptions = model?.context?.getPropertyOptions?.('item');
+      if (itemOptions) return true;
+      return typeof model?.context?.item !== 'undefined';
+    };
+
+    const hasSubTableRowMarker = (model: any): boolean => {
+      const markerOptions = model?.context?.getPropertyOptions?.('subTableRowFork');
+      if (markerOptions) return true;
+      return (
+        typeof model?.context?.subTableRowFork !== 'undefined' ||
+        typeof model?.subTableRowFork !== 'undefined' ||
+        model?.subTableRowFork === true
+      );
+    };
+
     const isRowGridForkModel = (model: any): boolean => {
       if (!model || typeof model !== 'object') return false;
       if ((model as any)?.subModels?.field) return false;
       if (!(model as any)?.subModels?.items) return false;
-      return !!getRowScopeKeyFromModel(model);
+      return !!getRowScopeKeyFromModel(model) && !!getRowFieldIndexKeyFromModel(model);
+    };
+
+    const isSubTableRowForkModel = (model: any): boolean => {
+      if (!model || typeof model !== 'object') return false;
+      if (!hasSubTableRowMarker(model)) return false;
+      if (!getRowScopeKeyFromModel(model) || !getRowFieldIndexKeyFromModel(model)) return false;
+      return hasRowItemContext(model);
+    };
+
+    const isRowScopedForkModel = (model: any): boolean => {
+      return isRowGridForkModel(model) || isSubTableRowForkModel(model);
     };
 
-    const collectRowGridForksByKey = (): Map<string, FlowModel[]> => {
+    const collectRowScopedForksByKey = (): Map<string, FlowModel[]> => {
       const out = new Map<string, FlowModel[]>();
+      const seenByKey = new Map<string, Set<string>>();
       const engine = ctx.engine;
       if (!engine?.forEachModel) return out;
 
@@ -2383,9 +2475,15 @@ export const fieldLinkageRules = defineAction({
         if (!forks || typeof forks.forEach !== 'function') return;
         forks.forEach((fork: any) => {
           if (!fork || fork.disposed) return;
-          if (!isRowGridForkModel(fork)) return;
+          if (!isRowScopedForkModel(fork)) return;
+          if (!isRowForkMountedInCurrentValue(fork)) return;
           const rowScopeKey = getRowScopeKeyFromModel(fork);
-          if (!rowScopeKey) return;
+          const fieldIndexKey = getRowFieldIndexKeyFromModel(fork);
+          if (!rowScopeKey || !fieldIndexKey) return;
+          const seen = seenByKey.get(rowScopeKey) || new Set<string>();
+          if (seen.has(fieldIndexKey)) return;
+          seen.add(fieldIndexKey);
+          seenByKey.set(rowScopeKey, seen);
           const arr = out.get(rowScopeKey) || [];
           arr.push(fork as FlowModel);
           out.set(rowScopeKey, arr);
@@ -2396,7 +2494,7 @@ export const fieldLinkageRules = defineAction({
     };
 
     const runRowScoped = async (): Promise<boolean> => {
-      const forksByKey = collectRowGridForksByKey();
+      const forksByKey = collectRowScopedForksByKey();
       let hasAnyRowFork = false;
       for (const [rowScopeKey, rowParams] of rowParamsByKey.entries()) {
         const forks = forksByKey.get(rowScopeKey) || [];

package/src/flow/actions/openView.tsx

@@ -345,7 +345,8 @@ export const openView = defineAction({
         target: ctx.inputArgs.target || ctx.layoutContentElement,
         dataSourceKey: runtimeDataSourceKey ?? actionDefaults.dataSourceKey,
         collectionName: runtimeCollectionName ?? actionDefaults.collectionName,
-        associationName: runtimeAssociationName ?? actionDefaults.associationName,
+        associationName:
+          typeof runtimeAssociationName !== 'undefined' ? runtimeAssociationName : actionDefaults.associationName,
         filterByTk: mergedFilterByTk,
         sourceId: mergedSourceId,
         tabUid: mergedTabUid,

package/src/flow/actions/pattern.tsx

@@ -7,9 +7,25 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { BindingOptions, defineAction, tExpr, DisplayItemModel } from '@nocobase/flow-engine';
+import { defineAction, tExpr } from '@nocobase/flow-engine';
 import { DetailsItemModel } from '../models/blocks/details/DetailsItemModel';
-import { rebuildFieldSubModel } from '../internal/utils/rebuildFieldSubModel';
+import { getFieldBindingUse, rebuildFieldSubModel } from '../internal/utils/rebuildFieldSubModel';
+
+type PatternAwareFieldModelMeta = {
+  preserveOnPatternChange?: boolean;
+};
+
+type PatternAwareFieldModel = {
+  scheduleApplyJsSettings?: () => void;
+};
+
+function shouldPreserveFieldModelOnPatternChange(ctx: any) {
+  const fieldModel = ctx.model.subModels.field;
+  const fieldUse = getFieldBindingUse(fieldModel) ?? fieldModel?.use;
+  const ModelClass = typeof fieldUse === 'string' ? ctx.engine.getModelClass(fieldUse) : fieldUse;
+
+  return ((ModelClass?.meta as PatternAwareFieldModelMeta | undefined)?.preserveOnPatternChange ?? false) === true;
+}
 
 export const pattern = defineAction({
   name: 'pattern',
@@ -56,6 +72,13 @@ export const pattern = defineAction({
     };
   },
   afterParamsSave: async (ctx: any, params, previousParams) => {
+    if (shouldPreserveFieldModelOnPatternChange(ctx)) {
+      if (params.pattern !== previousParams.pattern) {
+        (ctx.model.subModels.field as PatternAwareFieldModel | undefined)?.scheduleApplyJsSettings?.();
+      }
+      return;
+    }
+
     const targetCollection = ctx.collectionField.targetCollection;
     const targetCollectionTitleField = targetCollection?.getField(
       ctx.model.subModels.field.props?.fieldNames?.label || ctx.model.props.titleField,

package/src/flow/admin-shell/AdminLayoutRouteCoordinator.ts

@@ -47,6 +47,8 @@ interface RouteLike {
   pathname?: string;
 }
 
+const hasUsableSourceId = (sourceId: unknown) => sourceId !== undefined && sourceId !== null && String(sourceId) !== '';
+
 /**
  * 管理 admin 场景下每个 page 的 v2 视图栈编排。
  * 该协调器只负责状态机和开关视图，不直接绑定 React 生命周期。
@@ -264,6 +266,10 @@ export class AdminLayoutRouteCoordinator {
     const destroyRef = React.createRef<(result?: any, force?: boolean) => void>();
     const updateRef = React.createRef<(value: any) => void>();
     const openViewParams = getOpenViewStepParams(viewItem.model);
+    const associationName =
+      openViewParams?.associationName && !hasUsableSourceId(viewItem.params.sourceId)
+        ? null
+        : openViewParams?.associationName;
     const openerUids = viewList.slice(0, viewItem.index).map((item) => item.params.viewUid);
     const navigation = new ViewNavigation(
       this.flowEngine.context,
@@ -273,7 +279,7 @@ export class AdminLayoutRouteCoordinator {
     viewItem.model.dispatchEvent('click', {
       target: runtime.meta.layoutContentElement || this.layoutContentElement,
       collectionName: openViewParams?.collectionName,
-      associationName: openViewParams?.associationName,
+      associationName,
       dataSourceKey: openViewParams?.dataSourceKey,
       destroyRef,
       updateRef,