@nocobase/flow-engine 2.1.0-alpha.4 → 2.1.0-alpha.45

package/src/reactive/__tests__/observer.test.tsx

@@ -208,4 +208,86 @@ describe('observer', () => {
     expect(screen.getByText('Count: 0')).toBeInTheDocument();
     expect(screen.queryByText('Count: 1')).not.toBeInTheDocument();
   });
+
+  it('should flush pending update without TDZ error when context becomes active before timer callback runs', async () => {
+    vi.useFakeTimers();
+
+    try {
+      const model = observable({ count: 0 });
+      const pageActive = observable.ref(false);
+      const tabActive = observable.ref(true);
+
+      const context = {
+        pageActive,
+        tabActive,
+      };
+
+      (useFlowContext as any).mockReturnValue(context);
+
+      const Component = observer(() => <div>Count: {model.count}</div>);
+
+      render(<Component />);
+
+      expect(screen.getByText('Count: 0')).toBeInTheDocument();
+
+      act(() => {
+        model.count++;
+        pageActive.value = true;
+      });
+
+      await act(async () => {
+        await vi.runAllTimersAsync();
+      });
+
+      expect(screen.getByText('Count: 1')).toBeInTheDocument();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('should cleanup pending timer and listener on unmount', async () => {
+    vi.useFakeTimers();
+
+    try {
+      const model = observable({ count: 0 });
+      const pageActive = observable.ref(false);
+      const tabActive = observable.ref(true);
+      const renderSpy = vi.fn();
+
+      const context = {
+        pageActive,
+        tabActive,
+      };
+
+      (useFlowContext as any).mockReturnValue(context);
+
+      const Component = observer(() => {
+        renderSpy(model.count);
+        return <div>Count: {model.count}</div>;
+      });
+
+      const { unmount } = render(<Component />);
+
+      expect(renderSpy).toHaveBeenCalledTimes(1);
+      expect(screen.getByText('Count: 0')).toBeInTheDocument();
+
+      act(() => {
+        model.count++;
+      });
+
+      unmount();
+
+      act(() => {
+        pageActive.value = true;
+      });
+
+      await act(async () => {
+        await vi.runAllTimersAsync();
+      });
+
+      expect(renderSpy).toHaveBeenCalledTimes(1);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
 });

package/src/reactive/observer.tsx

@@ -10,7 +10,7 @@
 import { observer as originalObserver, IObserverOptions, ReactFC } from '@formily/reactive-react';
 import React, { useMemo, useEffect, useRef } from 'react';
 import { useFlowContext } from '../FlowContextProvider';
-import { autorun } from '@formily/reactive';
+import { reaction } from '@formily/reactive';
 import { FlowEngineContext } from '..';
 
 type ObserverComponentProps<P, Options extends IObserverOptions> = Options extends {
@@ -30,12 +30,67 @@ export const observer = <P, Options extends IObserverOptions = IObserverOptions>
     const ctxRef = useRef(ctx);
     ctxRef.current = ctx;
 
-    // Store the pending disposer to avoid creating multiple listeners
+    // 保存延迟更新的监听器，避免重复创建监听。
     const pendingDisposerRef = useRef<(() => void) | null>(null);
+    // 保存延迟创建监听器的定时器，避免组件卸载后仍继续调度。
+    const pendingTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 
-    // Cleanup on unmount
+    /**
+     * 清理挂起的可见性监听器。
+     *
+     * @example
+     * ```typescript
+     * clearPendingDisposer();
+     * ```
+     */
+    const clearPendingDisposer = () => {
+      if (pendingDisposerRef.current) {
+        pendingDisposerRef.current();
+        pendingDisposerRef.current = null;
+      }
+    };
+
+    /**
+     * 清理挂起的定时器。
+     *
+     * @example
+     * ```typescript
+     * clearPendingTimer();
+     * ```
+     */
+    const clearPendingTimer = () => {
+      if (pendingTimerRef.current) {
+        clearTimeout(pendingTimerRef.current);
+        pendingTimerRef.current = null;
+      }
+    };
+
+    /**
+     * 判断当前页面与标签页是否允许立即更新。
+     *
+     * @returns 当前上下文是否处于可更新状态。
+     * @example
+     * ```typescript
+     * if (isContextActive()) {
+     *   updater();
+     * }
+     * ```
+     */
+    const isContextActive = () => {
+      const pageActive = getPageActive(ctxRef.current);
+      const tabActive = ctxRef.current?.tabActive?.value;
+
+      return pageActive !== false && tabActive !== false;
+    };
+
+    // 组件卸载时统一清理所有挂起任务，避免异步回调在卸载后继续运行。
     useEffect(() => {
       return () => {
+        if (pendingTimerRef.current) {
+          clearTimeout(pendingTimerRef.current);
+          pendingTimerRef.current = null;
+        }
+
         if (pendingDisposerRef.current) {
           pendingDisposerRef.current();
           pendingDisposerRef.current = null;
@@ -47,38 +102,45 @@ export const observer = <P, Options extends IObserverOptions = IObserverOptions>
       () =>
         originalObserver(Component, {
           scheduler(updater) {
-            const pageActive = getPageActive(ctxRef.current);
-            const tabActive = ctxRef.current?.tabActive?.value;
+            if (!isContextActive()) {
+              if (pendingTimerRef.current || pendingDisposerRef.current) {
+                return;
+              }
+
+              // 通过异步任务打断同步调度，避免连续触发时形成递归更新。
+              pendingTimerRef.current = setTimeout(() => {
+                pendingTimerRef.current = null;
 
-            if (pageActive === false || tabActive === false) {
-              // Avoid stack overflow
-              setTimeout(() => {
-                // If there is already a pending updater, do nothing
                 if (pendingDisposerRef.current) {
                   return;
                 }
 
-                // Delay the update until the page and tab become active
-                const disposer = autorun(() => {
-                  if (
-                    ctxRef.current?.pageActive?.value &&
-                    (ctxRef.current?.tabActive?.value === true || ctxRef.current?.tabActive?.value === undefined)
-                  ) {
+                if (isContextActive()) {
+                  updater();
+                  return;
+                }
+
+                // 只监听组合后的“是否可更新”状态，条件恢复后执行一次并立即销毁。
+                pendingDisposerRef.current = reaction(
+                  () => isContextActive(),
+                  (active) => {
+                    if (!active) {
+                      return;
+                    }
+
+                    clearPendingDisposer();
                     updater();
-                    disposer?.();
-                    pendingDisposerRef.current = null;
-                  }
-                });
-                pendingDisposerRef.current = disposer;
+                  },
+                  {
+                    name: 'FlowObserverPendingUpdate',
+                  },
+                );
               });
               return;
             }
 
-            // If we are updating immediately, clear any pending disposer
-            if (pendingDisposerRef.current) {
-              pendingDisposerRef.current();
-              pendingDisposerRef.current = null;
-            }
+            clearPendingTimer();
+            clearPendingDisposer();
 
             updater();
           },

package/src/runjs-context/registry.ts

@@ -10,7 +10,7 @@
 // 为避免在模块初始化阶段引入 FlowContext（从而触发循环依赖），不要在顶层导入各类 RunJSContext。
 // 在需要默认映射时（首次 resolve）再使用 createRequire 同步加载对应模块。
 
-export type RunJSVersion = 'v1' | (string & {});
+export type RunJSVersion = 'v1' | 'v2' | (string & {});
 export type RunJSContextCtor = new (delegate: any) => any;
 export type RunJSContextMeta = {
   scenes?: string[];

package/src/runjs-context/setup.ts

@@ -41,17 +41,27 @@ export async function setupRunJSContexts() {
     import('./contexts/JSCollectionActionRunJSContext'),
   ]);
 
-  const v1 = 'v1';
-  RunJSContextRegistry.register(v1, '*', FlowRunJSContext);
-  RunJSContextRegistry.register(v1, 'JSBlockModel', JSBlockRunJSContext, { scenes: ['block'] });
-  RunJSContextRegistry.register(v1, 'JSFieldModel', JSFieldRunJSContext, { scenes: ['detail'] });
-  RunJSContextRegistry.register(v1, 'JSEditableFieldModel', JSEditableFieldRunJSContext, { scenes: ['form'] });
-  RunJSContextRegistry.register(v1, 'JSItemModel', JSItemRunJSContext, { scenes: ['form'] });
-  RunJSContextRegistry.register(v1, 'JSColumnModel', JSColumnRunJSContext, { scenes: ['table'] });
-  RunJSContextRegistry.register(v1, 'FormJSFieldItemModel', FormJSFieldItemRunJSContext, { scenes: ['form'] });
-  RunJSContextRegistry.register(v1, 'JSRecordActionModel', JSRecordActionRunJSContext, { scenes: ['table'] });
-  RunJSContextRegistry.register(v1, 'JSCollectionActionModel', JSCollectionActionRunJSContext, { scenes: ['table'] });
-  await applyRunJSContextContributions(v1);
+  const registerBuiltins = (version: 'v1' | 'v2') => {
+    RunJSContextRegistry.register(version, '*', FlowRunJSContext);
+    RunJSContextRegistry.register(version, 'JSBlockModel', JSBlockRunJSContext, { scenes: ['block'] });
+    RunJSContextRegistry.register(version, 'JSFieldModel', JSFieldRunJSContext, { scenes: ['detail'] });
+    RunJSContextRegistry.register(version, 'JSEditableFieldModel', JSEditableFieldRunJSContext, { scenes: ['form'] });
+    RunJSContextRegistry.register(version, 'JSItemModel', JSItemRunJSContext, { scenes: ['form'] });
+    RunJSContextRegistry.register(version, 'JSItemActionModel', JSItemRunJSContext, { scenes: ['table'] });
+    RunJSContextRegistry.register(version, 'JSColumnModel', JSColumnRunJSContext, { scenes: ['table'] });
+    RunJSContextRegistry.register(version, 'FormJSFieldItemModel', FormJSFieldItemRunJSContext, { scenes: ['form'] });
+    RunJSContextRegistry.register(version, 'JSRecordActionModel', JSRecordActionRunJSContext, { scenes: ['table'] });
+    RunJSContextRegistry.register(version, 'JSCollectionActionModel', JSCollectionActionRunJSContext, {
+      scenes: ['table'],
+    });
+  };
+
+  const versions: Array<'v1' | 'v2'> = ['v1', 'v2'];
+  for (const version of versions) {
+    registerBuiltins(version);
+    await applyRunJSContextContributions(version);
+    markRunJSContextsSetupDone(version);
+  }
+
   done = true;
-  markRunJSContextsSetupDone(v1);
 }

package/src/runjs-context/snippets/index.ts

@@ -49,6 +49,7 @@ const snippets: Record<string, RunJSSnippetLoader | undefined> = {
   'scene/detail/status-tag': () => import('./scene/detail/status-tag.snippet'),
   'scene/detail/relative-time': () => import('./scene/detail/relative-time.snippet'),
   'scene/detail/percentage-bar': () => import('./scene/detail/percentage-bar.snippet'),
+  'scene/detail/set-field-style': () => import('./scene/detail/set-field-style.snippet'),
   // scene/form
   'scene/form/render-basic': () => import('./scene/form/render-basic.snippet'),
   'scene/form/set-field-value': () => import('./scene/form/set-field-value.snippet'),
@@ -67,6 +68,7 @@ const snippets: Record<string, RunJSSnippetLoader | undefined> = {
   'scene/table/iterate-selected-rows': () => import('./scene/table/iterate-selected-rows.snippet'),
   'scene/table/destroy-selected': () => import('./scene/table/destroy-selected.snippet'),
   'scene/table/export-selected-json': () => import('./scene/table/export-selected-json.snippet'),
+  'scene/table/set-cell-style': () => import('./scene/table/set-cell-style.snippet'),
 };
 
 export default snippets;
@@ -125,10 +127,19 @@ function normalizeScenes(def: any, key: string): string[] {
   return [];
 }
 
+function normalizeSceneGroup(scene: string): string {
+  const mapping: Record<string, string> = {
+    detailFieldEvent: 'detail',
+    tableFieldEvent: 'table',
+    formFieldEvent: 'form',
+  };
+  return mapping[scene] || scene;
+}
+
 function computeGroups(def: any, key: string): string[] {
   const scenes = normalizeScenes(def, key);
   if (scenes.length) {
-    return scenes.map((scene) => `scene/${scene}`);
+    return Array.from(new Set(scenes.map((scene) => `scene/${normalizeSceneGroup(scene)}`)));
   }
   const parts = key.split('/');
   if (!parts.length) return [];

package/src/runjs-context/snippets/scene/detail/set-field-style.snippet.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 { SnippetModule } from '../../types';
+const snippet: SnippetModule = {
+  contexts: ['*'],
+  scenes: ['detailFieldEvent', 'formFieldEvent'],
+  prefix: 'sn-item-style',
+  label: 'Set form item/details item style',
+  description: 'Customize form item and details item container styles',
+  locales: {
+    'zh-CN': {
+      label: '设置表单项/详情项样式',
+      description: '自定义表单项和详情项容器样式',
+    },
+  },
+  content: `
+ctx.model.props.style = {
+  background: 'red',
+};
+`,
+};
+
+export default snippet;

package/src/runjs-context/snippets/scene/table/set-cell-style.snippet.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 { SnippetModule } from '../../types';
+const snippet: SnippetModule = {
+  contexts: ['*'],
+  scenes: ['tableFieldEvent'],
+  prefix: 'sn-table-cell-style',
+  label: 'Set table cell style',
+  description: 'Customize table field cell styles with onCell',
+  locales: {
+    'zh-CN': {
+      label: '表格字段样式设置',
+      description: '通过 onCell 自定义表格字段单元格样式',
+    },
+  },
+  content: `
+ctx.model.props.onCell = (record, rowIndex) => {
+  return {
+    style: {
+      background: 'red',
+    },
+  };
+};
+`,
+};
+
+export default snippet;

package/src/scheduler/ModelOperationScheduler.ts

@@ -21,7 +21,11 @@ type LifecycleType =
   | `event:${string}:end`
   | `event:${string}:error`;
 
-export type ScheduleWhen = LifecycleType | ((e: LifecycleEvent) => boolean);
+type EventPredicateWhen = ((e: LifecycleEvent) => boolean) & {
+  __eventType?: string;
+};
+
+export type ScheduleWhen = LifecycleType | EventPredicateWhen;
 
 export interface ScheduleOptions {
   when?: ScheduleWhen;
@@ -37,6 +41,7 @@ export interface LifecycleEvent {
   error?: any;
   inputArgs?: Record<string, any>;
   result?: any;
+  aborted?: boolean;
   flowKey?: string;
   stepKey?: string;
 }
@@ -216,8 +221,14 @@ export class ModelOperationScheduler {
   }
 
   private ensureEventSubscriptionIfNeeded(when?: ScheduleWhen) {
-    if (!when || typeof when !== 'string') return;
-    const parsed = this.parseEventWhen(when);
+    const eventType =
+      typeof when === 'string'
+        ? when
+        : typeof when === 'function'
+          ? (when as EventPredicateWhen).__eventType
+          : undefined;
+    if (!eventType) return;
+    const parsed = this.parseEventWhen(eventType as ScheduleWhen);
     if (!parsed) return;
     const { name } = parsed;
     if (this.subscribedEventNames.has(name)) return;

package/src/types.ts

@@ -145,6 +145,8 @@ export enum ActionScene {
   ACTION_LINKAGE_RULES,
   /** 动态事件流可用 */
   DYNAMIC_EVENT_FLOW,
+  /** 菜单项联动规则可用 */
+  MENU_LINKAGE_RULES,
 }
 
 /**
@@ -213,6 +215,7 @@ export interface ActionDefinition<TModel extends FlowModel = FlowModel, TCtx ext
  */
 export type FlowEventName =
   | 'click'
+  | 'close'
   | 'submit'
   | 'reset'
   | 'remove'
@@ -387,6 +390,65 @@ export interface CreateModelOptions {
   delegateToParent?: boolean;
   [key: string]: any; // 允许额外的自定义选项
 }
+
+/**
+ * FlowModel loader result.
+ * Supports returning the model constructor directly, a default export, or a module object containing the named export.
+ */
+export type FlowModelLoaderResult =
+  | ModelConstructor
+  | {
+      default?: ModelConstructor;
+      [key: string]: unknown;
+    }
+  | Record<string, unknown>;
+
+/**
+ * FlowModel loader function.
+ */
+export type FlowModelLoader = () => Promise<FlowModelLoaderResult>;
+
+/**
+ * FlowModel loader entry (normalized internal form).
+ */
+export interface FlowModelLoaderEntry {
+  loader: FlowModelLoader;
+  extends?: string[];
+  // meta?: Partial<FlowModelMeta>;
+  // scenes?: string[];
+}
+
+/**
+ * FlowModel loader input (user-facing form for registerModelLoaders).
+ * The `extends` field accepts flexible formats that will be normalized to `string[]` at registration time.
+ */
+export interface FlowModelLoaderInput {
+  loader: FlowModelLoader;
+  extends?: string | ModelConstructor | (string | ModelConstructor)[];
+}
+
+/**
+ * FlowModel loader entry map (normalized internal form).
+ */
+export type FlowModelLoaderMap = Record<string, FlowModelLoaderEntry>;
+
+/**
+ * FlowModel loader input map (user-facing form for registerModelLoaders).
+ */
+export type FlowModelLoaderInputMap = Record<string, FlowModelLoaderInput>;
+
+/**
+ * Batch ensure result.
+ */
+export interface EnsureBatchResult {
+  requested: string[];
+  loaded: string[];
+  failed: Array<{
+    name: string;
+    error?: unknown;
+  }>;
+}
+
 export interface IFlowModelRepository<T extends FlowModel = FlowModel> {
   findOne(query: Record<string, any>): Promise<Record<string, any> | null>;
   save(model: T, options?: { onlyStepParams?: boolean }): Promise<Record<string, any>>;

package/src/utils/__tests__/createCollectionContextMeta.test.ts

@@ -26,6 +26,7 @@ describe('createCollectionContextMeta', () => {
         { name: 'id', type: 'integer', interface: 'number', filterable: true },
         { name: 'email', type: 'string', interface: 'text', filterable: true },
         { name: 'nickname', type: 'string', interface: 'text' }, // 未声明 filterable
+        { name: 'rawUserPayload', type: 'json', filterable: true },
       ],
     });
 
@@ -34,6 +35,7 @@ describe('createCollectionContextMeta', () => {
       fields: [
         { name: 'title', type: 'string', interface: 'text', filterable: true },
         { name: 'author', type: 'belongsTo', target: 'users', interface: 'm2o', filterable: true },
+        { name: 'rawPostPayload', type: 'json', filterable: true },
       ],
     });
 
@@ -44,8 +46,54 @@ describe('createCollectionContextMeta', () => {
     const authorMeta: any = props?.author;
     const authorFields = await authorMeta?.properties?.();
 
+    expect(props).toHaveProperty('title');
+    expect(props).toHaveProperty('author');
+    expect(props).not.toHaveProperty('rawPostPayload');
     expect(authorFields).toBeTruthy();
     expect(authorFields).toHaveProperty('email');
     expect(authorFields).not.toHaveProperty('nickname');
+    expect(authorFields).not.toHaveProperty('rawUserPayload');
+  });
+
+  it('keeps interfaced non-filterable fields but hides fields without interface when includeNonFilterable is true', async () => {
+    const engine = new FlowEngine();
+    const dm = engine.dataSourceManager as any;
+    dm.collectionFieldInterfaceManager = new CollectionFieldInterfaceManager([], {}, dm);
+    engine.context.defineProperty('app', { value: { dataSourceManager: dm } });
+    const ds = dm.getDataSource('main')!;
+
+    ds.addCollection({
+      name: 'users',
+      fields: [
+        { name: 'id', type: 'integer', interface: 'number', filterable: true },
+        { name: 'email', type: 'string', interface: 'text', filterable: true },
+        { name: 'nickname', type: 'string', interface: 'text' },
+        { name: 'rawUserPayload', type: 'json', filterable: true },
+      ],
+    });
+
+    ds.addCollection({
+      name: 'posts',
+      fields: [
+        { name: 'title', type: 'string', interface: 'text', filterable: true },
+        { name: 'internalName', type: 'string', interface: 'text' },
+        { name: 'rawPostPayload', type: 'json', filterable: true },
+        { name: 'author', type: 'belongsTo', target: 'users', interface: 'm2o', filterable: true },
+      ],
+    });
+
+    const posts = ds.getCollection('posts')!;
+    const metaFactory = createCollectionContextMeta(posts, 'Posts', true);
+    const meta = await metaFactory();
+    const props = await (meta?.properties as any)?.();
+    const authorFields = await props?.author?.properties?.();
+
+    expect(props).toHaveProperty('title');
+    expect(props).toHaveProperty('internalName');
+    expect(props).toHaveProperty('author');
+    expect(props).not.toHaveProperty('rawPostPayload');
+    expect(authorFields).toHaveProperty('email');
+    expect(authorFields).toHaveProperty('nickname');
+    expect(authorFields).not.toHaveProperty('rawUserPayload');
   });
 });

package/src/utils/__tests__/parsePathnameToViewParams.test.ts

@@ -102,6 +102,27 @@ describe('parsePathnameToViewParams', () => {
     expect(result).toEqual([{ viewUid: 'xxx', tabUid: 'yyy' }]);
   });
 
+  test('should parse custom root prefix', () => {
+    const result = parsePathnameToViewParams('/embed/xxx/tab/yyy/view/zzz', { rootPrefix: 'embed' });
+    expect(result).toEqual([{ viewUid: 'xxx', tabUid: 'yyy' }, { viewUid: 'zzz' }]);
+  });
+
+  test('should parse pathname by basePath', () => {
+    const result = parsePathnameToViewParams('/embed/xxx/tab/yyy/view/zzz', { basePath: '/embed' });
+    expect(result).toEqual([{ viewUid: 'xxx', tabUid: 'yyy' }, { viewUid: 'zzz' }]);
+  });
+
+  test('should parse pathname by nested basePath', () => {
+    const result = parsePathnameToViewParams('/admin/settings/public-forms/xxx/view/zzz', {
+      basePath: '/admin/settings/public-forms',
+    });
+    expect(result).toEqual([{ viewUid: 'xxx' }, { viewUid: 'zzz' }]);
+  });
+
+  test('should keep admin as default root prefix', () => {
+    expect(parsePathnameToViewParams('/embed/xxx')).toEqual([]);
+  });
+
   test('should parse filterByTk from key-value encoded segment into object', () => {
     const kv = encodeURIComponent('id=1&tenant=ac');
     const path = `/admin/xxx/filterbytk/${kv}`;
@@ -109,6 +130,13 @@ describe('parsePathnameToViewParams', () => {
     expect(result).toEqual([{ viewUid: 'xxx', filterByTk: { id: '1', tenant: 'ac' } }]);
   });
 
+  test('should parse filterByTk from single key-value encoded segment into object', () => {
+    const kv = encodeURIComponent('id=1');
+    const path = `/admin/xxx/filterbytk/${kv}`;
+    const result = parsePathnameToViewParams(path);
+    expect(result).toEqual([{ viewUid: 'xxx', filterByTk: { id: '1' } }]);
+  });
+
   test('should parse filterByTk from JSON object segment', () => {
     const json = encodeURIComponent('{"id":"1","tenant":"ac"}');
     const path = `/admin/xxx/filterbytk/${json}`;

package/src/utils/__tests__/runjsValue.test.ts

@@ -41,4 +41,15 @@ describe('runjsValue utils', () => {
     expect(out.someVar).toContain('');
     expect(out.user).toContain('name');
   });
+
+  it('extractUsedVariablePathsFromRunJS: extracts ctx.getVar string paths', () => {
+    const code = `
+      const phone = await ctx.getVar('ctx.item.value.phone');
+      const assignee = await ctx.getVar("ctx.user.profile.name");
+      return [phone, assignee];
+    `;
+    const out = extractUsedVariablePathsFromRunJS(code);
+    expect(out.item).toContain('value.phone');
+    expect(out.user).toContain('profile.name');
+  });
 });