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

package/src/flow/models/blocks/form/value-runtime/runtime.ts

@@ -137,6 +137,42 @@ export class FormValueRuntime {
     return this.getForm().getFieldsValue(true);
   }
 
+  canApplyDefaultValuePatch(namePath: NamePath, resolved: any) {
+    if (!namePath?.length) return false;
+    if (typeof resolved === 'undefined') return false;
+
+    const pathKey = namePathToPathKey(namePath);
+    const current = this.getFormValueAtPath(namePath);
+    const last = this.lastDefaultValueByPathKey.get(pathKey);
+    const nextSnapshot = isObservable(resolved) ? toJS(resolved) : resolved;
+    const currentSnapshot = isObservable(current) ? toJS(current) : current;
+    const currentEqualsLastDefault = typeof last !== 'undefined' && _.isEqual(currentSnapshot, last);
+    const explicitHit = this.findExplicitHit(pathKey);
+
+    if (explicitHit && !currentEqualsLastDefault) return false;
+
+    const canOverwrite = isEmptyValue(current) || currentEqualsLastDefault;
+    if (!canOverwrite && _.isEqual(current, nextSnapshot)) {
+      this.lastDefaultValueByPathKey.set(pathKey, nextSnapshot);
+      return false;
+    }
+
+    return canOverwrite;
+  }
+
+  recordDefaultValuePatch(namePath: NamePath, value?: any) {
+    if (!namePath?.length) return;
+    const pathKey = namePathToPathKey(namePath);
+    const snapshot =
+      arguments.length >= 2 ? (isObservable(value) ? toJS(value) : value) : this.getFormValueAtPath(namePath);
+    this.lastDefaultValueByPathKey.set(pathKey, snapshot);
+    const current = this.getFormValueAtPath(namePath);
+    const currentSnapshot = isObservable(current) ? toJS(current) : current;
+    if (_.isEqual(currentSnapshot, snapshot)) {
+      this.clearExplicitForDefaultPatch(pathKey);
+    }
+  }
+
   private getFormValueAtPath(namePath: NamePath) {
     const form: any = this.getForm?.();
     if (form && typeof form.getFieldValue === 'function') {
@@ -247,11 +283,7 @@ export class FormValueRuntime {
     let bumpedWriteSeq = false;
     for (const field of changedFields || []) {
       const name = field?.name;
-      const namePath: NamePath | null = Array.isArray(name)
-        ? (name as NamePath)
-        : typeof name === 'string' || typeof name === 'number'
-          ? ([name] as NamePath)
-          : null;
+      const namePath = this.normalizeObservedNamePath(name);
       if (!namePath?.length) continue;
       const nextValue = form.getFieldValue(namePath as any);
       const prevValue = _.get(this.valuesMirror, namePath);
@@ -265,8 +297,11 @@ export class FormValueRuntime {
       const isMeaningfulTouched =
         field?.touched === true && !this.shouldIgnoreSyntheticTouchedInit(namePath, prevValue, nextValue);
       if (isMeaningfulTouched) {
-        touchedChangedPathKeys.add(namePathToPathKey(namePath));
-        hasMeaningfulTouchedChange = true;
+        const pathKey = namePathToPathKey(namePath);
+        if (!this.shouldKeepDefaultPathValueEnabled(namePath, nextValue)) {
+          touchedChangedPathKeys.add(pathKey);
+          hasMeaningfulTouchedChange = true;
+        }
       }
     }
 
@@ -526,6 +561,10 @@ export class FormValueRuntime {
   }
 
   private getObservedChangedValue(path: NamePath, changedValues: any, snapshot: any) {
+    if (_.has(snapshot, path as any)) {
+      return _.get(snapshot, path as any);
+    }
+
     if (path?.length === 1) {
       const key = path[0];
       if (
@@ -546,6 +585,7 @@ export class FormValueRuntime {
 
     let observed = snapshot;
     for (const key of Object.keys(changedValues)) {
+      if (_.has(observed, [key])) continue;
       if (observed === snapshot) {
         observed = Array.isArray(snapshot) ? [...snapshot] : { ...snapshot };
       }
@@ -573,7 +613,15 @@ export class FormValueRuntime {
     this.lastObservedChangedPaths = null;
     this.lastObservedSource = null;
 
-    const rawSnapshot = allValues && typeof allValues === 'object' ? allValues : this.getFormValuesSnapshot();
+    // 子表格的 changedValues 可能只包含局部行对象，diff 必须以 form 当前完整快照为准，
+    // 否则缺失的 sibling 字段会被误判为用户清空。
+    const formSnapshot = this.getFormValuesSnapshot();
+    const rawSnapshot =
+      formSnapshot && typeof formSnapshot === 'object'
+        ? formSnapshot
+        : allValues && typeof allValues === 'object'
+          ? allValues
+          : changedValues;
     const snapshot = this.getObservedSnapshot(changedValues, rawSnapshot);
     this.reconcileArrayItemState([...rawChangedPaths, ...changedValuePaths], changedValues, snapshot);
     this.pruneDeletedArrayItemState(snapshot);
@@ -602,8 +650,16 @@ export class FormValueRuntime {
       this.bumpChangeTick();
     }
 
-    // 非 default 来源写入：需要使默认值永久失效（explicit）
+    const explicitPathsToMark: NamePath[] = [];
     for (const p of explicitPaths) {
+      if (this.shouldKeepDefaultPathEnabled(p, snapshot)) {
+        continue;
+      }
+      explicitPathsToMark.push(p);
+    }
+
+    // 非 default 来源写入：需要使默认值永久失效（explicit）
+    for (const p of explicitPathsToMark) {
       this.markExplicit(namePathToPathKey(p));
     }
 
@@ -733,7 +789,7 @@ export class FormValueRuntime {
     const source: ValueSource = options?.source ?? 'system';
     const triggerEvent = options?.triggerEvent !== false;
     const txId = options?.txId ?? createTxId();
-    const markExplicit = options?.markExplicit ?? source !== 'default';
+    const markExplicit = options?.markExplicit ?? (source !== 'default' && source !== 'linkage');
     const ownsTxId = typeof options?.txId === 'undefined';
 
     const linkageScopeDepth =
@@ -1071,10 +1127,12 @@ export class FormValueRuntime {
   private markExplicit(pathKey: string) {
     if (this.explicitSet.has(pathKey)) return;
     this.explicitSet.add(pathKey);
+    const preserveDescendantDefaults = this.shouldPreserveDescendantDefaultsOnExplicit(pathKey);
 
     // explicit 后默认值永远失效：清理该路径及其子路径的 lastDefault 记录，避免误判“仍是默认值”
     for (const k of Array.from(this.lastDefaultValueByPathKey.keys())) {
-      if (k === pathKey || k.startsWith(`${pathKey}.`) || k.startsWith(`${pathKey}[`)) {
+      const isDescendant = k.startsWith(`${pathKey}.`) || k.startsWith(`${pathKey}[`);
+      if (k === pathKey || (!preserveDescendantDefaults && isDescendant)) {
         this.lastDefaultValueByPathKey.delete(k);
       }
     }
@@ -1087,6 +1145,40 @@ export class FormValueRuntime {
     }
   }
 
+  private normalizeObservedNamePath(name: NamePath | string | number | undefined): NamePath | null {
+    if (Array.isArray(name)) return name as NamePath;
+    if (typeof name === 'number') return [name];
+    if (typeof name !== 'string' || !name) return null;
+    const parsed = pathKeyToNamePath(name);
+    return parsed.length ? parsed : [name];
+  }
+
+  private clearExplicitForDefaultPatch(pathKey: string) {
+    for (const key of Array.from(this.explicitSet)) {
+      if (key === pathKey || key.startsWith(`${pathKey}.`) || key.startsWith(`${pathKey}[`)) {
+        this.explicitSet.delete(key);
+      }
+    }
+  }
+
+  private shouldPreserveDescendantDefaultsOnExplicit(pathKey: string) {
+    const value = this.getFormValueAtPath(pathKeyToNamePath(pathKey));
+    return Array.isArray(value);
+  }
+
+  private shouldKeepDefaultPathEnabled(namePath: NamePath, snapshot: any) {
+    return this.shouldKeepDefaultPathValueEnabled(namePath, _.get(snapshot, namePath as any));
+  }
+
+  private shouldKeepDefaultPathValueEnabled(namePath: NamePath, value: any) {
+    const pathKey = namePathToPathKey(namePath);
+    const last = this.lastDefaultValueByPathKey.get(pathKey);
+    if (typeof last === 'undefined') return false;
+
+    const nextSnapshot = isObservable(value) ? toJS(value) : value;
+    return _.isEqual(nextSnapshot, last);
+  }
+
   private isExplicit(pathKey: string) {
     return !!this.findExplicitHit(pathKey);
   }

package/src/flow/models/fields/AssociationFieldModel/SubTableFieldModel/SubTableColumnModel.tsx

@@ -177,6 +177,25 @@ const MemoFieldRenderer = React.memo(FieldModelRenderer, (prev, next) => {
   return prev.value === next.value && prev.model === next.model;
 });
 
+export function buildRowPathFromFieldIndex(fieldIndex: unknown): Array<string | number> | null {
+  if (!Array.isArray(fieldIndex) || !fieldIndex.length) return null;
+  const out: Array<string | number> = [];
+  for (const entry of fieldIndex) {
+    if (typeof entry !== 'string') continue;
+    const [fieldName, indexStr] = entry.split(':');
+    const index = Number(indexStr);
+    if (!fieldName || !Number.isFinite(index)) continue;
+    out.push(fieldName, index);
+  }
+  return out.length ? out : null;
+}
+
+export function getLatestSubTableRowRecord(form: any, fieldIndex: unknown, fallbackRecord: any): any {
+  const latestRowPath = buildRowPathFromFieldIndex(fieldIndex);
+  const latestRecord = latestRowPath ? form?.getFieldValue?.(latestRowPath) : undefined;
+  return typeof latestRecord === 'undefined' ? fallbackRecord : latestRecord;
+}
+
 function shouldCommitImmediately(value: any) {
   if (Array.isArray(value)) {
     return true;
@@ -574,6 +593,9 @@ export class SubTableColumnModel<
       const rowForkKey = `row:${baseIndexKey}:${rowIdentity}:${String(rowIdx)}`;
       const rowFork: any = (() => {
         const fork = this.createFork({}, rowForkKey);
+        fork.context.defineProperty('subTableRowFork', {
+          value: true,
+        });
         const associationFieldPath =
           (this.parent as any)?.fieldPath ??
           (this.parent as any)?.context?.fieldPath ??
@@ -592,9 +614,11 @@ export class SubTableColumnModel<
         }
         fork.context.defineProperty('item', {
           get: () => {
+            const form = (fork.context as any)?.form || (this.context?.blockModel as any)?.context?.form;
+            const rowRecord = getLatestSubTableRowRecord(form, fork.context.fieldIndex, record);
             const parentItemCtx = (parentItem ?? this.context?.item) as any;
-            const isNew = record?.__is_new__;
-            const isStored = record?.__is_stored__;
+            const isNew = rowRecord?.__is_new__;
+            const isStored = rowRecord?.__is_stored__;
             const list = (this.parent as any)?.props?.value;
             const length = Array.isArray(list) ? list.length : undefined;
             return {
@@ -602,7 +626,7 @@ export class SubTableColumnModel<
               length,
               __is_new__: isNew,
               __is_stored__: isStored,
-              value: record,
+              value: rowRecord,
               parentItem: parentItemCtx,
             };
           },

package/src/flow/models/fields/AssociationFieldModel/SubTableFieldModel/SubTableField.tsx

@@ -14,8 +14,41 @@ import { useTranslation } from 'react-i18next';
 import { PlusOutlined } from '@ant-design/icons';
 import React, { useEffect, useMemo, useState } from 'react';
 import { ActionWithoutPermission } from '../../../base/ActionModel';
+import { parsePathString } from '../../../blocks/form/value-runtime/path';
 import { getSubTableRowIdentity, normalizeSubTableRows } from './rowIdentity';
 
+type NamePath = Array<string | number>;
+
+function isSamePathPrefix(prefix: NamePath, path: NamePath) {
+  if (!prefix.length || prefix.length > path.length) return false;
+  return prefix.every((seg, index) => seg === path[index]);
+}
+
+function isRelatedPath(a: NamePath, b: NamePath) {
+  return isSamePathPrefix(a, b) || isSamePathPrefix(b, a);
+}
+
+function normalizeChangedPath(path: unknown): NamePath | null {
+  const rawPath = Array.isArray(path) ? path : typeof path === 'string' ? [path] : null;
+  if (!rawPath) return null;
+  const normalized = rawPath.flatMap((seg) => {
+    if (typeof seg === 'number') return [seg];
+    if (typeof seg !== 'string') return [];
+    return parsePathString(seg).filter((parsed): parsed is string | number => typeof parsed !== 'object');
+  });
+  return normalized.length ? normalized : null;
+}
+
+function shouldRefreshForChangedPaths(fieldPath: unknown, changedPaths: unknown) {
+  const currentFieldPath = normalizeChangedPath(fieldPath);
+  if (!currentFieldPath) return false;
+  const paths = Array.isArray(changedPaths) ? changedPaths : [];
+  return paths.some((path) => {
+    const changedPath = normalizeChangedPath(path);
+    return changedPath ? isRelatedPath(currentFieldPath, changedPath) : false;
+  });
+}
+
 export function SubTableField(props) {
   const { t } = useTranslation();
   const {
@@ -35,9 +68,12 @@ export function SubTableField(props) {
     resetPage,
     filterTargetKey = 'id',
     getCurrentValue,
+    fieldPathArray,
+    formValuesChangeEmitter,
   } = props;
   const [currentPage, setCurrentPage] = useState(1);
   const [currentPageSize, setCurrentPageSize] = useState(pageSize);
+  const [, forceRefresh] = useState(0);
   const rawCurrentValue = getCurrentValue();
   const currentValue = useMemo(() => normalizeSubTableRows(rawCurrentValue), [rawCurrentValue]);
   const getRecordIdentity = React.useCallback(
@@ -50,6 +86,17 @@ export function SubTableField(props) {
   useEffect(() => {
     resetPage && setCurrentPage(1);
   }, [resetPage]);
+  useEffect(() => {
+    if (!formValuesChangeEmitter?.on || !formValuesChangeEmitter?.off) return;
+    const listener = (payload: any) => {
+      if (!shouldRefreshForChangedPaths(fieldPathArray, payload?.changedPaths)) return;
+      forceRefresh((v) => v + 1);
+    };
+    formValuesChangeEmitter.on('formValuesChange', listener);
+    return () => {
+      formValuesChangeEmitter.off('formValuesChange', listener);
+    };
+  }, [fieldPathArray, formValuesChangeEmitter]);
   const applyValue = React.useCallback((nextValue: any) => onChange?.(normalizeSubTableRows(nextValue)), [onChange]);
   const getLatestValue = React.useCallback(() => normalizeSubTableRows(getCurrentValue()), [getCurrentValue]);
   useEffect(() => {

package/src/flow/models/fields/AssociationFieldModel/SubTableFieldModel/__tests__/SubTableColumnModel.rowRecord.test.ts

@@ -0,0 +1,42 @@
+/**
+ * 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 { getLatestSubTableRowRecord, buildRowPathFromFieldIndex } from '../SubTableColumnModel';
+
+describe('SubTableColumnModel row record helpers', () => {
+  it('builds the row path from fieldIndex entries', () => {
+    expect(buildRowPathFromFieldIndex(['roles:0'])).toEqual(['roles', 0]);
+    expect(buildRowPathFromFieldIndex(['users:1', 'roles:2'])).toEqual(['users', 1, 'roles', 2]);
+  });
+
+  it('prefers the latest row value from form over the fallback record', () => {
+    const form = {
+      getFieldValue: vi.fn((path: any) => {
+        if (JSON.stringify(path) === JSON.stringify(['roles', 0])) {
+          return { uid: 'role-uid-1', __is_new__: true };
+        }
+      }),
+    };
+    const fallback = { uid: 'stale-role', __is_new__: false };
+
+    expect(getLatestSubTableRowRecord(form, ['roles:0'], fallback)).toEqual({
+      uid: 'role-uid-1',
+      __is_new__: true,
+    });
+    expect(form.getFieldValue).toHaveBeenCalledWith(['roles', 0]);
+  });
+
+  it('falls back to the record when latest row value is unavailable', () => {
+    const form = { getFieldValue: vi.fn(() => undefined) };
+    const fallback = { uid: 'stale-role', __is_new__: false };
+
+    expect(getLatestSubTableRowRecord(form, ['roles:0'], fallback)).toBe(fallback);
+  });
+});

package/src/flow/models/fields/AssociationFieldModel/SubTableFieldModel/__tests__/SubTableField.refresh.test.tsx

@@ -0,0 +1,122 @@
+/**
+ * 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 React from 'react';
+import { EventEmitter } from 'events';
+import { describe, expect, it, vi } from 'vitest';
+import { act, render, screen } from '@nocobase/test/client';
+import { SubTableField } from '../SubTableField';
+
+vi.mock('react-i18next', async (importOriginal) => ({
+  ...(await importOriginal<any>()),
+  useTranslation: () => ({
+    t: (value: string) => value,
+  }),
+}));
+
+vi.mock('antd', async () => {
+  const actual = await vi.importActual<any>('antd');
+  return {
+    ...actual,
+    Table: ({ dataSource = [], columns = [] }: any) => (
+      <div data-testid="subtable">
+        {dataSource.map((record: any, rowIdx: number) => (
+          <div data-testid={`row-${rowIdx}`} key={record.__index__ || rowIdx}>
+            {columns.map((column: any) => (
+              <div data-testid={`cell-${rowIdx}-${String(column.dataIndex || column.key)}`} key={column.key}>
+                {column.render?.(record[column.dataIndex], record, rowIdx)}
+              </div>
+            ))}
+          </div>
+        ))}
+      </div>
+    ),
+  };
+});
+
+describe('SubTableField refresh', () => {
+  it('rerenders from current form value when a nested subtable path changes', () => {
+    const emitter = new EventEmitter();
+    const store = {
+      roles: [{ __is_new__: true, __index__: 'row-1', uid: 'role-uid-1', name: '' }],
+    };
+    const columns = [
+      {
+        key: 'name',
+        dataIndex: 'name',
+        render: ({ value }: any) => <span>{value || 'empty'}</span>,
+      },
+    ];
+
+    render(
+      <SubTableField
+        columns={columns}
+        pageSize={10}
+        filterTargetKey="id"
+        fieldPathArray={['roles']}
+        formValuesChangeEmitter={emitter}
+        getCurrentValue={() => store.roles}
+      />,
+    );
+
+    expect(screen.getByTestId('cell-0-name')).toHaveTextContent('empty');
+
+    act(() => {
+      store.roles = [{ ...store.roles[0], name: 'role-uid-1' }];
+      emitter.emit('formValuesChange', {
+        source: 'linkage',
+        changedPaths: [['roles', 0, 'name']],
+      });
+    });
+
+    expect(screen.getByTestId('cell-0-name')).toHaveTextContent('role-uid-1');
+  });
+
+  it('ignores unrelated form value changes', () => {
+    const emitter = new EventEmitter();
+    let renderCount = 0;
+    const store = {
+      roles: [{ __is_new__: true, __index__: 'row-1', uid: 'role-uid-1', name: '' }],
+    };
+    const columns = [
+      {
+        key: 'name',
+        dataIndex: 'name',
+        render: ({ value }: any) => {
+          renderCount += 1;
+          return <span>{value || 'empty'}</span>;
+        },
+      },
+    ];
+
+    render(
+      <SubTableField
+        columns={columns}
+        pageSize={10}
+        filterTargetKey="id"
+        fieldPathArray={['roles']}
+        formValuesChangeEmitter={emitter}
+        getCurrentValue={() => store.roles}
+      />,
+    );
+
+    expect(renderCount).toBe(1);
+
+    act(() => {
+      store.roles = [{ ...store.roles[0], name: 'role-uid-1' }];
+      emitter.emit('formValuesChange', {
+        source: 'user',
+        changedPaths: [['profile', 'name']],
+      });
+    });
+
+    expect(renderCount).toBe(1);
+    expect(screen.getByTestId('cell-0-name')).toHaveTextContent('empty');
+  });
+});

package/src/flow/models/fields/AssociationFieldModel/SubTableFieldModel/index.tsx

@@ -120,6 +120,8 @@ export class SubTableFieldModel extends AssociationFieldModel {
         parentFieldIndex={this.context.fieldIndex}
         parentItem={this.context.item}
         filterTargetKey={this.collection.filterTargetKey}
+        formValuesChangeEmitter={this.context.blockModel?.emitter}
+        fieldPathArray={this.parent?.context?.fieldPathArray}
         getCurrentValue={this.getCurrentValue}
       />
     );

package/src/flow/models/fields/ClickableFieldModel.tsx

@@ -11,10 +11,9 @@ import { CollectionField, tExpr } from '@nocobase/flow-engine';
 import { Tag } from 'antd';
 import { castArray, get } from 'lodash';
 import React from 'react';
-import { EllipsisWithTooltip } from '../../components';
+import { EllipsisWithTooltip } from '../../components/EllipsisWithTooltip';
 import { openViewFlow } from '../../flows/openViewFlow';
 import { FieldModel } from '../base/FieldModel';
-import { EditFormModel } from '../blocks/form/EditFormModel';
 
 export function transformNestedData(inputData) {
   const resultArray = [];
@@ -36,6 +35,8 @@ export function transformNestedData(inputData) {
 const hasAssociationPathName = (parent: unknown): parent is { associationPathName?: string } =>
   !!parent && typeof parent === 'object' && 'associationPathName' in parent;
 
+const hasUsableSourceId = (sourceId: unknown) => sourceId !== undefined && sourceId !== null && String(sourceId) !== '';
+
 export class ClickableFieldModel extends FieldModel {
   get collectionField(): CollectionField {
     return this.context.collectionField;
@@ -62,14 +63,18 @@ export class ClickableFieldModel extends FieldModel {
       const parentObj = associationPathName
         ? get(this.context.blockModel?.form?.getFieldsValue?.(true) || this.context.record, associationPathName)
         : this.context.record;
+      const sourceId = parentObj?.[sourceKey];
+      const useAssociationResource = hasUsableSourceId(sourceId);
       this.dispatchEvent(
         'click',
         {
           event,
           filterByTk,
-          collectionName: this.collectionField.collection.name,
-          associationName: `${sourceCollection.name}.${this.collectionField.name}`, // `${sourceCollection.name}.${this.collectionField.name}`,
-          sourceId: parentObj[sourceKey],
+          collectionName: useAssociationResource
+            ? this.collectionField.collection.name
+            : targetCollection?.name || this.collectionField.target,
+          associationName: useAssociationResource ? `${sourceCollection.name}.${this.collectionField.name}` : null,
+          sourceId: useAssociationResource ? sourceId : null,
         },
         {
           debounce: true,
@@ -95,6 +100,10 @@ export class ClickableFieldModel extends FieldModel {
         const parentObj = associationPathName.includes('.')
           ? get(this.context.record, associationPathName.split('.')[0])
           : this.context.record;
+        const sourceId = hasUsableSourceId(parentObj?.[sourceKey])
+          ? parentObj?.[sourceKey]
+          : this.context.record?.[foreignKey];
+        const useAssociationResource = hasUsableSourceId(sourceId);
         let filterByTk = associationRecord?.[targetKey];
         if (associationField.interface === 'm2m') {
           // also incorrect for v1
@@ -106,10 +115,13 @@ export class ClickableFieldModel extends FieldModel {
           {
             event,
             filterByTk,
-            collectionName: this.collectionField.collection.name,
-            associationName: `${associationField.collection.name}.${this.collectionField.name}`,
-            // list api， 如果append了关系字段的某个属性，它并不会将关系字段对应的 filterByTk (sourceKey) 属性值返回， 但是会返回foriegnKey对应的值
-            sourceId: parentObj[sourceKey] || this.context.record[foreignKey],
+            collectionName: useAssociationResource
+              ? this.collectionField.collection.name
+              : targetCollection?.name || associationField.target || this.collectionField.collection.name,
+            associationName: useAssociationResource
+              ? `${associationField.collection.name}.${this.collectionField.name}`
+              : null,
+            sourceId: useAssociationResource ? sourceId : null,
           },
           {
             debounce: true,

package/src/flow/models/fields/DateTimeFieldModel/DateOnlyFieldModel.tsx

@@ -12,17 +12,26 @@ import { EditableItemModel, useFlowModelContext } from '@nocobase/flow-engine';
 import React from 'react';
 import { DateTimeFieldModel } from './DateTimeFieldModel';
 import { MobileDatePicker } from '../mobile-components/MobileDatePicker';
+import { useDateLimit } from './dateLimit';
 
 export const DateOnlyPicker = (props) => {
   const { value, format = 'YYYY-MM-DD', picker = 'date', showTime, ...rest } = props;
   const parsedValue = value && dayjs(value).isValid() ? dayjs(value) : null;
   const ctx = useFlowModelContext();
+  const { disabledDate, disabledTime, minDate, maxDate } = useDateLimit({
+    ...props,
+    currentForm: ctx.model?.context?.form,
+  });
   const componentProps = {
     ...rest,
     value: parsedValue,
     format,
     picker,
     showTime,
+    disabledDate,
+    disabledTime,
+    minDate,
+    maxDate,
     onChange: (val: any) => {
       const outputFormat = 'YYYY-MM-DD';
       if (!val) {

package/src/flow/models/fields/DateTimeFieldModel/DateTimeFieldModel.tsx

@@ -22,5 +22,9 @@ DateTimeFieldModel.registerFlow({
       use: 'dateDisplayFormat',
       title: tExpr('Date display format'),
     },
+    dateRangeLimit: {
+      use: 'dateRangeLimit',
+      title: tExpr('Date range limit'),
+    },
   },
 });

package/src/flow/models/fields/DateTimeFieldModel/DateTimeNoTzFieldModel.tsx

@@ -12,17 +12,26 @@ import React from 'react';
 import { EditableItemModel, useFlowModelContext } from '@nocobase/flow-engine';
 import { DateTimeFieldModel } from './DateTimeFieldModel';
 import { MobileDatePicker } from '../mobile-components/MobileDatePicker';
+import { useDateLimit } from './dateLimit';
 
 export const DateTimeNoTzPicker = (props) => {
   const { value, format = 'YYYY-MM-DD HH:mm:ss', showTime, picker = 'date', onChange, ...rest } = props;
   const parsedValue = value ? dayjs(value) : null;
   const ctx = useFlowModelContext();
+  const { disabledDate, disabledTime, minDate, maxDate } = useDateLimit({
+    ...props,
+    currentForm: ctx.model?.context?.form,
+  });
   const componentProps = {
     ...rest,
     value: parsedValue,
     format,
     picker,
     showTime,
+    disabledDate,
+    disabledTime,
+    minDate,
+    maxDate,
     onChange: (val: any) => {
       if (!val) {
         return onChange(val);

package/src/flow/models/fields/DateTimeFieldModel/DateTimeTzFieldModel.tsx

@@ -12,6 +12,7 @@ import React from 'react';
 import { DateTimeFieldModel } from './DateTimeFieldModel';
 import { MobileDatePicker } from '../mobile-components/MobileDatePicker';
 import { DatePicker } from 'antd';
+import { useDateLimit } from './dateLimit';
 
 function parseToDate(value: string | Date | dayjs.Dayjs | undefined, format?: string): Date | undefined {
   if (!value) return undefined;
@@ -49,12 +50,20 @@ function parseInitialValue(value: string | Date | undefined, format?: string): d
 export const DateTimeTzPicker = (props) => {
   const { value, format = 'YYYY-MM-DD HH:mm:ss', picker = 'date', showTime, ...rest } = props;
   const ctx = useFlowModelContext();
+  const { disabledDate, disabledTime, minDate, maxDate } = useDateLimit({
+    ...props,
+    currentForm: ctx.model?.context?.form,
+  });
   const componentProps = {
     ...rest,
     value: parseInitialValue(value, format),
     format,
     picker,
     showTime,
+    disabledDate,
+    disabledTime,
+    minDate,
+    maxDate,
     onChange: (val: any) => {
       let result = parseToDate(val, format);
       // Adjust to start of period for month/quarter/year pickers