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

package/lib/models/flowModel.js

@@ -62,7 +62,6 @@ var import_StepSettingsDialog = require("../components/settings/wrappers/context
 var import_emitter = require("../emitter");
 var import_InstanceFlowRegistry = require("../flow-registry/InstanceFlowRegistry");
 var import_flowContext = require("../flowContext");
-var import_flowEngine = require("../flowEngine");
 var import_utils = require("../utils");
 var import_lib = require("antd/lib");
 var import_ModelActionRegistry = require("../action-registry/ModelActionRegistry");
@@ -94,6 +93,7 @@ const _FlowModel = class _FlowModel {
     __publicField(this, "_title");
     __publicField(this, "isNew", false);
     // 标记是否为新建状态
+    __publicField(this, "skeleton", null);
     /**
      * 所有 fork 实例的引用集合。
      * 使用 Set 便于在销毁时主动遍历并调用 dispose，避免悬挂引用。
@@ -105,7 +105,7 @@ const _FlowModel = class _FlowModel {
      */
     __publicField(this, "forkCache", /* @__PURE__ */ new Map());
     /**
-     * 上一次 applyAutoFlows 的执行参数
+     * 上一次 beforeRender 的执行参数
      */
     __publicField(this, "_lastAutoRunParams", null);
     __publicField(this, "observerDispose");
@@ -120,18 +120,22 @@ const _FlowModel = class _FlowModel {
     __publicField(this, "_reactiveWrapperCache");
     __publicField(this, "flowRegistry");
     __publicField(this, "_cleanRun");
-    __publicField(this, "_dispatchEventWithDebounce", import_lodash.default.debounce(async (eventName, inputArgs) => {
-      return this._dispatchEvent(eventName, inputArgs);
-    }, 100));
+    __publicField(this, "_dispatchEventWithDebounce", import_lodash.default.debounce(
+      async (eventName, inputArgs, options) => {
+        return this._dispatchEvent(eventName, inputArgs, options);
+      },
+      100
+    ));
     /**
-     * 重新执行上一次的 applyAutoFlows，保持参数一致
+     * 重新执行上一次的 beforeRender，保持参数一致
      * 如果之前没有执行过，则直接跳过
      * 使用 lodash debounce 避免频繁调用
      */
     __publicField(this, "_rerunLastAutoRun", import_lodash.default.debounce(async () => {
       if (this._lastAutoRunParams) {
         try {
-          await this.applyAutoFlows(...this._lastAutoRunParams);
+          const [inputArgs] = this._lastAutoRunParams;
+          await this.dispatchEvent("beforeRender", inputArgs);
         } catch (error) {
           console.error("FlowModel._rerunLastAutoRun: Error during rerun:", error);
         }
@@ -172,7 +176,7 @@ const _FlowModel = class _FlowModel {
         return;
       }
       if (this.flowEngine) {
-        this.invalidateAutoFlowCache();
+        this.invalidateFlowCache("beforeRender");
       }
       this._rerunLastAutoRun();
       this.forks.forEach((fork) => {
@@ -342,13 +346,57 @@ const _FlowModel = class _FlowModel {
       }
     });
   }
-  invalidateAutoFlowCache(deep = false) {
+  /**
+   * 失效指定事件的流程缓存；未指定 eventName 时，失效当前模型全部事件缓存。
+   * - 默认 beforeRender 与其它事件共享同一缓存体系：prefix=`event:${scope}`，flowKey=`eventName`，uid=`model.uid`
+   */
+  invalidateFlowCache(eventName, deep = false) {
     if (this.flowEngine) {
-      const cacheKey = import_flowEngine.FlowEngine.generateApplyFlowCacheKey("autoFlow", "all", this.uid);
-      this.flowEngine.applyFlowCache.delete(cacheKey);
+      const scope = `event:${this.getFlowCacheScope(eventName || "beforeRender")}`;
+      const cache = this.flowEngine.applyFlowCache;
+      if (eventName) {
+        const altScope = scope.replace(/:/g, "-");
+        const uidSuffixes = [`:${this.uid}`, `-${this.uid}`];
+        const eventSegments = [`:${eventName}:`, `-${eventName}-`];
+        for (const key of cache.keys()) {
+          const startMatches = key.startsWith(scope) || key.startsWith(altScope);
+          const endMatches = uidSuffixes.some((s) => key.endsWith(s));
+          const eventMatches = eventSegments.some((seg) => key.includes(seg));
+          if (startMatches && endMatches && eventMatches) {
+            cache.delete(key);
+          }
+        }
+      } else {
+        const altScope = `${scope}:`.replace(/:/g, "-");
+        const prefixes = [`${scope}:`, altScope];
+        const uidSuffixes = [`:${this.uid}`, `-${this.uid}`];
+        for (const key of cache.keys()) {
+          const startMatches = prefixes.some((p) => key.startsWith(p));
+          const endMatches = uidSuffixes.some((s) => key.endsWith(s));
+          if (startMatches && endMatches) cache.delete(key);
+        }
+      }
       this.forks.forEach((fork) => {
-        const forkCacheKey = import_flowEngine.FlowEngine.generateApplyFlowCacheKey(`${fork["forkId"]}`, "all", this.uid);
-        this.flowEngine.applyFlowCache.delete(forkCacheKey);
+        var _a;
+        const forkScope = `event:${((_a = fork.getFlowCacheScope) == null ? void 0 : _a.call(fork, eventName || "beforeRender")) ?? String(fork["forkId"])}`;
+        const altForkScope = forkScope.replace(/:/g, "-");
+        const uidSuffixes = [`:${this.uid}`, `-${this.uid}`];
+        if (eventName) {
+          const eventSegments = [`:${eventName}:`, `-${eventName}-`];
+          for (const key of this.flowEngine.applyFlowCache.keys()) {
+            const startMatches = key.startsWith(forkScope) || key.startsWith(altForkScope);
+            const endMatches = uidSuffixes.some((s) => key.endsWith(s));
+            const eventMatches = eventSegments.some((seg) => key.includes(seg));
+            if (startMatches && endMatches && eventMatches) this.flowEngine.applyFlowCache.delete(key);
+          }
+        } else {
+          const prefixes = [`${forkScope}:`, `${altForkScope}-`];
+          for (const key of this.flowEngine.applyFlowCache.keys()) {
+            const startMatches = prefixes.some((p) => key.startsWith(p));
+            const endMatches = uidSuffixes.some((s) => key.endsWith(s));
+            if (startMatches && endMatches) this.flowEngine.applyFlowCache.delete(key);
+          }
+        }
       });
     }
     if (deep) {
@@ -357,10 +405,10 @@ const _FlowModel = class _FlowModel {
         const subModelValue = this.subModels[subModelKey];
         if (Array.isArray(subModelValue)) {
           for (const subModel of subModelValue) {
-            subModel.invalidateAutoFlowCache(deep);
+            subModel.invalidateFlowCache(eventName, deep);
           }
         } else if (subModelValue instanceof _FlowModel) {
-          subModelValue.invalidateAutoFlowCache(deep);
+          subModelValue.invalidateFlowCache(eventName, deep);
         }
       }
     }
@@ -544,7 +592,7 @@ const _FlowModel = class _FlowModel {
     );
     return currentFlowEngine.executor.runFlow(target, flowKey, inputArgs, runId);
   }
-  async _dispatchEvent(eventName, inputArgs) {
+  async _dispatchEvent(eventName, inputArgs, options) {
     const currentFlowEngine = this.flowEngine;
     if (!currentFlowEngine) {
       console.warn("FlowEngine not available on this model for dispatchEvent. Please set flowEngine on the model.");
@@ -555,93 +603,63 @@ const _FlowModel = class _FlowModel {
     console.log(
       `[FlowModel] dispatchEvent: uid=${this.uid}, event=${eventName}, isFork=${isFork}, cleanRun=${this.cleanRun}, targetIsFork=${(target == null ? void 0 : target.isFork) === true}`
     );
-    await currentFlowEngine.executor.dispatchEvent(target, eventName, inputArgs);
+    return await currentFlowEngine.executor.dispatchEvent(target, eventName, inputArgs, options);
   }
   async dispatchEvent(eventName, inputArgs, options) {
+    const isBeforeRender = eventName === "beforeRender";
+    const defaults = isBeforeRender ? { sequential: true, useCache: true } : {};
+    const execOptions = {
+      sequential: (options == null ? void 0 : options.sequential) ?? defaults.sequential,
+      useCache: (options == null ? void 0 : options.useCache) ?? defaults.useCache
+    };
+    if (isBeforeRender) {
+      this._lastAutoRunParams = [inputArgs, execOptions.useCache];
+    }
     if (options == null ? void 0 : options.debounce) {
-      return this._dispatchEventWithDebounce(eventName, inputArgs);
+      return this._dispatchEventWithDebounce(eventName, inputArgs, execOptions);
     }
-    return this._dispatchEvent(eventName, inputArgs);
+    return this._dispatchEvent(eventName, inputArgs, execOptions);
   }
   /**
-   * 获取所有自动应用流程定义（保持 getFlows 的顺序，即按 sort 排序）
-   * @returns {FlowDefinition[]} 自动应用流程定义数组（已按 sort 排序）
+   * 按事件名获取对应的流程集合（保持 getFlows 的顺序，即按 sort 排序）。
+   * - beforeRender 兼容：除显式 on: 'beforeRender' 外，包含未声明 on 且 manual !== true 的流程。
    */
-  getAutoFlows() {
+  getEventFlows(eventName) {
     const allFlows = this.getFlows();
-    const autoFlows = Array.from(allFlows.values()).filter((flow) => {
-      if (flow.on) {
-        return false;
+    const beforeRender = eventName === "beforeRender";
+    const isMatch = /* @__PURE__ */ __name((flow) => {
+      var _a;
+      if (beforeRender) {
+        if (flow.manual === true) return false;
+        if (!flow.on) return true;
+        return typeof flow.on === "string" ? flow.on === "beforeRender" : ((_a = flow.on) == null ? void 0 : _a.eventName) === "beforeRender";
       }
-      if (flow.manual === true) {
-        return false;
-      }
-      return true;
-    });
-    return autoFlows;
+      const on = flow.on;
+      if (!on) return false;
+      return typeof on === "string" ? on === eventName : (on == null ? void 0 : on.eventName) === eventName;
+    }, "isMatch");
+    return Array.from(allFlows.values()).filter(isMatch);
   }
   /**
-   * 自动流程执行前钩子。
-   * 子类可覆盖；可抛出 FlowExitException 提前终止。
+   * 通用事件分发钩子：开始
+   * 子类可覆盖；beforeRender 事件可通过抛出 FlowExitException 提前终止。
    */
-  async onBeforeAutoFlows(inputArgs) {
+  async onDispatchEventStart(eventName, options, inputArgs) {
   }
   /**
-   * 自动流程执行后钩子。
+   * 通用事件分发钩子：结束
    * 子类可覆盖。
    */
-  async onAfterAutoFlows(results, inputArgs) {
+  async onDispatchEventEnd(eventName, options, inputArgs, results) {
   }
   /**
-   * 自动流程错误钩子。
+   * 通用事件分发钩子：错误
    * 子类可覆盖。
    */
-  async onAutoFlowsError(error, inputArgs) {
+  async onDispatchEventError(eventName, options, inputArgs, error) {
   }
   useHooksBeforeRender() {
   }
-  async applyAutoFlows(...args) {
-    var _a, _b;
-    const [inputArgs, useCache = true] = args;
-    const cacheKey = useCache ? import_flowEngine.FlowEngine.generateApplyFlowCacheKey(this["forkId"] ?? "autoFlow", "all", this.uid) : null;
-    if (!import_lodash.default.isEqual(inputArgs, (_a = this._lastAutoRunParams) == null ? void 0 : _a[0]) && cacheKey) {
-      this.flowEngine.applyFlowCache.delete(cacheKey);
-    }
-    this._lastAutoRunParams = args;
-    try {
-      await this.onBeforeAutoFlows(inputArgs);
-    } catch (error) {
-      if (error instanceof import_utils.FlowExitException) {
-        (_b = this.context.logger) == null ? void 0 : _b.debug(`[FlowModel.applyAutoFlows] ${error.message}`);
-        return [];
-      }
-      try {
-        await this.onAutoFlowsError(error, inputArgs);
-      } catch (_2) {
-      }
-      throw error;
-    }
-    let results = [];
-    try {
-      results = await this.flowEngine.executor.runAutoFlows(this, inputArgs, useCache);
-    } catch (error) {
-      try {
-        await this.onAutoFlowsError(error, inputArgs);
-      } catch (_2) {
-      }
-      throw error;
-    }
-    try {
-      await this.onAfterAutoFlows(results, inputArgs);
-    } catch (error) {
-      try {
-        await this.onAutoFlowsError(error, inputArgs);
-      } catch (_2) {
-      }
-      throw error;
-    }
-    return results;
-  }
   /**
    * 智能检测是否应该跳过响应式包装
    * 说明：
@@ -717,6 +735,7 @@ const _FlowModel = class _FlowModel {
             }
             return (_c = modelInstance.renderHiddenInConfig) == null ? void 0 : _c.call(modelInstance);
           }
+          modelInstance.stepParams;
           return originalRender.call(renderTarget);
         });
         ReactiveWrapper.displayName = `ReactiveWrapper(${modelInstance.constructor.name})`;
@@ -768,13 +787,13 @@ const _FlowModel = class _FlowModel {
   }
   async rerender() {
     var _a;
-    await this.applyAutoFlows((_a = this._lastAutoRunParams) == null ? void 0 : _a[0], false);
+    await this.dispatchEvent("beforeRender", (_a = this._lastAutoRunParams) == null ? void 0 : _a[0], { useCache: false });
   }
   /**
-   * 自动流程缓存的作用域标识；fork 实例可覆盖以区分缓存。
+   * 事件缓存的作用域标识；可按事件区分（默认与事件无关的 scope 返回 'default'）。
    */
-  getAutoFlowCacheScope() {
-    return "autoFlow";
+  getFlowCacheScope(eventName) {
+    return String(eventName);
   }
   setParent(parent) {
     const isValidParent = parent && (parent.constructor === _FlowModel || (0, import_utils.isInheritedFrom)(parent.constructor, _FlowModel));
@@ -892,10 +911,13 @@ const _FlowModel = class _FlowModel {
   createRootModel(options) {
     return this.flowEngine.createModel(options);
   }
-  async applySubModelsAutoFlows(subKey, inputArgs, shared) {
+  /**
+   * 对指定子模型派发 beforeRender 事件（顺序执行并使用缓存）。
+   */
+  async applySubModelsBeforeRenderFlows(subKey, inputArgs, shared) {
     await Promise.all(
       this.mapSubModels(subKey, async (sub) => {
-        await sub.applyAutoFlows(inputArgs);
+        await sub.dispatchEvent("beforeRender", inputArgs);
       })
     );
   }
@@ -913,7 +935,7 @@ const _FlowModel = class _FlowModel {
         return cachedFork;
       }
     }
-    const forkId = this.forks.size;
+    const forkId = (0, import_secure.uid)();
     const fork = new import_forkFlowModel.ForkFlowModel(this, localProps, forkId);
     if ((options == null ? void 0 : options.register) !== false) {
       this.forks.add(fork);
@@ -952,7 +974,7 @@ const _FlowModel = class _FlowModel {
       throw new Error("FlowEngine is not set on this model. Please set flowEngine before saving.");
     }
     this.observerDispose();
-    this.invalidateAutoFlowCache(true);
+    this.invalidateFlowCache("beforeRender", true);
     return this.flowEngine.removeModel(this.uid);
   }
   async save() {
@@ -969,7 +991,7 @@ const _FlowModel = class _FlowModel {
       throw new Error("FlowEngine is not set on this model. Please set flowEngine before deleting.");
     }
     this.observerDispose();
-    this.invalidateAutoFlowCache(true);
+    this.invalidateFlowCache("beforeRender", true);
     return this.flowEngine.destroyModel(this.uid);
   }
   /**
@@ -1032,7 +1054,8 @@ const _FlowModel = class _FlowModel {
       uid: this.uid,
       ...import_lodash.default.omit(this._options, ["flowEngine"]),
       stepParams: this.stepParams,
-      sortIndex: this.sortIndex
+      sortIndex: this.sortIndex,
+      flowRegistry: {}
     };
     const subModels = this.subModels;
     for (const subModelKey in subModels) {
@@ -1047,8 +1070,7 @@ const _FlowModel = class _FlowModel {
       }
     }
     for (const [key, flow] of this.flowRegistry.getFlows()) {
-      data["flowRegistry"] = data["flowRegistry"] || {};
-      data["flowRegistry"][key] = flow.toData();
+      data.flowRegistry[key] = flow.toData();
     }
     return data;
   }

package/lib/models/forkFlowModel.d.ts

@@ -31,7 +31,7 @@ export declare class ForkFlowModel<TMaster extends FlowModel = FlowModel> {
     /** 是否已被释放 */
     private disposed;
     /** fork 在 master.forks 中的索引 */
-    readonly forkId: number;
+    readonly forkId: string;
     /** 需要与 master 共享的属性列表 */
     private static readonly SHARED_PROPERTIES;
     /**
@@ -48,7 +48,7 @@ export declare class ForkFlowModel<TMaster extends FlowModel = FlowModel> {
      * 注意：此属性通过 Proxy 在 get/set 陷阱中被动态访问，IDE 可能无法检测到使用, 切勿删除！
      */
     private localProperties;
-    constructor(master: TMaster, initialProps?: IModelComponentProps, forkId?: number);
+    constructor(master: TMaster, initialProps?: IModelComponentProps, forkId?: string);
     get context(): FlowModelContext;
     /**
      * 获取对象及其原型链上的属性描述符
@@ -63,9 +63,9 @@ export declare class ForkFlowModel<TMaster extends FlowModel = FlowModel> {
      */
     render(): any;
     /**
-     * 自动流程缓存的作用域标识（fork 专用）。
+     * 事件缓存的作用域标识（fork 专用）。
      */
-    getAutoFlowCacheScope(): string;
+    getFlowCacheScope(eventName: string): string;
     /**
      * 释放 fork：从 master.forks 中移除自身并断开引用
      */

package/lib/models/forkFlowModel.js

@@ -38,10 +38,10 @@ __export(forkFlowModel_exports, {
 module.exports = __toCommonJS(forkFlowModel_exports);
 var import_reactive = require("@formily/reactive");
 var import_flowContext = require("../flowContext");
-var import_flowEngine = require("../flowEngine");
+var import_secure = require("uid/secure");
 var _flowContext;
 const _ForkFlowModel = class _ForkFlowModel {
-  constructor(master, initialProps = {}, forkId = 0) {
+  constructor(master, initialProps = {}, forkId) {
     /** 与 master 相同的 UID，用于日志调试 */
     __publicField(this, "uid");
     /** 调试标识，便于在日志或断言中快速识别 */
@@ -65,7 +65,7 @@ const _ForkFlowModel = class _ForkFlowModel {
     this.master = master;
     this.uid = master.uid;
     this.localProps = { ...initialProps };
-    this.forkId = forkId;
+    this.forkId = forkId || (0, import_secure.uid)();
     this.hidden = this.master.hidden;
     (0, import_reactive.define)(this, {
       localProps: import_reactive.observable,
@@ -194,10 +194,10 @@ const _ForkFlowModel = class _ForkFlowModel {
     }
   }
   /**
-   * 自动流程缓存的作用域标识（fork 专用）。
+   * 事件缓存的作用域标识（fork 专用）。
    */
-  getAutoFlowCacheScope() {
-    return String(this.forkId);
+  getFlowCacheScope(eventName) {
+    return `${String(eventName)}:${String(this.forkId)}`;
   }
   // onUnmount() {
   //   // 不在此处自动 dispose（避免破坏外部 fork 管理），但应透传到 master 的 onUnmount 钩子，
@@ -216,11 +216,35 @@ const _ForkFlowModel = class _ForkFlowModel {
    * 释放 fork：从 master.forks 中移除自身并断开引用
    */
   dispose() {
+    var _a;
     if (this.disposed) return;
     this.disposed = true;
+    try {
+      const cache = (_a = this.flowEngine) == null ? void 0 : _a.applyFlowCache;
+      if (cache && cache.size > 0) {
+        const uidSuffixes = [`:${this.uid}`, `-${this.uid}`];
+        const forkIdColon = `:${this.forkId}:`;
+        const forkIdHyphen = `-${this.forkId}-`;
+        for (const key of cache.keys()) {
+          const isEventCache = key.startsWith("event:") || key.startsWith("event-");
+          if (!isEventCache) continue;
+          const endMatches = uidSuffixes.some((s) => key.endsWith(s));
+          if (!endMatches) continue;
+          let trimmed = key;
+          for (const suf of uidSuffixes) {
+            if (trimmed.endsWith(suf)) {
+              trimmed = trimmed.slice(0, -suf.length);
+              break;
+            }
+          }
+          if (trimmed.includes(forkIdColon) || trimmed.includes(forkIdHyphen)) {
+            cache.delete(key);
+          }
+        }
+      }
+    } catch {
+    }
     if (this.master && this.master.forks) {
-      const forkCacheKey = import_flowEngine.FlowEngine.generateApplyFlowCacheKey(`${this.forkId}`, "all", this.uid);
-      this.flowEngine.applyFlowCache.delete(forkCacheKey);
       this.master.forks.delete(this);
     }
     if (this.master && this.master.forkCache) {

package/lib/provider.d.ts

@@ -17,6 +17,8 @@ export declare const FlowEngineProvider: React.FC<FlowEngineProviderProps>;
 export declare const FlowEngineGlobalsContextProvider: React.FC<{
     children: React.ReactNode;
 }>;
-export declare const useFlowEngine: () => FlowEngine;
+export declare const useFlowEngine: ({ throwError }?: {
+    throwError?: boolean;
+}) => FlowEngine;
 export declare const useFlowEngineContext: () => FlowEngineContext;
 export {};

package/lib/provider.js

@@ -49,14 +49,16 @@ var import_FlowContextProvider = require("./FlowContextProvider");
 var import_views = require("./views");
 var import_FlowView = require("./views/FlowView");
 const FlowEngineReactContext = (0, import_react.createContext)(null);
-const FlowEngineProvider = /* @__PURE__ */ __name((props) => {
+const FlowEngineProvider = import_react.default.memo((props) => {
   const { engine, children } = props;
   if (!engine) {
     throw new Error("FlowEngineProvider must be supplied with an engine.");
   }
   return /* @__PURE__ */ import_react.default.createElement(FlowEngineReactContext.Provider, { value: engine }, /* @__PURE__ */ import_react.default.createElement(import_FlowContextProvider.FlowContextProvider, { context: engine.context }, children));
-}, "FlowEngineProvider");
+});
+FlowEngineProvider.displayName = "FlowEngineProvider";
 const FlowEngineGlobalsContextProvider = /* @__PURE__ */ __name(({ children }) => {
+  var _a;
   const { modal, message, notification } = import_antd.App.useApp();
   const [drawer, contextHolder] = (0, import_views.useDrawer)();
   const [embed, pageContextHolder] = (0, import_views.usePage)();
@@ -90,11 +92,11 @@ const FlowEngineGlobalsContextProvider = /* @__PURE__ */ __name(({ children }) =
     }
     engine.reactView.refresh();
   }, [engine, drawer, modal, message, notification, config, popover, token, dialog, embed]);
-  return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, children, contextHolder, popoverContextHolder, pageContextHolder, dialogContextHolder);
+  return /* @__PURE__ */ import_react.default.createElement(import_antd.ConfigProvider, { ...config, locale: (_a = engine.context.locales) == null ? void 0 : _a.antd, popupMatchSelectWidth: false }, children, contextHolder, popoverContextHolder, pageContextHolder, dialogContextHolder);
 }, "FlowEngineGlobalsContextProvider");
-const useFlowEngine = /* @__PURE__ */ __name(() => {
+const useFlowEngine = /* @__PURE__ */ __name(({ throwError = true } = {}) => {
   const context = (0, import_react.useContext)(FlowEngineReactContext);
-  if (!context) {
+  if (!context && throwError) {
     throw new Error(
       "useFlowEngine must be used within a FlowEngineProvider, and FlowEngineProvider must be supplied with an engine."
     );

package/lib/resources/multiRecordResource.js

@@ -130,6 +130,7 @@ const _MultiRecordResource = class _MultiRecordResource extends import_baseRecor
   async create(data, options) {
     const config = this.mergeRequestConfig({ data }, this.createActionOptions, options);
     await this.runAction("create", config);
+    this.emit("saved", data);
     await this.refresh();
   }
   async get(filterByTk) {
@@ -155,6 +156,7 @@ const _MultiRecordResource = class _MultiRecordResource extends import_baseRecor
       options
     );
     await this.runAction("update", config);
+    this.emit("saved", data);
     await this.refresh();
   }
   async destroySelectedRows() {

package/lib/resources/singleRecordResource.js

@@ -69,6 +69,7 @@ const _SingleRecordResource = class _SingleRecordResource extends import_baseRec
       ...config,
       data
     });
+    this.emit("saved", data);
     if ((options == null ? void 0 : options.refresh) !== false) {
       await this.refresh();
     }

package/lib/resources/sqlResource.d.ts

@@ -61,6 +61,7 @@ export declare class SQLResource<TData = any> extends BaseRecordResource<TData>
     setFilterByTk(filterByTk: any): this;
     setFilter(filter: Record<string, any>): this;
     setBind(bind: Record<string, any> | Array<any>): this;
+    setLiquidContext(liquidContext: Record<string, any>): this;
     run(): Promise<any>;
     runBySQL(): Promise<any>;
     runById(): Promise<any>;

package/lib/resources/sqlResource.js

@@ -45,18 +45,7 @@ var import_reactive = require("@formily/reactive");
 var import_lodash = __toESM(require("lodash"));
 var import_flowContext = require("../flowContext");
 var import_baseRecordResource = require("./baseRecordResource");
-function transformSQL(template) {
-  let index = 1;
-  const bind = {};
-  const sql = template.replace(/{{\s*([^}]+)\s*}}/g, (_2, expr) => {
-    const key = `__var${index}`;
-    bind[key] = `{{${expr.trim()}}}`;
-    index++;
-    return `$${key}`;
-  });
-  return { sql, bind };
-}
-__name(transformSQL, "transformSQL");
+var import_client = require("@nocobase/utils/client");
 const _FlowSQLRepository = class _FlowSQLRepository {
   ctx;
   constructor(ctx) {
@@ -72,16 +61,17 @@ const _FlowSQLRepository = class _FlowSQLRepository {
     });
   }
   async run(sql, options = {}) {
-    const result = transformSQL(sql);
-    const bind = await this.ctx.resolveJsonTemplate(result.bind);
+    const { sql: transformedSQL, bind, liquidContext } = await (0, import_client.transformSQL)(sql);
+    const resolved = await this.ctx.resolveJsonTemplate({ bind, liquidContext });
+    const parsedSQL = await (0, import_client.parseLiquidContext)(transformedSQL, resolved.liquidContext);
     const { data } = await this.ctx.api.request({
       method: "POST",
       url: "flowSql:run",
       data: {
-        sql: result.sql,
+        sql: parsedSQL,
         ...options,
         bind: {
-          ...bind,
+          ...resolved.bind,
           ...options.bind
         }
       }
@@ -105,7 +95,7 @@ const _FlowSQLRepository = class _FlowSQLRepository {
         uid
       }
     });
-    const bind = await this.ctx.resolveJsonTemplate(response.data.data || {});
+    const { bind, liquidContext } = await this.ctx.resolveJsonTemplate(response.data.data || {});
     const { data } = await this.ctx.api.request({
       method: "POST",
       url: "flowSql:runById",
@@ -114,8 +104,9 @@ const _FlowSQLRepository = class _FlowSQLRepository {
         ...options,
         bind: {
           ...bind,
-          ...options.bind
-        }
+          ...options == null ? void 0 : options.bind
+        },
+        liquidContext
       }
     });
     return data == null ? void 0 : data.data;
@@ -227,19 +218,23 @@ const _SQLResource = class _SQLResource extends import_baseRecordResource.BaseRe
     this.request.data.bind = bind;
     return this;
   }
+  setLiquidContext(liquidContext) {
+    this.request.data.liquidContext = liquidContext;
+    return this;
+  }
   async run() {
     return this._debugEnabled ? await this.runBySQL() : await this.runById();
   }
   async runBySQL() {
     const sql = this._sql;
-    const result = transformSQL(sql);
-    const bind = await this.context.resolveJsonTemplate(result.bind);
+    const { sql: transformedSQL, bind, liquidContext } = await (0, import_client.transformSQL)(sql);
+    const resolved = await this.context.resolveJsonTemplate({ bind, liquidContext });
     const options = import_lodash.default.cloneDeep({
       method: "post",
       ...this.getRefreshRequestOptions()
     });
-    options.data.bind = bind;
-    options.data.sql = result.sql;
+    options.data.sql = await (0, import_client.parseLiquidContext)(transformedSQL, resolved.liquidContext);
+    options.data.bind = resolved.bind;
     return await this.runAction("run", options);
   }
   async runById() {
@@ -249,8 +244,9 @@ const _SQLResource = class _SQLResource extends import_baseRecordResource.BaseRe
         uid: this.request.data.uid
       }
     });
-    const bind = await this.context.resolveJsonTemplate(data);
+    const { bind, liquidContext } = await this.context.resolveJsonTemplate(data);
     this.setBind(bind);
+    this.setLiquidContext(liquidContext);
     return await this.runAction("runById", {
       method: "post",
       ...this.getRefreshRequestOptions()

package/lib/runjs-context/contexts/FormJSFieldItemRunJSContext.d.ts

@@ -6,11 +6,6 @@
  * 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 { FlowRunJSContext } from './FlowRunJSContext';
+import { FlowRunJSContext } from '../../flowContext';
 export declare class FormJSFieldItemRunJSContext extends FlowRunJSContext {
-    static injectDefaultGlobals(): {
-        window: {};
-        document: {};
-    };
-    constructor(delegate: any);
 }