@nocobase/client-v2 2.1.0-alpha.34 → 2.1.0-alpha.35

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

@@ -8,10 +8,31 @@
  */
 
 import { describe, expect, it, vi } from 'vitest';
+import { FlowEngine, MultiRecordResource } from '@nocobase/flow-engine';
 import { dataScope } from '../dataScope';
 import { normalizeDataScopeFilter } from '../dataScopeFilter';
 import { setTargetDataScope } from '../setTargetDataScope';
 
+function createSetTargetDataScopeContext(resource: any, options: { selected?: boolean; resolvedValue?: any } = {}) {
+  const targetModel = { resource };
+  const inputArgs = options.selected === undefined ? undefined : { selected: options.selected };
+
+  return {
+    ...(inputArgs ? { inputArgs } : {}),
+    model: {
+      uid: 'action-1',
+      scheduleModelOperation: vi.fn((_uid, callback) => callback(targetModel)),
+    },
+    resolveJsonTemplate: vi.fn(async (template) => ({
+      ...template,
+      filter: {
+        ...template.filter,
+        items: [{ ...template.filter.items[0], value: options.resolvedValue }],
+      },
+    })),
+  };
+}
+
 describe('normalizeDataScopeFilter', () => {
   it('keeps null when a right-side variable resolves to empty', () => {
     const rawFilter = {
@@ -125,34 +146,92 @@ describe('normalizeDataScopeFilter', () => {
       hasData: vi.fn(() => false),
       refresh: vi.fn(),
     };
-    const targetModel = { resource };
-    const ctx = {
-      model: {
-        uid: 'action-1',
-        scheduleModelOperation: vi.fn((_uid, callback) => callback(targetModel)),
+    const ctx = createSetTargetDataScopeContext(resource);
+    const params = {
+      targetBlockUid: 'target-1',
+      filter: {
+        logic: '$and',
+        items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.formValues.department.id }}' }],
       },
-      resolveJsonTemplate: vi.fn(async (template) => ({
-        ...template,
-        filter: {
-          ...template.filter,
-          items: [{ ...template.filter.items[0], value: undefined }],
-        },
-      })),
     };
+
+    await (setTargetDataScope as any).handler(ctx, params);
+
+    expect(ctx.model.scheduleModelOperation).toHaveBeenCalledWith('target-1', expect.any(Function));
+    expect(resource.addFilterGroup).toHaveBeenCalledWith('setTargetDataScope_action-1', {
+      $and: [{ departmentId: { $eq: null } }],
+    });
+    expect(resource.removeFilterGroup).not.toHaveBeenCalled();
+  });
+
+  it('setTargetDataScope handler removes clicked-row data scope when row click deselects', async () => {
+    const resource = {
+      addFilterGroup: vi.fn(),
+      removeFilterGroup: vi.fn(),
+      hasData: vi.fn(() => true),
+      refresh: vi.fn(),
+    };
+    const ctx = createSetTargetDataScopeContext(resource, { selected: false, resolvedValue: null });
     const params = {
       targetBlockUid: 'target-1',
       filter: {
         logic: '$and',
-        items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.formValues.department.id }}' }],
+        items: [{ path: 'id', operator: '$eq', value: '{{ ctx.clickedRowRecord.id }}' }],
       },
     };
 
     await (setTargetDataScope as any).handler(ctx, params);
 
     expect(ctx.model.scheduleModelOperation).toHaveBeenCalledWith('target-1', expect.any(Function));
+    expect(resource.removeFilterGroup).toHaveBeenCalledWith('setTargetDataScope_action-1');
+    expect(resource.addFilterGroup).not.toHaveBeenCalled();
+    expect(resource.refresh).toHaveBeenCalledTimes(1);
+  });
+
+  it('setTargetDataScope handler keeps null clicked-row field values while row is selected', async () => {
+    const resource = {
+      addFilterGroup: vi.fn(),
+      removeFilterGroup: vi.fn(),
+      hasData: vi.fn(() => false),
+      refresh: vi.fn(),
+    };
+    const ctx = createSetTargetDataScopeContext(resource, { selected: true, resolvedValue: null });
+    const params = {
+      targetBlockUid: 'target-1',
+      filter: {
+        logic: '$and',
+        items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.clickedRowRecord.departmentId }}' }],
+      },
+    };
+
+    await (setTargetDataScope as any).handler(ctx, params);
+
     expect(resource.addFilterGroup).toHaveBeenCalledWith('setTargetDataScope_action-1', {
       $and: [{ departmentId: { $eq: null } }],
     });
     expect(resource.removeFilterGroup).not.toHaveBeenCalled();
   });
+
+  it('setTargetDataScope handler refreshes empty loaded target while preserving its own data scope', async () => {
+    const engine = new FlowEngine();
+    const resource = engine.createResource(MultiRecordResource);
+    resource.addFilterGroup('target-table', { status: { $eq: 'active' } });
+    resource.addFilterGroup('setTargetDataScope_action-1', { id: { $eq: 1 } });
+    resource.setData([]);
+    resource.setMeta({ count: 0, hasNext: false });
+    const refresh = vi.spyOn(resource, 'refresh').mockResolvedValue(undefined);
+    const ctx = createSetTargetDataScopeContext(resource, { selected: false, resolvedValue: null });
+    const params = {
+      targetBlockUid: 'target-1',
+      filter: {
+        logic: '$and',
+        items: [{ path: 'id', operator: '$eq', value: '{{ ctx.clickedRowRecord.id }}' }],
+      },
+    };
+
+    await (setTargetDataScope as any).handler(ctx, params);
+
+    expect(resource.getRequestParameter('filter')).toBe(JSON.stringify({ $and: [{ status: { $eq: 'active' } }] }));
+    expect(refresh).toHaveBeenCalledTimes(1);
+  });
 });

package/src/flow/actions/__tests__/formAssignRules.legacyMigration.test.tsx

@@ -0,0 +1,173 @@
+/**
+ * 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 { render, waitFor } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { FlowEngine, FlowModel, FlowSettingsContextProvider } from '@nocobase/flow-engine';
+import { formAssignRules } from '../formAssignRules';
+import { filterFormDefaultValues } from '../filterFormDefaultValues';
+
+const mockState = vi.hoisted(() => ({
+  editorProps: [] as any[],
+}));
+
+vi.mock('../../components/FieldAssignRulesEditor', () => ({
+  FieldAssignRulesEditor: (props: any) => {
+    mockState.editorProps.push(props);
+    return null;
+  },
+}));
+
+vi.mock('../../components/fieldAssignOptions', () => ({
+  collectFieldAssignCascaderOptions: vi.fn(() => []),
+}));
+
+vi.mock('../../components/useAssociationTitleFieldSync', () => ({
+  useAssociationTitleFieldSync: () => ({
+    isTitleFieldCandidate: vi.fn(() => false),
+    onSyncAssociationTitleField: vi.fn(),
+  }),
+}));
+
+vi.mock('../../internal/utils/modelUtils', () => ({
+  findFormItemModelByFieldPath: vi.fn(() => null),
+  getCollectionFromModel: vi.fn(() => null),
+}));
+
+function createLegacyField(fieldPath: string, value: any, legacyFlowKey: string) {
+  return {
+    props: {},
+    stepParams: {
+      fieldSettings: { init: { fieldPath } },
+      [legacyFlowKey]: { initialValue: { defaultValue: value } },
+    },
+    getProps() {
+      return this.props;
+    },
+    getStepParams(flowKey: string, stepKey: string) {
+      return this.stepParams?.[flowKey]?.[stepKey];
+    },
+  };
+}
+
+function createModel(legacyFlowKey: string, fields = [{ fieldPath: 'description', value: 'Legacy description' }]) {
+  const engine = new FlowEngine();
+  engine.translate = vi.fn((key: string) => key) as any;
+  const model = new FlowModel({ uid: `model-${legacyFlowKey}`, flowEngine: engine }) as any;
+  model.subModels.grid = {
+    subModels: {
+      items: fields.map((field) => createLegacyField(field.fieldPath, field.value, legacyFlowKey)),
+    },
+  };
+  return model;
+}
+
+function getActionComponent(action: any) {
+  const schema = typeof action.uiSchema === 'function' ? action.uiSchema() : action.uiSchema;
+  return schema.value['x-component'];
+}
+
+function renderAction(action: any, model: any, initialValue: any[] = []) {
+  const Comp = getActionComponent(action);
+  const onChange = vi.fn();
+
+  const Harness = () => {
+    const [value, setValue] = React.useState(initialValue);
+    const handleChange = React.useCallback(
+      (next: any[]) => {
+        onChange(next);
+        setValue(next);
+      },
+      [onChange],
+    );
+
+    return (
+      <FlowSettingsContextProvider value={model.context}>
+        <Comp value={value} onChange={handleChange} />
+      </FlowSettingsContextProvider>
+    );
+  };
+
+  render(<Harness />);
+  return { onChange };
+}
+
+function lastEditorValue() {
+  return mockState.editorProps.at(-1)?.value;
+}
+
+describe('Field values legacy default migration', () => {
+  beforeEach(() => {
+    mockState.editorProps.length = 0;
+    vi.clearAllMocks();
+  });
+
+  it('imports form field legacy defaults before form-level value is persisted', async () => {
+    const model = createModel('editItemSettings');
+    const { onChange } = renderAction(formAssignRules, model);
+
+    await waitFor(() => {
+      expect(onChange).toHaveBeenCalledWith([
+        expect.objectContaining({
+          key: 'legacy-default:description',
+          targetPath: 'description',
+          mode: 'default',
+          value: 'Legacy description',
+        }),
+      ]);
+    });
+    expect(lastEditorValue()).toEqual([
+      expect.objectContaining({
+        targetPath: 'description',
+        value: 'Legacy description',
+      }),
+    ]);
+  });
+
+  it('does not re-import form legacy defaults after an empty form-level value is persisted', async () => {
+    const model = createModel('editItemSettings');
+    model.setStepParams('formModelSettings', 'assignRules', { value: [] });
+    const { onChange } = renderAction(formAssignRules, model, []);
+
+    await waitFor(() => {
+      expect(mockState.editorProps.length).toBeGreaterThan(1);
+    });
+    expect(onChange).not.toHaveBeenCalled();
+    expect(lastEditorValue()).toEqual([]);
+  });
+
+  it('does not append deleted legacy form targets when another rule is already persisted', async () => {
+    const persisted = [{ key: 'kept', targetPath: 'title', mode: 'default', value: 'Kept title' }];
+    const model = createModel('editItemSettings', [
+      { fieldPath: 'title', value: 'Kept title' },
+      { fieldPath: 'description', value: 'Legacy description' },
+    ]);
+    model.setStepParams('formModelSettings', 'assignRules', { value: persisted });
+    const { onChange } = renderAction(formAssignRules, model, persisted);
+
+    await waitFor(() => {
+      expect(mockState.editorProps.length).toBeGreaterThan(1);
+    });
+    expect(onChange).not.toHaveBeenCalled();
+    expect(lastEditorValue()).toEqual(persisted);
+  });
+
+  it('does not re-import filter form legacy defaults after an empty form-level value is persisted', async () => {
+    const model = createModel('filterFormItemSettings');
+    model.setStepParams('formFilterBlockModelSettings', 'defaultValues', { value: [] });
+    const { onChange } = renderAction(filterFormDefaultValues, model, []);
+
+    await waitFor(() => {
+      expect(mockState.editorProps.length).toBeGreaterThan(1);
+    });
+    expect(onChange).not.toHaveBeenCalled();
+    expect(lastEditorValue()).toEqual([]);
+  });
+});