@nocobase/flow-engine 2.0.0-alpha.7 → 2.0.0-alpha.71

package/lib/views/viewEvents.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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';
+export declare const VIEW_ACTIVATED_VERSION: unique symbol;
+export declare const VIEW_ACTIVATED_EVENT: "view:activated";
+export declare const DATA_SOURCE_DIRTY_EVENT: "dataSource:dirty";
+export declare const ENGINE_SCOPE_KEY: "__NOCOBASE_ENGINE_SCOPE__";
+export declare const VIEW_ENGINE_SCOPE: "view";
+export declare function getEmitterViewActivatedVersion(emitter: any): number;
+export declare function bumpViewActivatedVersion(emitter: any): number;
+export declare function resolveOpenerEngine(parentEngine: FlowEngine, scopedEngine: FlowEngine): FlowEngine | undefined;

package/lib/views/viewEvents.js

@@ -0,0 +1,90 @@
+/**
+ * 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 viewEvents_exports = {};
+__export(viewEvents_exports, {
+  DATA_SOURCE_DIRTY_EVENT: () => DATA_SOURCE_DIRTY_EVENT,
+  ENGINE_SCOPE_KEY: () => ENGINE_SCOPE_KEY,
+  VIEW_ACTIVATED_EVENT: () => VIEW_ACTIVATED_EVENT,
+  VIEW_ACTIVATED_VERSION: () => VIEW_ACTIVATED_VERSION,
+  VIEW_ENGINE_SCOPE: () => VIEW_ENGINE_SCOPE,
+  bumpViewActivatedVersion: () => bumpViewActivatedVersion,
+  getEmitterViewActivatedVersion: () => getEmitterViewActivatedVersion,
+  resolveOpenerEngine: () => resolveOpenerEngine
+});
+module.exports = __toCommonJS(viewEvents_exports);
+const VIEW_ACTIVATED_VERSION = Symbol.for("__NOCOBASE_VIEW_ACTIVATED_VERSION__");
+const VIEW_ACTIVATED_EVENT = "view:activated";
+const DATA_SOURCE_DIRTY_EVENT = "dataSource:dirty";
+const ENGINE_SCOPE_KEY = "__NOCOBASE_ENGINE_SCOPE__";
+const VIEW_ENGINE_SCOPE = "view";
+function getEmitterViewActivatedVersion(emitter) {
+  const raw = Reflect.get(emitter, VIEW_ACTIVATED_VERSION);
+  const num = typeof raw === "number" ? raw : Number(raw);
+  return Number.isFinite(num) && num > 0 ? num : 0;
+}
+__name(getEmitterViewActivatedVersion, "getEmitterViewActivatedVersion");
+function bumpViewActivatedVersion(emitter) {
+  const current = getEmitterViewActivatedVersion(emitter);
+  if (!Object.isExtensible(emitter)) return current;
+  const next = current + 1;
+  Reflect.set(emitter, VIEW_ACTIVATED_VERSION, next);
+  return next;
+}
+__name(bumpViewActivatedVersion, "bumpViewActivatedVersion");
+function isViewEngine(engine) {
+  return Reflect.get(engine, ENGINE_SCOPE_KEY) === VIEW_ENGINE_SCOPE;
+}
+__name(isViewEngine, "isViewEngine");
+function findNearestViewEngine(engine) {
+  let cur = engine;
+  let guard = 0;
+  while (cur && guard++ < 50) {
+    if (isViewEngine(cur)) return cur;
+    cur = cur.previousEngine;
+  }
+}
+__name(findNearestViewEngine, "findNearestViewEngine");
+function resolveOpenerEngine(parentEngine, scopedEngine) {
+  if (!parentEngine) return void 0;
+  const parentViewEngine = findNearestViewEngine(parentEngine);
+  if (parentViewEngine) return parentViewEngine;
+  const previousEngine = scopedEngine == null ? void 0 : scopedEngine.previousEngine;
+  return findNearestViewEngine(previousEngine) || parentEngine;
+}
+__name(resolveOpenerEngine, "resolveOpenerEngine");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DATA_SOURCE_DIRTY_EVENT,
+  ENGINE_SCOPE_KEY,
+  VIEW_ACTIVATED_EVENT,
+  VIEW_ACTIVATED_VERSION,
+  VIEW_ENGINE_SCOPE,
+  bumpViewActivatedVersion,
+  getEmitterViewActivatedVersion,
+  resolveOpenerEngine
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/flow-engine",
-  "version": "2.0.0-alpha.7",
+  "version": "2.0.0-alpha.71",
   "private": false,
   "description": "A standalone flow engine for NocoBase, managing workflows, models, and actions.",
   "main": "lib/index.js",
@@ -8,8 +8,10 @@
   "dependencies": {
     "@formily/antd-v5": "1.x",
     "@formily/reactive": "2.x",
-    "@nocobase/sdk": "1.8.0-beta.4",
+    "@nocobase/sdk": "2.0.0-alpha.71",
+    "@nocobase/shared": "2.0.0-alpha.71",
     "ahooks": "^3.7.2",
+    "dayjs": "^1.11.9",
     "dompurify": "^3.0.2",
     "lodash": "^4.x",
     "pino": "^8.0.0",
@@ -17,6 +19,7 @@
     "slate": "^0.103.0",
     "slate-history": "^0.109.0",
     "slate-react": "^0.110.3",
+    "sucrase": "^3.35.0",
     "uid": "^2.0.2"
   },
   "peerDependencies": {
@@ -33,5 +36,5 @@
   ],
   "author": "NocoBase Team",
   "license": "AGPL-3.0",
-  "gitHead": "cb012f93256f534472d3ae56e075839ca1675779"
+  "gitHead": "b6fc484eb698fa12fba02dd468a04e39079b1e79"
 }

package/src/BlockScopedFlowEngine.ts

@@ -0,0 +1,85 @@
+/**
+ * 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';
+
+/**
+ * BlockScopedFlowEngine（区块作用域引擎）
+ *
+ * 设计目标：
+ * - 仅在“区块”作用域内隔离“模型实例表”和“事件缓存”；
+ * - 其余能力（动作/事件/模型类/资源/仓库/设置/日志/翻译等）全部直接代理到父引擎；
+ * - 使用 Proxy 实现“最小代理”，保持与父引擎的全局一致性。
+ *
+ * 注意：
+ * - 本地化的字段仅有：`_modelInstances`、`_applyFlowCache`、`executor`、`context`、栈指针；
+ * - 其它字段/方法均通过 Proxy 转发到父引擎；
+ * - 这样可满足“同一 uid 的模型可在不同区块隔离出现（实例/缓存隔离）”与“共享全局注册/仓库”的诉求。
+ */
+export function createBlockScopedEngine(parent: FlowEngine): FlowEngine {
+  const local = new FlowEngine();
+  if (parent.modelRepository) {
+    local.setModelRepository(parent.modelRepository);
+  }
+  // 继承父级上下文能力
+  local.context.addDelegate(parent.context);
+
+  // 覆盖 unlinkFromStack：BlockScoped 引擎被移除时，修复前后指针，避免“截断”后续视图/作用域
+  local.unlinkFromStack = function () {
+    const prev = (local as any)._previousEngine as FlowEngine | undefined;
+    const next = (local as any)._nextEngine as FlowEngine | undefined;
+    if (prev) (prev as any)._nextEngine = next;
+    if (next) (next as any)._previousEngine = prev;
+    (local as any)._previousEngine = undefined;
+    (local as any)._nextEngine = undefined;
+  };
+
+  // 默认全部代理到父引擎，只有少数字段（实例/缓存/执行器/上下文/链表指针）使用本地值
+  const localOnly = new Set<keyof FlowEngine | string>([
+    '_modelInstances',
+    '_applyFlowCache',
+    'executor',
+    'context',
+    'previousEngine',
+    'nextEngine',
+    // 栈指针维护方法需要在本地执行，而非代理到父引擎
+    'unlinkFromStack',
+    'linkAfter',
+    '_previousEngine',
+    '_nextEngine',
+    // getModel 需要在本地执行以确保全局查找时正确遍历整个引擎栈
+    'getModel',
+  ]);
+
+  const handler: ProxyHandler<FlowEngine> = {
+    get(target, prop: string, receiver) {
+      if (localOnly.has(prop)) {
+        return Reflect.get(target, prop, receiver);
+      }
+      const value = Reflect.get(parent, prop, receiver);
+      if (prop === 'registerModels' && typeof value === 'function') {
+        return value.bind(parent);
+      }
+      return value;
+    },
+    set(target, prop: string, value: unknown) {
+      if (localOnly.has(prop)) {
+        return Reflect.set(target, prop, value);
+      }
+      return Reflect.set(parent, prop, value);
+    },
+    has(target, prop: string) {
+      return prop in target || prop in parent;
+    },
+  };
+
+  // 与父引擎形成栈式关系，便于在多层作用域间进行全局查找
+  local.linkAfter(parent);
+  return new Proxy(local, handler) as FlowEngine;
+}

package/src/FlowContextProvider.tsx

@@ -18,13 +18,15 @@ export function FlowContextProvider(props: { children: React.ReactNode; context:
   return <FlowReactContext.Provider value={props.context}>{props.children}</FlowReactContext.Provider>;
 }
 
-export function FlowViewContextProvider(props: { children: React.ReactNode; context: FlowContext }) {
+export const FlowViewContextProvider = React.memo((props: { children: React.ReactNode; context: FlowContext }) => {
   return (
     <FlowViewContext.Provider value={props.context}>
       <FlowReactContext.Provider value={props.context}>{props.children}</FlowReactContext.Provider>
     </FlowViewContext.Provider>
   );
-}
+});
+
+FlowViewContextProvider.displayName = 'FlowViewContextProvider';
 
 export function useFlowContext<T = FlowEngineContext>() {
   return useContext(FlowReactContext) as T;

package/src/JSRunner.ts

@@ -13,6 +13,12 @@ export interface JSRunnerOptions {
   timeoutMs?: number;
   globals?: Record<string, any>;
   version?: string;
+  /**
+   * Enable RunJS template compatibility preprocessing for `{{ ... }}`.
+   * When enabled via `ctx.runjs(code, vars, { preprocessTemplates: true })` (default),
+   * the code will be rewritten to call `ctx.resolveJsonTemplate(...)` at runtime.
+   */
+  preprocessTemplates?: boolean;
 }
 
 export class JSRunner {
@@ -28,13 +34,41 @@ export class JSRunner {
       return typeof fn === 'function' ? fn.bind(globalThis) : fn;
     };
 
+    const providedGlobals = options.globals || {};
+    const liftedGlobals: Record<string, any> = {};
+
+    // Auto-lift selected globals from safe window into top-level sandbox globals
+    // so user code can access them directly (e.g. `new Blob(...)`).
+    if (!Object.prototype.hasOwnProperty.call(providedGlobals, 'Blob')) {
+      try {
+        const blobCtor = (providedGlobals as any).window?.Blob;
+        if (typeof blobCtor !== 'undefined') {
+          liftedGlobals.Blob = blobCtor;
+        }
+      } catch {
+        // ignore when window proxy blocks property access
+      }
+    }
+
+    if (!Object.prototype.hasOwnProperty.call(providedGlobals, 'URL')) {
+      try {
+        const urlCtor = (providedGlobals as any).window?.URL;
+        if (typeof urlCtor !== 'undefined') {
+          liftedGlobals.URL = urlCtor;
+        }
+      } catch {
+        // ignore when window proxy blocks property access
+      }
+    }
+
     this.globals = {
       console,
       setTimeout: bindWindowFn('setTimeout'),
       clearTimeout: bindWindowFn('clearTimeout'),
       setInterval: bindWindowFn('setInterval'),
       clearInterval: bindWindowFn('clearInterval'),
-      ...(options.globals || {}),
+      ...liftedGlobals,
+      ...providedGlobals,
     };
     this.timeoutMs = options.timeoutMs ?? 5000; // 默认 5 秒超时
   }
@@ -55,6 +89,10 @@ export class JSRunner {
     error?: any;
     timeout?: boolean;
   }> {
+    const search = typeof location !== 'undefined' ? location.search : undefined;
+    if (typeof search === 'string' && search.includes('skipRunJs=true')) {
+      return { success: true, value: null };
+    }
     const wrapped = `(async () => {
       try {
         ${code};

package/src/ViewScopedFlowEngine.ts

@@ -8,12 +8,13 @@
  */
 
 import { FlowEngine } from './flowEngine';
+import { ENGINE_SCOPE_KEY, VIEW_ENGINE_SCOPE } from './views/viewEvents';
 
 /**
  * ViewScopedFlowEngine（视图作用域引擎）
  *
  * 设计目标：
- * - 仅在视图（dialog/drawer/embed）作用域内隔离“模型实例表”和“自动流缓存”；
+ * - 仅在视图（dialog/drawer/embed）作用域内隔离“模型实例表”和“事件缓存”；
  * - 其余能力（动作/事件/模型类/资源/仓库/设置/日志/翻译等）全部直接代理到父引擎；
  * - 使用 Proxy 实现“最小代理”，保持与父引擎的全局一致性。
  *
@@ -24,24 +25,43 @@ import { FlowEngine } from './flowEngine';
  */
 export function createViewScopedEngine(parent: FlowEngine): FlowEngine {
   const local = new FlowEngine();
+  // Mark for view-stack traversal (used by view activation events).
+  Object.defineProperty(local, ENGINE_SCOPE_KEY, { value: VIEW_ENGINE_SCOPE, configurable: true });
   if (parent.modelRepository) {
     local.setModelRepository(parent.modelRepository);
   }
   local.context.addDelegate(parent.context);
 
+  // 视图引擎关闭时，主动释放本地调度器以避免残留任务与引用
+  const originalUnlink = local.unlinkFromStack.bind(local);
+  local.unlinkFromStack = function () {
+    // 释放本地调度器与其事件监听，避免残留引用
+    local.disposeScheduler?.();
+    return originalUnlink();
+  };
+
   // 默认全部代理到父引擎，只有少数字段（实例/缓存/执行器/上下文/链表指针）使用本地值
   const localOnly = new Set<keyof FlowEngine | string>([
     '_modelInstances',
     '_applyFlowCache',
     'executor',
     'context',
+    ENGINE_SCOPE_KEY,
     'previousEngine',
     'nextEngine',
+    // 调度器与事件总线局部化
+    'emitter',
+    '_modelOperationScheduler',
+    'getScheduler',
+    'scheduleModelOperation',
+    'disposeScheduler',
     // 栈指针维护方法需要在本地执行，而非代理到父引擎
     'unlinkFromStack',
     'linkAfter',
     '_previousEngine',
     '_nextEngine',
+    // getModel 需要在本地执行以确保全局查找时正确遍历整个引擎栈
+    'getModel',
   ]);
 
   const handler: ProxyHandler<FlowEngine> = {

package/src/__tests__/JSRunner.test.ts

@@ -7,86 +7,159 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { JSRunner } from '../JSRunner';
+import { createSafeWindow } from '../utils';
 
 describe('JSRunner', () => {
-  it('should run simple code successfully', async () => {
+  let originalSearch: string;
+
+  beforeEach(() => {
+    originalSearch = globalThis.location?.search || '';
+  });
+
+  afterEach(() => {
+    // 恢复 URL 查询参数，避免影响其他用例
+    try {
+      if (typeof window !== 'undefined' && typeof window.history?.replaceState === 'function') {
+        window.history.replaceState({}, '', originalSearch || '');
+      }
+    } catch (_) {
+      // ignore
+    }
+    vi.restoreAllMocks();
+  });
+
+  it('executes simple code and returns value', async () => {
     const runner = new JSRunner();
-    const result = await runner.run(`
-      const x = 10;
-      return x + 5;    
-    `);
+    const result = await runner.run('return 1 + 2 + 3');
     expect(result.success).toBe(true);
-    expect(result.value).toBe(15);
+    expect(result.value).toBe(6);
   });
 
-  it('should handle syntax errors in the code', async () => {
-    const runner = new JSRunner();
-    const result = await runner.run('const x = 10 x + 5;'); // Syntax error
-    expect(result.success).toBe(false);
-    expect(result.error).toBeInstanceOf(SyntaxError);
+  it('injects custom globals and supports register()', async () => {
+    const runner = new JSRunner({ globals: { foo: 42 } });
+    const res1 = await runner.run('return foo');
+    expect(res1.success).toBe(true);
+    expect(res1.value).toBe(42);
+
+    runner.register('bar', 'baz');
+    const res2 = await runner.run('return bar');
+    expect(res2.success).toBe(true);
+    expect(res2.value).toBe('baz');
   });
 
-  it('should handle runtime errors in the code', async () => {
-    const runner = new JSRunner();
-    const result = await runner.run(`
-      const x = 10;
-      throw new Error('Test error');
-    `);
-    expect(result.success).toBe(false);
-    expect(result.error).toBeInstanceOf(Error);
-    expect(result.error.message).toBe('Test error');
+  it('auto-lifts Blob from injected window to top-level globals', async () => {
+    if (typeof Blob === 'undefined') {
+      return;
+    }
+
+    const runner = new JSRunner({
+      globals: {
+        window: createSafeWindow(),
+      },
+    });
+
+    const result = await runner.run('return new Blob(["x"]).size');
+    expect(result.success).toBe(true);
+    expect(result.value).toBe(1);
   });
 
-  it('should handle timeout errors', async () => {
-    const runner = new JSRunner({ timeoutMs: 100 }); // Set a short timeout
-    const result = await runner.run(`
-      await new Promise(resolve => setTimeout(resolve, 500)); // Exceeds timeout
-      return 'Done';
-    `);
-    console.log(result);
-    expect(result.success).toBe(false);
-    expect(result.timeout).toBe(true);
-    expect(result.error.message).toBe('Execution timed out');
+  it('keeps explicit globals.Blob higher priority than auto-lifted Blob', async () => {
+    const explicitBlob = function ExplicitBlob(this: any, chunks: any[]) {
+      this.size = Array.isArray(chunks) ? chunks.length : 0;
+    } as any;
+
+    const runner = new JSRunner({
+      globals: {
+        window: createSafeWindow(),
+        Blob: explicitBlob,
+      },
+    });
+
+    const result = await runner.run('const b = new Blob([1,2,3]); return b.size;');
+    expect(result.success).toBe(true);
+    expect(result.value).toBe(3);
+  });
+
+  it('auto-lifts URL from injected window to top-level globals', async () => {
+    const runner = new JSRunner({
+      globals: {
+        window: createSafeWindow(),
+      },
+    });
+
+    const result = await runner.run('return typeof URL.createObjectURL === "function"');
+    expect(result.success).toBe(true);
+    expect(result.value).toBe(true);
   });
 
-  it('should use registered globals', async () => {
+  it('keeps explicit globals.URL higher priority than auto-lifted URL', async () => {
+    const explicitURL = {
+      createObjectURL: () => 'explicit://url',
+      revokeObjectURL: (_url: string) => undefined,
+    };
+
+    const runner = new JSRunner({
+      globals: {
+        window: createSafeWindow(),
+        URL: explicitURL,
+      },
+    });
+
+    const result = await runner.run('return URL.createObjectURL(new Blob(["x"]))');
+    expect(result.success).toBe(true);
+    expect(result.value).toBe('explicit://url');
+  });
+
+  it('exposes console in sandbox by default', async () => {
     const runner = new JSRunner();
-    runner.register('globalVar', 42);
-    const result = await runner.run(`
-      return globalVar + 8;
-    `);
+    const result = await runner.run('return typeof console !== "undefined"');
     expect(result.success).toBe(true);
-    expect(result.value).toBe(50);
+    expect(result.value).toBe(true);
   });
 
-  it('should handle code with async/await', async () => {
+  it('supports timers (setTimeout) inside evaluated code', async () => {
     const runner = new JSRunner();
     const result = await runner.run(`
-      const fetchData = async () => {
-        return new Promise(resolve => setTimeout(() => resolve(100), 50));
-      };
-      const data = await fetchData();
-      return data + 50;
+      return new Promise((resolve) => {
+        setTimeout(() => resolve('ok'), 20);
+      });
     `);
     expect(result.success).toBe(true);
-    expect(result.value).toBe(150);
+    expect(result.value).toBe('ok');
   });
 
-  it('should handle empty code', async () => {
+  it('handles thrown errors and marks as non-timeout', async () => {
+    const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
     const runner = new JSRunner();
-    const result = await runner.run('');
-    expect(result.success).toBe(true);
-    expect(result.value).toBe(undefined);
+    const result = await runner.run('throw new Error("boom")');
+    expect(result.success).toBe(false);
+    expect(result.timeout).toBe(false);
+    expect(result.error).toBeInstanceOf(Error);
+    expect((result.error as Error).message).toBe('boom');
+    expect(spy).toHaveBeenCalled();
   });
 
-  it('should handle code returning undefined explicitly', async () => {
-    const runner = new JSRunner();
+  it('respects timeout setting and marks timeout=true', async () => {
+    const runner = new JSRunner({ timeoutMs: 10 });
     const result = await runner.run(`
-      const x = 10;
-      return undefined;
+      return new Promise((resolve) => setTimeout(() => resolve('late'), 100));
     `);
+    expect(result.success).toBe(false);
+    expect(result.timeout).toBe(true);
+    expect(result.error).toBeInstanceOf(Error);
+    expect((result.error as Error).message).toBe('Execution timed out');
+  });
+
+  it('skips execution when URL contains skipRunJs=true', async () => {
+    // 模拟预览模式下通过 URL 参数跳过代码执行
+    if (typeof window !== 'undefined' && typeof window.history?.pushState === 'function') {
+      window.history.pushState({}, '', '?skipRunJs=true');
+    }
+    const runner = new JSRunner();
+    const result = await runner.run('throw new Error("should not run")');
     expect(result.success).toBe(true);
-    expect(result.value).toBe(undefined);
+    expect(result.value).toBeNull();
   });
 });