@nocobase/client-v2 2.3.0-alpha.1 → 2.3.0-beta.11

package/src/flow/models/fields/AssociationFieldModel/recordSelectShared.tsx

@@ -119,6 +119,162 @@ export interface LazySelectProps extends Omit<SelectProps<any>, 'mode' | 'option
   allowEdit?: boolean;
 }
 
+type AssociationHydrationSetterOptions = {
+  source?: string;
+  markExplicit?: boolean;
+  triggerEvent?: boolean;
+};
+
+type AssociationHydrationSetterContext = {
+  setFormValue?: (
+    namePath: unknown,
+    value: unknown,
+    options?: AssociationHydrationSetterOptions,
+  ) => Promise<unknown> | void;
+};
+
+export type AssociationHydrationModel = {
+  resource?: {
+    get?: (tk: unknown) => Promise<unknown> | unknown;
+  };
+  context?: unknown;
+  props?: {
+    name?: unknown;
+  };
+};
+
+type AssociationHydrationStatus = 'pending' | 'done';
+
+type AssociationHydrationCandidate = {
+  item: AssociationOption;
+  tk: unknown;
+  tkKey: string;
+};
+
+export function isAssociationRecord(value: unknown): value is AssociationOption {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+export function collectAssociationHydrationCandidates(options: {
+  value: LazySelectProps['value'];
+  isMultiple: boolean;
+  valueKey: string;
+  labelKey: string;
+  statusMap: Map<string, AssociationHydrationStatus>;
+}): AssociationHydrationCandidate[] {
+  const { value, isMultiple, valueKey, labelKey, statusMap } = options;
+  const list = isMultiple ? (Array.isArray(value) ? value : []) : value != null ? [value] : [];
+  const activeTkKeys = new Set<string>();
+
+  for (const item of list) {
+    if (!isAssociationRecord(item)) continue;
+    const tk = item[valueKey];
+    if (tk == null) continue;
+    const tkKey = typeof tk === 'object' ? JSON.stringify(tk) : String(tk);
+    if (tkKey) activeTkKeys.add(tkKey);
+  }
+
+  for (const key of Array.from(statusMap.keys())) {
+    if (!activeTkKeys.has(key)) statusMap.delete(key);
+  }
+
+  const candidates: AssociationHydrationCandidate[] = [];
+  for (const item of list) {
+    if (!isAssociationRecord(item)) continue;
+    const tk = item[valueKey];
+    if (tk == null || item[labelKey] != null) continue;
+
+    const tkKey = typeof tk === 'object' ? JSON.stringify(tk) : String(tk);
+    if (!tkKey || statusMap.has(tkKey)) continue;
+
+    statusMap.set(tkKey, 'pending');
+    candidates.push({ item, tk, tkKey });
+  }
+
+  return candidates;
+}
+
+function hasAssociationHydrationSetter(value: unknown): value is AssociationHydrationSetterContext {
+  return isAssociationRecord(value) && typeof value.setFormValue === 'function';
+}
+
+export function getAssociationHydrationNamePath(model: AssociationHydrationModel) {
+  const context = isAssociationRecord(model.context) ? model.context : undefined;
+  return context?.fieldPathArray ?? context?.fieldPath ?? model.props?.name;
+}
+
+export function getAssociationHydrationSetterContext(model: AssociationHydrationModel) {
+  if (hasAssociationHydrationSetter(model.context)) return model.context;
+
+  const context = isAssociationRecord(model.context) ? model.context : undefined;
+  const blockModel = isAssociationRecord(context?.blockModel) ? context.blockModel : undefined;
+  return hasAssociationHydrationSetter(blockModel?.context) ? blockModel.context : undefined;
+}
+
+export function useAssociationValueHydration(options: {
+  model: AssociationHydrationModel;
+  value: LazySelectProps['value'];
+  isMultiple: boolean;
+  fieldNames: AssociationFieldNames;
+  onChange: LazySelectProps['onChange'];
+}) {
+  const { model, value, isMultiple, fieldNames, onChange } = options;
+  const hydrateStatusRef = React.useRef<Map<string, AssociationHydrationStatus>>(new Map());
+
+  React.useEffect(() => {
+    const resource = model.resource;
+    if (typeof resource?.get !== 'function' || !fieldNames.value || !fieldNames.label) return;
+
+    const current = value;
+    const candidates = collectAssociationHydrationCandidates({
+      value: current,
+      isMultiple,
+      valueKey: fieldNames.value,
+      labelKey: fieldNames.label,
+      statusMap: hydrateStatusRef.current,
+    });
+    if (!candidates.length) return;
+
+    const namePath = getAssociationHydrationNamePath(model);
+    const setterContext = getAssociationHydrationSetterContext(model);
+
+    const hydrateCandidate = async ({ item, tk, tkKey }: AssociationHydrationCandidate) => {
+      try {
+        const record = await resource.get?.(tk);
+        if (!isAssociationRecord(record)) return;
+
+        const merged = { ...item, ...record };
+        if (merged[fieldNames.label] == null) return;
+
+        const nextValue = isMultiple
+          ? (Array.isArray(current) ? current : []).map((entry) =>
+              isAssociationRecord(entry) && entry[fieldNames.value] === tk ? merged : entry,
+            )
+          : merged;
+
+        if (typeof setterContext?.setFormValue === 'function' && namePath != null) {
+          await setterContext.setFormValue(namePath, nextValue, {
+            source: 'default',
+            markExplicit: false,
+            triggerEvent: false,
+          });
+          return;
+        }
+
+        onChange(nextValue);
+      } catch {
+        // Keep the original ID-only value when the related record cannot be loaded.
+      } finally {
+        hydrateStatusRef.current.set(tkKey, 'done');
+      }
+    };
+
+    candidates.forEach((candidate) => {
+      hydrateCandidate(candidate);
+    });
+  }, [fieldNames.label, fieldNames.value, isMultiple, model, onChange, value]);
+}
+
 export interface LabelByFieldProps {
   option: AssociationOption;
   fieldNames: AssociationFieldNames;

package/src/flow/models/fields/DateTimeFieldModel/__tests__/DateTimeNoTzFieldModel.dateLimit.test.tsx

@@ -17,6 +17,8 @@ import { DateTimeNoTzPicker } from '../DateTimeNoTzFieldModel';
 let capturedDatePickerProps: any;
 let currentForm: any;
 const mockResolveJsonTemplate = vi.fn();
+const mockRunjs = vi.fn();
+const mockLoggerWarn = vi.fn();
 
 vi.mock('@nocobase/flow-engine', async (importOriginal) => {
   const actual = await importOriginal<typeof import('@nocobase/flow-engine')>();
@@ -32,6 +34,10 @@ vi.mock('@nocobase/flow-engine', async (importOriginal) => {
     }),
     useFlowContext: () => ({
       resolveJsonTemplate: mockResolveJsonTemplate,
+      runjs: mockRunjs,
+      logger: {
+        warn: mockLoggerWarn,
+      },
     }),
   };
 });
@@ -64,6 +70,9 @@ describe('DateTimeNoTzPicker date range limit', () => {
     currentForm = undefined;
     capturedDatePickerProps = undefined;
     mockResolveJsonTemplate.mockReset();
+    mockRunjs.mockReset();
+    mockLoggerWarn.mockReset();
+    mockRunjs.mockResolvedValue({ success: true, value: undefined });
     mockResolveJsonTemplate.mockImplementation(async (params) => ({
       ...params,
       _maxDate: currentForm?.getFieldValue?.('b'),
@@ -239,4 +248,144 @@ describe('DateTimeNoTzPicker date range limit', () => {
     expect(timeConfig?.disabledMinutes?.(12)).toEqual([]);
     expect(timeConfig?.disabledSeconds?.(12, 34)).toEqual([]);
   });
+
+  it('evaluates RunJS before applying minDate', async () => {
+    const code = 'return new Date("2026-05-10T08:09:10.000Z").toISOString();';
+    mockRunjs.mockResolvedValue({ success: true, value: '2026-05-10T08:09:10.000Z' });
+    mockResolveJsonTemplate.mockImplementation(async (params) => params);
+
+    render(<TestWrapper picker="date" showTime _minDate={{ code, version: 'v2' }} onChange={vi.fn()} value={null} />);
+
+    await waitFor(() => {
+      expect(capturedDatePickerProps?.disabledDate?.(dayjs('2026-05-09 00:00:00'))).toBe(true);
+      expect(capturedDatePickerProps?.disabledDate?.(dayjs('2026-05-10 00:00:00'))).toBe(false);
+    });
+
+    expect(mockRunjs.mock.calls[0]?.[0]).toBe(code);
+    expect(mockRunjs.mock.calls[0]?.[2]).toEqual({ version: 'v2' });
+    expect(mockResolveJsonTemplate).toHaveBeenCalledWith({
+      _minDate: '2026-05-10T08:09:10.000Z',
+      _maxDate: undefined,
+    });
+  });
+
+  it('supports a RunJS minDate together with a variable maxDate', async () => {
+    mockRunjs.mockResolvedValue({ success: true, value: '2026-05-10 08:00:00' });
+    mockResolveJsonTemplate.mockImplementation(async (params) => ({
+      ...params,
+      _maxDate: '2026-05-12 18:30:40',
+    }));
+
+    render(
+      <TestWrapper
+        picker="date"
+        showTime
+        _minDate={{ code: 'return "2026-05-10 08:00:00";', version: 'v2' }}
+        _maxDate={'{{ $nForm.max }}'}
+        onChange={vi.fn()}
+        value={null}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(capturedDatePickerProps?.disabledDate?.(dayjs('2026-05-09 00:00:00'))).toBe(true);
+      expect(capturedDatePickerProps?.disabledDate?.(dayjs('2026-05-13 00:00:00'))).toBe(true);
+    });
+
+    expect(capturedDatePickerProps?.disabledDate?.(dayjs('2026-05-11 00:00:00'))).toBe(false);
+  });
+
+  it('clears stale restrictions when RunJS execution fails', async () => {
+    mockResolveJsonTemplate.mockImplementation(async (params) => params);
+    mockRunjs.mockImplementation(async (code) => {
+      if (code === 'throw new Error("failed");') {
+        return { success: false, error: new Error('failed') };
+      }
+      return { success: true, value: '2026-05-10 08:00:00' };
+    });
+
+    const view = render(
+      <TestWrapper
+        picker="date"
+        showTime
+        _minDate={{ code: 'return "2026-05-10 08:00:00";', version: 'v2' }}
+        onChange={vi.fn()}
+        value={null}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(capturedDatePickerProps?.disabledDate?.(dayjs('2026-05-09 00:00:00'))).toBe(true);
+    });
+
+    view.rerender(
+      <TestWrapper
+        picker="date"
+        showTime
+        _minDate={{ code: 'throw new Error("failed");', version: 'v2' }}
+        onChange={vi.fn()}
+        value={null}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(mockLoggerWarn).toHaveBeenCalled();
+      expect(capturedDatePickerProps?.minDate).toBeNull();
+      expect(capturedDatePickerProps?.disabledDate).toBeNull();
+      expect(capturedDatePickerProps?.disabledTime).toBeNull();
+    });
+  });
+
+  it('keeps the latest RunJS result when an earlier execution finishes later', async () => {
+    const slowResolvers: Array<(result: { success: boolean; value: string }) => void> = [];
+    mockResolveJsonTemplate.mockImplementation(async (params) => params);
+    mockRunjs.mockImplementation((code) => {
+      if (code === 'return "slow";') {
+        return new Promise((resolve) => {
+          slowResolvers.push(resolve);
+        });
+      }
+      return Promise.resolve({ success: true, value: '2026-06-01 00:00:00' });
+    });
+
+    const view = render(
+      <TestWrapper
+        picker="date"
+        showTime
+        _minDate={{ code: 'return "slow";', version: 'v2' }}
+        onChange={vi.fn()}
+        value={null}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(slowResolvers.length).toBeGreaterThan(0);
+    });
+
+    view.rerender(
+      <TestWrapper
+        picker="date"
+        showTime
+        _minDate={{ code: 'return "fast";', version: 'v2' }}
+        onChange={vi.fn()}
+        value={null}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(capturedDatePickerProps?.disabledDate?.(dayjs('2026-05-31 00:00:00'))).toBe(true);
+      expect(capturedDatePickerProps?.disabledDate?.(dayjs('2026-07-01 00:00:00'))).toBe(false);
+    });
+
+    slowResolvers.forEach((resolve) => resolve({ success: true, value: '2026-12-01 00:00:00' }));
+
+    await waitFor(() => {
+      expect(mockResolveJsonTemplate).toHaveBeenCalledWith({
+        _minDate: '2026-12-01 00:00:00',
+        _maxDate: undefined,
+      });
+    });
+
+    expect(capturedDatePickerProps?.disabledDate?.(dayjs('2026-07-01 00:00:00'))).toBe(false);
+  });
 });

package/src/flow/models/fields/DateTimeFieldModel/dateLimit.ts

@@ -8,140 +8,176 @@
  */
 
 import { autorun } from '@formily/reactive';
-import { Form } from 'antd';
-import { useFlowContext } from '@nocobase/flow-engine';
+import { Form, type FormInstance } from 'antd';
+import { resolveRunJSObjectValues, useFlowContext } from '@nocobase/flow-engine';
 import { dayjs } from '@nocobase/utils/client';
+import type { ConfigType, Dayjs } from 'dayjs';
 import { first, last } from 'lodash';
-import React, { useEffect, useRef, useState } from 'react';
+import { useCallback, useEffect, useRef, useState } from 'react';
 
 type DateLimitProps = {
-  _minDate?: any;
-  _maxDate?: any;
-  currentForm?: any;
+  _minDate?: unknown;
+  _maxDate?: unknown;
+  currentForm?: unknown;
 };
 
-export function useDateLimit(props: DateLimitProps) {
-  const ctx = useFlowContext();
-  const isAntdFormInstance = typeof props.currentForm?.getFieldsValue === 'function';
-  const currentFormValues = Form.useWatch([], isAntdFormInstance ? props.currentForm : undefined);
-  const [minDate, setMinDate] = useState<dayjs.Dayjs | null>(null);
-  const [maxDate, setMaxDate] = useState<dayjs.Dayjs | null>(null);
-  const [disabledDate, setDisabledDate] = useState<any>(null);
-  const [disabledTime, setDisabledTime] = useState<any>(null);
-  const disposeRef = useRef<any>(null);
+type DisabledTimeConfig = {
+  disabledHours: () => number[];
+  disabledMinutes: (selectedHour: number) => number[];
+  disabledSeconds: (selectedHour: number, selectedMinute: number) => number[];
+};
 
-  useEffect(() => {
-    if (disposeRef.current) {
-      disposeRef.current();
-    }
+type DisabledDate = (current: Dayjs) => boolean;
+type DisabledTime = (current: Dayjs | null) => DisabledTimeConfig;
 
-    disposeRef.current = autorun(() => {
-      void limitDate();
-    });
+function isAntdFormInstance(value: unknown): value is FormInstance {
+  if (!value || typeof value !== 'object') return false;
+  return typeof (value as Partial<FormInstance>).getFieldsValue === 'function';
+}
 
-    return () => {
-      disposeRef.current?.();
-    };
-  }, [ctx, currentFormValues, props._maxDate, props._minDate]);
+function parseDateLimitValue(value: unknown): Dayjs | null {
+  if (!value) return null;
+  const parsed = dayjs(value as ConfigType);
+  return parsed.isValid() ? parsed : null;
+}
 
-  const limitDate = async () => {
-    const resolvedParams = await ctx.resolveJsonTemplate({
-      _minDate: props._minDate,
-      _maxDate: props._maxDate,
-    });
+export function useDateLimit(props: DateLimitProps) {
+  const ctx = useFlowContext();
+  const currentForm = isAntdFormInstance(props.currentForm) ? props.currentForm : undefined;
+  const currentFormValues = Form.useWatch([], currentForm);
+  const [minDate, setMinDate] = useState<Dayjs | null>(null);
+  const [maxDate, setMaxDate] = useState<Dayjs | null>(null);
+  const [disabledDate, setDisabledDate] = useState<DisabledDate | null>(null);
+  const [disabledTime, setDisabledTime] = useState<DisabledTime | null>(null);
+  const evaluationIdRef = useRef(0);
+
+  const limitDate = useCallback(async () => {
+    const evaluationId = ++evaluationIdRef.current;
+
+    try {
+      const runJSResolvedParams = await resolveRunJSObjectValues(ctx, {
+        _minDate: props._minDate,
+        _maxDate: props._maxDate,
+      });
+      const resolvedParams = (await ctx.resolveJsonTemplate({
+        _minDate: runJSResolvedParams._minDate,
+        _maxDate: runJSResolvedParams._maxDate,
+      })) as { _minDate?: unknown; _maxDate?: unknown };
+
+      if (evaluationId !== evaluationIdRef.current) return;
+
+      const nextMinRaw = Array.isArray(resolvedParams?._minDate)
+        ? first(resolvedParams._minDate)
+        : resolvedParams?._minDate;
+      const nextMaxRaw = Array.isArray(resolvedParams?._maxDate)
+        ? last(resolvedParams._maxDate)
+        : resolvedParams?._maxDate;
+      const nextMinDate = parseDateLimitValue(nextMinRaw);
+      const nextMaxDate = parseDateLimitValue(nextMaxRaw);
+
+      setMinDate(nextMinDate);
+      setMaxDate(nextMaxDate);
+
+      const fullTimeArr = Array.from({ length: 60 }, (_, i) => i);
+
+      const nextDisabledDate: DisabledDate = (current) => {
+        if (!dayjs.isDayjs(current)) return false;
+
+        const min = nextMinDate?.startOf('day') || null;
+        const max = nextMaxDate?.endOf('day') || null;
+
+        if (min && current.startOf('day').isBefore(min)) {
+          return true;
+        }
+        if (max && current.startOf('day').isAfter(max)) {
+          return true;
+        }
+        return false;
+      };
 
-    const nextMinRaw = Array.isArray(resolvedParams?._minDate)
-      ? first(resolvedParams._minDate)
-      : resolvedParams?._minDate;
-    const nextMaxRaw = Array.isArray(resolvedParams?._maxDate)
-      ? last(resolvedParams._maxDate)
-      : resolvedParams?._maxDate;
-    const nextMinDate = nextMinRaw ? dayjs(nextMinRaw) : null;
-    const nextMaxDate = nextMaxRaw ? dayjs(nextMaxRaw) : null;
-
-    setMinDate(nextMinDate?.isValid?.() ? nextMinDate : null);
-    setMaxDate(nextMaxDate?.isValid?.() ? nextMaxDate : null);
-
-    const fullTimeArr = Array.from({ length: 60 }, (_, i) => i);
-
-    const nextDisabledDate = (current: dayjs.Dayjs) => {
-      if (!dayjs.isDayjs(current)) return false;
-
-      const min = nextMinDate?.isValid?.() ? nextMinDate.startOf('day') : null;
-      const max = nextMaxDate?.isValid?.() ? nextMaxDate.endOf('day') : null;
-
-      if (min && current.startOf('day').isBefore(min)) {
-        return true;
-      }
-      if (max && current.startOf('day').isAfter(max)) {
-        return true;
-      }
-      return false;
-    };
+      const nextDisabledTime: DisabledTime = (current) => {
+        if (!current || (!nextMinDate && !nextMaxDate)) {
+          return { disabledHours: () => [], disabledMinutes: () => [], disabledSeconds: () => [] };
+        }
 
-    const nextDisabledTime = (current: dayjs.Dayjs) => {
-      if (!current || (!nextMinDate?.isValid?.() && !nextMaxDate?.isValid?.())) {
-        return { disabledHours: () => [], disabledMinutes: () => [], disabledSeconds: () => [] };
-      }
+        const isCurrentMinDay = !!nextMinDate && current.isSame(nextMinDate, 'day');
+        const isCurrentMaxDay = !!nextMaxDate && current.isSame(nextMaxDate, 'day');
 
-      const isCurrentMinDay = !!nextMinDate?.isValid?.() && current.isSame(nextMinDate, 'day');
-      const isCurrentMaxDay = !!nextMaxDate?.isValid?.() && current.isSame(nextMaxDate, 'day');
+        const disabledHours = () => {
+          const hours = [];
+          if (isCurrentMinDay && nextMinDate) {
+            for (let hour = 0; hour < nextMinDate.hour(); hour++) {
+              hours.push(hour);
+            }
+          }
+          if (isCurrentMaxDay && nextMaxDate) {
+            for (let hour = nextMaxDate.hour() + 1; hour < 24; hour++) {
+              hours.push(hour);
+            }
+          }
+          return hours;
+        };
 
-      const disabledHours = () => {
-        const hours = [];
-        if (isCurrentMinDay && nextMinDate) {
-          for (let hour = 0; hour < nextMinDate.hour(); hour++) {
-            hours.push(hour);
+        const disabledMinutes = (selectedHour: number) => {
+          if (isCurrentMinDay && nextMinDate && selectedHour === nextMinDate.hour()) {
+            return fullTimeArr.filter((minute) => minute < nextMinDate.minute());
           }
-        }
-        if (isCurrentMaxDay && nextMaxDate) {
-          for (let hour = nextMaxDate.hour() + 1; hour < 24; hour++) {
-            hours.push(hour);
+          if (isCurrentMaxDay && nextMaxDate && selectedHour === nextMaxDate.hour()) {
+            return fullTimeArr.filter((minute) => minute > nextMaxDate.minute());
           }
-        }
-        return hours;
+          return [];
+        };
+
+        const disabledSeconds = (selectedHour: number, selectedMinute: number) => {
+          if (
+            isCurrentMinDay &&
+            nextMinDate &&
+            selectedHour === nextMinDate.hour() &&
+            selectedMinute === nextMinDate.minute()
+          ) {
+            return fullTimeArr.filter((second) => second < nextMinDate.second());
+          }
+          if (
+            isCurrentMaxDay &&
+            nextMaxDate &&
+            selectedHour === nextMaxDate.hour() &&
+            selectedMinute === nextMaxDate.minute()
+          ) {
+            return fullTimeArr.filter((second) => second > nextMaxDate.second());
+          }
+          return [];
+        };
+
+        return {
+          disabledHours,
+          disabledMinutes,
+          disabledSeconds,
+        };
       };
 
-      const disabledMinutes = (selectedHour: number) => {
-        if (isCurrentMinDay && nextMinDate && selectedHour === nextMinDate.hour()) {
-          return fullTimeArr.filter((minute) => minute < nextMinDate.minute());
-        }
-        if (isCurrentMaxDay && nextMaxDate && selectedHour === nextMaxDate.hour()) {
-          return fullTimeArr.filter((minute) => minute > nextMaxDate.minute());
-        }
-        return [];
-      };
+      setDisabledDate(() => nextDisabledDate);
+      setDisabledTime(() => nextDisabledTime);
+    } catch (error) {
+      if (evaluationId !== evaluationIdRef.current) return;
 
-      const disabledSeconds = (selectedHour: number, selectedMinute: number) => {
-        if (
-          isCurrentMinDay &&
-          nextMinDate &&
-          selectedHour === nextMinDate.hour() &&
-          selectedMinute === nextMinDate.minute()
-        ) {
-          return fullTimeArr.filter((second) => second < nextMinDate.second());
-        }
-        if (
-          isCurrentMaxDay &&
-          nextMaxDate &&
-          selectedHour === nextMaxDate.hour() &&
-          selectedMinute === nextMaxDate.minute()
-        ) {
-          return fullTimeArr.filter((second) => second > nextMaxDate.second());
-        }
-        return [];
-      };
+      ctx.logger?.warn?.({ err: error }, 'Failed to resolve date range limit');
+      setMinDate(null);
+      setMaxDate(null);
+      setDisabledDate(null);
+      setDisabledTime(null);
+    }
+  }, [ctx, props._maxDate, props._minDate]);
 
-      return {
-        disabledHours,
-        disabledMinutes,
-        disabledSeconds,
-      };
-    };
+  useEffect(() => {
+    const dispose = autorun(() => {
+      limitDate();
+    });
 
-    setDisabledDate(() => nextDisabledDate);
-    setDisabledTime(() => nextDisabledTime);
-  };
+    return () => {
+      evaluationIdRef.current += 1;
+      dispose();
+    };
+  }, [currentFormValues, limitDate]);
 
   return {
     minDate,