@nocobase/client-v2 2.2.0-beta.15 → 2.2.0-beta.17

package/src/flow/models/blocks/form/value-runtime/runtime.ts

@@ -86,6 +86,10 @@ export class FormValueRuntime {
 
     this.ruleEngine = new RuleEngine({
       getBlockModelUid: () => String(this.model?.uid),
+      getAssignRulesModelUid: () => {
+        const grid = this.model?.subModels?.grid;
+        return !Array.isArray(grid) && grid?.uid ? String(grid.uid) : undefined;
+      },
       getActionName: () => this.model?.getAclActionName?.() ?? this.model?.context?.actionName,
       getBlockContext: () => this.model?.context,
       getEngine: () => this.model?.context?.engine,
@@ -190,13 +194,32 @@ export class FormValueRuntime {
     return values;
   }
 
-  private toMirrorSnapshot(value: any) {
-    const raw = isObservable(value) ? toJS(value) : value;
-    return _.cloneDeepWith(raw, (item) => {
-      if (!item || typeof item !== 'object') return undefined;
-      if (Array.isArray(item) || _.isPlainObject(item)) return undefined;
-      return item;
-    });
+  private toMirrorSnapshot<T>(value: T): T {
+    const cloneValue = (input: unknown): unknown =>
+      _.cloneDeepWith(input, (item: unknown) => {
+        if (isObservable(item)) {
+          const plainItem = toJS(item);
+          if (plainItem !== item) return cloneValue(plainItem);
+        }
+
+        // Tracking form-value array proxies hide `constructor`, while Lodash's array
+        // clone relies on it being callable.
+        if (Array.isArray(item) && typeof item.constructor !== 'function') {
+          const plainArray = new Array(item.length);
+          for (let index = 0; index < item.length; index++) {
+            if (Object.hasOwn(item, index)) {
+              plainArray[index] = cloneValue(item[index]);
+            }
+          }
+          return plainArray;
+        }
+
+        if (!item || typeof item !== 'object') return undefined;
+        if (Array.isArray(item) || _.isPlainObject(item)) return undefined;
+        return item;
+      });
+
+    return cloneValue(value) as T;
   }
 
   canApplyDefaultValuePatch(namePath: NamePath, resolved: any) {
@@ -940,11 +963,12 @@ export class FormValueRuntime {
       const changedPaths: NamePath[] = [];
 
       if (!Array.isArray(patch)) {
-        const patchEntries = Object.entries(patch || {}).filter(([pathKey, rawValue]) => {
-          if (shouldSkipByLinkageScope(pathKey)) return false;
-          const value = isObservable(rawValue) ? toJS(rawValue) : rawValue;
-          return !_.isEqual(this.getFormValueAtPath([pathKey]), value);
-        });
+        const patchEntries = Object.entries(patch || {})
+          .map(([pathKey, rawValue]) => [pathKey, this.toMirrorSnapshot(rawValue)] as const)
+          .filter(([pathKey, value]) => {
+            if (shouldSkipByLinkageScope(pathKey)) return false;
+            return !_.isEqual(this.getFormValueAtPath([pathKey]), value);
+          });
         const patchToApply = Object.fromEntries(patchEntries);
         const patchKeys = patchEntries.map(([pathKey]) => pathKey);
         if (!patchKeys.length) {
@@ -955,8 +979,7 @@ export class FormValueRuntime {
         }
         this.suppressFormCallbackDepth++;
         try {
-          for (const [pathKey, rawValue] of patchEntries) {
-            const value = isObservable(rawValue) ? toJS(rawValue) : rawValue;
+          for (const [pathKey, value] of patchEntries) {
             if (typeof form.setFieldValue === 'function') {
               form.setFieldValue(pathKey, value);
             } else if (typeof (form as any).setFields === 'function') {
@@ -1017,7 +1040,7 @@ export class FormValueRuntime {
         const namePath = this.resolveNamePath(callerCtx, item.path);
         const pathKey = namePathToPathKey(namePath);
         const rawValue = item.value;
-        const value = isObservable(rawValue) ? toJS(rawValue) : rawValue;
+        const value = this.toMirrorSnapshot(rawValue);
 
         if (shouldSkipByLinkageScope(pathKey)) continue;
 
@@ -1156,17 +1179,18 @@ export class FormValueRuntime {
     if (!form) return;
     if (source === 'override' && this.findUserEditedHit(pathKey)) return;
 
+    const value = this.toMirrorSnapshot(nextValue);
     const prevValue = _.get(this.valuesMirror, namePath);
-    if (_.isEqual(prevValue, nextValue)) return;
+    if (_.isEqual(prevValue, value)) return;
 
     this.writeSeq += 1;
     const writeSeq = this.writeSeq;
 
     this.suppressFormCallbackDepth++;
     try {
-      form.setFieldValue?.(namePath, nextValue);
-      _.set(this.valuesMirror, namePath, this.toMirrorSnapshot(nextValue));
-      this.syncMountedFieldModelValue(namePath, nextValue);
+      form.setFieldValue?.(namePath, value);
+      _.set(this.valuesMirror, namePath, this.toMirrorSnapshot(value));
+      this.syncMountedFieldModelValue(namePath, value);
       this.bumpChangeTick();
     } finally {
       this.suppressFormCallbackDepth--;

package/src/flow/models/blocks/js-block/JSBlock.tsx

@@ -235,7 +235,7 @@ export class JSBlockModel extends BlockModel {
     const cardProps = {
       ...rest,
       height,
-      style,
+      ...(style === undefined ? {} : { style }),
       ...(beforeContent === undefined ? {} : { beforeContent }),
       ...(afterContent === undefined ? {} : { afterContent }),
     };

package/src/flow/models/blocks/table/JSColumnModel.tsx

@@ -9,13 +9,14 @@
 
 import { LockOutlined, QuestionCircleOutlined } from '@ant-design/icons';
 import { css } from '@emotion/css';
-import type { PropertyMetaFactory } from '@nocobase/flow-engine';
+import type { FlowModelOptions, PropertyMetaFactory } from '@nocobase/flow-engine';
 import {
   Droppable,
   tExpr,
   FlowsFloatContextMenu,
   DragHandler,
   MemoFlowModelRenderer,
+  createCurrentRecordMetaFactory,
   createRecordMetaFactory,
   createRecordResolveOnServerWithLocal,
   ElementProxy,
@@ -51,6 +52,14 @@ function getRecordRenderSignature(record: any) {
 export class JSColumnModel extends TableCustomColumnModel {
   // Stable per‑instance render component to avoid remounts across re-renders
   private _RenderComponent?: React.ComponentType;
+
+  onInit(options: FlowModelOptions): void {
+    super.onInit(options);
+    this.context.defineProperty('record', {
+      meta: createCurrentRecordMetaFactory(this.context, () => this.context.collection),
+    });
+  }
+
   renderHiddenInConfig() {
     return (
       <Tooltip

package/src/flow/models/blocks/table/TableBlockModel.tsx

@@ -244,7 +244,9 @@ export class TableBlockModel extends CollectionBlockModel<TableBlockModelStructu
   }
 
   createResource(ctx, params) {
-    return this.context.createResource(MultiRecordResource);
+    const resource = this.context.createResource(MultiRecordResource);
+    resource.addRequestHeader('X-With-ACL-Meta', 'true');
+    return resource;
   }
 
   /**

package/src/flow/models/blocks/table/TableColumnModel.tsx

@@ -194,6 +194,35 @@ export class TableColumnModel extends DisplayItemModel {
       .filter(Boolean);
   }
 
+  canQuickEdit(record: Record<string, unknown>): boolean {
+    if (!this.props.editable) {
+      return false;
+    }
+    if (this.context.skipAclCheck) {
+      return true;
+    }
+
+    const blockModel = this.context.blockModel;
+    const collection = blockModel?.collection;
+    const resource = blockModel?.resource;
+    const collectionField = this.collectionField;
+    if (!collection || !resource || !collectionField) {
+      return false;
+    }
+
+    const filterByTk = collection.getFilterByTK(record);
+    const recordPkValue = typeof filterByTk === 'string' || typeof filterByTk === 'number' ? filterByTk : undefined;
+
+    return this.context.acl.can({
+      dataSourceKey: collection.dataSourceKey,
+      resourceName: resource.getResourceName() || collection.name,
+      actionName: 'update',
+      recordPkValue,
+      allowedActions: resource.getMeta('allowedActions'),
+      fields: [collectionField.name],
+    });
+  }
+
   getColumnProps(): TableColumnProps & { sortField?: string } {
     if (!this.props.width) {
       return;
@@ -250,7 +279,7 @@ export class TableColumnModel extends DisplayItemModel {
           record,
           recordIndex: record?.__index || recordIndex,
           width: this.props.width - 16,
-          editable: this.props.editable,
+          editable: this.canQuickEdit(record),
           dataIndex: this.props.dataIndex,
           title: this.props.title,
           overflowMode: this.props.overflowMode,

package/src/flow/models/blocks/table/__tests__/JSColumnModel.test.tsx

@@ -11,17 +11,62 @@ import { FlowEngine } from '@nocobase/flow-engine';
 import { describe, expect, it, vi } from 'vitest';
 import { JSColumnModel } from '../JSColumnModel';
 
-describe('JSColumnModel row refresh', () => {
+describe('JSColumnModel', () => {
+  it('declares current record metadata before rendering any row', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ JSColumnModel });
+    const model = engine.createModel<JSColumnModel>({
+      use: 'JSColumnModel',
+      uid: 'js-column-record-meta',
+      props: {
+        width: 200,
+        title: 'JS column',
+      },
+    });
+
+    engine.context.dataSourceManager.getDataSource('main').addCollection({
+      name: 'users',
+      filterTargetKey: 'id',
+      fields: [
+        { name: 'id', type: 'integer', interface: 'number' },
+        { name: 'age', type: 'integer', interface: 'integer' },
+      ],
+    });
+
+    const collection = engine.context.dataSourceManager.getCollection('main', 'users');
+    model.context.defineProperty('collection', {
+      value: collection,
+    });
+
+    const recordNode = model.context.getPropertyMetaTree().find((node) => node.name === 'record');
+    const recordFields =
+      typeof recordNode?.children === 'function' ? await recordNode.children() : recordNode?.children || [];
+
+    expect(model.context.record).toBeUndefined();
+    expect(recordNode).toMatchObject({
+      name: 'record',
+      title: 'Current record',
+      paths: ['record'],
+    });
+    expect(recordFields).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ name: 'id', paths: ['record', 'id'] }),
+        expect.objectContaining({ name: 'age', paths: ['record', 'age'] }),
+      ]),
+    );
+  });
+
   it('changes renderer key and invalidates beforeRender cache when row content changes', () => {
     const engine = new FlowEngine();
-    const model = new JSColumnModel({
+    engine.registerModels({ JSColumnModel });
+    const model = engine.createModel<JSColumnModel>({
+      use: 'JSColumnModel',
       uid: 'js-column-row-refresh',
-      flowEngine: engine,
       props: {
         width: 200,
         title: 'JS column',
       },
-    } as any);
+    });
 
     engine.context.dataSourceManager.getDataSource('main').addCollection({
       name: 'users',
@@ -39,12 +84,14 @@ describe('JSColumnModel row refresh', () => {
     });
 
     const column = model.getColumnProps();
-    const first = column.render(null, { id: 1, age: 3, workyears: 39.2 }, 0) as any;
+    const firstRecord = { id: 1, age: 3, workyears: 39.2 };
+    const first = column.render(null, firstRecord, 0) as any;
     const fork = model.getFork('1') as any;
     const invalidateFlowCache = vi.fn();
     fork.invalidateFlowCache = invalidateFlowCache;
     const second = column.render(null, { id: 1, age: 37, workyears: 39.2 }, 0) as any;
 
+    expect(fork.context.record).toEqual({ id: 1, age: 37, workyears: 39.2 });
     expect(first.key).not.toBe(second.key);
     expect(invalidateFlowCache).toHaveBeenCalledWith('beforeRender');
   });

package/src/flow/models/blocks/table/__tests__/TableBlockModel.quickEditRefresh.test.ts

@@ -9,8 +9,20 @@
 
 import { FlowEngine, MultiRecordResource } from '@nocobase/flow-engine';
 import { describe, expect, it } from 'vitest';
+import { TableBlockModel } from '../TableBlockModel';
 
 describe('TableBlockModel quick edit refresh', () => {
+  it('requests record-level ACL metadata for table data', () => {
+    const engine = new FlowEngine();
+    const model = {
+      context: engine.context,
+    };
+
+    const resource = TableBlockModel.prototype.createResource.call(model, {}, {});
+
+    expect(resource.getRequestOptions().headers['X-With-ACL-Meta']).toBe('true');
+  });
+
   it('updates table data through a new array reference after quick editing a flat row', () => {
     const engine = new FlowEngine();
     const resource = engine.context.createResource(MultiRecordResource);

package/src/flow/models/blocks/table/__tests__/TableColumnModel.test.tsx

@@ -66,6 +66,39 @@ describe('TableColumnModel sorter settings', () => {
     expect(setProps).toHaveBeenCalledWith('editable', false);
   });
 
+  it('checks record update scope and field permission before enabling quick edit', () => {
+    const can = vi.fn(() => false);
+    const model = {
+      props: { editable: true },
+      collectionField: { name: 'title' },
+      context: {
+        skipAclCheck: false,
+        acl: { can },
+        blockModel: {
+          collection: {
+            dataSourceKey: 'main',
+            name: 'posts',
+            getFilterByTK: () => 2,
+          },
+          resource: {
+            getResourceName: () => 'posts',
+            getMeta: () => ({ update: [1] }),
+          },
+        },
+      },
+    };
+
+    expect(TableColumnModel.prototype.canQuickEdit.call(model, { id: 2 })).toBe(false);
+    expect(can).toHaveBeenCalledWith({
+      dataSourceKey: 'main',
+      resourceName: 'posts',
+      actionName: 'update',
+      recordPkValue: 2,
+      allowedActions: { update: [1] },
+      fields: ['title'],
+    });
+  });
+
   it('hides sortable setting for association fields', async () => {
     const engine = new FlowEngine();
     const model = new TableColumnModel({ uid: 'table-column-association-sorter', flowEngine: engine } as any);

package/src/flow/models/fields/AssociationFieldModel/PopupSubTableFieldModel/PopupSubTableFieldModel.tsx

@@ -28,6 +28,7 @@ import { observer } from '@formily/reactive-react';
 import React, { useEffect, useMemo, useState, useRef } from 'react';
 import { useTranslation } from 'react-i18next';
 import { buildRecordPickerPopupContextInputArgs, RecordPickerContent } from '../RecordPickerFieldModel';
+import { buildOpenerUids } from '../recordSelectShared';
 import { AssociationFieldModel } from '../AssociationFieldModel';
 import { adjustColumnOrder } from '../../../blocks/table/utils';
 import { isSubTableColumnFieldComponentContext } from '../SubTableFieldModel/SubTableColumnModel';
@@ -653,6 +654,11 @@ PopupSubTableFieldModel.registerFlow({
         const parentItemOptions = ctx?.getPropertyOptions?.('item');
         const itemIndex = Array.isArray(ctx.model?.props?.value) ? ctx.model.props.value.length : 0;
         const itemLength = itemIndex + 1;
+        const associationName = ctx.collectionField?.resourceName;
+        const sourceId = parentItem?.value
+          ? ctx.collectionField?.collection?.getFilterByTK?.(parentItem.value)
+          : undefined;
+        const openerUids = buildOpenerUids(ctx, ctx.inputArgs);
         ctx.viewer.open({
           type: openMode,
           width: sizeToWidthMap[openMode][size],
@@ -663,12 +669,14 @@ PopupSubTableFieldModel.registerFlow({
             scene: 'subForm',
             dataSourceKey: ctx.collection.dataSourceKey,
             collectionName: ctx.collectionField?.target,
+            ...(associationName && sourceId != null ? { associationName, sourceId } : {}),
             collectionField: ctx.collectionField,
             parentItem,
             parentItemMeta: parentItemOptions?.meta,
             parentItemResolver: parentItemOptions?.resolveOnServer,
             itemIndex,
             itemLength,
+            openerUids,
           },
           content: () => <EditFormContent model={ctx.model} scene="create" />,
           styles: {

package/src/flow/models/fields/AssociationFieldModel/PopupSubTableFieldModel/__tests__/popupContext.test.ts

@@ -0,0 +1,120 @@
+/**
+ * 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 { describe, expect, it, vi } from 'vitest';
+import { PopupSubTableFieldModel } from '../PopupSubTableFieldModel';
+import { PopupSubTableEditActionModel } from '../actions/PopupSubTableEditActionModel';
+
+function getOpenViewHandler(modelClass: typeof PopupSubTableFieldModel | typeof PopupSubTableEditActionModel) {
+  const flow = modelClass.globalFlowRegistry.getFlow('popupSettings');
+  const step = flow?.getStep('openView');
+  const handler = step?.serialize().handler;
+
+  if (!handler) {
+    throw new Error('popupSettings.openView handler is not registered');
+  }
+
+  return handler;
+}
+
+function createContext(record?: Record<string, unknown>, parentRecord: Record<string, unknown> = { id: 1 }) {
+  const open = vi.fn();
+  const sourceCollection = {
+    getFilterByTK: vi.fn((sourceRecord: Record<string, unknown>) => sourceRecord.id),
+  };
+  const model = {
+    uid: 'popup-subtable-uid',
+    props: {
+      value: record ? [record] : [],
+    },
+    context: {
+      inputArgs: {},
+    },
+    flowEngine: {
+      context: {
+        themeToken: {
+          colorBgLayout: '#fff',
+        },
+      },
+    },
+  };
+
+  return {
+    open,
+    context: {
+      inputArgs: {},
+      item: {
+        value: parentRecord,
+      },
+      view: {
+        inputArgs: {
+          viewUid: 'parent-popup-uid',
+          openerUids: ['root-page-uid'],
+        },
+      },
+      viewer: { open },
+      layoutContentElement: {},
+      model,
+      associationModel: model,
+      collection: {
+        dataSourceKey: 'main',
+        filterTargetKey: 'id',
+      },
+      collectionField: {
+        target: 'roles',
+        resourceName: 'users.roles',
+        collection: sourceCollection,
+      },
+      record,
+      getFormValues: () => ({ id: 1 }),
+      getPropertyOptions: () => undefined,
+    },
+  };
+}
+
+describe('PopupSubTable popup context', () => {
+  it('passes popup and parent record context to the add-new popup', () => {
+    const { context, open } = createContext();
+    const handler = getOpenViewHandler(PopupSubTableFieldModel);
+
+    handler(context, { mode: 'drawer', size: 'medium' });
+
+    expect(open).toHaveBeenCalledOnce();
+    expect(open.mock.calls[0][0].inputArgs).toMatchObject({
+      openerUids: ['root-page-uid', 'parent-popup-uid'],
+      associationName: 'users.roles',
+      sourceId: 1,
+    });
+  });
+
+  it('passes popup and parent record context to the edit popup', () => {
+    const { context, open } = createContext({ id: 2, name: 'Member' });
+    const handler = getOpenViewHandler(PopupSubTableEditActionModel);
+
+    handler(context, { mode: 'dialog', size: 'medium' });
+
+    expect(open).toHaveBeenCalledOnce();
+    expect(open.mock.calls[0][0].inputArgs).toMatchObject({
+      openerUids: ['root-page-uid', 'parent-popup-uid'],
+      associationName: 'users.roles',
+      sourceId: 1,
+    });
+  });
+
+  it('does not expose a parent record reference before the parent record is persisted', () => {
+    const { context, open } = createContext(undefined, { nickname: 'Draft user' });
+    const handler = getOpenViewHandler(PopupSubTableFieldModel);
+
+    handler(context, { mode: 'drawer', size: 'medium' });
+
+    expect(open).toHaveBeenCalledOnce();
+    expect(open.mock.calls[0][0].inputArgs).not.toHaveProperty('associationName');
+    expect(open.mock.calls[0][0].inputArgs).not.toHaveProperty('sourceId');
+  });
+});

package/src/flow/models/fields/AssociationFieldModel/PopupSubTableFieldModel/actions/PopupSubTableEditActionModel.tsx

@@ -17,6 +17,7 @@ import { capitalize } from 'lodash';
 import '../../../../base/ActionModel';
 import { ActionModel, ActionWithoutPermission } from '../../../../base/ActionModelCore';
 import { SkeletonFallback } from '../../../../../components/SkeletonFallback';
+import { buildOpenerUids } from '../../recordSelectShared';
 import { bindPopupSubTableBeforeClose } from './popupSubTableBeforeClose';
 
 function FieldWithoutPermissionPlaceholder({ targetModel, children }) {
@@ -29,7 +30,7 @@ function FieldWithoutPermissionPlaceholder({ targetModel, children }) {
     const dataSourcePrefix = `${t(dataSource.displayName || dataSource.key)} > `;
     const collectionPrefix = collection ? `${t(collection.title) || collection.name || collection.tableName} > ` : '';
     return `${dataSourcePrefix}${collectionPrefix}${name}`;
-  }, []);
+  }, [collection, dataSource.displayName, dataSource.key, name, t]);
   const { actionName } = fieldModel.forbidden || {};
   const messageValue = useMemo(() => {
     return t(
@@ -39,7 +40,7 @@ function FieldWithoutPermissionPlaceholder({ targetModel, children }) {
         actionName: t(capitalize(actionName)),
       },
     ).replaceAll('>', '>');
-  }, [nameValue, t]);
+  }, [actionName, nameValue, t]);
   return <Tooltip title={messageValue}>{children}</Tooltip>;
 }
 
@@ -347,6 +348,11 @@ PopupSubTableEditActionModel.registerFlow({
             return undefined;
           }
         })();
+        const associationName = ctx.collectionField?.resourceName;
+        const sourceId = parentItem?.value
+          ? ctx.collectionField?.collection?.getFilterByTK?.(parentItem.value)
+          : undefined;
+        const openerUids = buildOpenerUids(ctx, ctx.inputArgs);
         ctx.viewer.open({
           type: openMode,
           width: sizeToWidthMap[openMode][size],
@@ -357,6 +363,7 @@ PopupSubTableEditActionModel.registerFlow({
             scene: 'subForm',
             dataSourceKey: ctx.collection.dataSourceKey,
             collectionName: ctx.collectionField?.target,
+            ...(associationName && sourceId != null ? { associationName, sourceId } : {}),
             collectionField: ctx.collectionField,
             record: ctx.record,
             parentItem,
@@ -364,6 +371,7 @@ PopupSubTableEditActionModel.registerFlow({
             parentItemResolver: parentItemOptions?.resolveOnServer,
             itemIndex,
             itemLength,
+            openerUids,
           },
           content: () => <EditFormContent model={ctx.model} />,
           styles: {

package/src/flow/models/fields/AssociationFieldModel/__tests__/RecordPickerFieldModel.itemContext.test.ts

@@ -243,6 +243,52 @@ describe('RecordPickerFieldModel item context', () => {
     expect(associationOpts.serverOnlyWhenContextParams).toBe(true);
   });
 
+  it('builds whole-association descriptors for current and recursive parent item values', async () => {
+    const people = {
+      name: 'people',
+      dataSourceKey: 'main',
+      filterTargetKey: 'id',
+      getFields: () => [],
+      getField: () => undefined,
+    } as any;
+    const owner = {
+      name: 'owner',
+      target: 'people',
+      targetCollection: people,
+      isAssociationField: () => true,
+    } as any;
+    const collection = {
+      name: 'tasks',
+      dataSourceKey: 'main',
+      getFields: () => [owner],
+      getField: (name: string) => (name === 'owner' ? owner : undefined),
+    } as any;
+    const options = createAssociationItemChainContextPropertyOptions({
+      t: (value) => value,
+      title: 'Current item',
+      collectionAccessor: () => collection,
+      propertiesAccessor: (ctx) => ctx.item.value,
+      resolverPropertiesAccessor: () => ({ owner: { id: 7 } }),
+      parentCollectionAccessor: () => collection,
+      parentAccessors: {
+        parentPropertiesAccessor: () => ({ owner: { id: 8 } }),
+        parentItemMetaAccessor: () => undefined,
+        parentItemResolverAccessor: () => undefined,
+      },
+    });
+    const meta = await options.meta();
+    const params = await meta.buildVariablesParams({
+      item: { value: { owner: { id: 7 } }, parentItem: { value: { owner: { id: 8 } } } },
+    });
+
+    expect(params).toEqual({
+      parentItem: { value: { owner: { collection: 'people', dataSourceKey: 'main', filterByTk: 8 } } },
+      value: { owner: { collection: 'people', dataSourceKey: 'main', filterByTk: 7 } },
+    });
+    expect(options.resolveOnServer('value.owner.name')).toBe(true);
+    expect(options.resolveOnServer('parentItem.value.owner.name')).toBe(true);
+  });
+
   it('disables current item attributes for select-record popup item context', async () => {
     const parentCtx = new FlowContext();
     const departmentsCollection = {