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

package/src/flow/models/base/__tests__/BlockGridModel.selectSceneActivation.test.ts

@@ -0,0 +1,124 @@
+/**
+ * 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 { FlowEngine, type FlowModelContext, MultiRecordResource, VIEW_ACTIVATED_EVENT } from '@nocobase/flow-engine';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { BlockGridModel } from '../BlockGridModel';
+import { CollectionBlockModel } from '../CollectionBlockModel';
+
+class TestBlockGridModel extends BlockGridModel {
+  mountForTest() {
+    super.onMount();
+  }
+
+  unmountForTest() {
+    super.onUnmount();
+  }
+}
+
+class TestMultiRecordResource extends MultiRecordResource<Record<string, unknown>> {
+  refreshCalls = 0;
+
+  override async refresh(): Promise<void> {
+    this.refreshCalls += 1;
+    this.emit('refresh');
+  }
+}
+
+class TestCollectionBlockModel extends CollectionBlockModel {
+  createResource(ctx: FlowModelContext) {
+    return ctx.createResource(TestMultiRecordResource);
+  }
+
+  mountForTest() {
+    super.onMount();
+  }
+}
+
+describe('BlockGridModel - select scene activation', () => {
+  let engine: FlowEngine;
+
+  beforeEach(() => {
+    engine = new FlowEngine();
+    engine.context.defineProperty('location', { value: { search: '' } });
+    engine.registerModels({ TestBlockGridModel, TestCollectionBlockModel });
+
+    engine.dataSourceManager.getDataSource('main').addCollection({
+      name: 'roles',
+      filterTargetKey: 'id',
+      fields: [
+        { name: 'id', type: 'integer', interface: 'number' },
+        { name: 'name', type: 'string', interface: 'input' },
+      ],
+    });
+  });
+
+  function createModels(scene = 'select') {
+    engine.context.defineProperty('view', { value: { inputArgs: { scene } } });
+    const grid = engine.createModel<TestBlockGridModel>({ use: 'TestBlockGridModel' });
+    const block = grid.addSubModel<TestCollectionBlockModel>('items', {
+      use: 'TestCollectionBlockModel',
+      stepParams: {
+        resourceSettings: {
+          init: {
+            dataSourceKey: 'main',
+            collectionName: 'roles',
+          },
+        },
+      },
+    });
+    const resource = block.context.resource as TestMultiRecordResource;
+
+    block.mountForTest();
+    grid.mountForTest();
+    return { grid, resource };
+  }
+
+  it('refreshes dirty collection blocks once when a nested view closes', async () => {
+    const { grid, resource } = createModels();
+
+    engine.markDataSourceDirty('main', 'roles');
+    engine.emitter.emit(VIEW_ACTIVATED_EVENT);
+    await Promise.resolve();
+
+    expect(resource.refreshCalls).toBe(1);
+
+    engine.emitter.emit(VIEW_ACTIVATED_EVENT);
+    await Promise.resolve();
+
+    expect(resource.refreshCalls).toBe(1);
+    grid.unmountForTest();
+  });
+
+  it('does not refresh without dirty data or after the grid unmounts', async () => {
+    const { grid, resource } = createModels();
+
+    engine.emitter.emit(VIEW_ACTIVATED_EVENT);
+    await Promise.resolve();
+    expect(resource.refreshCalls).toBe(0);
+
+    grid.unmountForTest();
+    engine.markDataSourceDirty('main', 'roles');
+    engine.emitter.emit(VIEW_ACTIVATED_EVENT);
+    await Promise.resolve();
+
+    expect(resource.refreshCalls).toBe(0);
+  });
+
+  it('does not handle activation outside the select scene', async () => {
+    const { grid, resource } = createModels('list');
+
+    engine.markDataSourceDirty('main', 'roles');
+    engine.emitter.emit(VIEW_ACTIVATED_EVENT);
+    await Promise.resolve();
+
+    expect(resource.refreshCalls).toBe(0);
+    grid.unmountForTest();
+  });
+});

package/src/flow/models/base/__tests__/CollectionBlockModel.addAppends.test.ts

@@ -0,0 +1,41 @@
+/**
+ * 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 { FlowEngine, FlowModelContext, MultiRecordResource } from '@nocobase/flow-engine';
+import { describe, expect, it } from 'vitest';
+import { CollectionBlockModel } from '../CollectionBlockModel';
+
+class AddAppendsCollectionBlockModel extends CollectionBlockModel {
+  createResource(ctx: FlowModelContext) {
+    return ctx.createResource(MultiRecordResource);
+  }
+}
+
+describe('CollectionBlockModel addAppends', () => {
+  it('does not throw for a nested field path when the collection is unavailable', () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ AddAppendsCollectionBlockModel });
+
+    const model = engine.createModel<AddAppendsCollectionBlockModel>({
+      uid: 'missing-collection-add-appends-block',
+      use: 'AddAppendsCollectionBlockModel',
+      stepParams: {
+        resourceSettings: {
+          init: {
+            dataSourceKey: 'main',
+            collectionName: 'missing_collection',
+          },
+        },
+      },
+    });
+
+    expect(model.collection).toBeUndefined();
+    expect(() => model.addAppends('createdBy.departments')).not.toThrow();
+  });
+});

package/src/flow/models/base/__tests__/CollectionBlockModel.initialBeforeRenderRefresh.test.ts

@@ -7,9 +7,10 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { FlowEngine, MultiRecordResource } from '@nocobase/flow-engine';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { FlowEngine, FlowRuntimeContext, MultiRecordResource, ResourceError } from '@nocobase/flow-engine';
 import '../../../index';
+import { BlockResourceErrorPlaceholder } from '../../../components/placeholders/BlockPlaceholder';
 import { CollectionBlockModel } from '../CollectionBlockModel';
 import { dataLoadingMode } from '../../../actions/dataLoadingMode';
 
@@ -19,13 +20,16 @@ class InitialBeforeRenderTestBlockModel extends CollectionBlockModel {
   }
 }
 
-function setupModel() {
+function setupModel(dataSourceKey = 'main') {
   const engine = new FlowEngine();
   engine.context.defineProperty('location', { value: { search: '' } as any });
   engine.registerActions({ dataLoadingMode });
   engine.registerModels({ InitialBeforeRenderTestBlockModel });
 
-  const ds = engine.dataSourceManager.getDataSource('main');
+  if (!engine.dataSourceManager.getDataSource(dataSourceKey)) {
+    engine.dataSourceManager.addDataSource({ key: dataSourceKey });
+  }
+  const ds = engine.dataSourceManager.getDataSource(dataSourceKey);
   ds.addCollection({
     name: 'users',
     filterTargetKey: 'id',
@@ -41,7 +45,7 @@ function setupModel() {
     stepParams: {
       resourceSettings: {
         init: {
-          dataSourceKey: 'main',
+          dataSourceKey,
           collectionName: 'users',
         },
       },
@@ -88,16 +92,21 @@ function setupModelWithManualMode() {
   return { model, resource: model.resource as MultiRecordResource };
 }
 
-describe('CollectionBlockModel initial beforeRender refresh', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
+async function runRefreshStep(model: InitialBeforeRenderTestBlockModel) {
+  const handler = model.getFlow('refreshSettings')?.getStep('refresh')?.serialize().handler;
+  if (!handler) {
+    throw new Error('refreshSettings.refresh handler is not registered');
+  }
+  await handler(new FlowRuntimeContext(model, 'refreshSettings'), {});
+}
 
+describe('CollectionBlockModel initial beforeRender refresh', () => {
   afterEach(() => {
     vi.useRealTimers();
   });
 
   it('only performs one actual data request on first beforeRender', async () => {
+    vi.useFakeTimers();
     const { model, resource } = setupModel();
     const runActionSpy = vi.spyOn(resource, 'runAction').mockResolvedValue({
       data: [{ id: 1, name: 'Alice' }],
@@ -112,7 +121,54 @@ describe('CollectionBlockModel initial beforeRender refresh', () => {
     expect(runActionSpy).toHaveBeenCalledTimes(1);
   });
 
+  it('keeps resource request failures in the block error state', async () => {
+    const { model, resource } = setupModel('external');
+    const resourceError = new ResourceError({
+      response: {
+        data: {
+          errors: [{ code: 'DATA_SOURCE_UNAVAILABLE', message: 'Data source unavailable' }],
+        },
+      },
+    });
+    vi.spyOn(resource, 'refresh').mockImplementation(async () => {
+      resource.setError(resourceError);
+      throw resourceError;
+    });
+
+    await runRefreshStep(model);
+
+    expect(resource.getError()).toBe(resourceError);
+    expect(CollectionBlockModel.prototype.render.call(model)).toMatchObject({
+      type: BlockResourceErrorPlaceholder,
+    });
+  });
+
+  it('continues to throw resource request failures from the main data source', async () => {
+    const { model, resource } = setupModel();
+    const resourceError = new ResourceError({
+      response: {
+        data: {
+          errors: [{ code: 'UNKNOWN_ERROR', message: 'Main data source failed' }],
+        },
+      },
+    });
+    vi.spyOn(resource, 'refresh').mockImplementation(async () => {
+      resource.setError(resourceError);
+      throw resourceError;
+    });
+
+    await expect(runRefreshStep(model)).rejects.toBe(resourceError);
+  });
+
+  it('continues to throw non-resource errors from beforeRender', async () => {
+    const { model, resource } = setupModel('external');
+    vi.spyOn(resource, 'refresh').mockRejectedValue(new Error('beforeRender bug'));
+
+    await expect(runRefreshStep(model)).rejects.toThrow('beforeRender bug');
+  });
+
   it('respects saved manual mode and skips initial request when filters are empty', async () => {
+    vi.useFakeTimers();
     const { model, resource } = setupModelWithManualMode();
     const runActionSpy = vi.spyOn(resource, 'runAction').mockResolvedValue({
       data: [{ id: 1, name: 'Alice' }],
@@ -128,4 +184,64 @@ describe('CollectionBlockModel initial beforeRender refresh', () => {
     expect(resource.getData()).toEqual([]);
     expect(resource.getMeta('count')).toBe(0);
   });
+
+  it('skips forced active refresh in manual mode when filters are empty', async () => {
+    const { model, resource } = setupModelWithManualMode();
+    const refreshSpy = vi.spyOn(resource, 'refresh');
+
+    resource.setData([{ id: 2, name: 'Stale' }]);
+    resource.setMeta({ count: 1, hasNext: true });
+    resource.setPage(2);
+    resource.loading = true;
+
+    model.onActive(true);
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(refreshSpy).not.toHaveBeenCalled();
+    expect(resource.getData()).toEqual([]);
+    expect(resource.getMeta('count')).toBe(0);
+    expect(resource.getMeta('hasNext')).toBe(false);
+    expect(resource.getMeta('page')).toBe(1);
+    expect(resource.getRequestParameter('page')).toBe(1);
+    expect(resource.loading).toBe(false);
+  });
+
+  it('keeps forced active refresh in manual mode when filters are active', async () => {
+    const { model, resource } = setupModelWithManualMode();
+    const refreshSpy = vi.spyOn(resource, 'refresh').mockResolvedValue();
+
+    resource.setData([{ id: 2, name: 'Stale' }]);
+    resource.setMeta({ count: 1, hasNext: true, page: 2 });
+    model.setFilterActive('filter-form-item', true);
+
+    model.onActive(true);
+    await Promise.resolve();
+
+    expect(refreshSpy).toHaveBeenCalledTimes(1);
+    expect(resource.getData()).toEqual([{ id: 2, name: 'Stale' }]);
+    expect(resource.getMeta('count')).toBe(1);
+  });
+
+  it('skips forced active refresh in manual mode when only resource filters are active', async () => {
+    const { model, resource } = setupModelWithManualMode();
+    const refreshSpy = vi.spyOn(resource, 'refresh');
+
+    resource.setData([{ id: 2, name: 'Stale' }]);
+    resource.setMeta({ count: 1, hasNext: true });
+    resource.setPage(2);
+    resource.loading = true;
+    resource.addFilterGroup('data-scope', { status: { $eq: 'active' } });
+
+    model.onActive(true);
+    await Promise.resolve();
+
+    expect(refreshSpy).not.toHaveBeenCalled();
+    expect(resource.getData()).toEqual([]);
+    expect(resource.getMeta('count')).toBe(0);
+    expect(resource.getMeta('hasNext')).toBe(false);
+    expect(resource.getMeta('page')).toBe(1);
+    expect(resource.getRequestParameter('page')).toBe(1);
+    expect(resource.loading).toBe(false);
+  });
 });

package/src/flow/models/blocks/assign-form/AssignFormItemModel.tsx

@@ -10,23 +10,20 @@
 import React from 'react';
 import { Input } from 'antd';
 import { define, observable } from '@formily/reactive';
-import {
-  FlowModelRenderer,
-  FormItem,
-  VariableInput,
-  tExpr,
-  isVariableExpression,
-  parseValueToPath,
-  isRunJSValue,
-  EditableItemModel,
-  jioToJoiSchema,
-} from '@nocobase/flow-engine';
+import { FlowModelRenderer, FormItem, tExpr, EditableItemModel, jioToJoiSchema } from '@nocobase/flow-engine';
 // 无需类型导入（避免未使用的类型）
 import { FormItemModel } from '../form/FormItemModel';
 import { EditFormModel } from '../form/EditFormModel';
 import { customAlphabet as Alphabet } from 'nanoid';
 import { ensureOptionsFromUiSchemaEnumIfAbsent } from '../../../internal/utils/enumOptionsUtils';
 import { RunJSValueEditor } from '../../../components/RunJSValueEditor';
+import {
+  DEFAULT_DATE_VARIABLE_COMPONENT_PROPS,
+  FieldValueVariableInput,
+  getFieldInterface,
+  isDateLikeField,
+  resolveDateVariableComponentProps,
+} from '../../../components/field-value-variable';
 
 type AssignFormTempOriginField = {
   uid?: string;
@@ -285,7 +282,9 @@ export class AssignFormItemModel extends FormItemModel {
         ) : null;
       };
 
-      const NullComponent: React.FC = () => <Input placeholder={'<Null>'} readOnly style={{ width: '100%' }} />;
+      const NullComponent: React.FC = () => (
+        <Input placeholder={`<${this.context.t?.('Null') ?? 'Null'}>`} readOnly style={{ width: '100%' }} />
+      );
 
       const RunJSComponent: React.FC<any> = (inputProps: any) => {
         return (
@@ -298,46 +297,18 @@ export class AssignFormItemModel extends FormItemModel {
         );
       };
 
-      const converters = {
-        renderInputComponent: (meta: any) => {
-          const firstPath = meta?.paths?.[0];
-          if (firstPath === 'constant') return ConstantValueEditor as any;
-          if (firstPath === 'null') return NullComponent as any;
-          if (firstPath === 'runjs') return RunJSComponent as any;
-          return undefined;
-        },
-        resolveValueFromPath: (item: any) => {
-          const firstPath = item?.paths?.[0];
-          if (firstPath === 'constant') return '';
-          if (firstPath === 'null') return null;
-          if (firstPath === 'runjs') return { code: '', version: 'v2' };
-          return undefined;
-        },
-        resolvePathFromValue: (currentValue: any) => {
-          if (currentValue === null) return ['null'];
-          if (isRunJSValue(currentValue)) return ['runjs'];
-          return isVariableExpression(currentValue) ? parseValueToPath(currentValue) : ['constant'];
-        },
-      } as any;
-
-      // 合并变量树：在最前面追加“常量/空值”两个选项
-      const mergedMetaTree = async () => {
+      const baseMetaTree = async () => {
         const getTree = (this.context as any)?.getPropertyMetaTree;
-        const base: any[] = typeof getTree === 'function' ? await getTree() : [];
-        return [
-          {
-            title: tExpr('Constant'),
-            name: 'constant',
-            type: 'string',
-            paths: ['constant'],
-            render: ConstantValueEditor,
-          },
-          { title: tExpr('Null'), name: 'null', type: 'object', paths: ['null'], render: NullComponent },
-          { title: tExpr('RunJS'), name: 'runjs', type: 'object', paths: ['runjs'], render: RunJSComponent },
-          ...base,
-        ];
+        return typeof getTree === 'function' ? await getTree() : [];
       };
 
+      const targetCollectionField = collection?.getField?.(this.fieldPath);
+      const targetFieldInterface = getFieldInterface(targetCollectionField);
+      const dateLike = isDateLikeField(targetCollectionField, this.fieldPath?.split('.').slice(-1)[0]);
+      const dateComponentProps = dateLike
+        ? resolveDateVariableComponentProps(targetCollectionField, targetFieldInterface)
+        : DEFAULT_DATE_VARIABLE_COMPONENT_PROPS;
+
       // 计算 label：优先使用配置中的 label，其次集合字段标题，最后回退字段路径
       let labelText = this.props?.label ?? this.fieldPath ?? '';
       const cf = collection?.getField?.(this.fieldPath);
@@ -357,14 +328,18 @@ export class AssignFormItemModel extends FormItemModel {
             const formValue = formBindingProps?.__assign_value__;
             const mergedValue = typeof formValue === 'undefined' ? this.assignValue : formValue;
             return (
-              <VariableInput
+              <FieldValueVariableInput
                 value={mergedValue}
-                onChange={(v: any) => {
+                onChange={(v) => {
                   this.assignValue = v;
                   formBindingProps?.__assign_trigger__?.(v);
                 }}
-                metaTree={mergedMetaTree}
-                converters={converters}
+                baseMetaTree={baseMetaTree}
+                constantComponent={ConstantValueEditor}
+                nullComponent={NullComponent}
+                runJSComponent={RunJSComponent}
+                isDateLikeField={dateLike}
+                dateComponentProps={dateComponentProps}
                 clearValue={''}
               />
             );

package/src/flow/models/blocks/details/DetailsBlockModel.tsx

@@ -20,6 +20,7 @@ import {
   SingleRecordResource,
   createCurrentRecordMetaFactory,
   createRecordResolveOnServerWithLocal,
+  observer,
   tExpr,
 } from '@nocobase/flow-engine';
 import { Pagination, Space } from 'antd';
@@ -154,8 +155,8 @@ export class DetailsBlockModel extends CollectionBlockModel<{
           simple
           pageSize={1}
           showSizeChanger={false}
-          defaultCurrent={resource.getPage()}
-          total={resource.getTotalPage()}
+          current={resource.getPage()}
+          total={resource.getCount()}
           onChange={this.handlePageChange}
           style={{ display: 'inline-block' }}
         />
@@ -226,6 +227,8 @@ export class DetailsBlockModel extends CollectionBlockModel<{
   }
 }
 
+export const DetailsPagination = observer(({ model }: { model: DetailsBlockModel }) => model.renderPagination());
+
 const DetailsBlockContent = ({
   model,
   gridModel,
@@ -297,7 +300,9 @@ const DetailsBlockContent = ({
           model={gridModel}
           showFlowSettings={false}
         />
-        <div ref={paginationRef}>{model.renderPagination()}</div>
+        <div ref={paginationRef}>
+          <DetailsPagination model={model} />
+        </div>
       </div>
     </FormComponent>
   );

package/src/flow/models/blocks/details/__tests__/DetailsBlockModel.initialPaginationChangeRefresh.test.ts

@@ -7,10 +7,12 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
+import { act, render, screen } from '@testing-library/react';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { FlowEngine, MultiRecordResource, SingleRecordResource } from '@nocobase/flow-engine';
+import React from 'react';
 import '../../../../index';
-import { DetailsBlockModel } from '../DetailsBlockModel';
+import { DetailsBlockModel, DetailsPagination } from '../DetailsBlockModel';
 import { DetailsGridModel } from '../DetailsGridModel';
 
 function setupDetailsBlockModel(options?: { filterByTk?: string | number }) {
@@ -93,6 +95,35 @@ describe('DetailsBlockModel initial pagination refresh', () => {
     expect(dispatchSpy.mock.calls.filter(([eventName]) => eventName === 'paginationChange')).toHaveLength(1);
   });
 
+  it('renders pagination from the current count and page after filtering', () => {
+    const { model, resource } = setupDetailsBlockModel();
+    resource.setData([{ id: 3, name: 'CC', title: 'filtered' }] as any);
+    resource.setMeta({ count: 7, page: 3, pageSize: 1, totalPage: 20 });
+
+    const paginationContainer = model.renderPagination() as any;
+    const pagination = paginationContainer.props.children;
+
+    expect(pagination.props.total).toBe(7);
+    expect(pagination.props.current).toBe(3);
+    expect(pagination.props.defaultCurrent).toBeUndefined();
+  });
+
+  it('updates the rendered pagination when filtering changes only resource metadata', () => {
+    const { model, resource } = setupDetailsBlockModel();
+    resource.setData([{ id: 1, name: 'AA', title: 'foo' }] as any);
+    resource.setMeta({ count: 7, page: 1, pageSize: 1, totalPage: 7 });
+
+    render(React.createElement(DetailsPagination, { model }));
+
+    expect(screen.getByRole('list')).toBeInTheDocument();
+
+    act(() => {
+      resource.setMeta({ count: 1, page: 1, pageSize: 1, totalPage: 1 });
+    });
+
+    expect(screen.queryByRole('list')).not.toBeInTheDocument();
+  });
+
   it('uses a real single-record details model and does not emit root paginationChange on initial render', async () => {
     const { model, resource } = setupDetailsBlockModel({ filterByTk: 1 });
     expect(resource).toBeInstanceOf(SingleRecordResource);

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

@@ -15,8 +15,10 @@ import {
   DndProvider,
   DragHandler,
   Droppable,
+  isCtxDateExpression,
   isRunJSValue,
   normalizeRunJSValue,
+  parseCtxDateExpression,
   tExpr,
   FlowModelRenderer,
   FlowSettingsButton,
@@ -44,6 +46,15 @@ import { normalizeFilterValueByOperator } from './valueNormalization';
 
 const RELATION_FIELD_TYPES = ['belongsTo', 'hasOne', 'hasMany', 'belongsToMany', 'belongsToArray'];
 const NUMERIC_FIELD_TYPES = ['integer', 'float', 'double', 'decimal'];
+const DATE_FILTER_OPERATORS = new Set([
+  '$dateOn',
+  '$dateNotOn',
+  '$dateBefore',
+  '$dateAfter',
+  '$dateNotBefore',
+  '$dateNotAfter',
+  '$dateBetween',
+]);
 
 function getFilterFormFieldMetaType(field: CollectionField) {
   if (RELATION_FIELD_TYPES.includes(field.type)) {
@@ -66,6 +77,14 @@ function getFilterFormFieldMetaType(field: CollectionField) {
   }
 }
 
+function parseDateFilterDefaultValue(operator: string | undefined, rawValue: unknown) {
+  if (!operator || !DATE_FILTER_OPERATORS.has(operator) || !isCtxDateExpression(rawValue)) {
+    return undefined;
+  }
+
+  return parseCtxDateExpression(rawValue);
+}
+
 function shouldShowFilterFormFieldMeta(field: CollectionField) {
   return Boolean(field?.interface);
 }
@@ -489,7 +508,7 @@ export class FilterFormBlockModel extends FilterBlockModel<{
     const rules = (params?.value || []) as any[];
     if (!Array.isArray(rules) || rules.length === 0) return appliedValues;
 
-    const resolveValue = async (raw: any) => {
+    const resolveValue = async (raw: any, operator?: string) => {
       // RunJS support
       if (isRunJSValue(raw)) {
         const { code, version } = normalizeRunJSValue(raw);
@@ -497,6 +516,11 @@ export class FilterFormBlockModel extends FilterBlockModel<{
         return ret?.success ? ret.value : undefined;
       }
 
+      const parsedDateFilterValue = parseDateFilterDefaultValue(operator, raw);
+      if (typeof parsedDateFilterValue !== 'undefined') {
+        return parsedDateFilterValue;
+      }
+
       return await (this.context as any).resolveJsonTemplate?.(raw);
     };
 
@@ -520,11 +544,11 @@ export class FilterFormBlockModel extends FilterBlockModel<{
 
       const current = (form as any).getFieldValue?.(name);
 
-      const resolved = await resolveValue(rule.value);
+      const operator = getDefaultOperator(itemModel as any);
+      const resolved = await resolveValue(rule.value, operator);
       if (options?.refreshSeq && options.refreshSeq !== this.defaultValuesRefreshSeq) return appliedValues;
       if (typeof resolved === 'undefined') continue;
 
-      const operator = getDefaultOperator(itemModel as any);
       const normalized = normalizeFilterValueByOperator(operator, resolved);
       const mode = this.normalizeFieldValueMode(rule.mode);
       if (mode === 'default' && !this.canApplyFormDefaultValue(String(name), current, force)) continue;