@nocobase/flow-engine 2.0.0-alpha.3 → 2.0.0-alpha.30

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);
       }
@@ -400,7 +401,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 +412,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 +486,7 @@ export class Collection {
     if (otherKeys.length === 0) {
       return field;
     }
-    if (!field.targetCollection) {
+    if (!field?.targetCollection) {
       return null;
     }
     return field.targetCollection.getFieldByPath(otherKeys.join('.'));
@@ -651,7 +656,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 +705,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;
+}