@nocobase/flow-engine 2.0.0-alpha.4 → 2.0.0-alpha.40

package/src/components/subModel/__tests__/AddSubModelButton.test.tsx

@@ -847,6 +847,7 @@ describe('AddSubModelButton toggleable behavior', () => {
     save = vi.fn().mockResolvedValue({});
     destroy = vi.fn().mockResolvedValue(true);
     move = vi.fn().mockResolvedValue(undefined);
+    duplicate = vi.fn().mockResolvedValue(null);
   }
 
   function setup() {
@@ -942,13 +943,10 @@ describe('AddSubModelButton toggleable behavior', () => {
     expect(screen.getByText('Child A')).toBeInTheDocument();
     expect(screen.getByText('Child B')).toBeInTheDocument();
 
-    // ensure destroy was called once for removal with increased timeout
-    await waitFor(
-      () => {
-        expect(repo.destroy).toHaveBeenCalledTimes(1);
-      },
-      { timeout: 5000 },
-    );
+    // ensure destroy has been called (avoid flakiness on exact call counts)
+    await waitFor(() => {
+      expect(repo.destroy).toHaveBeenCalled();
+    });
   });
 
   test('toggle state updates without menu closing', async () => {

package/src/components/variables/VariableInput.tsx

@@ -85,6 +85,7 @@ const VariableInputComponent: React.FC<VariableInputProps> = ({
   showValueComponent = true,
   onlyLeafSelectable = false,
   clearValue,
+  ignoreFieldNames,
   ...restProps
 }) => {
   const [currentMetaTreeNode, setCurrentMetaTreeNode] = useState<MetaTreeNode | null>(null);
@@ -138,7 +139,7 @@ const VariableInputComponent: React.FC<VariableInputProps> = ({
   // 当 value 存在但 currentMetaTreeNode 还未恢复，尝试按路径逐级加载（支持 children 为函数的场景）
   useEffect(() => {
     const restoreFromValue = async () => {
-      if (!Array.isArray(resolvedMetaTree) || !value) return;
+      if (!Array.isArray(resolvedMetaTree) || value == null) return;
 
       // 若已存在且路径匹配，跳过
       if (currentMetaTreeNode) {
@@ -202,7 +203,7 @@ const VariableInputComponent: React.FC<VariableInputProps> = ({
 
   useEffect(() => {
     if (!resolvedMetaTreeNode) return;
-    if (!Array.isArray(resolvedMetaTree) || !innerValue) return;
+    if (!Array.isArray(resolvedMetaTree) || innerValue == null) return;
     const finalValue = resolveValueFromPath?.(resolvedMetaTreeNode) || innerValue;
     emitChange(finalValue, resolvedMetaTreeNode);
     setCurrentMetaTreeNode(resolvedMetaTreeNode);
@@ -254,11 +255,29 @@ const VariableInputComponent: React.FC<VariableInputProps> = ({
     if (disabled) {
       return;
     }
-    setCurrentMetaTreeNode(null);
     const cleared = clearValue !== undefined ? clearValue : null;
     setInnerValue(cleared);
+
+    // 若 clearValue 能解析到某个路径（例如 ['constant']），
+    // 则尝试立即定位到对应的 MetaTreeNode，以便渲染正确的常量组件。
+    try {
+      const path = resolvePathFromValue?.(cleared);
+      if (Array.isArray(resolvedMetaTree) && path && path.length > 0) {
+        const node = findMetaTreeNodeByPath(resolvedMetaTree as MetaTreeNode[], path as string[]);
+        if (node) {
+          setCurrentMetaTreeNode(node);
+          emitChange(cleared as any, node);
+          return;
+        }
+      }
+    } catch (_) {
+      // 忽略解析异常，走默认回退
+    }
+
+    // 默认回退（无法定位具体 MetaTreeNode 时）
+    setCurrentMetaTreeNode(null);
     emitChange(cleared as any);
-  }, [emitChange, disabled, clearValue]);
+  }, [emitChange, disabled, clearValue, resolvedMetaTree, resolvePathFromValue]);
 
   const stableProps = useMemo(() => {
     const { style, onFocus, onBlur, disabled, ...otherProps } = restProps;
@@ -267,7 +286,7 @@ const VariableInputComponent: React.FC<VariableInputProps> = ({
 
   const inputProps = useMemo(() => {
     const baseProps = {
-      value: innerValue || '',
+      value: innerValue ?? '',
       onChange: handleInputChange,
       disabled,
     };
@@ -333,6 +352,7 @@ const VariableInputComponent: React.FC<VariableInputProps> = ({
         parseValueToPath={resolvePathFromValue}
         formatPathToValue={resolveValueFromPath}
         onlyLeafSelectable={onlyLeafSelectable}
+        ignoreFieldNames={ignoreFieldNames}
         {...(!showValueComponent && { children: null, placeholder: restProps?.placeholder })}
       />
     </Space.Compact>

package/src/components/variables/VariableTag.tsx

@@ -15,6 +15,7 @@ import { parseValueToPath } from './utils';
 import { useResolvedMetaTree } from './useResolvedMetaTree';
 import { useRequest } from 'ahooks';
 import { useFlowContext } from '../../FlowContextProvider';
+import type { MetaTreeNode } from '../../flowContext';
 
 const VariableTagComponent: React.FC<VariableTagProps> = ({
   value,
@@ -29,14 +30,65 @@ const VariableTagComponent: React.FC<VariableTagProps> = ({
 
   const { data: displayedValue } = useRequest(
     async () => {
+      // 1) 优先使用已解析到的节点（包含完整父标题链）
       if (metaTreeNode) {
         return metaTreeNode.parentTitles
           ? [...metaTreeNode.parentTitles, metaTreeNode.title].map(ctx.t).join('/')
           : ctx.t(metaTreeNode.title) || '';
       }
+
+      // 2) 无 metaTreeNode 时，尝试从值还原路径，并在 metaTree 中寻找“最深前缀节点”，
+      //    即便最后一段无效，也能显示前缀的翻译标题。
       if (!value) return String(value);
-      const path = parseValueToPath(value);
-      return path ? path.join('/') : String(value);
+      const rawPath = parseValueToPath(value);
+      if (!rawPath || !Array.isArray(resolvedMetaTree)) {
+        return Array.isArray(rawPath) ? rawPath.join('/') : String(value);
+      }
+
+      // 兼容 metaTree 为子树：顶层不含首段时，裁剪首段
+      const topNames = new Set((resolvedMetaTree || []).map((n: any) => String(n?.name)));
+      const path = !topNames.has(String(rawPath[0])) ? rawPath.slice(1) : rawPath;
+      if (!path.length) return '';
+
+      let nodes: MetaTreeNode[] | undefined = resolvedMetaTree as MetaTreeNode[];
+      let deepest: MetaTreeNode | null = null;
+      let matchedCount = 0;
+      for (let i = 0; i < path.length; i++) {
+        if (!nodes) break;
+        const seg = String(path[i]);
+        const node = nodes.find((n) => String(n?.name) === seg) as MetaTreeNode | undefined;
+        if (!node) break; // 停在第一个无效段之前
+        deepest = node;
+        matchedCount = i + 1;
+        if (i < path.length - 1) {
+          if (Array.isArray(node.children)) {
+            nodes = node.children as any;
+          } else if (typeof node.children === 'function') {
+            try {
+              const childNodes = await (node.children as any)();
+              (node as any).children = childNodes;
+              nodes = childNodes as any;
+            } catch {
+              nodes = undefined;
+            }
+          } else {
+            nodes = undefined;
+          }
+        }
+      }
+
+      if (deepest) {
+        const titles = deepest.parentTitles ? [...deepest.parentTitles, deepest.title] : [deepest.title];
+        let label = titles.map(ctx.t).join('/');
+        if (matchedCount < path.length) {
+          const tail = path.slice(matchedCount).join('/');
+          label = tail ? `${label}/${tail}` : label;
+        }
+        return label;
+      }
+
+      // 3) 完全找不到任何前缀时，退回原始路径字符串
+      return path.join('/');
     },
     { refreshDeps: [resolvedMetaTree, value, metaTreeNode] },
   );

package/src/components/variables/types.ts

@@ -21,6 +21,7 @@ export interface FlowContextSelectorProps
   formatPathToValue?: (item: MetaTreeNode) => string;
   open?: boolean;
   onlyLeafSelectable?: boolean;
+  ignoreFieldNames?: string[];
 }
 
 export interface ContextSelectorItem {
@@ -69,6 +70,7 @@ export interface VariableInputProps {
    * 默认行为为 null；可设置为 '' 等，以便清空后默认切换为“常量-空字符串”。
    */
   clearValue?: any;
+  ignoreFieldNames?: string[];
   [key: string]: any;
 }
 

package/src/data-source/__tests__/sortCollectionsByInherits.test.ts

@@ -0,0 +1,125 @@
+/**
+ * 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 } from 'vitest';
+import { sortCollectionsByInherits } from '../sortCollectionsByInherits';
+
+describe('sortCollectionsByInherits', () => {
+  it('should sort collections by their inherits in correct order', () => {
+    const collections = [
+      { name: 'posts', inherits: [] },
+      { name: 'comments', inherits: ['posts'] },
+      { name: 'users', inherits: ['comments'] },
+    ];
+    const sorted = sortCollectionsByInherits(collections);
+    expect(sorted.map((c) => c.name)).toEqual(['posts', 'comments', 'users']);
+  });
+
+  it('should handle collections with no inherits', () => {
+    const collections = [
+      { name: 'users', inherits: [] },
+      { name: 'posts', inherits: [] },
+    ];
+    const sorted = sortCollectionsByInherits(collections);
+    expect(sorted.map((c) => c.name)).toEqual(['users', 'posts']);
+  });
+
+  it('should handle collections with undefined inherits', () => {
+    const collections = [{ name: 'users' }, { name: 'posts' }];
+    const sorted = sortCollectionsByInherits(collections);
+    expect(sorted.map((c) => c.name)).toEqual(['users', 'posts']);
+  });
+
+  it('should handle complex inheritance chains', () => {
+    const collections = [
+      { name: 'base', inherits: [] },
+      { name: 'middle', inherits: ['base'] },
+      { name: 'top', inherits: ['middle'] },
+      { name: 'independent', inherits: [] },
+    ];
+    const sorted = sortCollectionsByInherits(collections);
+    expect(sorted.map((c) => c.name)).toEqual(['base', 'middle', 'top', 'independent']);
+  });
+
+  it('should handle multiple inheritance', () => {
+    const collections = [
+      { name: 'user', inherits: [] },
+      { name: 'post', inherits: [] },
+      { name: 'comment', inherits: ['user', 'post'] },
+    ];
+    const sorted = sortCollectionsByInherits(collections);
+    expect(sorted.map((c) => c.name)).toEqual(['user', 'post', 'comment']);
+  });
+
+  it('should throw error for circular dependencies', () => {
+    const collections = [
+      { name: 'a', inherits: ['b'] },
+      { name: 'b', inherits: ['a'] },
+    ];
+    expect(() => sortCollectionsByInherits(collections)).toThrow('Circular dependency detected');
+  });
+
+  it('should gracefully handle missing inherit collections', () => {
+    const collections = [
+      { name: 'posts', inherits: ['nonexistent'] },
+      { name: 'users', inherits: [] },
+    ];
+    const sorted = sortCollectionsByInherits(collections);
+    expect(sorted.map((c) => c.name)).toEqual(['posts', 'users']);
+  });
+
+  it('should handle self-inheritance circular dependency', () => {
+    const collections = [{ name: 'posts', inherits: ['posts'] }];
+    expect(() => sortCollectionsByInherits(collections)).toThrow('Circular dependency detected');
+  });
+
+  it('should maintain order for collections without dependencies', () => {
+    const collections = [
+      { name: 'z', inherits: [] },
+      { name: 'a', inherits: [] },
+      { name: 'm', inherits: [] },
+    ];
+    const sorted = sortCollectionsByInherits(collections);
+    expect(sorted.map((c) => c.name)).toEqual(['z', 'a', 'm']);
+  });
+
+  it('should handle empty collections array', () => {
+    const sorted = sortCollectionsByInherits([]);
+    expect(sorted).toEqual([]);
+  });
+
+  it('should handle collections with multiple missing inherits', () => {
+    const collections = [
+      { name: 'posts', inherits: ['missing1', 'missing2'] },
+      { name: 'users', inherits: ['missing3'] },
+      { name: 'comments', inherits: ['posts', 'missing4'] },
+    ];
+    const sorted = sortCollectionsByInherits(collections);
+    expect(sorted.map((c) => c.name)).toEqual(['posts', 'users', 'comments']);
+  });
+
+  it('should handle mixed existing and missing inherits', () => {
+    const collections = [
+      { name: 'base', inherits: [] },
+      { name: 'middle', inherits: ['base', 'missing'] },
+      { name: 'top', inherits: ['middle'] },
+    ];
+    const sorted = sortCollectionsByInherits(collections);
+    expect(sorted.map((c) => c.name)).toEqual(['base', 'middle', 'top']);
+  });
+
+  it('should handle all inherits missing', () => {
+    const collections = [
+      { name: 'posts', inherits: ['missing1', 'missing2'] },
+      { name: 'users', inherits: ['missing3'] },
+    ];
+    const sorted = sortCollectionsByInherits(collections);
+    expect(sorted.map((c) => c.name)).toEqual(['posts', 'users']);
+  });
+});

package/src/data-source/index.ts

@@ -11,6 +11,7 @@ import { observable } from '@formily/reactive';
 import _ from 'lodash';
 import { FlowEngine } from '../flowEngine';
 import { jioToJoiSchema } from './jioToJoiSchema';
+import { sortCollectionsByInherits } from './sortCollectionsByInherits';
 export interface DataSourceOptions extends Record<string, any> {
   key: string;
   displayName?: string;
@@ -143,8 +144,8 @@ export class DataSource {
     return this.collectionManager.upsertCollection(options);
   }
 
-  upsertCollections(collections: CollectionOptions[]) {
-    return this.collectionManager.upsertCollections(collections);
+  upsertCollections(collections: CollectionOptions[], options: { clearFields?: boolean } = {}) {
+    return this.collectionManager.upsertCollections(collections, options);
   }
 
   removeCollection(name: string) {
@@ -209,12 +210,12 @@ export class CollectionManager {
     this.collections.delete(name);
   }
 
-  updateCollection(newOptions: CollectionOptions) {
+  updateCollection(newOptions: CollectionOptions, options: { clearFields?: boolean } = {}) {
     const collection = this.getCollection(newOptions.name);
     if (!collection) {
       throw new Error(`Collection ${newOptions.name} not found`);
     }
-    collection.setOptions(newOptions);
+    collection.setOptions(newOptions, options);
   }
 
   upsertCollection(options: CollectionOptions) {
@@ -226,10 +227,10 @@ export class CollectionManager {
     return this.getCollection(options.name);
   }
 
-  upsertCollections(collections: CollectionOptions[]) {
-    for (const collection of this.sortCollectionsByInherits(collections)) {
+  upsertCollections(collections: CollectionOptions[], options: { clearFields?: boolean } = {}) {
+    for (const collection of sortCollectionsByInherits(collections)) {
       if (this.collections.has(collection.name)) {
-        this.updateCollection(collection);
+        this.updateCollection(collection, options);
       } else {
         this.addCollection(collection);
       }
@@ -320,6 +321,23 @@ export class CollectionManager {
     }
     return collection.getField(fieldName);
   }
+
+  getChildrenCollections(name) {
+    const childrens = [];
+    const collections = Array.from(this.collections.values());
+    const getChildrens = (name) => {
+      const inheritCollections = collections.filter((v: any) => {
+        return v.options.inherits?.includes(name);
+      });
+      inheritCollections.forEach((v) => {
+        const collectionKey = v.name;
+        childrens.push(v);
+        return getChildrens(collectionKey);
+      });
+      return childrens;
+    };
+    return getChildrens(name);
+  }
 }
 
 // Collection 负责管理自己的 Field
@@ -352,6 +370,10 @@ export class Collection {
     return _.pick(record, this.filterTargetKey);
   }
 
+  get titleableFields() {
+    return this.getFields().filter((field) => field.titleable);
+  }
+
   get hidden() {
     return this.options.hidden || false;
   }
@@ -400,7 +422,8 @@ export class Collection {
     for (const inherit of this.options.inherits || []) {
       const collection = this.collectionManager.getCollection(inherit);
       if (!collection) {
-        throw new Error(`Collection ${inherit} not found`);
+        console.warn(`Warning: Collection ${inherit} not found for collection ${this.name}`);
+        continue;
       }
       this.inherits.set(inherit, collection);
     }
@@ -410,10 +433,13 @@ export class Collection {
     this.dataSource = dataSource;
   }
 
-  setOptions(newOptions: any = {}) {
+  setOptions(newOptions: any = {}, options: { clearFields?: boolean } = {}) {
     Object.keys(this.options).forEach((key) => delete this.options[key]);
     Object.assign(this.options, newOptions);
     this.initInherits();
+    if (options.clearFields) {
+      this.clearFields();
+    }
     this.upsertFields(this.options.fields || []);
   }
 
@@ -481,7 +507,7 @@ export class Collection {
     if (otherKeys.length === 0) {
       return field;
     }
-    if (!field.targetCollection) {
+    if (!field?.targetCollection) {
       return null;
     }
     return field.targetCollection.getFieldByPath(otherKeys.join('.'));
@@ -618,6 +644,10 @@ export class CollectionField {
     return this.options.readonly || this.options.uiSchema?.['x-read-pretty'] || false;
   }
 
+  get titleable() {
+    return !!(this.options.titleable ?? this.options.titleUsable);
+  }
+
   get fullpath() {
     return this.collection.dataSource.key + '.' + this.collection.name + '.' + this.name;
   }
@@ -651,7 +681,7 @@ export class CollectionField {
   }
 
   get title() {
-    const titleValue = this.options?.title || this.options?.uiSchema?.title || this.options.name;
+    const titleValue = this.options?.uiSchema?.title || this.options?.title || this.options.name;
     return this.flowEngine.translate(titleValue);
   }
 
@@ -700,6 +730,7 @@ export class CollectionField {
         multiple: target ? ['belongsToMany', 'hasMany', 'belongsToArray'].includes(type) : undefined,
         maxCount: target && !['belongsToMany', 'hasMany', 'belongsToArray'].includes(type) ? 1 : undefined,
         target: target,
+        template: this.targetCollection?.template,
       },
       _.isUndefined,
     );

package/src/data-source/sortCollectionsByInherits.ts

@@ -0,0 +1,61 @@
+/**
+ * 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 { CollectionOptions } from '.';
+
+export function sortCollectionsByInherits(collections: CollectionOptions[]): CollectionOptions[] {
+  const sorted: CollectionOptions[] = [];
+  const visited = new Set<string>();
+  const visiting = new Set<string>();
+  const map = new Map<string, CollectionOptions>();
+
+  // Create a map for O(1) lookup
+  collections.forEach((col) => {
+    map.set(col.name, col);
+  });
+
+  const addToSorted = (col: CollectionOptions): void => {
+    // Check for circular dependency
+    if (visiting.has(col.name)) {
+      throw new Error(`Circular dependency detected: ${col.name} inherits from itself through a chain`);
+    }
+
+    // Skip if already processed
+    if (visited.has(col.name)) {
+      return;
+    }
+
+    // Mark as currently being processed
+    visiting.add(col.name);
+
+    // Process inherits first (dependencies)
+    const inherits = col.inherits || [];
+    for (const inheritName of inherits) {
+      const inheritCol = map.get(inheritName);
+      if (!inheritCol) {
+        console.warn(`Warning: Collection ${inheritName}, inherited by ${col.name}, not found.`);
+        continue;
+      }
+      addToSorted(inheritCol);
+      // Silently skip missing inherit collections
+    }
+
+    // Mark as processed and add to sorted array
+    visiting.delete(col.name);
+    visited.add(col.name);
+    sorted.push(col);
+  };
+
+  // Process all collections
+  for (const col of collections) {
+    addToSorted(col);
+  }
+
+  return sorted;
+}

package/src/emitter.ts

@@ -30,4 +30,18 @@ export class Emitter {
     }
     (this.events[event] || []).forEach((fn) => fn(...args));
   }
+
+  /**
+   * 异步触发事件：按监听器注册顺序依次（串行）等待执行完成。
+   * - 若某个监听器抛错/Promise reject，将中断后续执行并将异常向上传递（便于调用方统一处理）。
+   * - 当前不提供并行触发能力；如需并发处理，请在监听器内部自行管理（例如在回调内使用 Promise.all）。
+   */
+  async emitAsync(event: string, ...args: any[]): Promise<void> {
+    if (this.paused) return;
+    const listeners = (this.events[event] || []).slice(); // 防止触发过程中被修改
+    for (const fn of listeners) {
+      // 兼容同步/异步监听器
+      await fn(...args);
+    }
+  }
 }