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

package/lib/data-source/index.js

@@ -49,6 +49,7 @@ module.exports = __toCommonJS(data_source_exports);
 var import_reactive = require("@formily/reactive");
 var import_lodash = __toESM(require("lodash"));
 var import_jioToJoiSchema = require("./jioToJoiSchema");
+var import_sortCollectionsByInherits = require("./sortCollectionsByInherits");
 const _DataSourceManager = class _DataSourceManager {
   dataSources;
   flowEngine;
@@ -220,7 +221,7 @@ const _CollectionManager = class _CollectionManager {
     return this.getCollection(options.name);
   }
   upsertCollections(collections) {
-    for (const collection of this.sortCollectionsByInherits(collections)) {
+    for (const collection of (0, import_sortCollectionsByInherits.sortCollectionsByInherits)(collections)) {
       if (this.collections.has(collection.name)) {
         this.updateCollection(collection);
       } else {
@@ -368,7 +369,8 @@ const _Collection = 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);
     }

package/lib/data-source/sortCollectionsByInherits.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 declare function sortCollectionsByInherits(collections: CollectionOptions[]): CollectionOptions[];

package/lib/data-source/sortCollectionsByInherits.js

@@ -0,0 +1,71 @@
+/**
+ * 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.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sortCollectionsByInherits_exports = {};
+__export(sortCollectionsByInherits_exports, {
+  sortCollectionsByInherits: () => sortCollectionsByInherits
+});
+module.exports = __toCommonJS(sortCollectionsByInherits_exports);
+function sortCollectionsByInherits(collections) {
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const map = /* @__PURE__ */ new Map();
+  collections.forEach((col) => {
+    map.set(col.name, col);
+  });
+  const addToSorted = /* @__PURE__ */ __name((col) => {
+    if (visiting.has(col.name)) {
+      throw new Error(`Circular dependency detected: ${col.name} inherits from itself through a chain`);
+    }
+    if (visited.has(col.name)) {
+      return;
+    }
+    visiting.add(col.name);
+    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);
+    }
+    visiting.delete(col.name);
+    visited.add(col.name);
+    sorted.push(col);
+  }, "addToSorted");
+  for (const col of collections) {
+    addToSorted(col);
+  }
+  return sorted;
+}
+__name(sortCollectionsByInherits, "sortCollectionsByInherits");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sortCollectionsByInherits
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/flow-engine",
-  "version": "2.0.0-alpha.4",
+  "version": "2.0.0-alpha.5",
   "private": false,
   "description": "A standalone flow engine for NocoBase, managing workflows, models, and actions.",
   "main": "lib/index.js",
@@ -33,5 +33,5 @@
   ],
   "author": "NocoBase Team",
   "license": "AGPL-3.0",
-  "gitHead": "54f3cab47e7efbdc73377014d05f5fc66a4affbb"
+  "gitHead": "943e035bbec27f9ecfe8ce8857955945f20976f3"
 }

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;
@@ -227,7 +228,7 @@ export class CollectionManager {
   }
 
   upsertCollections(collections: CollectionOptions[]) {
-    for (const collection of this.sortCollectionsByInherits(collections)) {
+    for (const collection of sortCollectionsByInherits(collections)) {
       if (this.collections.has(collection.name)) {
         this.updateCollection(collection);
       } else {
@@ -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);
     }

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