@nocobase/client-v2 2.2.0-alpha.1 → 2.2.0-alpha.11

package/src/flow/components/__tests__/FieldAssignValueInput.context.test.tsx

@@ -0,0 +1,216 @@
+/**
+ * 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 { describe, expect, it, vi } from 'vitest';
+import { render, waitFor } from '@nocobase/test/client';
+import { FieldAssignValueInput } from '../FieldAssignValueInput';
+
+const { mockUseFlowContext, mockGetDefaultBindingByField, mockVariableInput } = vi.hoisted(() => ({
+  mockUseFlowContext: vi.fn(),
+  mockGetDefaultBindingByField: vi.fn(),
+  mockVariableInput: vi.fn(() => <div data-testid="variable-input" />),
+}));
+
+vi.mock('@nocobase/flow-engine', async () => {
+  const actual = await vi.importActual<typeof import('@nocobase/flow-engine')>('@nocobase/flow-engine');
+  class MockEditableItemModel extends actual.EditableItemModel {}
+  MockEditableItemModel.getDefaultBindingByField = mockGetDefaultBindingByField;
+
+  return {
+    ...actual,
+    useFlowContext: () => mockUseFlowContext(),
+    VariableInput: mockVariableInput,
+    FlowModelRenderer: () => <div data-testid="flow-model-renderer" />,
+    EditableItemModel: MockEditableItemModel,
+  };
+});
+
+describe('FieldAssignValueInput context', () => {
+  it('delegates temporary field model context to the source form context', async () => {
+    type MockContext = {
+      dataSourceManager: { getDataSource: ReturnType<typeof vi.fn> };
+      t: (key: string) => string;
+      engine?: { createModel: ReturnType<typeof vi.fn> };
+      collection?: MockCollection;
+      blockModel?: MockFormModel;
+    };
+    type MockFieldModel = {
+      props: Record<string, unknown>;
+      setProps: ReturnType<typeof vi.fn>;
+      dispatchEvent: ReturnType<typeof vi.fn>;
+      remove: ReturnType<typeof vi.fn>;
+    };
+    type MockCollectionField = {
+      name: string;
+      interface: string;
+      uiSchema: { enum: Array<{ label: string; value: string }> };
+      isAssociationField: () => boolean;
+      getComponentProps: () => Record<string, unknown>;
+    };
+    type MockCollection = {
+      dataSourceKey: string;
+      name: string;
+      getField: (name: string) => MockCollectionField | null;
+      getFields: () => MockCollectionField[];
+    };
+    type MockFormModel = {
+      context: MockContext;
+      collection: MockCollection;
+      subModels: Record<string, unknown>;
+    };
+
+    const sourceContext: MockContext = {
+      dataSourceManager: {
+        getDataSource: vi.fn(() => ({})),
+      },
+      t: (key: string) => key,
+    };
+    const fieldModel: MockFieldModel = {
+      props: {},
+      setProps: vi.fn((props: Record<string, unknown>) => {
+        fieldModel.props = { ...fieldModel.props, ...props };
+      }),
+      dispatchEvent: vi.fn(),
+      remove: vi.fn(),
+    };
+    const tempRoot = {
+      context: {
+        defineProperty: vi.fn(),
+      },
+      subModels: {
+        fields: [fieldModel],
+      },
+      setProps: vi.fn(),
+      remove: vi.fn(),
+    };
+    const engine = {
+      createModel: vi.fn(() => tempRoot),
+    };
+    sourceContext.engine = engine;
+
+    const collectionField: MockCollectionField = {
+      name: 'status',
+      interface: 'select',
+      uiSchema: {
+        enum: [{ label: 'Open', value: 'open' }],
+      },
+      isAssociationField: () => false,
+      getComponentProps: () => ({}),
+    };
+    const collection: MockCollection = {
+      dataSourceKey: 'main',
+      name: 'tasks',
+      getField: (name: string) => (name === 'status' ? collectionField : null),
+      getFields: () => [collectionField],
+    };
+    const formModel: MockFormModel = {
+      context: sourceContext,
+      collection,
+      subModels: {},
+    };
+    sourceContext.collection = collection;
+    sourceContext.blockModel = formModel;
+
+    mockGetDefaultBindingByField.mockReturnValue({ modelName: 'SelectFieldModel' });
+    mockUseFlowContext.mockReturnValue({
+      model: formModel,
+      t: (key: string) => key,
+      getPropertyMetaTree: vi.fn(async () => []),
+    });
+
+    render(<FieldAssignValueInput targetPath="status" value="" onChange={vi.fn()} />);
+
+    await waitFor(() => {
+      expect(engine.createModel).toHaveBeenCalled();
+    });
+    expect(engine.createModel).toHaveBeenCalledWith(expect.any(Object), { delegate: sourceContext });
+  });
+
+  it('lets callers override variable path parsing for domain-specific stored formats', async () => {
+    mockVariableInput.mockClear();
+    const sourceContext = {
+      dataSourceManager: {
+        getDataSource: vi.fn(() => ({})),
+      },
+      t: (key: string) => key,
+    };
+    const fieldModel = {
+      props: {},
+      setProps: vi.fn(),
+      dispatchEvent: vi.fn(),
+      remove: vi.fn(),
+    };
+    const tempRoot = {
+      context: {
+        defineProperty: vi.fn(),
+      },
+      subModels: {
+        fields: [fieldModel],
+      },
+      setProps: vi.fn(),
+      remove: vi.fn(),
+    };
+    const engine = {
+      createModel: vi.fn(() => tempRoot),
+    };
+    const collectionField = {
+      name: 'status',
+      interface: 'input',
+      uiSchema: { 'x-component': 'Input' },
+      isAssociationField: () => false,
+      getComponentProps: () => ({}),
+    };
+    const collection = {
+      dataSourceKey: 'main',
+      name: 'tasks',
+      getField: (name: string) => (name === 'status' ? collectionField : null),
+      getFields: () => [collectionField],
+    };
+    const formModel = {
+      context: { ...sourceContext, engine, collection, blockModel: null as any },
+      collection,
+      subModels: {},
+    };
+    formModel.context.blockModel = formModel;
+
+    mockGetDefaultBindingByField.mockReturnValue({ modelName: 'InputFieldModel' });
+    mockUseFlowContext.mockReturnValue({
+      model: formModel,
+      t: (key: string) => key,
+      getPropertyMetaTree: vi.fn(async () => []),
+    });
+
+    const variableConverters = {
+      resolvePathFromValue: vi.fn((value: string) =>
+        value === '{{$context.data.updatedAt}}' ? ['$context', 'data', 'updatedAt'] : undefined,
+      ),
+      resolveValueFromPath: vi.fn(() => undefined),
+    };
+
+    render(
+      <FieldAssignValueInput
+        targetPath="status"
+        value="{{$context.data.updatedAt}}"
+        onChange={vi.fn()}
+        variableConverters={variableConverters}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(engine.createModel).toHaveBeenCalled();
+    });
+    const latestVariableInputCall = mockVariableInput.mock.calls.at(-1)?.[0];
+    expect(latestVariableInputCall.converters.resolvePathFromValue('{{$context.data.updatedAt}}')).toEqual([
+      '$context',
+      'data',
+      'updatedAt',
+    ]);
+  });
+});

package/src/flow/components/__tests__/fieldAssignOptions.test.ts

@@ -14,6 +14,15 @@ import {
   collectFieldAssignCascaderOptions,
 } from '../fieldAssignOptions';
 
+type TestCollectionField = {
+  name?: string;
+  title?: string;
+  interface?: string;
+  target?: string;
+  targetCollection?: unknown;
+  isAssociationField?: () => boolean;
+};
+
 describe('fieldAssignOptions', () => {
   it('marks subform node as non-leaf so Cascader can lazy-load target collection fields', () => {
     const usersCollection = {
@@ -98,8 +107,58 @@ describe('fieldAssignOptions', () => {
     ).toBe(true);
   });
 
+  it('preserves configured display association field paths as nested cascader options', () => {
+    const orgNameField = {
+      name: 'orgname',
+      title: '公司名称(单行文本)',
+      interface: 'input',
+      type: 'string',
+      isAssociationField: () => false,
+    };
+    const orgCollection = {
+      getFields: () => [orgNameField],
+      getField: (name: string) => (name === 'orgname' ? orgNameField : null),
+    };
+    const orgAssociationField = {
+      name: 'org_m2o',
+      title: 'org_m2o',
+      interface: 'm2o',
+      type: 'belongsTo',
+      target: 'org',
+      isAssociationField: () => true,
+      targetCollection: orgCollection,
+    };
+    const rootCollection = {
+      getField: (name: string) => (name === 'org_m2o' ? orgAssociationField : null),
+      getFields: () => [orgAssociationField],
+    };
+    const displayAssociationItemModel = {
+      props: { label: '公司名称(单行文本)' },
+      getStepParams: (flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') return { fieldPath: 'org_m2o.orgname' };
+        return {};
+      },
+      subModels: {
+        field: {
+          context: { collectionField: orgNameField },
+        },
+      },
+    };
+    const formBlockModel = {
+      context: { collection: rootCollection },
+      subModels: { grid: { subModels: { items: [displayAssociationItemModel] } } },
+    };
+
+    const options = collectFieldAssignCascaderOptions({ formBlockModel, t: (s) => s });
+    const orgOption = options.find((option) => option.value === 'org_m2o');
+
+    expect(orgOption?.isLeaf).toBe(false);
+    expect(orgOption?.children?.some((child) => child.value === 'orgname' && child.isLeaf === true)).toBe(true);
+    expect(options.some((option) => option.value === 'orgname')).toBe(false);
+  });
+
   it('hides configured association fields deeper than relation / relation / field', () => {
-    const makeItem = (fieldPath: string, field: any, label: string) => ({
+    const makeItem = (fieldPath: string, field: TestCollectionField, label: string) => ({
       props: { label },
       getStepParams: (flowKey: string, stepKey: string) => {
         if (flowKey === 'fieldSettings' && stepKey === 'init') return { fieldPath };
@@ -141,9 +200,98 @@ describe('fieldAssignOptions', () => {
     };
 
     const options = collectFieldAssignCascaderOptions({ formBlockModel, t: (s) => s });
+    const usersOption = options.find((item) => item.value === 'users');
+    const departmentOption = usersOption?.children?.find((item) => item.value === 'department');
+
+    expect(departmentOption?.children?.map((item) => item.value)).toContain('name');
+    expect(departmentOption?.children?.map((item) => item.value)).not.toContain('company');
+  });
+
+  it('hides configured non-association fields under a third association level', () => {
+    const codeField = {
+      name: 'code',
+      title: 'Code',
+      interface: 'input',
+      isAssociationField: () => false,
+    };
+    const companyCollection = {
+      getField: (name: string) => (name === 'code' ? codeField : null),
+      getFields: () => [codeField],
+    };
+    const companyField = {
+      name: 'company',
+      title: 'Company',
+      interface: 'm2o',
+      target: 'companies',
+      isAssociationField: () => true,
+      targetCollection: companyCollection,
+    };
+    const nameField = {
+      name: 'name',
+      title: 'Name',
+      interface: 'input',
+      isAssociationField: () => false,
+    };
+    const departmentCollection = {
+      getField: (name: string) => (name === 'name' ? nameField : name === 'company' ? companyField : null),
+      getFields: () => [nameField, companyField],
+    };
+    const departmentField = {
+      name: 'department',
+      title: 'Department',
+      interface: 'm2o',
+      target: 'departments',
+      isAssociationField: () => true,
+      targetCollection: departmentCollection,
+    };
+    const userCollection = {
+      getField: (name: string) => (name === 'department' ? departmentField : null),
+      getFields: () => [departmentField],
+    };
+    const usersField = {
+      name: 'users',
+      title: 'Users',
+      interface: 'm2m',
+      target: 'users',
+      isAssociationField: () => true,
+      targetCollection: userCollection,
+    };
+    const rootCollection = {
+      getField: (name: string) => (name === 'users' ? usersField : null),
+      getFields: () => [usersField],
+    };
+    const makeItem = (fieldPath: string, field: TestCollectionField, label: string) => ({
+      props: { label },
+      getStepParams: (flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') return { fieldPath };
+        return {};
+      },
+      subModels: {
+        field: {
+          context: { collectionField: field },
+        },
+      },
+    });
+    const formBlockModel = {
+      context: { collection: rootCollection },
+      subModels: {
+        grid: {
+          subModels: {
+            items: [
+              makeItem('users.department.name', nameField, 'Department name'),
+              makeItem('users.department.company.code', codeField, 'Company code'),
+            ],
+          },
+        },
+      },
+    };
+
+    const options = collectFieldAssignCascaderOptions({ formBlockModel, t: (s) => s });
+    const usersOption = options.find((item) => item.value === 'users');
+    const departmentOption = usersOption?.children?.find((item) => item.value === 'department');
 
-    expect(options.map((item) => item.value)).toContain('name');
-    expect(options.map((item) => item.value)).not.toContain('company');
+    expect(departmentOption?.children?.map((item) => item.value)).toContain('name');
+    expect(departmentOption?.children?.map((item) => item.value)).not.toContain('company');
   });
 
   it('hides lazy-loaded association selector options after two association levels', () => {

package/src/flow/components/code-editor/__tests__/useCodeRunner.test.tsx

@@ -20,8 +20,6 @@ import {
   FlowEngineProvider,
   FlowModelRenderer,
   ElementProxy,
-  createSafeWindow,
-  createSafeDocument,
   createViewScopedEngine,
 } from '@nocobase/flow-engine';
 import { JSEditableFieldModel } from '../../../models/fields/JSEditableFieldModel';
@@ -167,11 +165,7 @@ describe('useCodeRunner (beforeRender)', () => {
             const code = ctx?.inputArgs?.preview?.code || '';
             ctx.onRefReady(ctx.ref, async (el) => {
               ctx.defineProperty('element', { get: () => new ElementProxy(el as any) });
-              await ctx.runjs(
-                code,
-                { window: createSafeWindow(), document: createSafeDocument() },
-                { preprocessTemplates: true },
-              );
+              await ctx.runjs(code, undefined, { preprocessTemplates: true });
             });
           },
         },
@@ -286,16 +280,7 @@ return currentUsername;
             const code = ctx?.inputArgs?.preview?.code || '';
             ctx.onRefReady(ctx.ref, async (el) => {
               ctx.defineProperty('element', { get: () => new ElementProxy(el as any) });
-              const navigator = { userAgent: 'test' } as any;
-              await ctx.runjs(
-                code,
-                {
-                  window: createSafeWindow({ navigator }),
-                  document: createSafeDocument(),
-                  navigator,
-                },
-                { preprocessTemplates: true },
-              );
+              await ctx.runjs(code, undefined, { preprocessTemplates: true });
             });
           },
         },

package/src/flow/components/code-editor/hooks/useCodeRunner.ts

@@ -9,14 +9,7 @@
 
 import { useCallback, useRef, useState } from 'react';
 import { parseErrorLineColumn, WRAPPER_PRELUDE_LINES } from '../errorHelpers';
-import {
-  FlowModelContext,
-  JSRunner,
-  createSafeWindow,
-  createSafeDocument,
-  createSafeNavigator,
-  prepareRunJsCode,
-} from '@nocobase/flow-engine';
+import { FlowModelContext, JSRunner, prepareRunJsCode } from '@nocobase/flow-engine';
 
 export type RunLog = { level: 'log' | 'info' | 'warn' | 'error'; msg: string; line?: number; column?: number };
 type RunResult = Awaited<ReturnType<JSRunner['run']>>;
@@ -286,12 +279,7 @@ export function useCodeRunner(hostCtx: FlowModelContext, version = 'v1') {
           const eventName = typeof onDef === 'string' ? onDef : onDef?.eventName;
           if (!flow) {
             // 无可用流程（典型场景：联动规则里的 RunJS 预览），直接在当前上下文执行代码
-            const navigator = createSafeNavigator();
-            await directRunCtx.runjs(
-              code,
-              { window: createSafeWindow({ navigator }), document: createSafeDocument(), navigator },
-              { version },
-            );
+            await directRunCtx.runjs(code, undefined, { version });
           } else if (typeof eventName === 'string') {
             await m.dispatchEvent(eventName, { preview: { code } }, { sequential: true, useCache: false });
           } else if (isManual) {

package/src/flow/components/code-editor/runjsDiagnostics.ts

@@ -20,10 +20,8 @@ import * as acornWalk from 'acorn-walk';
 import {
   JSRunner,
   FlowContext,
-  createSafeDocument,
-  createSafeNavigator,
-  createSafeWindow,
   prepareRunJsCode,
+  RUNJS_ALLOWED_BARE_GLOBAL_NAMES,
   shouldPreprocessRunJSTemplates,
 } from '@nocobase/flow-engine';
 
@@ -604,41 +602,7 @@ function collectHeuristicIssues(code: string): RunJSIssue[] {
     return issues;
   }
 
-  const declared = new Set<string>([
-    // Common globals / allowed runtime context roots
-    'ctx',
-    'console',
-    'window',
-    'document',
-    'navigator',
-    'Math',
-    'Date',
-    'Array',
-    'Object',
-    'Number',
-    'String',
-    'Boolean',
-    'Promise',
-    'RegExp',
-    'Set',
-    'Map',
-    'WeakSet',
-    'WeakMap',
-    'JSON',
-    'Intl',
-    'URL',
-    'Error',
-    'TypeError',
-    'encodeURIComponent',
-    'decodeURIComponent',
-    'parseInt',
-    'parseFloat',
-    'isNaN',
-    'isFinite',
-    'undefined',
-    'NaN',
-    'Infinity',
-  ]);
+  const declared = new Set<string>(RUNJS_ALLOWED_BARE_GLOBAL_NAMES);
 
   const addId = (id: any) => {
     if (id && typeof id.name === 'string') declared.add(id.name);
@@ -1036,15 +1000,14 @@ export async function diagnoseRunJS(
     const { consoleCapture, loggerCapture } = createLogCollectors(logs);
 
     const baseGlobals: Record<string, any> = { console: consoleCapture };
-    try {
-      if (typeof window !== 'undefined') {
-        const navigator = createSafeNavigator();
+    if (typeof window !== 'undefined') {
+      baseGlobals.window = window;
+      if (typeof navigator !== 'undefined') {
         baseGlobals.navigator = navigator;
-        baseGlobals.window = createSafeWindow({ navigator });
-        baseGlobals.document = createSafeDocument();
       }
-    } catch (_) {
-      // ignore safe globals failures
+    }
+    if (typeof document !== 'undefined') {
+      baseGlobals.document = document;
     }
 
     let prepared = src;