@nocobase/client-v2 2.3.0-beta.2 → 2.3.0-beta.20

package/src/flow/components/filter/__tests__/VariableFilterItem.rightMetaTree.test.tsx

@@ -0,0 +1,158 @@
+/**
+ * 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, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import type { MetaTreeNode } from '@nocobase/flow-engine';
+import { FlowEngine, FlowModel } from '@nocobase/flow-engine';
+import { VariableFilterItem } from '../VariableFilterItem';
+import { createMockFlowApp, TestCollectionFieldInterface } from '../../../__tests__/helpers/mockFlowApp';
+
+const captured = vi.hoisted(() => ({ metaTrees: [] as any[] }));
+
+vi.mock('@nocobase/flow-engine', async () => {
+  const actual = await vi.importActual<any>('@nocobase/flow-engine');
+  const MockVariableInput = ({ onChange, metaTree }: any) => {
+    if (metaTree) {
+      captured.metaTrees.push(metaTree);
+    }
+    return (
+      <button
+        type="button"
+        data-testid="variable-input"
+        onClick={() =>
+          onChange?.('title', {
+            interface: 'input',
+            uiSchema: { 'x-component': 'Input' },
+            paths: ['collection', 'title'],
+          })
+        }
+      >
+        mock-variable-input
+      </button>
+    );
+  };
+  return { ...actual, VariableInput: MockVariableInput };
+});
+
+// $context.data (not an association) -> category (m2o) -> book (m2o) -> createdBy (not counted) -> departments (m2m).
+// Mirrors a workflow collection-event trigger that preloads `category.book.createdBy.departments`.
+function buildRightMetaTree(): MetaTreeNode[] {
+  const departments: MetaTreeNode = {
+    name: 'departments',
+    title: 'Departments',
+    type: 'object',
+    interface: 'm2m',
+    paths: ['$context', 'data', 'category', 'book', 'createdBy', 'departments'],
+  };
+  const createdBy: MetaTreeNode = {
+    name: 'createdBy',
+    title: 'Created by',
+    type: 'object',
+    interface: 'createdBy',
+    paths: ['$context', 'data', 'category', 'book', 'createdBy'],
+    children: async () => [departments],
+  };
+  const book: MetaTreeNode = {
+    name: 'book',
+    title: 'Book',
+    type: 'object',
+    interface: 'obo',
+    paths: ['$context', 'data', 'category', 'book'],
+    children: async () => [createdBy],
+  };
+  const category: MetaTreeNode = {
+    name: 'category',
+    title: 'Category',
+    type: 'object',
+    interface: 'm2o',
+    paths: ['$context', 'data', 'category'],
+    children: async () => [book],
+  };
+  const data: MetaTreeNode = {
+    name: 'data',
+    title: 'Trigger data',
+    type: 'object',
+    paths: ['$context', 'data'],
+    children: async () => [category],
+  };
+  return [{ name: '$context', title: 'Trigger variables', type: '', paths: ['$context'], children: [data] }];
+}
+
+async function resolveChildren(node: MetaTreeNode | undefined) {
+  const children = node?.children;
+  if (typeof children === 'function') {
+    return (await (children as () => Promise<MetaTreeNode[]>)()) ?? [];
+  }
+  return Array.isArray(children) ? children : [];
+}
+
+async function walkToCreatedByChildren(metaTree: any) {
+  const roots: MetaTreeNode[] = typeof metaTree === 'function' ? await metaTree() : metaTree;
+  const context = roots.find((node) => node.name === '$context');
+  const data = (await resolveChildren(context)).find((node) => node.name === 'data');
+  const category = (await resolveChildren(data)).find((node) => node.name === 'category');
+  const book = (await resolveChildren(category)).find((node) => node.name === 'book');
+  const createdBy = (await resolveChildren(book)).find((node) => node.name === 'createdBy');
+  return (await resolveChildren(createdBy)).map((node) => node.name);
+}
+
+function createModel() {
+  const engine = new FlowEngine();
+  const model = new FlowModel({ uid: 'm-variable-filter-right', flowEngine: engine });
+  const app = createMockFlowApp();
+  model.context.defineProperty('app', { value: app });
+
+  class InputInterface extends TestCollectionFieldInterface {
+    name = 'input';
+    group = 'basic';
+    filterable = { operators: [{ value: '$eq', label: 'Equals' }] };
+  }
+  app.addFieldInterfaces([InputInterface]);
+
+  const ds = engine.dataSourceManager.getDataSource('main');
+  ds.addCollection({
+    name: 'posts',
+    fields: [{ name: 'title', type: 'string', interface: 'input', uiSchema: { 'x-component': 'Input' } }],
+  });
+  model.context.defineProperty('collection', { get: () => ds.getCollection('posts') });
+
+  return model as any;
+}
+
+function renderItem(props: Record<string, unknown>) {
+  const value = { path: 'title', operator: '$eq', value: '' } as any;
+  const model = createModel();
+  render(
+    <VariableFilterItem value={value} model={model} rightAsVariable rightMetaTree={buildRightMetaTree()} {...props} />,
+  );
+  fireEvent.click(screen.getAllByTestId('variable-input')[0]);
+  return captured.metaTrees.at(-1);
+}
+
+describe('VariableFilterItem right-side association depth', () => {
+  beforeEach(() => {
+    document.body.innerHTML = '';
+    captured.metaTrees = [];
+  });
+
+  it('applies maxAssociationFieldDepth to the right tree by default', async () => {
+    const metaTree = renderItem({ maxAssociationFieldDepth: 2 });
+    // `departments` is the third association down the path, so the default cap removes it.
+    expect(await walkToCreatedByChildren(metaTree)).toEqual([]);
+  });
+
+  // The right side is a variable tree whose depth is decided by its provider (in workflow, by the trigger's
+  // "Preload associations" config). Capping it by the left-side field-picker limit hid preloaded variables.
+  it('leaves the right tree untouched when rightMaxAssociationFieldDepth is null', async () => {
+    const metaTree = renderItem({ maxAssociationFieldDepth: 2, rightMaxAssociationFieldDepth: null });
+    expect(await walkToCreatedByChildren(metaTree)).toEqual(['departments']);
+  });
+});

package/src/flow/internal/components/Markdown/DisplayMarkdown.tsx

@@ -7,16 +7,17 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import React, { useRef, useState, useEffect } from 'react';
-import { useParseMarkdown, convertToText } from './util';
-import { useMarkdownStyles } from './style';
+import React, { useEffect, useRef, useState } from 'react';
 import { Tooltip } from 'antd';
+import { useMarkdownStyles } from './style';
+import { convertToText, useParseMarkdown } from './util';
 
 export const DisplayMarkdown = (props) => {
-  const { textOnly, overflowMode, style } = props;
+  const { textOnly, overflowMode, sanitizeHtml, style } = props;
   const markdownClass = useMarkdownStyles();
   const { html = '' } = useParseMarkdown(props.value);
-  const text: any = convertToText(html);
+  const displayHtml = sanitizeHtml ? sanitizeHtml(html) : html;
+  const text = convertToText(displayHtml);
   const isEllipsis = overflowMode === 'ellipsis';
 
   const contentRef = useRef<HTMLDivElement>(null);
@@ -29,7 +30,7 @@ export const DisplayMarkdown = (props) => {
       const overflowed = el.scrollWidth > el.clientWidth || el.scrollHeight > el.clientHeight;
       setIsOverflowed(overflowed);
     }
-  }, [html, style, overflowMode]);
+  }, [displayHtml, style, overflowMode]);
 
   // 通用样式（用于 ellipsis 模式）
   const baseStyle: React.CSSProperties = {
@@ -48,11 +49,15 @@ export const DisplayMarkdown = (props) => {
       : {}),
   };
 
-  const content = (
+  const content = textOnly ? (
+    <div ref={contentRef} className={`${markdownClass} nb-markdown`} style={baseStyle}>
+      {text}
+    </div>
+  ) : (
     <div
       ref={contentRef}
       className={`${markdownClass} nb-markdown`}
-      dangerouslySetInnerHTML={{ __html: textOnly ? text : html }}
+      dangerouslySetInnerHTML={{ __html: displayHtml }}
       style={baseStyle}
     />
   );
@@ -61,7 +66,7 @@ export const DisplayMarkdown = (props) => {
     <Tooltip
       title={
         <div
-          dangerouslySetInnerHTML={{ __html: html }}
+          dangerouslySetInnerHTML={{ __html: displayHtml }}
           style={{
             maxHeight: 500,
             overflowY: 'auto',

package/src/flow/internal/components/Markdown/__tests__/DisplayMarkdown.test.tsx

@@ -0,0 +1,46 @@
+/**
+ * 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 { render } from '@nocobase/test/client';
+import { sanitizeRichTextHtml } from '@nocobase/utils/client';
+import React from 'react';
+import { DisplayMarkdown } from '../DisplayMarkdown';
+
+vi.mock('../util', () => ({
+  useParseMarkdown: (value: string) => ({ html: value }),
+  convertToText: (value: string) => {
+    const element = document.createElement('div');
+    element.innerHTML = value;
+    return element.textContent || '';
+  },
+}));
+
+describe('DisplayMarkdown', () => {
+  it('sanitizes HTML mode', () => {
+    const { container } = render(
+      <DisplayMarkdown
+        value={'<p>safe</p><img src="https://example.com/image.png" onerror="alert(1)"><script>alert(1)</script>'}
+        sanitizeHtml={sanitizeRichTextHtml}
+        textOnly={false}
+      />,
+    );
+
+    expect(container.querySelector('p')).toHaveTextContent('safe');
+    expect(container.querySelector('img')).not.toHaveAttribute('onerror');
+    expect(container.querySelector('script')).toBeNull();
+  });
+
+  it('renders decoded text as a text node', () => {
+    const payload = '&lt;img src=x onerror=alert(document.domain)&gt;';
+    const { container } = render(<DisplayMarkdown value={payload} sanitizeHtml={sanitizeRichTextHtml} textOnly />);
+
+    expect(container).toHaveTextContent('<img src=x onerror=alert(document.domain)>');
+    expect(container.querySelector('img')).toBeNull();
+  });
+});

package/src/flow/internal/utils/__tests__/quickEditDataScope.test.ts

@@ -0,0 +1,156 @@
+/**
+ * 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 { beforeEach, describe, expect, it } from 'vitest';
+// Prime the model module graph: the association field models sit in an import cycle that only resolves cleanly when the
+// models barrel is loaded first.
+import '../../../models';
+import { FlowEngine, FlowModel } from '@nocobase/flow-engine';
+import { CascadeSelectFieldModel } from '../../../models/fields/AssociationFieldModel/CascadeSelectFieldModel';
+import { RecordSelectFieldModel } from '../../../models/fields/AssociationFieldModel/RecordSelectFieldModel';
+import { SelectFieldModel } from '../../../models/fields/SelectFieldModel';
+import {
+  createQuickEditDataScopeContext,
+  findDataScopeStep,
+  getQuickEditDataScopeFilter,
+  isEmptyDataScopeFilter,
+} from '../quickEditDataScope';
+
+const resolveSubTree = async (subTree: unknown) => {
+  if (typeof subTree === 'function') {
+    return (await (subTree as () => Promise<Array<{ name: string }>>)()) || [];
+  }
+  return (subTree as Array<{ name: string }>) || [];
+};
+
+describe('quickEditDataScope', () => {
+  describe('findDataScopeStep', () => {
+    it('finds the data scope step of the dropdown association editor', () => {
+      expect(findDataScopeStep(RecordSelectFieldModel)).toEqual({ flowKey: 'selectSettings', stepKey: 'dataScope' });
+    });
+
+    it('finds the data scope step of the cascade association editor', () => {
+      expect(findDataScopeStep(CascadeSelectFieldModel)).toEqual({ flowKey: 'selectSettings', stepKey: 'dataScope' });
+    });
+
+    it('returns null for editors without a data scope step', () => {
+      expect(findDataScopeStep(SelectFieldModel)).toBeNull();
+    });
+
+    it('returns null for a missing model class', () => {
+      expect(findDataScopeStep(undefined)).toBeNull();
+    });
+  });
+
+  describe('isEmptyDataScopeFilter', () => {
+    it('treats a filter without conditions as empty', () => {
+      expect(isEmptyDataScopeFilter(undefined)).toBe(true);
+      expect(isEmptyDataScopeFilter({ logic: '$and', items: [] })).toBe(true);
+    });
+
+    it('treats a filter with conditions as non-empty', () => {
+      expect(isEmptyDataScopeFilter({ logic: '$and', items: [{ path: 'name', operator: 'eq', value: 'a' }] })).toBe(
+        false,
+      );
+    });
+  });
+
+  describe('getQuickEditDataScopeFilter', () => {
+    let engine: FlowEngine;
+    let column: FlowModel;
+    let displayField: FlowModel;
+
+    beforeEach(() => {
+      engine = new FlowEngine();
+      column = engine.createModel<FlowModel>({ use: 'FlowModel', uid: 'table-column' });
+      displayField = engine.createModel<FlowModel>({ use: 'FlowModel', uid: 'display-field', parentId: column.uid });
+    });
+
+    it('reads the filter configured on the owning table column', () => {
+      const filter = { logic: '$and', items: [{ path: 'status', operator: 'eq', value: 'active' }] };
+      column.setStepParams('tableColumnSettings', 'quickEditDataScope', { filter });
+
+      expect(getQuickEditDataScopeFilter(displayField)).toEqual(filter);
+    });
+
+    it('ignores an unconfigured filter so no step params are injected', () => {
+      column.setStepParams('tableColumnSettings', 'quickEditDataScope', { filter: { logic: '$and', items: [] } });
+
+      expect(getQuickEditDataScopeFilter(displayField)).toBeUndefined();
+    });
+
+    it('returns undefined when there is no source field model', () => {
+      expect(getQuickEditDataScopeFilter(undefined)).toBeUndefined();
+    });
+  });
+
+  describe('createQuickEditDataScopeContext', () => {
+    let engine: FlowEngine;
+    let column: FlowModel;
+
+    beforeEach(() => {
+      engine = new FlowEngine();
+      const ds = engine.context.dataSourceManager.getDataSource('main');
+      ds.addCollection({
+        name: 'departments',
+        filterTargetKey: 'id',
+        titleField: 'name',
+        fields: [
+          { name: 'id', type: 'integer', interface: 'number' },
+          { name: 'name', type: 'string', interface: 'input', uiSchema: { title: 'Name' } },
+        ],
+      });
+      ds.addCollection({
+        name: 'members',
+        filterTargetKey: 'id',
+        fields: [
+          { name: 'id', type: 'integer', interface: 'number' },
+          { name: 'level', type: 'string', interface: 'input', uiSchema: { title: 'Level' } },
+          {
+            name: 'department',
+            type: 'belongsTo',
+            interface: 'm2o',
+            target: 'departments',
+            targetKey: 'id',
+            uiSchema: { title: 'Department' },
+          },
+        ],
+      });
+      const membersCollection = engine.context.dataSourceManager.getCollection('main', 'members');
+      column = engine.createModel<FlowModel>({ use: 'FlowModel', uid: 'scoped-column' });
+      column.context.defineProperty('collection', { get: () => membersCollection });
+      column.context.defineProperty('collectionField', { get: () => membersCollection.getField('department') });
+    });
+
+    it('points the left-hand field list at the association target', async () => {
+      const scoped = await createQuickEditDataScopeContext(column);
+
+      expect(scoped.collection?.name).toBe('departments');
+    });
+
+    it('offers the edited row as a right-hand variable that the column context alone does not provide', async () => {
+      // Regression guard: the right-hand tree used to come from the settings view context, which delegates to the
+      // column and therefore carries no row record, so "Current record" was missing from the variable picker.
+      const columnTree = column.context.getPropertyMetaTree();
+      expect(columnTree.find((node) => node.name === 'record')).toBeUndefined();
+
+      const scoped = await createQuickEditDataScopeContext(column);
+      const scopedTree = scoped.getPropertyMetaTree();
+
+      expect(scopedTree.find((node) => node.name === 'record')).toBeDefined();
+    });
+
+    it('keeps the row record describing the table collection rather than the association target', async () => {
+      const scoped = await createQuickEditDataScopeContext(column);
+      const recordSubTree = await resolveSubTree(scoped.getPropertyMetaTree('{{ ctx.record }}'));
+
+      expect(recordSubTree.map((node) => node.name)).toContain('level');
+    });
+  });
+});

package/src/flow/internal/utils/__tests__/quickEditViewContainer.test.ts

@@ -0,0 +1,52 @@
+/**
+ * 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 { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { getQuickEditViewContainer, syncQuickEditPreventClose } from '../quickEditViewContainer';
+
+describe('quickEditViewContainer', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('only resolves the view container of a QuickEditFormModel parent', () => {
+    const viewContainer = { update: vi.fn() };
+    expect(getQuickEditViewContainer({ parent: { use: 'QuickEditFormModel', viewContainer } })).toBe(viewContainer);
+    expect(getQuickEditViewContainer({ parent: { use: 'EditFormModel', viewContainer } })).toBeUndefined();
+    expect(getQuickEditViewContainer({ parent: null })).toBeUndefined();
+    expect(getQuickEditViewContainer(undefined)).toBeUndefined();
+  });
+
+  it('locks the popover while the dropdown is open and releases it after the closing click', () => {
+    const update = vi.fn();
+    const model = { parent: { use: 'QuickEditFormModel', viewContainer: { update } } };
+
+    syncQuickEditPreventClose(model, true);
+    expect(update).toHaveBeenCalledWith({ preventClose: true });
+
+    syncQuickEditPreventClose(model, false);
+    expect(update).toHaveBeenCalledTimes(1);
+
+    vi.runAllTimers();
+    expect(update).toHaveBeenCalledTimes(2);
+    expect(update).toHaveBeenLastCalledWith({ preventClose: false });
+  });
+
+  it('is a no-op outside of quick edit', () => {
+    const update = vi.fn();
+    syncQuickEditPreventClose({ parent: { use: 'EditFormModel', viewContainer: { update } } }, true);
+    syncQuickEditPreventClose({ parent: { use: 'QuickEditFormModel' } }, true);
+    vi.runAllTimers();
+    expect(update).not.toHaveBeenCalled();
+  });
+});

package/src/flow/internal/utils/quickEditDataScope.tsx

@@ -0,0 +1,177 @@
+/**
+ * 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 { FlowEngineContext, ModelConstructor } from '@nocobase/flow-engine';
+import {
+  CollectionField,
+  FlowModel,
+  createCollectionContextMeta,
+  createCurrentRecordMetaFactory,
+  createEphemeralContext,
+  useFlowSettingsContext,
+} from '@nocobase/flow-engine';
+import { Skeleton } from 'antd';
+import React, { useCallback, useEffect, useState } from 'react';
+import { FilterGroup, VariableFilterItem } from '../../components/filter';
+import { FormItemModel } from '../../models/blocks/form/FormItemModel';
+
+const DATA_SCOPE_ACTION_NAME = 'dataScope';
+
+export const QUICK_EDIT_DATA_SCOPE_FLOW_KEY = 'tableColumnSettings';
+export const QUICK_EDIT_DATA_SCOPE_STEP_KEY = 'quickEditDataScope';
+
+export type DataScopeStepLocation = { flowKey: string; stepKey: string };
+
+/**
+ * Minimal shape read off a model class: the static flow registry and the `use` of each step. `ModelConstructor` does not
+ * declare the registry, so the lookup reaches for it through this shape instead of widening to `any`.
+ */
+type FlowRegistryHolder = {
+  globalFlowRegistry?: {
+    getFlows?: () => Map<string, { steps?: Record<string, { use?: string } | undefined> } | undefined>;
+  };
+};
+
+type DataScopeFilter = { logic?: string; items?: unknown[] } | undefined;
+
+/**
+ * Locate the flow and step that carry the shared `dataScope` action on a field model class. Both association editors
+ * currently keep it under `selectSettings`, but the lookup resolves it from the class instead of hard-coding that name,
+ * so an editor registered later is picked up without touching the quick edit path. Returns the first match.
+ */
+export function findDataScopeStep(
+  ModelClass: ModelConstructor | typeof FlowModel | undefined | null,
+): DataScopeStepLocation | null {
+  const flows = (ModelClass as unknown as FlowRegistryHolder | undefined)?.globalFlowRegistry?.getFlows?.();
+  if (!flows) {
+    return null;
+  }
+  for (const [flowKey, flow] of flows) {
+    for (const [stepKey, step] of Object.entries(flow?.steps || {})) {
+      if (step?.use === DATA_SCOPE_ACTION_NAME) {
+        return { flowKey, stepKey };
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Resolve the data scope step of the editor model that the quick edit popover builds for `collectionField`. Returns null
+ * when the field is not an association or when its default editor has no data scope step, which is what the column
+ * setting uses to decide whether to offer the item at all.
+ */
+export function resolveQuickEditDataScopeStep(
+  ctx: FlowEngineContext,
+  collectionField: CollectionField,
+): DataScopeStepLocation | null {
+  if (!collectionField?.isAssociationField?.()) {
+    return null;
+  }
+  // Resolve through the same class the quick edit popover builds its editor with, so the setting is offered exactly
+  // when the editor that will actually open has a data scope step.
+  const binding = FormItemModel.getDefaultBindingByField(ctx, collectionField);
+  if (!binding?.modelName) {
+    return null;
+  }
+  return findDataScopeStep(ctx.engine?.getModelClass?.(binding.modelName));
+}
+
+export function isEmptyDataScopeFilter(filter: DataScopeFilter) {
+  return !filter || !Array.isArray(filter.items) || filter.items.length === 0;
+}
+
+/** Read the quick edit data scope filter stored on the table column that owns `sourceFieldModel`. */
+export function getQuickEditDataScopeFilter(sourceFieldModel?: FlowModel): DataScopeFilter {
+  const columnModel = sourceFieldModel?.parent as FlowModel | undefined;
+  const params = columnModel?.getStepParams?.(QUICK_EDIT_DATA_SCOPE_FLOW_KEY, QUICK_EDIT_DATA_SCOPE_STEP_KEY);
+  const filter = params?.filter as DataScopeFilter;
+  return isEmptyDataScopeFilter(filter) ? undefined : filter;
+}
+
+/**
+ * Context the filter builder is configured against. The setting lives on the table column, but the filter describes
+ * records of the association target, so `collection` points at the target collection to drive the left-hand field list.
+ * `record` is declared with meta only so that "Current record" is offered as a right-hand variable and describes the row
+ * being edited rather than whatever record an enclosing popup happens to supply; it has no value while configuring and
+ * resolves per row once the popover opens.
+ */
+export function createQuickEditDataScopeContext(columnModel: FlowModel) {
+  const collectionField = columnModel.context.collectionField as CollectionField;
+  const getTargetCollection = () => collectionField?.targetCollection ?? null;
+  const getSourceCollection = () => columnModel.context.collection ?? null;
+  return createEphemeralContext(columnModel.context, {
+    defineProperties: {
+      collection: {
+        get: getTargetCollection,
+        meta: createCollectionContextMeta(getTargetCollection, 'Current collection'),
+      },
+      record: {
+        get: () => undefined,
+        meta: createCurrentRecordMetaFactory(columnModel.context, getSourceCollection),
+      },
+    },
+  });
+}
+
+/** Wrap the column model so the filter builder reads the scoped context instead of the column's own. */
+function useQuickEditDataScopeModel(columnModel: FlowModel): FlowModel | null {
+  const [scopedModel, setScopedModel] = useState<FlowModel | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    const build = async () => {
+      const scopedContext = await createQuickEditDataScopeContext(columnModel);
+      if (cancelled) {
+        return;
+      }
+      setScopedModel(
+        new Proxy(columnModel, {
+          get(target, key, receiver) {
+            if (key === 'context') {
+              return scopedContext;
+            }
+            const value = Reflect.get(target, key, receiver);
+            return typeof value === 'function' ? value.bind(target) : value;
+          },
+        }),
+      );
+    };
+
+    build();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [columnModel]);
+
+  return scopedModel;
+}
+
+export function QuickEditDataScopeInput(props: { value?: Record<string, any> }) {
+  const flowContext = useFlowSettingsContext<FlowModel>();
+  const scopedModel = useQuickEditDataScopeModel(flowContext.model);
+  // The right-hand variable tree defaults to the settings view context, which delegates to the table column and
+  // therefore carries no row record. Feed it the scoped context so "Current record" is offered and describes the row.
+  const rightMetaTree = useCallback(() => scopedModel?.context.getPropertyMetaTree() ?? [], [scopedModel]);
+
+  if (!scopedModel) {
+    return <Skeleton.Input active size="small" />;
+  }
+
+  return (
+    <FilterGroup
+      value={props.value}
+      FilterItem={(p) => (
+        <VariableFilterItem {...p} model={scopedModel} rightAsVariable rightMetaTree={rightMetaTree} />
+      )}
+    />
+  );
+}