@nocobase/client-v2 2.2.0-beta.3 → 2.2.0-beta.6

package/src/flow/actions/__tests__/linkageAssignField.legacy.test.ts

@@ -69,6 +69,72 @@ describe('linkage assign actions - legacy params', () => {
     expect(setProps).not.toHaveBeenCalledWith(fieldModel, { value: 'default-in-update' });
   });
 
+  it('linkageAssignField should mark override mode for field targets', async () => {
+    const fieldModel: any = { uid: 'f-override', fieldPath: 'a.b' };
+    const ctx: any = {
+      model: {
+        subModels: { grid: { subModels: { items: [fieldModel] } } },
+      },
+      engine: { getModel: vi.fn(() => ({ fieldPath: 'a.b' })) },
+      app: { jsonLogic: { apply: vi.fn() } },
+    };
+    const setProps = vi.fn();
+
+    await linkageAssignField.handler(ctx, {
+      value: [
+        {
+          key: 'r-override',
+          enable: true,
+          targetPath: 'a.b',
+          mode: 'override',
+          condition: { logic: '$and', items: [] },
+          value: 'override-value',
+        },
+      ],
+      setProps,
+    });
+
+    expect(setProps).toHaveBeenCalledTimes(1);
+    const [, props] = setProps.mock.calls[0];
+    expect(props).toMatchObject({
+      value: 'override-value',
+      __linkageAssignMode: 'override',
+    });
+  });
+
+  it('linkageAssignField should emit override patches for targets without form item models', async () => {
+    const ctx: any = {
+      model: { subModels: { grid: { subModels: { items: [] } } } },
+      engine: { getModel: vi.fn(() => null) },
+      app: { jsonLogic: { apply: vi.fn() } },
+    };
+    const setProps = vi.fn();
+    const addFormValuePatch = vi.fn();
+
+    await linkageAssignField.handler(ctx, {
+      value: [
+        {
+          key: 'r-override-direct',
+          enable: true,
+          targetPath: 'user.name',
+          mode: 'override',
+          condition: { logic: '$and', items: [] },
+          value: 'override-direct',
+        },
+      ],
+      setProps,
+      addFormValuePatch,
+    });
+
+    expect(setProps).not.toHaveBeenCalled();
+    expect(addFormValuePatch).toHaveBeenCalledWith({
+      path: 'user.name',
+      value: 'override-direct',
+      whenEmpty: false,
+      mode: 'override',
+    });
+  });
+
   it('subFormLinkageAssignField should apply legacy object params at runtime', () => {
     const forkModel: any = {
       uid: 'f1',
@@ -381,6 +447,75 @@ describe('linkage assign actions - legacy params', () => {
     expect(addFormValuePatch).toHaveBeenCalledTimes(1);
   });
 
+  it('subFormLinkageAssignField should skip override patch after user edits the target path', () => {
+    const ctx: any = {
+      model: {
+        uid: 'sub-form-override-path',
+        getAclActionName: vi.fn(() => 'create'),
+        context: {},
+        parent: {
+          getStepParams: (flowKey: string, stepKey: string) => {
+            if (flowKey === 'fieldSettings' && stepKey === 'init') {
+              return { fieldPath: 'M2M.M2M' };
+            }
+            return {};
+          },
+        },
+        subModels: { grid: { subModels: { items: [] } } },
+      },
+      engine: {
+        getModel: vi.fn(() => null),
+      },
+      app: { jsonLogic: { apply: vi.fn() } },
+    };
+    const addFormValuePatch = vi.fn();
+
+    subFormLinkageAssignField.handler(ctx, {
+      value: [
+        {
+          key: 'r-override-path-1',
+          enable: true,
+          targetPath: 'Name',
+          mode: 'override',
+          condition: { logic: '$and', items: [] },
+          value: 'override-1',
+        },
+      ],
+      addFormValuePatch,
+      setProps: vi.fn(),
+    });
+
+    expect(addFormValuePatch).toHaveBeenCalledTimes(1);
+    expect(addFormValuePatch).toHaveBeenNthCalledWith(1, {
+      path: 'M2M.M2M.Name',
+      value: 'override-1',
+      whenEmpty: false,
+      mode: 'override',
+    });
+
+    ctx.inputArgs = {
+      source: 'user',
+      changedPaths: [['M2M', 'M2M', 'Name']],
+    };
+
+    subFormLinkageAssignField.handler(ctx, {
+      value: [
+        {
+          key: 'r-override-path-2',
+          enable: true,
+          targetPath: 'Name',
+          mode: 'override',
+          condition: { logic: '$and', items: [] },
+          value: 'override-2',
+        },
+      ],
+      addFormValuePatch,
+      setProps: vi.fn(),
+    });
+
+    expect(addFormValuePatch).toHaveBeenCalledTimes(1);
+  });
+
   it('linkageAssignField should evaluate RunJS value before assign', async () => {
     const fieldModel: any = { uid: 'f-runjs-assign', fieldPath: 'a.b' };
     const runjs = vi.fn(async () => ({ success: true, value: 'from-runjs' }));

package/src/flow/actions/__tests__/linkageRules.hiddenSync.restore.test.ts

@@ -27,12 +27,12 @@ describe('linkageRules hidden state propagation', () => {
     const hostModel: any = {
       uid: 'host',
       hidden: false,
-      context: { blockModel },
+      context: { blockModel, fieldPathArray: ['children'] },
       __allModels: [],
       setProps: vi.fn(),
       getFlow: vi.fn(() => ({})),
       getStepParams: vi.fn((_flowKey: string, stepKey: string) => {
-        if (stepKey === 'init') return { fieldPath: 'org_m2o' };
+        if (stepKey === 'init') return { fieldPath: 'children' };
         return undefined;
       }),
       translate: (s: string) => s,
@@ -41,10 +41,22 @@ describe('linkageRules hidden state propagation', () => {
     const sameTargetModel: any = {
       uid: 'same-target',
       hidden: false,
-      context: { blockModel },
+      context: { blockModel, fieldPathArray: ['children'] },
       setProps: vi.fn(),
       getStepParams: vi.fn((_flowKey: string, stepKey: string) => {
-        if (stepKey === 'init') return { fieldPath: 'org_m2o' };
+        if (stepKey === 'init') return { fieldPath: 'children' };
+        return undefined;
+      }),
+      translate: (s: string) => s,
+    };
+
+    const nestedColumnModel: any = {
+      uid: 'nested-column',
+      hidden: true,
+      context: { blockModel, fieldPathArray: ['children'] },
+      setProps: vi.fn(),
+      getStepParams: vi.fn((_flowKey: string, stepKey: string) => {
+        if (stepKey === 'init') return { fieldPath: 'children.children' };
         return undefined;
       }),
       translate: (s: string) => s,
@@ -52,7 +64,7 @@ describe('linkageRules hidden state propagation', () => {
 
     const engine = {
       forEachModel: (visitor: (m: any) => void) => {
-        [hostModel, sameTargetModel].forEach(visitor);
+        [hostModel, sameTargetModel, nestedColumnModel].forEach(visitor);
       },
     };
 
@@ -92,9 +104,11 @@ describe('linkageRules hidden state propagation', () => {
     });
     expect(hostModel.hidden).toBe(true);
     expect(sameTargetModel.hidden).toBe(true);
+    expect(nestedColumnModel.hidden).toBe(true);
 
     await actionLinkageRules.handler(ctx, { value: [] });
     expect(hostModel.hidden).toBe(false);
     expect(sameTargetModel.hidden).toBe(false);
+    expect(nestedColumnModel.hidden).toBe(true);
   });
 });

package/src/flow/actions/__tests__/linkageRules.subFormSetFieldProps.test.ts

@@ -728,6 +728,98 @@ describe('linkageSetFieldProps action', () => {
     expect(form.setFieldValue).not.toHaveBeenCalled();
   });
 
+  it('should not clear the parent field when a nested same-name field inherits the parent path', async () => {
+    const setFormValues = vi.fn(async () => undefined);
+    const form = {
+      getFieldValue: vi.fn((path: Array<string | number>) => {
+        if (JSON.stringify(path) === JSON.stringify(['children', 'children'])) {
+          return [{ title: 'nested' }];
+        }
+        if (JSON.stringify(path) === JSON.stringify(['children'])) {
+          return [{ title: 'parent' }];
+        }
+        return undefined;
+      }),
+      setFieldValue: vi.fn(),
+    };
+    const fieldModel: any = {
+      uid: 'nested-children-field',
+      hidden: false,
+      context: {
+        form,
+        fieldPathArray: ['children'],
+      },
+      props: {
+        label: 'Children',
+      },
+      getStepParams: vi.fn((flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') {
+          return { fieldPath: 'children.children' };
+        }
+      }),
+      setProps(key: any, value?: any) {
+        if (typeof key === 'string') {
+          this.props[key] = value;
+        } else {
+          this.props = { ...this.props, ...key };
+        }
+      },
+    };
+    const ctx: any = {
+      app: {
+        jsonLogic: {
+          apply: vi.fn(() => true),
+        },
+      },
+      model: {
+        context: { form },
+        subModels: {
+          grid: {
+            subModels: {
+              items: [fieldModel],
+            },
+          },
+        },
+      },
+      setFormValues,
+      getAction: (name: string) => (name === 'linkageSetFieldProps' ? linkageSetFieldProps : null),
+      resolveJsonTemplate: vi.fn(async (value) => value),
+    };
+
+    await fieldLinkageRules.handler(ctx, {
+      value: [
+        {
+          key: 'rule-1',
+          enable: true,
+          condition: { logic: '$and', items: [] },
+          actions: [
+            {
+              key: 'action-1',
+              name: 'linkageSetFieldProps',
+              params: {
+                value: {
+                  fields: ['nested-children-field'],
+                  state: 'hidden',
+                },
+              },
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(fieldModel.hidden).toBe(true);
+    expect(setFormValues).toHaveBeenCalledWith(
+      [{ path: ['children', 'children'], value: undefined }],
+      expect.objectContaining({ source: 'linkage' }),
+    );
+    expect(setFormValues).not.toHaveBeenCalledWith(
+      [{ path: ['children'], value: undefined }],
+      expect.objectContaining({ source: 'linkage' }),
+    );
+    expect(form.setFieldValue).not.toHaveBeenCalled();
+  });
+
   it('should keep hidden clear after same-round assignment for the same field', async () => {
     const formValues: { name?: string } = {};
     const setFormValues = vi.fn(async (patches: Array<{ path: Array<string | number>; value: string | undefined }>) => {

package/src/flow/actions/customVariable.tsx

@@ -12,7 +12,6 @@ import {
   defineAction,
   isRunJSValue,
   normalizeRunJSValue,
-  runjsWithSafeGlobals,
   tExpr,
   type RunJSValue,
   useFlowContext,
@@ -43,7 +42,7 @@ export const customVariable = defineAction({
       if (variable.type === 'runjs') {
         const getFunction = async () => {
           const { code, version } = normalizeRunJSValue(variable.runjs);
-          return runjsWithSafeGlobals(ctx, code, { version });
+          return ctx.runjs(code, undefined, { version });
         };
         const metaFunction = () => ({
           title: variable.title,

package/src/flow/actions/dateTimeFormat.tsx

@@ -11,13 +11,36 @@ import { css } from '@emotion/css';
 import { defineAction, tExpr } from '@nocobase/flow-engine';
 import { getPickerFormat } from '@nocobase/utils/client';
 import { DateFormatCom, ExpiresRadio } from '../components';
+import {
+  getDateTimeFormatCollectionField,
+  isDateOnlyCollectionField,
+  isTimeCollectionField,
+  resolveDateTimeDisplayProps,
+} from '../utils/dateTimeDisplayProps';
+
+const isTableColumnFieldSubModel = (model) => {
+  const parent = model?.parent;
+  return (
+    parent?.subModels?.field === model &&
+    (parent?.use === 'TableColumnModel' || parent?.constructor?.name === 'TableColumnModel')
+  );
+};
+
+const syncTableColumnDateTimeFormatProps = (ctx, props) => {
+  const model = ctx.model;
+  if (!isTableColumnFieldSubModel(model) || !model?.parent?.collectionField?.isAssociationField?.()) {
+    return;
+  }
+
+  model.parent.setProps(props);
+};
 
 export const dateTimeFormat = defineAction({
   title: tExpr('Date display format'),
   name: 'dateDisplayFormat',
   uiSchema: (ctx) => {
-    const { collectionField } = ctx.model.context as any;
-    const isTimeField = collectionField.type === 'time' || collectionField.interface === 'time';
+    const collectionField = getDateTimeFormatCollectionField({ model: ctx.model });
+    const isTimeField = isTimeCollectionField(collectionField);
     const timeFormatField = {
       type: 'string',
       title: '{{t("Time format")}}',
@@ -43,7 +66,7 @@ export const dateTimeFormat = defineAction({
         (field) => {
           if (!isTimeField) {
             const { showTime, picker } = field.form.values || {};
-            field.hidden = !showTime || picker !== 'date';
+            field.hidden = isDateOnlyCollectionField(collectionField) || !showTime || picker !== 'date';
           }
         },
       ],
@@ -146,10 +169,11 @@ export const dateTimeFormat = defineAction({
             },
           },
           (field) => {
-            const { collectionField } = ctx.model.context as any;
+            const collectionField = getDateTimeFormatCollectionField({ model: ctx.model });
             const { picker } = field.form.values || {};
-            field.hidden = collectionField.type === 'dateOnly' || picker !== 'date';
-            if (picker !== 'date') {
+            const isDateOnlyField = isDateOnlyCollectionField(collectionField);
+            field.hidden = isDateOnlyField || picker !== 'date';
+            if (isDateOnlyField || picker !== 'date') {
               field.value = false;
             }
           },
@@ -159,34 +183,24 @@ export const dateTimeFormat = defineAction({
     };
   },
   defaultParams: (ctx: any) => {
-    const { showTime, dateFormat, format, timeFormat, picker }: any = {
-      ...ctx.model.context.collectionField.getComponentProps(),
-      ...ctx.model.props,
-    };
-    const collectionField = ctx.model.context.collectionField;
-    const isTimeField = collectionField.type === 'time' || collectionField.interface === 'time';
+    const { showTime, dateFormat, timeFormat, picker } = resolveDateTimeDisplayProps({
+      model: ctx.model,
+      withDefaults: true,
+    });
     return {
       picker: picker || 'date',
       dateFormat: dateFormat || 'YYYY-MM-DD',
-      timeFormat: timeFormat || (isTimeField ? format : undefined) || 'HH:mm:ss',
+      timeFormat: timeFormat || 'HH:mm:ss',
       showTime,
     };
   },
+  async beforeParamsSave(ctx: any, params) {
+    const props = resolveDateTimeDisplayProps({ model: ctx.model, params });
+    ctx.model.setProps(props);
+    syncTableColumnDateTimeFormatProps(ctx, props);
+    await ctx.model.save?.();
+  },
   handler(ctx: any, params) {
-    const { collectionField } = ctx.model.context as any;
-    const isTimeField = collectionField.type === 'time' || collectionField.interface === 'time';
-    if (isTimeField) {
-      const timeFormat = params?.timeFormat || params?.format || 'HH:mm:ss';
-      ctx.model.setProps({
-        ...params,
-        timeFormat,
-        format: timeFormat,
-      });
-    } else {
-      ctx.model.setProps({
-        ...params,
-        format: params?.showTime ? `${params.dateFormat} ${params.timeFormat}` : params.dateFormat,
-      });
-    }
+    ctx.model.setProps(resolveDateTimeDisplayProps({ model: ctx.model, params }));
   },
 });