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

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);
+    }
+  }
 }