@nocobase/flow-engine 2.0.0-beta.8 → 2.0.0

package/src/__tests__/runjsExternalLibs.test.ts

@@ -0,0 +1,242 @@
+/**
+ * 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 { beforeEach, describe, expect, it, vi } from 'vitest';
+import { observable } from '@formily/reactive';
+
+vi.mock('../utils/runjsModuleLoader', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../utils/runjsModuleLoader')>();
+  return {
+    ...actual,
+    runjsImportAsync: vi.fn(),
+    runjsRequireAsync: vi.fn(),
+  };
+});
+
+import { runjsImportAsync } from '../utils/runjsModuleLoader';
+import { FlowEngine, FlowRunJSContext } from '..';
+import { externalReactRender } from '../runjsLibs';
+
+function newEngine(): FlowEngine {
+  const engine = new FlowEngine();
+  // 提供最小 api，避免 ctx.auth getter 在打印对象时抛错
+  engine.context.defineProperty('api', { value: { auth: { role: 'guest', locale: 'zh-CN', token: '' } } });
+  return engine;
+}
+
+beforeEach(() => {
+  (globalThis as any).__nocobaseImportAsyncCache = undefined;
+  (globalThis as any).__nbRunjsRoots = undefined;
+  (runjsImportAsync as any).mockReset();
+
+  if (typeof window !== 'undefined') {
+    (window as any).__esm_cdn_base_url__ = 'https://esm.sh';
+    (window as any).__esm_cdn_suffix__ = '';
+  }
+});
+
+describe('RunJS external libs', () => {
+  it('should override ctx.React/ReactDOM when importing external react', async () => {
+    const engine = newEngine();
+    const ctx = new FlowRunJSContext(engine.context);
+
+    const fakeReact = { createElement: vi.fn(), Fragment: Symbol('Fragment') };
+    const fakeReactDOM = { createRoot: vi.fn(() => ({ render: vi.fn(), unmount: vi.fn() })) };
+
+    (runjsImportAsync as any).mockImplementation(async (url: string) => {
+      if (url === 'https://esm.sh/react@18.2.0') return fakeReact;
+      if (url === 'https://esm.sh/react-dom@18.2.0/client') return fakeReactDOM;
+      throw new Error(`unexpected import url: ${url}`);
+    });
+
+    await ctx.importAsync('react@18.2.0');
+
+    expect(ctx.React).toBe(fakeReact);
+    expect(ctx.libs.React).toBe(fakeReact);
+    expect(ctx.ReactDOM).toBe(fakeReactDOM);
+    expect(ctx.libs.ReactDOM).toBe(fakeReactDOM);
+
+    expect(runjsImportAsync).toHaveBeenNthCalledWith(1, 'https://esm.sh/react@18.2.0');
+    expect(runjsImportAsync).toHaveBeenNthCalledWith(2, 'https://esm.sh/react-dom@18.2.0/client');
+  });
+
+  it('should override ctx.antd and ctx.libs.antd when importing antd', async () => {
+    const engine = newEngine();
+    const ctx = new FlowRunJSContext(engine.context);
+
+    const fakeAntd = { Button: 'Button' };
+
+    (runjsImportAsync as any).mockImplementation(async (url: string) => {
+      if (url === 'https://esm.sh/antd@5.29.3?bundle=1') return fakeAntd;
+      throw new Error(`unexpected import url: ${url}`);
+    });
+
+    await ctx.importAsync('antd@5.29.3');
+
+    expect(ctx.antd).toBe(fakeAntd);
+    expect(ctx.libs.antd).toBe(fakeAntd);
+  });
+
+  it('should isolate roots by rendererKey and unmount on ReactDOM switch', () => {
+    const engine = newEngine();
+    const ctx = new FlowRunJSContext(engine.context);
+
+    const root1 = { render: vi.fn(), unmount: vi.fn() };
+    const root2 = { render: vi.fn(), unmount: vi.fn() };
+
+    const renderer1 = { createRoot: vi.fn(() => root1) };
+    const renderer2 = { createRoot: vi.fn(() => root2) };
+
+    ctx.defineProperty('ReactDOM', { value: renderer1 });
+
+    const container = document.createElement('div');
+
+    ctx.render({ step: 1 }, container);
+    ctx.render({ step: 2 }, container);
+
+    expect(renderer1.createRoot).toHaveBeenCalledTimes(1);
+    expect(root1.render).toHaveBeenCalledTimes(2);
+
+    ctx.defineProperty('ReactDOM', { value: renderer2 });
+    ctx.render({ step: 3 }, container);
+
+    expect(root1.unmount).toHaveBeenCalledTimes(1);
+    expect(renderer2.createRoot).toHaveBeenCalledTimes(1);
+    expect(root2.render).toHaveBeenCalledTimes(1);
+  });
+
+  it('should not reuse roots across different ctx owners when rendererKey is the same', () => {
+    const engine1 = newEngine();
+    const ctx1 = new FlowRunJSContext(engine1.context);
+
+    const engine2 = newEngine();
+    const ctx2 = new FlowRunJSContext(engine2.context);
+
+    const root1 = { render: vi.fn(), unmount: vi.fn() };
+    const root2 = { render: vi.fn(), unmount: vi.fn() };
+
+    // 两个 ctx 共享同一个 ReactDOM 实例引用（rendererKey 相同），但 owner 不同；
+    // 若错误复用 entry，会导致旧 ctx 的 autorun 闭包继续持有并驱动新渲染，进而泄漏。
+    const renderer = {
+      createRoot: vi.fn(() => root1),
+    };
+    (renderer.createRoot as any).mockImplementationOnce(() => root1).mockImplementationOnce(() => root2);
+
+    ctx1.defineProperty('ReactDOM', { value: renderer });
+    ctx2.defineProperty('ReactDOM', { value: renderer });
+
+    const container = document.createElement('div');
+
+    ctx1.render({ step: 1 } as any, container);
+    ctx2.render({ step: 2 } as any, container);
+
+    expect(renderer.createRoot).toHaveBeenCalledTimes(2);
+    expect(root1.unmount).toHaveBeenCalledTimes(1);
+    expect(root2.render).toHaveBeenCalledTimes(1);
+  });
+
+  it('should wrap external antd ConfigProvider and rerender on themeToken change', async () => {
+    const engine = newEngine();
+
+    const themeState = observable.shallow({ token: { colorPrimary: 'red' } });
+    engine.context.defineProperty('themeToken', {
+      get: () => themeState.token,
+      cache: false,
+    });
+    engine.context.defineProperty('antdConfig', {
+      value: {
+        theme: { token: { colorPrimary: 'red' } },
+        prefixCls: 'ant',
+      },
+    });
+
+    const ctx = new FlowRunJSContext(engine.context);
+
+    const createElement = vi.fn((type: any, props: any, ...children: any[]) => ({ type, props, children }));
+    const fakeReact = { createElement };
+    const fakeAntdConfigProvider = function ConfigProvider() {};
+    const fakeAntdApp = function App() {};
+    const fakeAntd = { ConfigProvider: fakeAntdConfigProvider, App: fakeAntdApp };
+
+    const root = { render: vi.fn(), unmount: vi.fn() };
+    const fakeReactDOM = { createRoot: vi.fn(() => root) };
+
+    ctx.defineProperty('React', { value: fakeReact });
+    ctx.defineProperty('ReactDOM', { value: fakeReactDOM });
+    ctx.defineProperty('antd', { value: fakeAntd });
+
+    const container = document.createElement('div');
+    const vnode = { v: 1 };
+
+    ctx.render(vnode as any, container);
+
+    expect(root.render).toHaveBeenCalledTimes(1);
+    // createElement is called twice: App first, then ConfigProvider
+    expect(createElement).toHaveBeenNthCalledWith(
+      2,
+      fakeAntdConfigProvider,
+      expect.objectContaining({ prefixCls: 'ant' }),
+      expect.anything(),
+    );
+
+    themeState.token = { colorPrimary: 'blue' };
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(root.render).toHaveBeenCalledTimes(2);
+
+    // cleanup (dispose autorun + unmount root)
+    ctx.render('', container);
+  });
+
+  it('should enhance hooks dispatcher-null TypeError with a helpful hint', () => {
+    const original = new TypeError(`Cannot read properties of null (reading 'useMemo')`);
+    // Mimic a real browser stack from ESM CDN where a dependency brings its own React.
+    (original as any).stack = [
+      `TypeError: Cannot read properties of null (reading 'useMemo')`,
+      `    at u.useMemo (https://esm.sh/react@19.2.4/es2022/react.mjs:2:7636)`,
+      `    at to (https://esm.sh/@dnd-kit/core@6.1.0/es2022/core.mjs:6:1574)`,
+    ].join('\n');
+
+    const root = {
+      render: vi.fn(() => {
+        throw original;
+      }),
+      unmount: vi.fn(),
+    };
+
+    const internalReact = {};
+    const internalAntd = {};
+    const ctx: any = {
+      React: internalReact,
+      ReactDOM: { __nbRunjsInternalShim: true },
+      antd: internalAntd,
+    };
+
+    const entry: any = { root };
+    const containerEl = document.createElement('div');
+
+    try {
+      externalReactRender({
+        ctx,
+        entry,
+        vnode: { v: 1 },
+        containerEl,
+        rootMap: new WeakMap(),
+        unmountContainerRoot: vi.fn(),
+        internalReact,
+        internalAntd,
+      });
+      expect.fail('expected externalReactRender to throw');
+    } catch (e: any) {
+      expect(String(e?.message || '')).toContain('[RunJS Hint]');
+      expect(String(e?.message || '')).toContain('await ctx.importAsync("react@19.2.4")');
+      expect(e?.cause).toBe(original);
+    }
+  });
+});

package/src/__tests__/runjsLibsLazyLoading.test.ts

@@ -0,0 +1,44 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { FlowEngine } from '../flowEngine';
+import { registerRunJSLib } from '../runjsLibs';
+
+describe('RunJS ctx.libs lazy loading', () => {
+  it('preloads member access via prepareRunJsCode injection', async () => {
+    registerRunJSLib('testLib', async () => ({ foo: 123 }));
+
+    const engine = new FlowEngine();
+    const ctx: any = engine.context;
+    const r = await ctx.runjs(`return ctx.libs.testLib.foo;`);
+    expect(r.success).toBe(true);
+    expect(r.value).toBe(123);
+  });
+
+  it('preloads bracket access via prepareRunJsCode injection', async () => {
+    registerRunJSLib('testLib', async () => ({ foo: 456 }));
+
+    const engine = new FlowEngine();
+    const ctx: any = engine.context;
+    const r = await ctx.runjs(`return ctx.libs['testLib'].foo;`);
+    expect(r.success).toBe(true);
+    expect(r.value).toBe(456);
+  });
+
+  it('preloads object destructuring via prepareRunJsCode injection', async () => {
+    registerRunJSLib('testLib', async () => ({ foo: 789 }));
+
+    const engine = new FlowEngine();
+    const ctx: any = engine.context;
+    const r = await ctx.runjs(`const { testLib } = ctx.libs; return testLib.foo;`);
+    expect(r.success).toBe(true);
+    expect(r.value).toBe(789);
+  });
+});

package/src/__tests__/runjsLocales.test.ts

@@ -30,7 +30,10 @@ describe('RunJS locales patch (engine doc)', () => {
     (ctx as any).defineProperty('model', { value: { constructor: { name: 'JSBlockModel' } } });
     (ctx as any).defineProperty('api', { value: { auth: { locale: 'zh-CN' } } });
     const doc = getRunJSDocFor(ctx as any, { version: 'v1' });
-    expect(String(doc?.properties?.message || '')).toMatch(/Ant Design 全局消息 API/);
+    const message = doc?.properties?.message;
+    const messageText =
+      typeof message === 'string' ? message : (message as any)?.description ?? (message as any)?.detail ?? '';
+    expect(String(messageText)).toMatch(/Ant Design 全局消息 API/);
     expect(String(doc?.methods?.t || '')).toMatch(/国际化函数/);
   });
 });

package/src/__tests__/runjsPreprocessDefault.test.ts

@@ -0,0 +1,49 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { FlowEngine } from '../flowEngine';
+import { prepareRunJsCode } from '../utils/runjsTemplateCompat';
+
+describe('ctx.runjs preprocessTemplates default', () => {
+  it('enables template preprocess by default', async () => {
+    const engine = new FlowEngine();
+    const ctx = engine.context as any;
+    ctx.defineProperty('user', { value: { id: 123 } });
+
+    const r1 = await ctx.runjs('return {{ctx.user.id}};');
+    expect(r1.success).toBe(true);
+    expect(r1.value).toBe(123);
+
+    const r2 = await ctx.runjs('return "{{ctx.user.id}}";');
+    expect(r2.success).toBe(true);
+    expect(r2.value).toBe('123');
+  });
+
+  it('can disable template preprocess explicitly', async () => {
+    const engine = new FlowEngine();
+    const ctx = engine.context as any;
+    ctx.defineProperty('user', { value: { id: 123 } });
+
+    const r = await ctx.runjs('return "{{ctx.user.id}}";', undefined, { preprocessTemplates: false });
+    expect(r.success).toBe(true);
+    expect(r.value).toBe('{{ctx.user.id}}');
+  });
+
+  it('does not double-preprocess already prepared code', async () => {
+    const engine = new FlowEngine();
+    const ctx = engine.context as any;
+    ctx.defineProperty('user', { value: { id: 123 } });
+
+    const prepared = await prepareRunJsCode('return "{{ctx.user.id}}";', { preprocessTemplates: true });
+    const r = await ctx.runjs(prepared);
+    expect(r.success).toBe(true);
+    expect(r.value).toBe('123');
+  });
+});

package/src/__tests__/runjsRuntimeFeatures.test.ts

@@ -13,6 +13,7 @@ import { FlowEngine } from '../flowEngine';
 import { FlowContext } from '../flowContext';
 import { setupRunJSContexts } from '../runjs-context/setup';
 import { createJSRunnerWithVersion } from '..';
+import { RunJSContextRegistry } from '../runjs-context/registry';
 
 describe('RunJS Runtime Features', () => {
   let engine: FlowEngine;
@@ -458,4 +459,169 @@ describe('RunJS Runtime Features', () => {
       expect(result?.error).toBeTruthy();
     });
   });
+
+  describe('Deprecation warnings', () => {
+    const version = 'test-deprecation-warnings';
+    const dynamicDefineVersion = 'test-deprecation-dynamic-defineProperty';
+
+    beforeAll(() => {
+      class TestDeprecatedRunJSContext extends FlowRunJSContext {}
+      TestDeprecatedRunJSContext.define({
+        label: 'RunJS deprecated test',
+        properties: {
+          resource: {
+            properties: {
+              getData: {
+                type: 'function',
+                description: 'Deprecated deep-path method for testing.',
+                deprecated: {
+                  message: 'Use refresh instead.',
+                  replacedBy: 'ctx.resource.refresh',
+                  since: '0.0.0-test',
+                },
+              },
+            },
+          },
+        },
+      });
+      RunJSContextRegistry.register(version as any, '*', TestDeprecatedRunJSContext);
+
+      class TestDynamicDefineRunJSContext extends FlowRunJSContext {}
+      TestDynamicDefineRunJSContext.define({
+        label: 'RunJS deprecated dynamic defineProperty test',
+      });
+      RunJSContextRegistry.register(dynamicDefineVersion as any, '*', TestDynamicDefineRunJSContext);
+    });
+
+    it('should warn when calling a deprecated deep-path API', async () => {
+      const ctx = new FlowContext();
+      const warn = vi.fn();
+      ctx.defineProperty('logger', { value: { warn } });
+      ctx.defineProperty('model', { value: { constructor: { name: 'JSBlockModel' } } });
+      ctx.defineProperty('resource', { value: { getData: () => 123 } });
+
+      const runner = createJSRunnerWithVersion.call(ctx, { version });
+      const result = await runner.run('return ctx.resource.getData()');
+
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe(123);
+      expect(warn).toHaveBeenCalledTimes(1);
+      expect(warn.mock.calls[0]?.[0]).toContain('[RunJS][Deprecated] ctx.resource.getData');
+      expect(warn.mock.calls[0]?.[0]).toContain('Use refresh instead.');
+      expect(warn.mock.calls[0]?.[0]).toContain('Use ctx.resource.refresh instead');
+    });
+
+    it('should only warn on invoke (accessing should not warn)', async () => {
+      const ctx = new FlowContext();
+      const warn = vi.fn();
+      ctx.defineProperty('logger', { value: { warn } });
+      ctx.defineProperty('model', { value: { constructor: { name: 'JSBlockModel' } } });
+      ctx.defineProperty('resource', { value: { getData: () => 1 } });
+
+      const runner = createJSRunnerWithVersion.call(ctx, { version });
+      const result = await runner.run(`
+        const fn = ctx.resource.getData;
+        return typeof fn === 'function';
+      `);
+
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe(true);
+      expect(warn).toHaveBeenCalledTimes(0);
+    });
+
+    it('should warn once per RunJS execution for the same API path', async () => {
+      const ctx = new FlowContext();
+      const warn = vi.fn();
+      ctx.defineProperty('logger', { value: { warn } });
+      ctx.defineProperty('model', { value: { constructor: { name: 'JSBlockModel' } } });
+      ctx.defineProperty('resource', { value: { getData: () => 1 } });
+
+      const runner1 = createJSRunnerWithVersion.call(ctx, { version });
+      const r1 = await runner1.run(`
+        ctx.resource.getData();
+        ctx.resource.getData();
+        return true;
+      `);
+      expect(r1?.success).toBe(true);
+      expect(warn).toHaveBeenCalledTimes(1);
+
+      const runner2 = createJSRunnerWithVersion.call(ctx, { version });
+      const r2 = await runner2.run('ctx.resource.getData(); return true;');
+      expect(r2?.success).toBe(true);
+      expect(warn).toHaveBeenCalledTimes(2);
+    });
+
+    it('should warn when accessing a deprecated property defined via FlowContext info', async () => {
+      const ctx = new FlowContext();
+      const warn = vi.fn();
+      ctx.defineProperty('logger', { value: { warn } });
+      ctx.defineProperty('model', { value: { constructor: { name: 'JSBlockModel' } } });
+      ctx.defineProperty('element', {
+        value: { innerHTML: '<div />' },
+        info: { deprecated: { message: 'it is deprecated!' } },
+      });
+
+      const runner = createJSRunnerWithVersion.call(ctx, { version: 'v1' });
+      const result = await runner.run('return ctx.element.innerHTML');
+
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe('<div />');
+      expect(warn).toHaveBeenCalledTimes(1);
+      expect(warn.mock.calls[0]?.[0]).toContain('[RunJS][Deprecated] ctx.element it is deprecated!');
+      expect(warn.mock.calls[0]?.[0]).not.toContain('已废弃');
+      expect(warn.mock.calls[0]?.[0]).toContain('line');
+    });
+
+    it('should warn for deprecated APIs defined via ctx.defineProperty during execution', async () => {
+      const ctx = new FlowContext();
+      const warn = vi.fn();
+      ctx.defineProperty('logger', { value: { warn } });
+      ctx.defineProperty('model', { value: { constructor: { name: 'JSBlockModel' } } });
+
+      const runner = createJSRunnerWithVersion.call(ctx, { version: dynamicDefineVersion });
+      const result = await runner.run(`
+        ctx.defineProperty('element', {
+          value: { innerHTML: '<div />' },
+          info: { deprecated: { message: 'it is deprecated!' } },
+        });
+        return ctx.element.innerHTML;
+      `);
+
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe('<div />');
+      expect(warn).toHaveBeenCalledTimes(1);
+      expect(warn.mock.calls[0]?.[0]).toContain('[RunJS][Deprecated] ctx.element it is deprecated!');
+      expect(warn.mock.calls[0]?.[0]).not.toContain('已废弃');
+    });
+
+    it('should support deprecated deep-path defined via FlowContext info.properties', async () => {
+      const ctx = new FlowContext();
+      const warn = vi.fn();
+      ctx.defineProperty('logger', { value: { warn } });
+      ctx.defineProperty('model', { value: { constructor: { name: 'JSBlockModel' } } });
+      ctx.defineProperty('element', {
+        value: { innerHTML: '<div />' },
+        info: {
+          properties: {
+            innerHTML: {
+              deprecated: {
+                message: 'Use append instead.',
+                replacedBy: 'ctx.element.append',
+              },
+            },
+          },
+        },
+      });
+
+      const runner = createJSRunnerWithVersion.call(ctx, { version: 'v1' });
+      const result = await runner.run('return ctx.element.innerHTML');
+
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe('<div />');
+      expect(warn).toHaveBeenCalledTimes(1);
+      expect(warn.mock.calls[0]?.[0]).toContain('[RunJS][Deprecated] ctx.element.innerHTML');
+      expect(warn.mock.calls[0]?.[0]).toContain('Use append instead.');
+      expect(warn.mock.calls[0]?.[0]).toContain('Use ctx.element.append instead');
+    });
+  });
 });

package/src/__tests__/runjsSnippets.test.ts

@@ -7,8 +7,8 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { describe, it, expect } from 'vitest';
-import { getSnippetBody, listSnippetsForContext } from '../runjs-context/snippets';
+import { describe, expect, it } from 'vitest';
+import { getSnippetBody, listSnippetsForContext, registerRunJSSnippet } from '../runjs-context/snippets';
 
 describe('RunJS Snippets', () => {
   describe('getSnippetBody', () => {
@@ -22,7 +22,7 @@ describe('RunJS Snippets', () => {
     it('should return snippet body for global/api-request', async () => {
       const body = await getSnippetBody('global/api-request');
       expect(body).toBeTruthy();
-      expect(body).toContain('ctx.api.request');
+      expect(body).toContain('ctx.request');
     });
 
     it('should throw error for non-existent snippet', async () => {
@@ -137,4 +137,41 @@ describe('RunJS Snippets', () => {
       await expect(getSnippetBody('global/copy-record-json')).rejects.toThrow();
     });
   });
+
+  describe('registerRunJSSnippet', () => {
+    it('should allow registering and consuming a custom snippet', async () => {
+      const ref = 'plugin/test/hello';
+      registerRunJSSnippet(ref, async () => ({
+        default: {
+          content: `console.log('hello');`,
+          label: 'Hello',
+          versions: ['v1'],
+          contexts: ['*'],
+          scenes: ['block'],
+        },
+      }));
+
+      const body = await getSnippetBody(ref);
+      expect(body).toContain('hello');
+
+      const list = await listSnippetsForContext('*', 'v1', 'en-US');
+      expect(list.some((s) => s.ref === ref)).toBe(true);
+    });
+
+    it('should not overwrite existing refs by default, but can overwrite with override=true', async () => {
+      const ref = 'plugin/test/collision';
+      registerRunJSSnippet(ref, async () => ({ default: { content: 'A', label: 'A' } }));
+      expect(await getSnippetBody(ref)).toBe('A');
+
+      const overwritten = registerRunJSSnippet(ref, async () => ({ default: { content: 'B', label: 'B' } }));
+      expect(overwritten).toBe(false);
+      expect(await getSnippetBody(ref)).toBe('A');
+
+      const forced = registerRunJSSnippet(ref, async () => ({ default: { content: 'C', label: 'C' } }), {
+        override: true,
+      });
+      expect(forced).toBe(true);
+      expect(await getSnippetBody(ref)).toBe('C');
+    });
+  });
 });

package/src/acl/Acl.tsx

@@ -6,7 +6,7 @@
  * 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 { omit } from 'lodash';
+import _, { omit } from 'lodash';
 import { FlowEngine } from '../flowEngine';
 import { FlowModel } from '../models/flowModel';
 
@@ -31,11 +31,11 @@ export class ACL {
   constructor(private flowEngine: FlowEngine) {}
 
   setData(data: Record<string, any>) {
-    this.data = data;
+    this.data = _.cloneDeep(data);
   }
 
   setMeta(data: Record<string, any>) {
-    this.meta = data;
+    this.meta = _.cloneDeep(data);
   }
 
   async load() {