@nocobase/client-v2 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/flow/components/field-value-variable/__tests__/FieldValueVariableInput.test.tsx

@@ -0,0 +1,380 @@
+/**
+ * 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 type { MetaTreeNode, VariableInputProps } from '@nocobase/flow-engine';
+import { parseCtxDateExpressionConfig, serializeCtxDateExpressionConfig } from '@nocobase/flow-engine';
+import { fireEvent, render, screen } from '@nocobase/test/client';
+import { dayjs } from '@nocobase/utils/client';
+import React from 'react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { DateVariableEditor, serializeExactDatePickerValue } from '../DateVariableEditor';
+import {
+  DEFAULT_DATE_VARIABLE_COMPONENT_PROPS,
+  isDateLikeField,
+  resolveDateVariableComponentProps,
+  type DateVariableComponentProps,
+} from '../dateValue';
+import { FieldValueVariableInput } from '../FieldValueVariableInput';
+
+const mocks = vi.hoisted(() => ({
+  variableInputProps: undefined as VariableInputProps | undefined,
+}));
+
+vi.mock('@nocobase/flow-engine', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@nocobase/flow-engine')>();
+  return {
+    ...actual,
+    VariableInput: (props: VariableInputProps) => {
+      mocks.variableInputProps = props;
+      return <div data-testid="variable-input" />;
+    },
+    useFlowContext: () => ({
+      isMobileLayout: false,
+      model: { translate: (value: string) => value },
+      t: (value: string) => value,
+    }),
+  };
+});
+
+const ConstantComponent: React.FC = () => <div>constant editor</div>;
+const NullComponent: React.FC = () => <div>null editor</div>;
+const RunJSComponent: React.FC = () => <div>runjs editor</div>;
+
+function renderInput(options?: {
+  value?: unknown;
+  isDateLikeField?: boolean;
+  dateComponentProps?: DateVariableComponentProps;
+}) {
+  const onChange = vi.fn();
+  render(
+    <FieldValueVariableInput
+      value={options?.value}
+      onChange={onChange}
+      baseMetaTree={[{ name: 'currentUser', title: 'Current user', type: 'object', paths: ['currentUser'] }]}
+      constantComponent={ConstantComponent}
+      nullComponent={NullComponent}
+      runJSComponent={RunJSComponent}
+      isDateLikeField={options?.isDateLikeField ?? false}
+      dateComponentProps={options?.dateComponentProps ?? DEFAULT_DATE_VARIABLE_COMPONENT_PROPS}
+    />,
+  );
+  return onChange;
+}
+
+async function resolveMetaTree() {
+  const provider = mocks.variableInputProps?.metaTree;
+  const tree = typeof provider === 'function' ? await provider() : provider;
+  return (tree || []) as MetaTreeNode[];
+}
+
+describe('FieldValueVariableInput', () => {
+  beforeEach(() => {
+    mocks.variableInputProps = undefined;
+  });
+
+  it('adds Date as a non-selectable first-level peer with complete second-level options', async () => {
+    renderInput({ isDateLikeField: true });
+
+    const tree = await resolveMetaTree();
+    expect(tree.slice(0, 4).map((node) => node.name)).toEqual(['constant', 'null', 'date', 'runjs']);
+
+    const dateNode = tree[2];
+    expect(dateNode.selectable).toBe(false);
+    expect((dateNode.children as MetaTreeNode[]).map((node) => node.name)).toEqual([
+      'exact',
+      'past',
+      'next',
+      'now',
+      'today',
+      'yesterday',
+      'tomorrow',
+      'thisWeek',
+      'lastWeek',
+      'nextWeek',
+      'thisMonth',
+      'lastMonth',
+      'nextMonth',
+      'thisQuarter',
+      'lastQuarter',
+      'nextQuarter',
+      'thisYear',
+      'lastYear',
+      'nextYear',
+    ]);
+    expect(tree[4].name).toBe('currentUser');
+  });
+
+  it('does not allow Now for pure date fields', async () => {
+    const dateComponentProps: DateVariableComponentProps = {
+      ...DEFAULT_DATE_VARIABLE_COMPONENT_PROPS,
+      exactNormalizeMode: 'date',
+    };
+    renderInput({ isDateLikeField: true, dateComponentProps });
+
+    const tree = await resolveMetaTree();
+    const dateNode = tree[2];
+    expect((dateNode.children as MetaTreeNode[]).map((node) => node.name)).not.toContain('now');
+    expect(
+      mocks.variableInputProps?.converters?.resolveValueFromPath?.({
+        name: 'now',
+        title: 'Now',
+        type: 'date',
+        paths: ['date', 'now'],
+      }),
+    ).toBeUndefined();
+  });
+
+  it('restores a legacy Now value for a pure date field without allowing it to be selected again', async () => {
+    const dateComponentProps: DateVariableComponentProps = {
+      ...DEFAULT_DATE_VARIABLE_COMPONENT_PROPS,
+      exactNormalizeMode: 'date',
+    };
+    renderInput({ value: '{{ ctx.date.preset.now }}', isDateLikeField: true, dateComponentProps });
+
+    const tree = await resolveMetaTree();
+    const dateNode = tree[2];
+    const nowNode = (dateNode.children as MetaTreeNode[]).find((node) => node.name === 'now');
+    expect(nowNode).toMatchObject({ disabled: true, selectable: false });
+    expect(mocks.variableInputProps?.converters?.resolvePathFromValue?.(mocks.variableInputProps.value)).toEqual([
+      'date',
+      'now',
+    ]);
+  });
+
+  it('restores legacy date expressions under Date without changing Constant semantics', () => {
+    renderInput({ value: '{{ ctx.date.preset.today }}', isDateLikeField: true });
+
+    expect(mocks.variableInputProps?.value).toMatchObject({ kind: 'preset', preset: 'today' });
+    expect(mocks.variableInputProps?.converters?.resolvePathFromValue?.(mocks.variableInputProps.value)).toEqual([
+      'date',
+      'today',
+    ]);
+    expect(
+      mocks.variableInputProps?.converters?.resolveValueFromPath?.({
+        name: 'constant',
+        title: 'Constant',
+        type: 'string',
+        paths: ['constant'],
+      }),
+    ).toBe('');
+  });
+
+  it.each([
+    { kind: 'exact', value: 'plain JSON value' },
+    { kind: 'relative', direction: 'next', amount: 1, unit: 'day' },
+    { kind: 'preset', preset: 'today' },
+  ])('keeps a JSON constant containing Date-like keys as a constant', (constantValue) => {
+    const onChange = renderInput({ value: constantValue, isDateLikeField: false });
+
+    expect(mocks.variableInputProps?.converters?.resolvePathFromValue?.(mocks.variableInputProps.value)).toEqual([
+      'constant',
+    ]);
+    mocks.variableInputProps?.onChange?.(constantValue);
+    expect(onChange).toHaveBeenCalledWith(constantValue);
+  });
+
+  it.each(['exact', 'past', 'next', 'today'])(
+    'initializes %s as a complete formatted expression for a non-date field',
+    (nodeName) => {
+      const onChange = renderInput({ isDateLikeField: false });
+      const initial = mocks.variableInputProps?.converters?.resolveValueFromPath?.({
+        name: nodeName,
+        title: nodeName,
+        type: 'date',
+        paths: ['date', nodeName],
+      });
+
+      mocks.variableInputProps?.onChange?.(initial);
+
+      const stored = onChange.mock.calls[0]?.[0];
+      const parsed = parseCtxDateExpressionConfig(stored);
+      expect(parsed).toBeDefined();
+      expect(parsed?.format).toBe('YYYY-MM-DD');
+    },
+  );
+
+  it('uses a datetime default Format for Now and restores a custom Format without emitting a change', () => {
+    const onChange = renderInput({ isDateLikeField: false });
+    const initial = mocks.variableInputProps?.converters?.resolveValueFromPath?.({
+      name: 'now',
+      title: 'Now',
+      type: 'date',
+      paths: ['date', 'now'],
+    });
+
+    mocks.variableInputProps?.onChange?.(initial);
+    expect(parseCtxDateExpressionConfig(onChange.mock.calls[0]?.[0])?.format).toBe('YYYY-MM-DD HH:mm:ss');
+
+    const customExpression = serializeCtxDateExpressionConfig({
+      kind: 'preset',
+      preset: 'today',
+      format: 'YYYY/MM/DD',
+    });
+    if (!customExpression) throw new Error('Expected a formatted Date expression');
+    const customOnChange = renderInput({ value: customExpression, isDateLikeField: false });
+
+    mocks.variableInputProps?.onChange?.(mocks.variableInputProps.value);
+    expect(mocks.variableInputProps?.value).toMatchObject({ kind: 'preset', preset: 'today', format: 'YYYY/MM/DD' });
+    expect(customOnChange).not.toHaveBeenCalled();
+  });
+
+  it('does not add the default Format while restoring a legacy expression for a non-date field', () => {
+    const onChange = renderInput({ value: '{{ ctx.date.preset.today }}', isDateLikeField: false });
+
+    mocks.variableInputProps?.onChange?.(mocks.variableInputProps.value);
+
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  it('keeps date-like field expressions unformatted', () => {
+    const onChange = renderInput({ isDateLikeField: true });
+    const initial = mocks.variableInputProps?.converters?.resolveValueFromPath?.({
+      name: 'today',
+      title: 'Today',
+      type: 'date',
+      paths: ['date', 'today'],
+    });
+
+    mocks.variableInputProps?.onChange?.(initial);
+
+    expect(parseCtxDateExpressionConfig(onChange.mock.calls[0]?.[0])).toEqual({
+      kind: 'preset',
+      preset: 'today',
+    });
+
+    const formattedExpression = serializeCtxDateExpressionConfig({
+      kind: 'preset',
+      preset: 'today',
+      format: 'YYYY/MM/DD',
+    });
+    if (!formattedExpression) throw new Error('Expected a formatted Date expression');
+    const formattedOnChange = renderInput({ value: formattedExpression, isDateLikeField: true });
+
+    mocks.variableInputProps?.onChange?.(mocks.variableInputProps.value);
+    expect(mocks.variableInputProps?.value).toMatchObject({ kind: 'preset', preset: 'today', format: 'YYYY/MM/DD' });
+    expect(formattedOnChange).not.toHaveBeenCalled();
+  });
+
+  it('preserves spaces while editing a custom Format', () => {
+    const expression = serializeCtxDateExpressionConfig({
+      kind: 'preset',
+      preset: 'today',
+      format: 'YYYY-MM-DD',
+    });
+    if (!expression) throw new Error('Expected a formatted Date expression');
+    const onChange = renderInput({ value: expression, isDateLikeField: false });
+    const DateEditor = mocks.variableInputProps?.converters?.renderInputComponent?.({
+      name: 'today',
+      title: 'Today',
+      type: 'date',
+      paths: ['date', 'today'],
+    });
+    if (!DateEditor) throw new Error('Expected the Date editor');
+
+    render(<DateEditor value={mocks.variableInputProps?.value} onChange={mocks.variableInputProps?.onChange} />);
+    fireEvent.change(screen.getByRole('combobox', { name: 'Format' }), {
+      target: { value: 'YYYY-MM-DD ' },
+    });
+
+    expect(parseCtxDateExpressionConfig(onChange.mock.calls[0]?.[0])?.format).toBe('YYYY-MM-DD ');
+  });
+});
+
+describe('DateVariableEditor Format', () => {
+  it('stores date-only picker values without converting them to a timezone-dependent ISO instant', () => {
+    expect(serializeExactDatePickerValue(dayjs('2026-02-12'), false)).toBe('2026-02-12');
+    expect(serializeExactDatePickerValue([dayjs('2026-02-12'), dayjs('2026-02-20')], false)).toEqual([
+      '2026-02-12',
+      '2026-02-20',
+    ]);
+  });
+
+  it('shows Format for non-date fields', () => {
+    render(
+      <DateVariableEditor
+        value={{ kind: 'preset', preset: 'today' }}
+        isDateLikeField={false}
+        dateComponentProps={DEFAULT_DATE_VARIABLE_COMPONENT_PROPS}
+      />,
+    );
+
+    expect(screen.getByRole('combobox', { name: 'Format' })).toBeInTheDocument();
+    expect(screen.queryByRole('textbox', { name: 'Preview' })).not.toBeInTheDocument();
+  });
+
+  it('keeps the relative amount visible beside its fixed-width unit selector', () => {
+    render(
+      <DateVariableEditor
+        value={{ kind: 'relative', direction: 'next', amount: 1, unit: 'day' }}
+        isDateLikeField={false}
+        dateComponentProps={DEFAULT_DATE_VARIABLE_COMPONENT_PROPS}
+      />,
+    );
+
+    const amountInput = screen.getByRole('spinbutton', { name: 'Next' });
+    expect(amountInput).toHaveValue('1');
+    expect(amountInput.closest('.ant-input-number')).toHaveStyle({ minWidth: '80px' });
+    expect(screen.getByRole('combobox', { name: 'Unit' }).closest('.ant-select')).toHaveStyle({ flex: '0 0 130px' });
+  });
+
+  it('shows the default Format as a placeholder when a legacy expression has no Format', () => {
+    render(
+      <DateVariableEditor
+        value={{ kind: 'preset', preset: 'now' }}
+        isDateLikeField={false}
+        dateComponentProps={DEFAULT_DATE_VARIABLE_COMPONENT_PROPS}
+      />,
+    );
+
+    const formatInput = screen.getByRole('combobox', { name: 'Format' });
+    expect(formatInput).toHaveValue('');
+    expect(screen.getByText('YYYY-MM-DD HH:mm:ss')).toHaveClass('ant-select-selection-placeholder');
+  });
+
+  it('hides Format for date-like fields', () => {
+    render(
+      <DateVariableEditor
+        value={{ kind: 'preset', preset: 'today' }}
+        isDateLikeField
+        dateComponentProps={DEFAULT_DATE_VARIABLE_COMPONENT_PROPS}
+      />,
+    );
+
+    expect(screen.queryByRole('combobox', { name: 'Format' })).not.toBeInTheDocument();
+  });
+});
+
+describe('date-like field detection', () => {
+  it('treats dateOnly interface and type as pure date fields', () => {
+    expect(isDateLikeField({ interface: 'dateOnly' })).toBe(true);
+    expect(isDateLikeField({ type: 'dateOnly' })).toBe(true);
+    expect(resolveDateVariableComponentProps({ interface: 'dateOnly' })).toMatchObject({
+      showTime: false,
+      exactNormalizeMode: 'date',
+    });
+    expect(resolveDateVariableComponentProps({ type: 'dateOnly' })).toMatchObject({
+      showTime: false,
+      exactNormalizeMode: 'date',
+    });
+    expect(
+      resolveDateVariableComponentProps({
+        interface: 'dateOnly',
+        getComponentProps: () => ({ showTime: true, format: 'YYYY-MM-DD HH:mm:ss' }),
+      }),
+    ).toMatchObject({
+      showTime: false,
+      format: 'YYYY-MM-DD',
+      exactNormalizeMode: 'date',
+    });
+  });
+
+  it('uses the resolved fallback interface when the preferred field metadata omits it', () => {
+    expect(isDateLikeField({}, 'scheduledAt', 'datetime')).toBe(true);
+  });
+});

package/src/flow/components/field-value-variable/dateValue.ts

@@ -0,0 +1,223 @@
+/**
+ * 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 { isCtxDateExpression, isRunJSValue, isVariableExpression, serializeCtxDateValue } from '@nocobase/flow-engine';
+import { dayjs } from '@nocobase/utils/client';
+import type { ExactDatePickerMode } from '../FieldAssignExactDatePicker';
+
+const DATE_FIELD_INTERFACES = new Set([
+  'date',
+  'dateOnly',
+  'datetime',
+  'datetimeNoTz',
+  'createdAt',
+  'updatedAt',
+  'unixTimestamp',
+]);
+const TZ_AWARE_DATE_INTERFACES = new Set(['datetime', 'createdAt', 'updatedAt', 'unixTimestamp']);
+const DATE_ONLY_OUTPUT_FORMAT = 'YYYY-MM-DD';
+const DATETIME_NO_TZ_OUTPUT_FORMAT = 'YYYY-MM-DD HH:mm:ss';
+
+type DateFieldLike = {
+  interface?: unknown;
+  type?: unknown;
+  getComponentProps?: () => unknown;
+  uiSchema?: Record<string, unknown>;
+};
+
+export type DateVariableExactNormalizeMode = 'none' | 'date' | 'datetimeNoTz' | 'iso';
+
+export type DateVariableComponentProps = {
+  picker: ExactDatePickerMode;
+  showTime: boolean;
+  timeFormat: string;
+  format: string;
+  exactNormalizeMode: DateVariableExactNormalizeMode;
+};
+
+export const DEFAULT_DATE_VARIABLE_COMPONENT_PROPS: DateVariableComponentProps = {
+  picker: 'date',
+  showTime: false,
+  timeFormat: 'HH:mm:ss',
+  format: DATE_ONLY_OUTPUT_FORMAT,
+  exactNormalizeMode: 'none',
+};
+
+export function getFieldInterface(field: DateFieldLike | null | undefined): string {
+  return typeof field?.interface === 'string' ? field.interface : '';
+}
+
+function getFieldComponentProps(field: DateFieldLike | null | undefined): Record<string, unknown> {
+  const fromGetter = typeof field?.getComponentProps === 'function' ? field.getComponentProps() : undefined;
+  if (fromGetter && typeof fromGetter === 'object' && !Array.isArray(fromGetter)) {
+    return fromGetter as Record<string, unknown>;
+  }
+  const fromSchema = field?.uiSchema?.['x-component-props'];
+  return fromSchema && typeof fromSchema === 'object' && !Array.isArray(fromSchema)
+    ? (fromSchema as Record<string, unknown>)
+    : {};
+}
+
+function normalizeExactDatePickerMode(value: unknown): ExactDatePickerMode {
+  if (value === 'year' || value === 'quarter' || value === 'month' || value === 'date') {
+    return value;
+  }
+  return 'date';
+}
+
+function getDateVariableExactNormalizeMode(
+  fieldInterface: string,
+  field: DateFieldLike | null | undefined,
+): DateVariableExactNormalizeMode {
+  if (fieldInterface === 'date' || fieldInterface === 'dateOnly' || field?.type === 'dateOnly') return 'date';
+  if (fieldInterface === 'datetimeNoTz') return 'datetimeNoTz';
+  if (TZ_AWARE_DATE_INTERFACES.has(fieldInterface)) return 'iso';
+  return 'none';
+}
+
+export function isDateLikeField(
+  field: DateFieldLike | null | undefined,
+  fallbackFieldName?: string,
+  fallbackFieldInterface?: string,
+): boolean {
+  const fieldInterface = getFieldInterface(field) || fallbackFieldInterface || '';
+  if (DATE_FIELD_INTERFACES.has(fieldInterface) || field?.type === 'dateOnly') return true;
+  return fallbackFieldName === 'createdAt' || fallbackFieldName === 'updatedAt';
+}
+
+export function resolveDateVariableComponentProps(
+  field: DateFieldLike | null | undefined,
+  fieldInterface = getFieldInterface(field),
+): DateVariableComponentProps {
+  const componentProps = getFieldComponentProps(field);
+  const picker = normalizeExactDatePickerMode(componentProps.picker);
+  const isDateOnly = fieldInterface === 'date' || fieldInterface === 'dateOnly' || field?.type === 'dateOnly';
+  const inferredShowTime = ['datetime', 'datetimeNoTz', 'createdAt', 'updatedAt', 'unixTimestamp'].includes(
+    fieldInterface,
+  );
+  const showTime = isDateOnly
+    ? false
+    : typeof componentProps.showTime === 'boolean'
+      ? componentProps.showTime
+      : inferredShowTime;
+  const configuredFormat = typeof componentProps.format === 'string' ? componentProps.format : '';
+  const dateFormat =
+    typeof componentProps.dateFormat === 'string' && componentProps.dateFormat
+      ? componentProps.dateFormat
+      : configuredFormat.split(' ')[0] || DATE_ONLY_OUTPUT_FORMAT;
+  const timeFormat =
+    typeof componentProps.timeFormat === 'string' && componentProps.timeFormat ? componentProps.timeFormat : 'HH:mm:ss';
+  const format = isDateOnly ? dateFormat : configuredFormat || (showTime ? `${dateFormat} ${timeFormat}` : dateFormat);
+
+  return {
+    picker,
+    showTime,
+    timeFormat,
+    format,
+    exactNormalizeMode: getDateVariableExactNormalizeMode(fieldInterface, field),
+  };
+}
+
+function parseDateByFormat(value: string, format: string): dayjs.Dayjs | null {
+  const raw = String(value || '').trim();
+  if (!raw) return null;
+
+  const hasTimezone = /(?:Z|[+-]\d{2}:\d{2})$/i.test(raw);
+  if (hasTimezone) {
+    const parsed = dayjs(raw);
+    if (parsed.isValid()) return parsed;
+  }
+
+  if (format) {
+    const strict = dayjs(raw, format, true);
+    if (strict.isValid()) return strict;
+  }
+
+  const fallback = dayjs(raw);
+  if (fallback.isValid()) return fallback;
+
+  if (format) {
+    const loose = dayjs(raw, format);
+    if (loose.isValid()) return loose;
+  }
+
+  return null;
+}
+
+function parseDateFromRawValue(value: unknown, format: string): dayjs.Dayjs | null {
+  if (dayjs.isDayjs(value)) return value;
+  if (value instanceof Date) {
+    const parsedDate = dayjs(value);
+    return parsedDate.isValid() ? parsedDate : null;
+  }
+  return typeof value === 'string' ? parseDateByFormat(value, format) : null;
+}
+
+function normalizeExactDateValue(
+  value: unknown,
+  options: Pick<DateVariableComponentProps, 'format' | 'showTime' | 'exactNormalizeMode'>,
+): unknown {
+  const parsed = parseDateFromRawValue(value, options.format);
+  if (!parsed?.isValid()) return value;
+
+  switch (options.exactNormalizeMode) {
+    case 'date':
+      return parsed.format(DATE_ONLY_OUTPUT_FORMAT);
+    case 'datetimeNoTz':
+      return parsed.format(options.showTime ? DATETIME_NO_TZ_OUTPUT_FORMAT : DATE_ONLY_OUTPUT_FORMAT);
+    case 'iso':
+      return parsed.toISOString();
+    default:
+      return value;
+  }
+}
+
+export function normalizeDateVariableExactValue(
+  rawValue: unknown,
+  options: Pick<DateVariableComponentProps, 'format' | 'showTime' | 'exactNormalizeMode'>,
+): unknown {
+  if (options.exactNormalizeMode === 'none') return rawValue;
+  if (typeof rawValue === 'string' || dayjs.isDayjs(rawValue) || rawValue instanceof Date) {
+    return normalizeExactDateValue(rawValue, options);
+  }
+  if (Array.isArray(rawValue)) {
+    return rawValue.map((item) => {
+      if (typeof item === 'string' || dayjs.isDayjs(item) || item instanceof Date) {
+        return normalizeExactDateValue(item, options);
+      }
+      return item;
+    });
+  }
+  return rawValue;
+}
+
+export function toExactPickerDisplayValue(
+  rawValue: unknown,
+  options: { format: string; isRange: boolean },
+): dayjs.Dayjs | [dayjs.Dayjs, dayjs.Dayjs] | null {
+  if (options.isRange) {
+    if (!Array.isArray(rawValue)) return null;
+    const left = parseDateFromRawValue(rawValue[0], options.format);
+    const right = parseDateFromRawValue(rawValue[1], options.format);
+    return left && right ? [left, right] : null;
+  }
+  return parseDateFromRawValue(rawValue, options.format);
+}
+
+/** Compatibility helper retained for existing callers and tests. */
+export function normalizeDateVariableOutput(rawValue: unknown, options: DateVariableComponentProps): unknown {
+  if (rawValue === null || isRunJSValue(rawValue)) return rawValue;
+  if (typeof rawValue === 'string' && isVariableExpression(rawValue) && !isCtxDateExpression(rawValue)) {
+    return rawValue;
+  }
+  if (rawValue === '' || typeof rawValue === 'undefined') return '';
+
+  const normalized = normalizeDateVariableExactValue(rawValue, options);
+  return serializeCtxDateValue(normalized) || normalized;
+}

package/src/flow/components/field-value-variable/index.ts

@@ -0,0 +1,12 @@
+/**
+ * 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.
+ */
+
+export * from './dateValue';
+export * from './DateVariableEditor';
+export * from './FieldValueVariableInput';

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

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