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

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__/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', () => {