@nocobase/flow-engine 2.0.0-alpha.10

package/lib/executor/FlowExecutor.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 { FlowEngine } from '../flowEngine';
+import type { FlowModel } from '../models';
+import type { DispatchEventOptions } from '../types';
+export declare class FlowExecutor {
+    private readonly engine;
+    constructor(engine: FlowEngine);
+    /** Cache wrapper for applyFlow cache lifecycle */
+    private withApplyFlowCache;
+    /**
+     * Execute a single flow on model.
+     */
+    runFlow(model: FlowModel, flowKey: string, inputArgs?: Record<string, any>, runId?: string): Promise<any>;
+    /**
+     * Dispatch an event to flows bound via flow.on and execute them.
+     */
+    dispatchEvent(model: FlowModel, eventName: string, inputArgs?: Record<string, any>, options?: DispatchEventOptions): Promise<any>;
+}

package/lib/executor/FlowExecutor.js

@@ -0,0 +1,290 @@
+/**
+ * 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 __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var FlowExecutor_exports = {};
+__export(FlowExecutor_exports, {
+  FlowExecutor: () => FlowExecutor
+});
+module.exports = __toCommonJS(FlowExecutor_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_flowContext = require("../flowContext");
+var import_flowEngine = require("../flowEngine");
+var import_utils = require("../utils");
+var import_exceptions = require("../utils/exceptions");
+var import_setupRuntimeContextSteps = require("../utils/setupRuntimeContextSteps");
+const _FlowExecutor = class _FlowExecutor {
+  constructor(engine) {
+    this.engine = engine;
+  }
+  /** Cache wrapper for applyFlow cache lifecycle */
+  async withApplyFlowCache(cacheKey, executor) {
+    if (!cacheKey || !this.engine) return await executor();
+    const cachedEntry = this.engine.applyFlowCache.get(cacheKey);
+    if (cachedEntry) {
+      if (cachedEntry.status === "resolved") return cachedEntry.data;
+      if (cachedEntry.status === "rejected") throw cachedEntry.error;
+      if (cachedEntry.status === "pending") return await cachedEntry.promise;
+    }
+    const promise = executor().then((result) => {
+      this.engine.applyFlowCache.set(cacheKey, {
+        status: "resolved",
+        data: result,
+        promise: Promise.resolve(result)
+      });
+      return result;
+    }).catch((err) => {
+      this.engine.applyFlowCache.set(cacheKey, {
+        status: "rejected",
+        error: err,
+        promise: Promise.reject(err)
+      });
+      throw err;
+    });
+    this.engine.applyFlowCache.set(cacheKey, { status: "pending", promise });
+    return await promise;
+  }
+  /**
+   * Execute a single flow on model.
+   */
+  async runFlow(model, flowKey, inputArgs, runId) {
+    var _a;
+    const flow = model.getFlow(flowKey);
+    if (!flow) {
+      model.context.logger.error(`BaseModel.applyFlow: Flow with key '${flowKey}' not found.`);
+      return Promise.reject(new Error(`Flow '${flowKey}' not found.`));
+    }
+    const flowContext = new import_flowContext.FlowRuntimeContext(model, flowKey);
+    flowContext.defineProperty("reactView", {
+      value: model.reactView
+    });
+    flowContext.defineProperty("inputArgs", {
+      value: {
+        ...inputArgs
+      }
+    });
+    flowContext.defineProperty("runId", {
+      value: runId || `run-${Date.now()}`
+    });
+    let lastResult;
+    const stepResults = flowContext.stepResults;
+    let eventStep = model.getEvent(typeof flow.on === "string" ? flow.on : (_a = flow.on) == null ? void 0 : _a.eventName);
+    if (eventStep) {
+      eventStep = { ...eventStep };
+      eventStep.defaultParams = {
+        ...import_lodash.default.get(flow, "on.defaultParams", {}),
+        ...eventStep.defaultParams
+      };
+    }
+    const stepDefs = eventStep ? { eventStep, ...flow.steps } : flow.steps;
+    (0, import_setupRuntimeContextSteps.setupRuntimeContextSteps)(flowContext, stepDefs, model, flowKey);
+    const stepsRuntime = flowContext.steps;
+    for (const [stepKey, step] of Object.entries(stepDefs)) {
+      let handler;
+      let combinedParams = {};
+      let useRawParams = step.useRawParams;
+      if (step.use) {
+        const actionDefinition = model.getAction(step.use);
+        if (!actionDefinition) {
+          flowContext.logger.error(
+            `BaseModel.applyFlow: Action '${step.use}' not found for step '${stepKey}' in flow '${flowKey}'. Skipping.`
+          );
+          continue;
+        }
+        handler = step.handler || actionDefinition.handler;
+        useRawParams = useRawParams ?? actionDefinition.useRawParams;
+        const actionDefaultParams = await (0, import_utils.resolveDefaultParams)(actionDefinition.defaultParams, flowContext);
+        const stepDefaultParams = await (0, import_utils.resolveDefaultParams)(step.defaultParams, flowContext);
+        combinedParams = { ...actionDefaultParams, ...stepDefaultParams };
+      } else if (step.handler) {
+        handler = step.handler;
+        const stepDefaultParams = await (0, import_utils.resolveDefaultParams)(step.defaultParams, flowContext);
+        combinedParams = { ...stepDefaultParams };
+      } else {
+        flowContext.logger.error(
+          `BaseModel.applyFlow: Step '${stepKey}' in flow '${flowKey}' has neither 'use' nor 'handler'. Skipping.`
+        );
+        continue;
+      }
+      const modelStepParams = model.getStepParams(flowKey, stepKey);
+      if (modelStepParams !== void 0) {
+        combinedParams = { ...combinedParams, ...modelStepParams };
+      }
+      if (typeof useRawParams === "function") {
+        useRawParams = await useRawParams(flowContext);
+      }
+      if (!useRawParams) {
+        combinedParams = await flowContext.resolveJsonTemplate(combinedParams);
+      }
+      try {
+        if (!handler) {
+          flowContext.logger.error(
+            `BaseModel.applyFlow: No handler available for step '${stepKey}' in flow '${flowKey}'. Skipping.`
+          );
+          continue;
+        }
+        const currentStepResult = handler(flowContext, combinedParams);
+        const isAwait = step.isAwait !== false;
+        lastResult = isAwait ? await currentStepResult : currentStepResult;
+        stepResults[stepKey] = lastResult;
+        stepsRuntime[stepKey].result = stepResults[stepKey];
+      } catch (error) {
+        if (error instanceof import_utils.FlowExitException) {
+          flowContext.logger.info(`[FlowEngine] ${error.message}`);
+          return Promise.resolve(stepResults);
+        }
+        if (error instanceof import_exceptions.FlowExitAllException) {
+          flowContext.logger.info(`[FlowEngine] ${error.message}`);
+          return Promise.resolve(error);
+        }
+        flowContext.logger.error(
+          { err: error },
+          `BaseModel.applyFlow: Error executing step '${stepKey}' in flow '${flowKey}':`
+        );
+        return Promise.reject(error);
+      }
+    }
+    return Promise.resolve(stepResults);
+  }
+  // runAutoFlows 已移除：统一通过 dispatchEvent('beforeRender') + useCache 控制
+  /**
+   * Dispatch an event to flows bound via flow.on and execute them.
+   */
+  async dispatchEvent(model, eventName, inputArgs, options) {
+    var _a, _b, _c, _d;
+    const isBeforeRender = eventName === "beforeRender";
+    const sequential = !!(options == null ? void 0 : options.sequential);
+    const useCache = !!(options == null ? void 0 : options.useCache);
+    const throwOnError = isBeforeRender;
+    const runId = `${model.uid}-${eventName}-${Date.now()}`;
+    const logger = model.context.logger;
+    try {
+      await ((_a = model.onDispatchEventStart) == null ? void 0 : _a.call(model, eventName, options, inputArgs));
+    } catch (err) {
+      if (isBeforeRender && err instanceof import_utils.FlowExitException) {
+        logger.debug(`[FlowModel.dispatchEvent] ${err.message}`);
+        return [];
+      }
+      try {
+        await ((_b = model.onDispatchEventError) == null ? void 0 : _b.call(model, eventName, options, inputArgs, err));
+      } finally {
+        logger.error({ err }, `BaseModel.dispatchEvent: Start hook error for event '${eventName}'`);
+      }
+      if (throwOnError) throw err;
+      return;
+    }
+    const flows = isBeforeRender ? model.getEventFlows("beforeRender") : Array.from(model.getFlows().values()).filter((flow) => {
+      const on = flow.on;
+      if (!on) return false;
+      if (typeof on === "string") return on === eventName;
+      if (typeof on === "object") return on.eventName === eventName;
+      return false;
+    });
+    const execute = /* @__PURE__ */ __name(async () => {
+      if (sequential) {
+        const ordered = flows.slice().sort((a, b) => (a.sort ?? 0) - (b.sort ?? 0));
+        const results2 = [];
+        for (const flow of ordered) {
+          try {
+            logger.debug(
+              `BaseModel '${model.uid}' dispatching event '${eventName}' to flow '${flow.key}' (sequential).`
+            );
+            const result = await this.runFlow(model, flow.key, inputArgs, runId);
+            if (result instanceof import_exceptions.FlowExitAllException) {
+              logger.debug(`[FlowEngine.dispatchEvent] ${result.message}`);
+              break;
+            }
+            results2.push(result);
+          } catch (error) {
+            logger.error(
+              { err: error },
+              `BaseModel.dispatchEvent: Error executing event-triggered flow '${flow.key}' for event '${eventName}' (sequential):`
+            );
+            throw error;
+          }
+        }
+        return results2;
+      }
+      const results = await Promise.all(
+        flows.map(async (flow) => {
+          logger.debug(`BaseModel '${model.uid}' dispatching event '${eventName}' to flow '${flow.key}'.`);
+          try {
+            return await this.runFlow(model, flow.key, inputArgs, runId);
+          } catch (error) {
+            logger.error(
+              { err: error },
+              `BaseModel.dispatchEvent: Error executing event-triggered flow '${flow.key}' for event '${eventName}':`
+            );
+            if (throwOnError) throw error;
+            return void 0;
+          }
+        })
+      );
+      return results.filter((x) => x !== void 0);
+    }, "execute");
+    const argsKey = useCache ? JSON.stringify(inputArgs ?? {}) : "";
+    const cacheKey = useCache ? import_flowEngine.FlowEngine.generateApplyFlowCacheKey(
+      `event:${model.getFlowCacheScope(eventName)}:${argsKey}`,
+      eventName,
+      model.uid
+    ) : null;
+    try {
+      const result = await this.withApplyFlowCache(cacheKey, execute);
+      try {
+        await ((_c = model.onDispatchEventEnd) == null ? void 0 : _c.call(model, eventName, options, inputArgs, result));
+      } catch (hookErr) {
+        logger.error({ err: hookErr }, `BaseModel.dispatchEvent: End hook error for event '${eventName}'`);
+      }
+      return result;
+    } catch (error) {
+      try {
+        await ((_d = model.onDispatchEventError) == null ? void 0 : _d.call(model, eventName, options, inputArgs, error));
+      } catch (_2) {
+      }
+      model.context.logger.error(
+        { err: error },
+        `BaseModel.dispatchEvent: Error executing event '${eventName}' for model '${model.uid}':`
+      );
+      if (throwOnError) throw error;
+    }
+  }
+};
+__name(_FlowExecutor, "FlowExecutor");
+let FlowExecutor = _FlowExecutor;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FlowExecutor
+});

package/lib/flow-registry/BaseFlowRegistry.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 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 { FlowDefinitionOptions } from '../types';
+import { FlowDefinition } from '../FlowDefinition';
+type FlowKey = string;
+export interface IFlowRepository {
+    addFlows(flowDefs: Record<string, Omit<FlowDefinitionOptions, 'key'>>): void;
+    addFlow(flowKey: string, flowOptions: Omit<FlowDefinitionOptions, 'key'>): FlowDefinition | void;
+    removeFlow(flowKey: string): void;
+    getFlows(): Map<string, FlowDefinition>;
+    mapFlows<T = any>(callback: (flow: FlowDefinition) => T): T[];
+    hasFlow(flowKey: string): boolean;
+    getFlow(flowKey: string): FlowDefinition | undefined;
+    saveFlow(flow: FlowDefinition): Promise<any> | void;
+    destroyFlow(flowKey: string): Promise<any> | void;
+    moveStep(flowKey: string, sourceStepKey: string, targetStepKey: string): Promise<any> | void;
+}
+/**
+ * 抽象基类，封装通用的 Flow Registry 逻辑
+ * 子类只需实现持久化相关的方法
+ */
+export declare abstract class BaseFlowRegistry implements IFlowRepository {
+    protected flows: Map<FlowKey, FlowDefinition>;
+    constructor();
+    addFlows(flows: Record<FlowKey, Omit<FlowDefinitionOptions, 'key'> & {
+        key?: string;
+    }>): void;
+    addFlow(flowKey: FlowKey, flowOptions: Omit<FlowDefinitionOptions, 'key'> & {
+        key?: string;
+    }): FlowDefinition;
+    hasFlow(flowKey: FlowKey): boolean;
+    getFlow(flowKey: FlowKey): FlowDefinition | undefined;
+    getFlows(): Map<FlowKey, FlowDefinition>;
+    removeFlow(flowKey: FlowKey): void;
+    mapFlows<T = any>(callback: (flow: FlowDefinition) => T): T[];
+    moveStep(flowKey: FlowKey, sourceStepKey: string, targetStepKey: string): void;
+    abstract saveFlow(flow: FlowDefinition): Promise<any> | void;
+    abstract destroyFlow(flowKey: string): Promise<any> | void;
+}
+export {};

package/lib/flow-registry/BaseFlowRegistry.js

@@ -0,0 +1,86 @@
+/**
+ * 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 BaseFlowRegistry_exports = {};
+__export(BaseFlowRegistry_exports, {
+  BaseFlowRegistry: () => BaseFlowRegistry
+});
+module.exports = __toCommonJS(BaseFlowRegistry_exports);
+var import_FlowDefinition = require("../FlowDefinition");
+var import_reactive = require("@formily/reactive");
+const _BaseFlowRegistry = class _BaseFlowRegistry {
+  flows;
+  constructor() {
+    this.flows = import_reactive.observable.shallow(/* @__PURE__ */ new Map());
+  }
+  addFlows(flows) {
+    for (const [flowKey, flowOptions] of Object.entries(flows || {})) {
+      this.addFlow(flowKey, flowOptions);
+    }
+  }
+  addFlow(flowKey, flowOptions) {
+    const flow = new import_FlowDefinition.FlowDefinition(
+      {
+        ...flowOptions,
+        key: flowKey
+      },
+      this
+    );
+    this.flows.set(flowKey, flow);
+    return flow;
+  }
+  hasFlow(flowKey) {
+    const flow = this.flows.get(flowKey);
+    return !!flow;
+  }
+  getFlow(flowKey) {
+    return this.flows.get(flowKey);
+  }
+  getFlows() {
+    return this.flows;
+  }
+  removeFlow(flowKey) {
+    this.flows.delete(flowKey);
+  }
+  mapFlows(callback) {
+    const flows = this.getFlows();
+    return [...flows.values()].map((flow) => callback(flow));
+  }
+  moveStep(flowKey, sourceStepKey, targetStepKey) {
+    const flow = this.getFlow(flowKey);
+    if (!flow) {
+      throw new Error(`Flow '${flowKey}' not found`);
+    }
+    flow.moveStep(sourceStepKey, targetStepKey);
+  }
+};
+__name(_BaseFlowRegistry, "BaseFlowRegistry");
+let BaseFlowRegistry = _BaseFlowRegistry;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseFlowRegistry
+});

package/lib/flow-registry/GlobalFlowRegistry.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 { ModelConstructor } from '../types';
+import { FlowDefinition } from '../FlowDefinition';
+import { BaseFlowRegistry } from './BaseFlowRegistry';
+type FlowKey = string;
+export declare class GlobalFlowRegistry extends BaseFlowRegistry {
+    protected target: ModelConstructor;
+    constructor(target: ModelConstructor);
+    removeFlow(flowKey: FlowKey): void;
+    getFlow(flowKey: FlowKey): FlowDefinition | undefined;
+    getFlows(): Map<FlowKey, FlowDefinition>;
+    saveFlow(flow: FlowDefinition): void;
+    destroyFlow(flowKey: string): void;
+}
+export {};

package/lib/flow-registry/GlobalFlowRegistry.js

@@ -0,0 +1,95 @@
+/**
+ * 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 GlobalFlowRegistry_exports = {};
+__export(GlobalFlowRegistry_exports, {
+  GlobalFlowRegistry: () => GlobalFlowRegistry
+});
+module.exports = __toCommonJS(GlobalFlowRegistry_exports);
+var import_models = require("../models");
+var import_BaseFlowRegistry = require("./BaseFlowRegistry");
+const _GlobalFlowRegistry = class _GlobalFlowRegistry extends import_BaseFlowRegistry.BaseFlowRegistry {
+  constructor(target) {
+    super();
+    this.target = target;
+  }
+  removeFlow(flowKey) {
+    console.warn(`GlobalFlowRegistry.removeFlow: removing static flow '${flowKey}' is not supported.`);
+  }
+  getFlow(flowKey) {
+    if (this.flows.has(flowKey)) {
+      return this.flows.get(flowKey);
+    }
+    const proto = Object.getPrototypeOf(this.target);
+    if (proto !== Function.prototype && proto !== Object.prototype && (proto == null ? void 0 : proto.globalFlowRegistry)) {
+      return proto.globalFlowRegistry.getFlow(flowKey);
+    }
+    return void 0;
+  }
+  getFlows() {
+    const flows = new Map(this.flows);
+    const proto = Object.getPrototypeOf(this.target);
+    if (proto !== Function.prototype && proto !== Object.prototype && (proto == null ? void 0 : proto.globalFlowRegistry)) {
+      for (const [key, def] of proto.globalFlowRegistry.getFlows().entries()) {
+        if (!flows.has(key)) {
+          flows.set(key, def);
+        }
+      }
+    }
+    const getClassDepth = /* @__PURE__ */ __name((klass) => {
+      let depth = 0;
+      let cur = klass;
+      while (cur && cur !== import_models.FlowModel && cur !== Function.prototype && cur !== Object.prototype) {
+        cur = Object.getPrototypeOf(cur);
+        depth += 1;
+      }
+      return depth;
+    }, "getClassDepth");
+    const sortedEntries = Array.from(flows.entries()).sort(([, a], [, b]) => {
+      const sa = a.sort ?? 0;
+      const sb = b.sort ?? 0;
+      if (sa !== sb) return sa - sb;
+      const ra = a["flowRegistry"];
+      const rb = b["flowRegistry"];
+      const da = getClassDepth(ra["target"]);
+      const db = getClassDepth(rb["target"]);
+      if (da !== db) return da - db;
+      return 0;
+    });
+    return new Map(sortedEntries);
+  }
+  saveFlow(flow) {
+  }
+  destroyFlow(flowKey) {
+  }
+};
+__name(_GlobalFlowRegistry, "GlobalFlowRegistry");
+let GlobalFlowRegistry = _GlobalFlowRegistry;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GlobalFlowRegistry
+});

package/lib/flow-registry/InstanceFlowRegistry.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 { FlowDefinition } from '../FlowDefinition';
+import { FlowModel } from '../models';
+import { BaseFlowRegistry } from './BaseFlowRegistry';
+type FlowKey = string;
+export declare class InstanceFlowRegistry extends BaseFlowRegistry {
+    protected model: FlowModel;
+    constructor(model: FlowModel);
+    save(): Promise<void>;
+    saveFlow(flow: FlowDefinition): Promise<void>;
+    destroyFlow(flowKey: FlowKey): Promise<void>;
+    moveStep(flowKey: FlowKey, sourceStepKey: string, targetStepKey: string): Promise<void>;
+}
+export {};

package/lib/flow-registry/InstanceFlowRegistry.js

@@ -0,0 +1,59 @@
+/**
+ * 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 InstanceFlowRegistry_exports = {};
+__export(InstanceFlowRegistry_exports, {
+  InstanceFlowRegistry: () => InstanceFlowRegistry
+});
+module.exports = __toCommonJS(InstanceFlowRegistry_exports);
+var import_BaseFlowRegistry = require("./BaseFlowRegistry");
+const _InstanceFlowRegistry = class _InstanceFlowRegistry extends import_BaseFlowRegistry.BaseFlowRegistry {
+  constructor(model) {
+    super();
+    this.model = model;
+  }
+  async save() {
+    await this.model.saveStepParams();
+  }
+  async saveFlow(flow) {
+    await this.model.saveStepParams();
+  }
+  async destroyFlow(flowKey) {
+    this.removeFlow(flowKey);
+    await this.model.saveStepParams();
+  }
+  async moveStep(flowKey, sourceStepKey, targetStepKey) {
+    super.moveStep(flowKey, sourceStepKey, targetStepKey);
+    await this.model.saveStepParams();
+  }
+};
+__name(_InstanceFlowRegistry, "InstanceFlowRegistry");
+let InstanceFlowRegistry = _InstanceFlowRegistry;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InstanceFlowRegistry
+});

package/lib/flow-registry/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ */
+export * from './BaseFlowRegistry';
+export * from './InstanceFlowRegistry';
+export * from './GlobalFlowRegistry';