@nocobase/flow-engine 2.0.0-alpha.4 → 2.0.0-alpha.41

package/src/__tests__/blockScopedFlowEngine.test.ts

@@ -0,0 +1,154 @@
+/**
+ * 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, expect, it, vi } from 'vitest';
+import { APIClient as SDKApiClient } from '@nocobase/sdk';
+import { FlowEngine } from '../flowEngine';
+import { createBlockScopedEngine } from '../BlockScopedFlowEngine';
+import { FlowModel } from '../models';
+
+describe('BlockScopedFlowEngine', () => {
+  it('shares global actions/events and model classes with parent', async () => {
+    const parent = new FlowEngine();
+    // 在运行时 host app 会注入 api，这里补一个最小 mock，避免偶发访问 ctx.auth 抛错
+    const api = new SDKApiClient({ storageType: 'memory' });
+    api.auth.role = 'guest';
+    api.auth.locale = 'en-US';
+    api.auth.token = 't';
+    parent.context.defineProperty('api', { value: api });
+    parent.registerActions({
+      ping: {
+        name: 'ping',
+        handler: () => 'pong',
+      },
+    });
+    const child = createBlockScopedEngine(parent);
+
+    // child can read parent's action
+    expect(child.getAction('ping')).toBeDefined();
+
+    // registering via child should affect parent
+    child.registerActions({ pong: { name: 'pong', handler: () => 'ok' } });
+    expect(parent.getAction('pong')).toBeDefined();
+
+    // model class resolution is proxied
+    class TestModel extends FlowModel {}
+    parent.registerModels({ TestModel });
+    expect(child.getModelClass('TestModel')).toBeDefined();
+  });
+
+  it('isolates model instances map and beforeRender cache across engines with identical model uid', async () => {
+    const parent = new FlowEngine();
+    // 提供最小 api mock，满足 ctx.auth 相关 getter
+    const api = new SDKApiClient({ storageType: 'memory' });
+    api.auth.role = 'guest';
+    api.auth.locale = 'en-US';
+    api.auth.token = 't';
+    parent.context.defineProperty('api', { value: api });
+    const child = createBlockScopedEngine(parent);
+
+    let count = 0;
+    class CounterModel extends FlowModel {}
+    CounterModel.registerFlow({
+      key: 'autoCounter',
+      steps: {
+        s1: {
+          handler: async () => {
+            count += 1;
+            return count;
+          },
+        },
+      },
+    });
+
+    const uid = 'model-uid-cache';
+    const pm = parent.createModel<CounterModel>({ use: CounterModel, uid });
+    const cm = child.createModel<CounterModel>({ use: CounterModel, uid });
+
+    await pm.dispatchEvent('beforeRender');
+    expect(count).toBe(1);
+
+    // If cache was shared, the next call would hit cache and not increment.
+    await cm.dispatchEvent('beforeRender');
+    expect(count).toBe(2);
+  });
+
+  it('stacks engines and repairs chain when unlinking a middle block-scoped engine', () => {
+    const root = new FlowEngine();
+    // 提供最小 api mock，满足 ctx.auth 相关 getter
+    const api = new SDKApiClient({ storageType: 'memory' });
+    api.auth.role = 'guest';
+    api.auth.locale = 'en-US';
+    api.auth.token = 't';
+    root.context.defineProperty('api', { value: api });
+    const c1 = createBlockScopedEngine(root);
+    const c2 = createBlockScopedEngine(root);
+    const c3 = createBlockScopedEngine(root);
+
+    // chain root -> c1 -> c2 -> c3
+    expect(root.nextEngine).toBeTruthy();
+    expect(root.nextEngine?.nextEngine).toBeTruthy();
+    expect(root.nextEngine?.nextEngine?.nextEngine).toBeTruthy();
+
+    // unlink middle (c2) should link c1 <-> c3 and keep the tail intact
+    c2.unlinkFromStack();
+
+    // root.nextEngine 指向的是被代理的本地 FlowEngine 实例，不与 c1 的 Proxy 引用相等
+    // 这里通过前后指针关系来校验链修复是否正确
+    const first = root.nextEngine;
+    const second = first?.nextEngine;
+    expect(first?.previousEngine).toBe(root);
+    expect(second?.previousEngine).toBe(first);
+    expect(second?.nextEngine).toBeUndefined();
+  });
+
+  it('global model lookup traverses from top to root across stack', () => {
+    const root = new FlowEngine();
+    // 提供最小 api mock，满足 ctx.auth 相关 getter
+    const api = new SDKApiClient({ storageType: 'memory' });
+    api.auth.role = 'guest';
+    api.auth.locale = 'en-US';
+    api.auth.token = 't';
+    root.context.defineProperty('api', { value: api });
+    const c1 = createBlockScopedEngine(root);
+    const c2 = createBlockScopedEngine(root);
+
+    class TM extends FlowModel {}
+    const uid = 'same-uid-global-lookup';
+    const mRoot = root.createModel<TM>({ use: TM, uid });
+    const m1 = c1.createModel<TM>({ use: TM, uid });
+    const m2 = c2.createModel<TM>({ use: TM, uid });
+
+    // sanity: each scope returns its own when not global
+    expect(root.getModel(uid)).toBe(mRoot);
+    expect(c1.getModel(uid)).toBe(m1);
+    expect(c2.getModel(uid)).toBe(m2);
+
+    // global search from any engine hits the top-most engine's instance first
+    expect(root.getModel(uid, true)).toBe(m2);
+    expect(c1.getModel(uid, true)).toBe(m2);
+    expect(c2.getModel(uid, true)).toBe(m2);
+  });
+
+  it('delegates saveModel to parent (concurrency gate sharing)', async () => {
+    const parent = new FlowEngine();
+    // 提供最小 api mock，满足 ctx.auth 相关 getter
+    const api = new SDKApiClient({ storageType: 'memory' });
+    api.auth.role = 'guest';
+    api.auth.locale = 'en-US';
+    api.auth.token = 't';
+    parent.context.defineProperty('api', { value: api });
+    const child = createBlockScopedEngine(parent);
+    const spy = vi.spyOn(parent, 'saveModel').mockResolvedValueOnce(true);
+    class T extends FlowModel {}
+    const m = child.createModel<T>({ use: T });
+    await child.saveModel(m);
+    expect(spy).toHaveBeenCalledOnce();
+  });
+});

package/src/__tests__/createViewMeta.popup.test.ts

@@ -0,0 +1,132 @@
+/**
+ * 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, vi } from 'vitest';
+import { FlowContext } from '../flowContext';
+import { FlowEngine } from '../flowEngine';
+import type { FlowView } from '../views/FlowView';
+import { createPopupMeta } from '../views/createViewMeta';
+
+describe('createViewMeta - popup variables', () => {
+  function makeCtx() {
+    const engine = new FlowEngine();
+    const ctx = new FlowContext();
+    ctx.defineProperty('engine', { value: engine });
+    // 简化 i18n：直接返回 key
+    ctx.defineProperty('t', { value: (s: string) => s });
+    return { engine, ctx };
+  }
+
+  it('buildVariablesParams(record) uses anchor view instead of ctx.view', async () => {
+    const { engine, ctx } = makeCtx();
+
+    // 模拟锚定弹窗视图（被测试目标）
+    const anchorView: FlowView = {
+      type: 'embed',
+      inputArgs: {},
+      Header: null,
+      Footer: null,
+      close: () => void 0,
+      update: () => void 0,
+      navigation: {
+        viewStack: [
+          {
+            viewUid: 'popup-uid',
+            filterByTk: 111,
+            sourceId: 42,
+          },
+        ],
+      } as any,
+    } as any;
+
+    // ctx.view 指向另一个（例如设置弹窗）
+    ctx.defineProperty('view', {
+      value: {
+        type: 'dialog',
+        inputArgs: {},
+        navigation: {
+          viewStack: [
+            {
+              viewUid: 'settings-uid',
+              filterByTk: 9999,
+            },
+          ],
+        },
+      },
+    });
+
+    // 为两个视图 uid 注入不同的 openView 配置，确保只取锚定视图
+    const popupModel = {
+      getStepParams: vi.fn((_fk: string, sk: string) =>
+        sk === 'openView'
+          ? {
+              collectionName: 'posts',
+              dataSourceKey: 'main',
+            }
+          : undefined,
+      ),
+    } as any;
+    const settingsModel = {
+      getStepParams: vi.fn((_fk: string, sk: string) =>
+        sk === 'openView'
+          ? {
+              collectionName: 'comments',
+              dataSourceKey: 'main',
+            }
+          : undefined,
+      ),
+    } as any;
+
+    const getModelSpy = vi.spyOn(engine as any, 'getModel');
+    getModelSpy.mockImplementation((uid: string) => (uid === 'popup-uid' ? popupModel : settingsModel));
+
+    const metaFactory = createPopupMeta(ctx, anchorView);
+    const meta = (await metaFactory())!;
+
+    // record 应来自锚定视图的 openView 配置
+    const vars = (await meta.buildVariablesParams!(ctx)) as any;
+    expect(vars).toBeTruthy();
+    expect(vars.record).toEqual({ collection: 'posts', dataSourceKey: 'main', filterByTk: 111 });
+
+    // 确认没有误用 ctx.view（settings-uid）的集合
+    expect(vars.record.collection).not.toBe('comments');
+  });
+
+  it('properties() provides a record factory node (lazy) with title', async () => {
+    const { engine, ctx } = makeCtx();
+    // 只要能通过 anchorView 推断到集合名和主键即可；集合详情在懒加载时再取
+    const anchorView: FlowView = {
+      type: 'embed',
+      inputArgs: {},
+      Header: null,
+      Footer: null,
+      close: () => void 0,
+      update: () => void 0,
+      navigation: { viewStack: [{ viewUid: 'popup-uid', filterByTk: 1 }] } as any,
+    } as any;
+    const popupModel = {
+      getStepParams: vi.fn((_fk: string, sk: string) =>
+        sk === 'openView'
+          ? {
+              collectionName: 'tasks',
+              dataSourceKey: 'main',
+            }
+          : undefined,
+      ),
+    } as any;
+    vi.spyOn(engine as any, 'getModel').mockImplementation(() => popupModel);
+
+    const meta = (await createPopupMeta(ctx, anchorView)())!;
+    const props = typeof meta.properties === 'function' ? await (meta.properties as any)() : meta.properties || {};
+    // 断言存在 record 节点工厂，且有标题（懒加载，不触发集合访问）
+    expect(typeof props.record).toBe('function');
+    expect((props.record as any).title).toBe('Current popup record');
+    expect((props.record as any).hasChildren).toBe(true);
+  });
+});

package/src/__tests__/flow-engine.test.ts

@@ -98,6 +98,9 @@ describe('FlowEngine', () => {
         return true;
       }
       async move() {}
+      async duplicate() {
+        return null;
+      }
     }
 
     let repo: MockFlowModelRepository;

package/src/__tests__/flowContext.test.ts

@@ -1282,6 +1282,58 @@ describe('FlowContext resolveOnServer selective server resolution', () => {
     // server was called
     expect(api.request).toHaveBeenCalledTimes(1);
   });
+
+  it('skips server call when all vars require contextParams but none provided', async () => {
+    const engine = new FlowEngine();
+    const api = { request: vi.fn() } as any;
+    engine.context.defineProperty('api', { value: api });
+
+    engine.context.defineProperty('foo', {
+      value: { a: 1 },
+      resolveOnServer: true,
+      serverOnlyWhenContextParams: true,
+      meta: async () => ({
+        type: 'object',
+        title: 'Foo',
+        // no buildVariablesParams -> empty contextParams
+      }),
+    });
+
+    const tpl = { a: '{{ ctx.foo.a }}' } as any;
+    const out = await (engine.context as any).resolveJsonTemplate(tpl);
+    expect(out).toEqual({ a: 1 });
+    // skipped server, because all server vars (only foo) require contextParams but none present
+    expect(api.request).not.toHaveBeenCalled();
+  });
+
+  it('still calls server when at least one var has contextParams (even if others require contextParams but none)', async () => {
+    const engine = new FlowEngine();
+    const api = { request: vi.fn(async () => ({ data: { ok: true } })) } as any;
+    engine.context.defineProperty('api', { value: api });
+
+    // foo: requires contextParams but none will be provided
+    engine.context.defineProperty('foo', {
+      value: { a: 1 },
+      resolveOnServer: true,
+      serverOnlyWhenContextParams: true,
+      meta: async () => ({ type: 'object', title: 'Foo' }),
+    });
+
+    // user: provides contextParams via builder
+    engine.context.defineProperty('user', {
+      value: { id: 9 },
+      resolveOnServer: true,
+      meta: async () => ({
+        type: 'object',
+        title: 'User',
+        buildVariablesParams: () => ({ collection: 'users', filterByTk: 9, dataSourceKey: 'main' }),
+      }),
+    });
+
+    const tpl = { a: '{{ ctx.foo.a }}', u: '{{ ctx.user.id }}' } as any;
+    await (engine.context as any).resolveJsonTemplate(tpl);
+    expect(api.request).toHaveBeenCalledTimes(1);
+  });
 });
 
 describe('FlowContext.getPropertyOptions()', () => {

package/src/__tests__/flowContextCreateJSRunner.test.ts

@@ -0,0 +1,163 @@
+/**
+ * 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, beforeAll } from 'vitest';
+import { FlowEngineContext } from '../flowContext';
+import { FlowEngine } from '../flowEngine';
+import { JSRunner } from '../JSRunner';
+
+describe('FlowContext async createJSRunner', () => {
+  let engine: FlowEngine;
+  let engineCtx: FlowEngineContext;
+
+  beforeAll(() => {
+    // Create minimal engine and context for testing
+    engine = new FlowEngine();
+    engineCtx = new FlowEngineContext(engine);
+  });
+
+  describe('createJSRunner method', () => {
+    it('should be async and return JSRunner instance', async () => {
+      const runner = await engineCtx.createJSRunner();
+      expect(runner).toBeInstanceOf(JSRunner);
+    });
+
+    it('should pass globals to JSRunner', async () => {
+      const customGlobals = { customVar: 'test' };
+      const runner = await engineCtx.createJSRunner({ globals: customGlobals });
+      const result = await runner.run('return customVar');
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe('test');
+    });
+
+    it('should always provide ctx in globals', async () => {
+      const runner = await engineCtx.createJSRunner();
+      const result = await runner.run('return typeof ctx !== "undefined"');
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe(true);
+    });
+
+    it('should support timeout option', async () => {
+      const runner = await engineCtx.createJSRunner({ timeoutMs: 100 });
+      expect(runner).toBeInstanceOf(JSRunner);
+    });
+
+    it('should select appropriate context based on model class', async () => {
+      // Test with JSBlockModel
+      const ctx = new FlowEngineContext(engine);
+      (ctx as any).defineProperty('model', {
+        value: { constructor: { name: 'JSBlockModel' } },
+      });
+
+      const runner = await ctx.createJSRunner();
+      expect(runner).toBeInstanceOf(JSRunner);
+
+      // Check if ctx.element is accessible (specific to JSBlockModel)
+      const result = await runner.run('return typeof ctx !== "undefined"');
+      expect(result?.success).toBe(true);
+    });
+
+    it('should select JSFieldModel context correctly', async () => {
+      const ctx = new FlowEngineContext(engine);
+      (ctx as any).defineProperty('model', {
+        value: { constructor: { name: 'JSFieldModel' } },
+      });
+
+      const runner = await ctx.createJSRunner();
+      expect(runner).toBeInstanceOf(JSRunner);
+    });
+
+    it('should select JSColumnModel context correctly', async () => {
+      const ctx = new FlowEngineContext(engine);
+      (ctx as any).defineProperty('model', {
+        value: { constructor: { name: 'JSColumnModel' } },
+      });
+
+      const runner = await ctx.createJSRunner();
+      expect(runner).toBeInstanceOf(JSRunner);
+    });
+
+    it('should fallback to base context for unknown model', async () => {
+      const ctx = new FlowEngineContext(engine);
+      (ctx as any).defineProperty('model', {
+        value: { constructor: { name: 'UnknownModel' } },
+      });
+
+      const runner = await ctx.createJSRunner();
+      expect(runner).toBeInstanceOf(JSRunner);
+
+      // Should still have ctx
+      const result = await runner.run('return typeof ctx !== "undefined"');
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe(true);
+    });
+
+    it('should support version option', async () => {
+      const runner = await engineCtx.createJSRunner({ version: 'v1' } as any);
+      expect(runner).toBeInstanceOf(JSRunner);
+    });
+
+    it('should merge custom globals with ctx', async () => {
+      const runner = await engineCtx.createJSRunner({
+        globals: { foo: 'bar', baz: 123 },
+      });
+
+      const result = await runner.run('return { hasCtx: typeof ctx !== "undefined", foo, baz }');
+      expect(result?.success).toBe(true);
+      expect(result?.value).toEqual({ hasCtx: true, foo: 'bar', baz: 123 });
+    });
+
+    it('should execute async code successfully', async () => {
+      const runner = await engineCtx.createJSRunner();
+      const result = await runner.run(`
+        return new Promise(resolve => {
+          setTimeout(() => resolve('async result'), 10);
+        });
+      `);
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe('async result');
+    });
+
+    it('should handle errors gracefully', async () => {
+      const runner = await engineCtx.createJSRunner();
+      const result = await runner.run('throw new Error("test error")');
+      expect(result?.success).toBe(false);
+      expect(result?.error).toBeTruthy();
+    });
+
+    it('should respect timeout setting', async () => {
+      const runner = await engineCtx.createJSRunner({ timeoutMs: 50 });
+      const result = await runner.run(`
+        return new Promise(resolve => {
+          setTimeout(() => resolve('done'), 1000);
+        });
+      `);
+      // Should timeout before completing
+      expect(result?.success).toBe(false);
+    });
+  });
+
+  describe('setupRunJSContexts integration', () => {
+    it('should auto-setup contexts when createJSRunner is called', async () => {
+      // Even if setup wasn't called manually, createJSRunner should trigger it
+      const ctx = new FlowEngineContext(engine);
+      (ctx as any).defineProperty('model', {
+        value: { constructor: { name: 'JSBlockModel' } },
+      });
+
+      const runner = await ctx.createJSRunner();
+      expect(runner).toBeInstanceOf(JSRunner);
+
+      // Verify context is properly initialized
+      const result = await runner.run('return typeof ctx !== "undefined"');
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe(true);
+    });
+  });
+});

package/src/__tests__/flowEngine.saveModel.test.ts

@@ -47,6 +47,10 @@ class MockFlowModelRepository implements IFlowModelRepository {
   async move(sourceId: string, targetId: string, position: 'before' | 'after'): Promise<void> {
     // Mock implementation
   }
+
+  async duplicate(uid: string): Promise<Record<string, any> | null> {
+    return null;
+  }
 }
 
 describe('FlowEngine.saveModel concurrent save prevention', () => {