@nocobase/flow-engine 2.1.0-alpha.3 → 2.1.0-alpha.31

package/lib/data-source/index.js

@@ -42,6 +42,7 @@ __export(data_source_exports, {
   CollectionManager: () => CollectionManager,
   DataSource: () => DataSource,
   DataSourceManager: () => DataSourceManager,
+  getCollectionFieldInterface: () => getCollectionFieldInterface,
   isFieldInterfaceMatch: () => isFieldInterfaceMatch,
   jioToJoiSchema: () => import_jioToJoiSchema.jioToJoiSchema
 });
@@ -53,12 +54,47 @@ var import_sortCollectionsByInherits = require("./sortCollectionsByInherits");
 const _DataSourceManager = class _DataSourceManager {
   dataSources;
   flowEngine;
+  requester;
+  collectionFieldInterfaceManager;
+  loaders = /* @__PURE__ */ new Map();
+  loadedKeys = /* @__PURE__ */ new Set();
+  loadingKeys = /* @__PURE__ */ new Set();
+  loadErrors = /* @__PURE__ */ new Map();
+  loadingPromise = null;
   constructor() {
     this.dataSources = import_reactive.observable.shallow(/* @__PURE__ */ new Map());
   }
   setFlowEngine(flowEngine) {
     this.flowEngine = flowEngine;
   }
+  setRequester(requester) {
+    this.requester = requester;
+  }
+  setCollectionFieldInterfaceManager(manager) {
+    this.collectionFieldInterfaceManager = manager;
+  }
+  addFieldInterfaces(fieldInterfaceClasses = []) {
+    var _a, _b;
+    (_b = (_a = this.collectionFieldInterfaceManager) == null ? void 0 : _a.addFieldInterfaces) == null ? void 0 : _b.call(_a, fieldInterfaceClasses);
+  }
+  addFieldInterfaceGroups(groups) {
+    var _a, _b;
+    (_b = (_a = this.collectionFieldInterfaceManager) == null ? void 0 : _a.addFieldInterfaceGroups) == null ? void 0 : _b.call(_a, groups);
+  }
+  addFieldInterfaceComponentOption(name, option) {
+    var _a, _b;
+    (_b = (_a = this.collectionFieldInterfaceManager) == null ? void 0 : _a.addFieldInterfaceComponentOption) == null ? void 0 : _b.call(_a, name, option);
+  }
+  addFieldInterfaceOperator(name, operator) {
+    var _a, _b;
+    (_b = (_a = this.collectionFieldInterfaceManager) == null ? void 0 : _a.addFieldInterfaceOperator) == null ? void 0 : _b.call(_a, name, operator);
+  }
+  registerLoader(key, loader) {
+    this.loaders.set(key, loader);
+  }
+  removeLoader(key) {
+    this.loaders.delete(key);
+  }
   addDataSource(ds) {
     if (this.dataSources.has(ds.key)) {
       throw new Error(`DataSource with name ${ds.key} already exists`);
@@ -75,7 +111,7 @@ const _DataSourceManager = class _DataSourceManager {
   upsertDataSource(ds) {
     var _a;
     if (this.dataSources.has(ds.key)) {
-      (_a = this.dataSources.get(ds.key)) == null ? void 0 : _a.setOptions(ds);
+      (_a = this.dataSources.get(ds.key)) == null ? void 0 : _a.patchOptions(ds);
     } else {
       this.addDataSource(ds);
     }
@@ -103,9 +139,161 @@ const _DataSourceManager = class _DataSourceManager {
     if (!ds) return void 0;
     return ds.getCollectionField(otherKeys.join("."));
   }
+  async ensureLoaded(options = {}) {
+    const { force = false } = options;
+    const keys = this.resolveLoadKeys(options.keys);
+    const pendingKeys = force ? keys : keys.filter((key) => !this.loadedKeys.has(key));
+    if (!pendingKeys.length) {
+      return;
+    }
+    if (this.loadingPromise) {
+      return this.loadingPromise;
+    }
+    this.loadingPromise = (async () => {
+      try {
+        for (const key of pendingKeys) {
+          await this.loadKey(key, { initial: !this.loadedKeys.has(key), force });
+        }
+      } finally {
+        this.loadingPromise = null;
+      }
+    })();
+    return this.loadingPromise;
+  }
+  async reload(options = {}) {
+    const keys = this.resolveLoadKeys(options.keys);
+    if (!keys.length) {
+      return;
+    }
+    if (this.loadingPromise) {
+      return this.loadingPromise;
+    }
+    this.loadingPromise = (async () => {
+      try {
+        for (const key of keys) {
+          await this.loadKey(key, { initial: false, force: true });
+        }
+      } finally {
+        this.loadingPromise = null;
+      }
+    })();
+    return this.loadingPromise;
+  }
+  async reloadDataSource(key) {
+    if (this.loadingKeys.has(key) && this.loadingPromise) {
+      return this.loadingPromise;
+    }
+    if (!this.loaders.has(key) && this.loaders.has("*")) {
+      return this.reload({ keys: ["*"] });
+    }
+    return this.reload({ keys: [key] });
+  }
+  resolveLoadKeys(requestedKeys) {
+    const normalizedKeys = (requestedKeys == null ? void 0 : requestedKeys.length) ? requestedKeys : ["main"];
+    const explicitKeys = normalizedKeys.filter((key) => this.loaders.has(key));
+    if (this.loaders.has("*")) {
+      return import_lodash.default.uniq(["*", ...explicitKeys]);
+    }
+    return explicitKeys.length ? explicitKeys : normalizedKeys;
+  }
+  getApp() {
+    var _a, _b;
+    return (_b = (_a = this.flowEngine) == null ? void 0 : _a.context) == null ? void 0 : _b.app;
+  }
+  dispatchDataSourceEvent(type, detail) {
+    var _a, _b;
+    (_b = (_a = this.getApp()) == null ? void 0 : _a.eventBus) == null ? void 0 : _b.dispatchEvent(new CustomEvent(type, { detail }));
+  }
+  setDataSourceState(key, options) {
+    const dataSource = this.getDataSource(key);
+    if (!dataSource) {
+      return;
+    }
+    dataSource.patchOptions(options);
+  }
+  applyDataSourceLoadResult(key, result) {
+    if (key === "*") {
+      const dataSources = (result == null ? void 0 : result.dataSources) || [];
+      dataSources.forEach((dataSourceOptions) => {
+        var _a;
+        const { collections, ...dataSource2 } = dataSourceOptions;
+        this.upsertDataSource(dataSource2);
+        if (collections) {
+          (_a = this.getDataSource(dataSource2.key)) == null ? void 0 : _a.setCollections(collections, { clearFields: true });
+        }
+      });
+      return;
+    }
+    const dataSource = this.getDataSource(key);
+    if (!dataSource) {
+      return;
+    }
+    dataSource.setCollections((result == null ? void 0 : result.collections) || [], { clearFields: true });
+  }
+  async loadKey(key, options) {
+    const loader = this.loaders.get(key);
+    if (!loader) {
+      return;
+    }
+    if (!this.getDataSource(key) && key !== "*") {
+      this.addDataSource({ key });
+    }
+    const { initial } = options;
+    this.loadingKeys.add(key);
+    if (key !== "*") {
+      this.setDataSourceState(key, {
+        status: initial ? "loading" : "reloading",
+        errorMessage: void 0
+      });
+    }
+    this.loadErrors.set(key, null);
+    try {
+      const result = await loader({ key, manager: this }) || {};
+      this.applyDataSourceLoadResult(key, result);
+      this.loadedKeys.add(key);
+      if (key !== "*") {
+        this.setDataSourceState(key, {
+          status: "loaded",
+          errorMessage: void 0
+        });
+      }
+      this.dispatchDataSourceEvent("dataSource:loaded", { dataSourceKey: key, initial });
+    } catch (error) {
+      const normalizedError = error instanceof Error ? error : new Error(String(error));
+      this.loadErrors.set(key, normalizedError);
+      if (key !== "*") {
+        this.setDataSourceState(key, {
+          status: initial ? "loading-failed" : "reloading-failed",
+          errorMessage: normalizedError.message
+        });
+      }
+      this.dispatchDataSourceEvent("dataSource:loadFailed", {
+        dataSourceKey: key,
+        initial,
+        error: normalizedError
+      });
+      throw normalizedError;
+    } finally {
+      this.loadingKeys.delete(key);
+    }
+  }
 };
 __name(_DataSourceManager, "DataSourceManager");
 let DataSourceManager = _DataSourceManager;
+function getCollectionFieldInterface(interfaceName, ...dataSourceManagers) {
+  if (!interfaceName) {
+    return void 0;
+  }
+  for (const dataSourceManager of dataSourceManagers) {
+    const collectionFieldInterfaceManager = dataSourceManager == null ? void 0 : dataSourceManager.collectionFieldInterfaceManager;
+    const getFieldInterface = collectionFieldInterfaceManager == null ? void 0 : collectionFieldInterfaceManager.getFieldInterface;
+    if (typeof getFieldInterface === "function") {
+      return getFieldInterface.call(collectionFieldInterfaceManager, interfaceName);
+    }
+  }
+  return void 0;
+}
+__name(getCollectionFieldInterface, "getCollectionFieldInterface");
 const _DataSource = class _DataSource {
   dataSourceManager;
   collectionManager;
@@ -126,6 +314,12 @@ const _DataSource = class _DataSource {
   get name() {
     return this.options.key;
   }
+  get status() {
+    return this.options.status;
+  }
+  get errorMessage() {
+    return this.options.errorMessage;
+  }
   setDataSourceManager(dataSourceManager) {
     this.dataSourceManager = dataSourceManager;
   }
@@ -156,6 +350,9 @@ const _DataSource = class _DataSource {
   upsertCollections(collections, options = {}) {
     return this.collectionManager.upsertCollections(collections, options);
   }
+  setCollections(collections, options = {}) {
+    return this.collectionManager.setCollections(collections, options);
+  }
   removeCollection(name) {
     return this.collectionManager.removeCollection(name);
   }
@@ -166,6 +363,12 @@ const _DataSource = class _DataSource {
     Object.keys(this.options).forEach((key) => delete this.options[key]);
     Object.assign(this.options, newOptions);
   }
+  patchOptions(newOptions = {}) {
+    Object.assign(this.options, newOptions);
+  }
+  reload() {
+    return this.dataSourceManager.reloadDataSource(this.key);
+  }
   getCollectionField(fieldPath) {
     const [collectionName, ...otherKeys] = fieldPath.split(".");
     const fieldName = otherKeys.join(".");
@@ -190,6 +393,10 @@ const _CollectionManager = class _CollectionManager {
   collections;
   allCollectionsInheritChain;
   childrenCollectionsName = {};
+  resetCaches() {
+    this.childrenCollectionsName = {};
+    this.allCollectionsInheritChain = void 0;
+  }
   get flowEngine() {
     return this.dataSource.flowEngine;
   }
@@ -203,9 +410,11 @@ const _CollectionManager = class _CollectionManager {
     col.setDataSource(this.dataSource);
     col.initInherits();
     this.collections.set(col.name, col);
+    this.resetCaches();
   }
   removeCollection(name) {
     this.collections.delete(name);
+    this.resetCaches();
   }
   updateCollection(newOptions, options = {}) {
     const collection = this.getCollection(newOptions.name);
@@ -213,6 +422,7 @@ const _CollectionManager = class _CollectionManager {
       throw new Error(`Collection ${newOptions.name} not found`);
     }
     collection.setOptions(newOptions, options);
+    this.resetCaches();
   }
   upsertCollection(options) {
     if (this.collections.has(options.name)) {
@@ -230,6 +440,11 @@ const _CollectionManager = class _CollectionManager {
         this.addCollection(collection);
       }
     }
+    this.resetCaches();
+  }
+  setCollections(collections, options = {}) {
+    this.clearCollections();
+    this.upsertCollections(collections, options);
   }
   sortCollectionsByInherits(collections) {
     const map = /* @__PURE__ */ new Map();
@@ -293,6 +508,7 @@ const _CollectionManager = class _CollectionManager {
   }
   clearCollections() {
     this.collections.clear();
+    this.resetCaches();
   }
   getAssociation(associationName) {
     const [collectionName, fieldName] = associationName.split(".");
@@ -461,6 +677,12 @@ const _Collection = class _Collection {
   }
   get titleCollectionField() {
     const titleFieldName = this.options.titleField || this.filterTargetKey;
+    if (Array.isArray(titleFieldName)) {
+      if (titleFieldName.length !== 1) {
+        return void 0;
+      }
+      return this.getField(titleFieldName[0]);
+    }
     const titleCollectionField = this.getField(titleFieldName);
     return titleCollectionField;
   }
@@ -487,6 +709,9 @@ const _Collection = class _Collection {
     }
     this.upsertFields(this.options.fields || []);
   }
+  setOption(key, value) {
+    this.options[key] = value;
+  }
   getFields() {
     const fieldMap = /* @__PURE__ */ new Map();
     for (const inherit of this.inherits.values()) {
@@ -772,7 +997,17 @@ const _CollectionField = class _CollectionField {
             abortEarly: false
           });
           if (error) {
-            const message = error.details.map((d) => d.message.replace(/"value"/g, `"${label}"`)).join(", ");
+            const message = error.details.map((d) => {
+              const translated = this.flowEngine.translate(d.type, {
+                ...d.context,
+                ns: "data-source-main",
+                label
+              });
+              if (translated && translated !== d.type) {
+                return translated;
+              }
+              return d.message.replace(/"value"/g, `"${label}"`);
+            }).join(", ");
             return Promise.reject(message);
           }
           return Promise.resolve();
@@ -792,8 +1027,14 @@ const _CollectionField = class _CollectionField {
     return this.targetCollection.getFields();
   }
   getInterfaceOptions() {
-    const app = this.flowEngine.context.app;
-    return app.dataSourceManager.collectionFieldInterfaceManager.getFieldInterface(this.interface);
+    var _a, _b, _c;
+    const ctx = this.flowEngine.context;
+    return getCollectionFieldInterface(
+      this.interface,
+      (_b = (_a = this.collection) == null ? void 0 : _a.dataSource) == null ? void 0 : _b.dataSourceManager,
+      ctx.dataSourceManager,
+      (_c = ctx.app) == null ? void 0 : _c.dataSourceManager
+    );
   }
   getFilterOperators() {
     var _a;
@@ -858,6 +1099,7 @@ __name(isFieldInterfaceMatch, "isFieldInterfaceMatch");
   CollectionManager,
   DataSource,
   DataSourceManager,
+  getCollectionFieldInterface,
   isFieldInterfaceMatch,
   jioToJoiSchema
 });

package/lib/executor/FlowExecutor.js

@@ -213,11 +213,13 @@ const _FlowExecutor = class _FlowExecutor {
           flowContext.logger.info(`[FlowEngine] ${error.message}`);
           await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:end`, {
             ...flowEventBasePayload,
-            stepKey
+            stepKey,
+            aborted: true
           });
           await this.emitModelEventIf(eventName, `flow:${flowKey}:end`, {
             ...flowEventBasePayload,
-            result: error
+            result: error,
+            aborted: true
           });
           return Promise.resolve(error);
         }
@@ -287,6 +289,7 @@ const _FlowExecutor = class _FlowExecutor {
     }) : flows;
     const scheduledCancels = [];
     const execute = /* @__PURE__ */ __name(async () => {
+      let abortedByExitAll = false;
       if (sequential) {
         const flowsWithIndex = flowsToRun.map((f, i) => ({ f, i }));
         const ordered = flowsWithIndex.slice().sort((a, b) => {
@@ -355,9 +358,10 @@ const _FlowExecutor = class _FlowExecutor {
             return;
           }
           if (!whenKey) return;
+          const shouldSkipOnAborted = whenKey === `event:${eventName}:end` || phase === "afterFlow" || phase === "afterStep";
           scheduled.add(flow.key);
           const list = scheduleGroups.get(whenKey) || [];
-          list.push({ flow, order: indexInOrdered });
+          list.push({ flow, order: indexInOrdered, shouldSkipOnAborted });
           scheduleGroups.set(whenKey, list);
         });
         for (const [whenKey, list] of scheduleGroups.entries()) {
@@ -368,6 +372,12 @@ const _FlowExecutor = class _FlowExecutor {
             return a.order - b.order;
           });
           for (const it of sorted) {
+            const when = it.shouldSkipOnAborted ? Object.assign(
+              (event) => event.type === whenKey && event.aborted !== true,
+              {
+                __eventType: whenKey
+              }
+            ) : whenKey;
             const cancel = model.scheduleModelOperation(
               model.uid,
               async (m) => {
@@ -377,7 +387,7 @@ const _FlowExecutor = class _FlowExecutor {
                 }
                 results2.push(res);
               },
-              { when: whenKey }
+              { when }
             );
             scheduledCancels.push(cancel);
           }
@@ -391,12 +401,14 @@ const _FlowExecutor = class _FlowExecutor {
             const result = await this.runFlow(model, flow.key, inputArgs, runId, eventName);
             if (result instanceof import_exceptions.FlowExitAllException) {
               logger.debug(`[FlowEngine.dispatchEvent] ${result.message}`);
+              abortedByExitAll = true;
               break;
             }
             results2.push(result);
           } catch (error) {
             if (error instanceof import_exceptions.FlowExitAllException) {
               logger.debug(`[FlowEngine.dispatchEvent] ${error.message}`);
+              abortedByExitAll = true;
               break;
             }
             logger.error(
@@ -406,7 +418,7 @@ const _FlowExecutor = class _FlowExecutor {
             throw error;
           }
         }
-        return results2;
+        return { result: results2, abortedByExitAll };
       }
       const results = await Promise.all(
         flowsToRun.map(async (flow) => {
@@ -423,7 +435,11 @@ const _FlowExecutor = class _FlowExecutor {
           }
         })
       );
-      return results.filter((x) => x !== void 0);
+      const filteredResults = results.filter((x) => x !== void 0);
+      if (filteredResults.some((x) => x instanceof import_exceptions.FlowExitAllException)) {
+        abortedByExitAll = true;
+      }
+      return { result: filteredResults, abortedByExitAll };
     }, "execute");
     const argsKey = useCache ? JSON.stringify(inputArgs ?? {}) : "";
     const cacheKey = useCache ? import_flowEngine.FlowEngine.generateApplyFlowCacheKey(
@@ -432,7 +448,7 @@ const _FlowExecutor = class _FlowExecutor {
       model.uid
     ) : null;
     try {
-      const result = await this.withApplyFlowCache(cacheKey, execute);
+      const { result, abortedByExitAll } = await this.withApplyFlowCache(cacheKey, execute);
       try {
         await ((_c = model.onDispatchEventEnd) == null ? void 0 : _c.call(model, eventName, options, inputArgs, result));
       } catch (hookErr) {
@@ -440,8 +456,15 @@ const _FlowExecutor = class _FlowExecutor {
       }
       await this.emitModelEventIf(eventName, "end", {
         ...eventBasePayload,
-        result
+        result,
+        ...abortedByExitAll ? { aborted: true } : {}
       });
+      if (result && typeof result === "object") {
+        Object.defineProperty(result, "__abortedByExitAll", {
+          value: abortedByExitAll,
+          configurable: true
+        });
+      }
       return result;
     } catch (error) {
       try {

package/lib/flowContext.d.ts

@@ -325,8 +325,10 @@ export declare class FlowContext {
     getPropertyOptions(key: string): PropertyOptions | undefined;
 }
 declare class BaseFlowEngineContext extends FlowContext {
+    t: (key: any, options?: any) => string;
     router: Router;
     dataSourceManager: DataSourceManager;
+    isDarkTheme: boolean;
     requireAsync: (url: string) => Promise<any>;
     importAsync: (url: string) => Promise<any>;
     createJSRunner: (options?: JSRunnerOptions) => Promise<JSRunner>;

package/lib/flowContext.js

@@ -57,6 +57,7 @@ __export(flowContext_exports, {
 });
 module.exports = __toCommonJS(flowContext_exports);
 var import_reactive = require("@formily/reactive");
+var import_axios = __toESM(require("axios"));
 var antd = __toESM(require("antd"));
 var import_lodash = __toESM(require("lodash"));
 var import_qs = __toESM(require("qs"));
@@ -81,6 +82,28 @@ var import_dayjs = __toESM(require("dayjs"));
 var import_runjsLibs = require("./runjsLibs");
 var import_runjsModuleLoader = require("./utils/runjsModuleLoader");
 var _proxy, _FlowContext_instances, createChildNodes_fn, findMetaByPath_fn, findMetaInDelegatesDeep_fn, findMetaInProperty_fn, resolvePathInMeta_fn, resolvePathInMetaAsync_fn, buildParentTitles_fn, toTreeNode_fn;
+function normalizePathname(pathname) {
+  return pathname.endsWith("/") ? pathname : `${pathname}/`;
+}
+__name(normalizePathname, "normalizePathname");
+function shouldBypassApiClient(url, app) {
+  try {
+    const requestUrl = new URL(url);
+    if (!["http:", "https:"].includes(requestUrl.protocol)) {
+      return false;
+    }
+    if (!(app == null ? void 0 : app.getApiUrl)) {
+      return true;
+    }
+    const apiUrl = new URL(app.getApiUrl());
+    const apiPath = normalizePathname(apiUrl.pathname);
+    const requestPath = normalizePathname(requestUrl.pathname);
+    return requestUrl.origin !== apiUrl.origin || !requestPath.startsWith(apiPath);
+  } catch {
+    return false;
+  }
+}
+__name(shouldBypassApiClient, "shouldBypassApiClient");
 function isRecordRefLike(val) {
   return !!(val && typeof val === "object" && "collection" in val && "filterByTk" in val);
 }
@@ -2211,6 +2234,10 @@ const _BaseFlowEngineContext = class _BaseFlowEngineContext extends FlowContext
       return this.engine.getModel(modelName, searchInPreviousEngines);
     });
     this.defineMethod("request", (options) => {
+      const app = this.app;
+      if (typeof (options == null ? void 0 : options.url) === "string" && shouldBypassApiClient(options.url, app)) {
+        return import_axios.default.request(options);
+      }
       return this.api.request(options);
     });
     this.defineMethod(
@@ -2222,7 +2249,10 @@ const _BaseFlowEngineContext = class _BaseFlowEngineContext extends FlowContext
           ...runnerOptions || {},
           globals: mergedGlobals
         });
-        const shouldPreprocessTemplates = preprocessTemplates !== false;
+        const shouldPreprocessTemplates = (0, import_JSRunner.shouldPreprocessRunJSTemplates)({
+          version: runnerOptions == null ? void 0 : runnerOptions.version,
+          preprocessTemplates
+        });
         const jsCode = await (0, import_utils.prepareRunJsCode)(String(code ?? ""), { preprocessTemplates: shouldPreprocessTemplates });
         return runner.run(jsCode);
       }