@nocobase/flow-engine 2.0.0-alpha.10

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

@@ -0,0 +1,171 @@
+/**
+ * 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, beforeEach, afterEach } from 'vitest';
+import { FlowEngine } from '../flowEngine';
+import { FlowModel } from '../models/flowModel';
+import type { IFlowModelRepository } from '../types';
+
+// Mock repository implementation for testing
+class MockFlowModelRepository implements IFlowModelRepository {
+  private saveDelay = 100;
+  private saveCount = 0;
+
+  setSaveDelay(delay: number) {
+    this.saveDelay = delay;
+  }
+
+  getSaveCount() {
+    return this.saveCount;
+  }
+
+  resetSaveCount() {
+    this.saveCount = 0;
+  }
+
+  async save(model: FlowModel, options?: { onlyStepParams?: boolean }): Promise<any> {
+    this.saveCount++;
+    // Simulate async save operation
+    await new Promise((resolve) => setTimeout(resolve, this.saveDelay));
+    return { success: true, uid: model.uid, saveCount: this.saveCount };
+  }
+
+  async findOne(options: any): Promise<any> {
+    return null;
+  }
+
+  async destroy(uid: string): Promise<boolean> {
+    return true;
+  }
+
+  async move(sourceId: string, targetId: string, position: 'before' | 'after'): Promise<void> {
+    // Mock implementation
+  }
+}
+
+describe('FlowEngine.saveModel concurrent save prevention', () => {
+  let engine: FlowEngine;
+  let mockRepository: MockFlowModelRepository;
+  let model: FlowModel;
+
+  beforeEach(() => {
+    engine = new FlowEngine();
+    mockRepository = new MockFlowModelRepository();
+    engine.setModelRepository(mockRepository);
+
+    // Create a test model
+    model = engine.createModel({
+      uid: 'test-model-uid',
+      use: 'FlowModel',
+      props: { title: 'Test Model' },
+    });
+  });
+
+  afterEach(() => {
+    mockRepository.resetSaveCount();
+  });
+
+  it('should prevent concurrent saves of the same model', async () => {
+    // Set a longer delay to ensure concurrency
+    mockRepository.setSaveDelay(200);
+
+    // Start multiple save operations concurrently
+    const savePromise1 = engine.saveModel(model);
+    const savePromise2 = engine.saveModel(model);
+    const savePromise3 = engine.saveModel(model);
+
+    // Wait for all promises to complete
+    const [result1, result2, result3] = await Promise.all([savePromise1, savePromise2, savePromise3]);
+
+    // All should return the same result (from the first save operation)
+    expect(result1).toEqual(result2);
+    expect(result2).toEqual(result3);
+    expect(result1.uid).toBe('test-model-uid');
+
+    // Repository save should only be called once
+    expect(mockRepository.getSaveCount()).toBe(1);
+  });
+
+  it('should allow saves after previous save completes', async () => {
+    mockRepository.setSaveDelay(50);
+
+    // First save
+    const result1 = await engine.saveModel(model);
+    expect(result1.saveCount).toBe(1);
+
+    // Second save (after first completes)
+    const result2 = await engine.saveModel(model);
+    expect(result2.saveCount).toBe(2);
+
+    // Repository save should be called twice
+    expect(mockRepository.getSaveCount()).toBe(2);
+  });
+
+  it('should handle save errors correctly and reset state', async () => {
+    // Mock repository to throw error
+    const originalSave = mockRepository.save.bind(mockRepository);
+    mockRepository.save = vi.fn().mockRejectedValueOnce(new Error('Save failed'));
+
+    // First save should fail
+    await expect(engine.saveModel(model)).rejects.toThrow('Save failed');
+
+    // Restore original save method
+    mockRepository.save = originalSave;
+
+    // Second save should work normally
+    const result = await engine.saveModel(model);
+    expect(result.success).toBe(true);
+  });
+
+  it('should handle different models independently', async () => {
+    mockRepository.setSaveDelay(100);
+
+    // Create another model
+    const model2 = engine.createModel({
+      uid: 'test-model-uid-2',
+      use: 'FlowModel',
+      props: { title: 'Test Model 2' },
+    });
+
+    // Start saves for different models concurrently
+    const savePromise1 = engine.saveModel(model);
+    const savePromise2 = engine.saveModel(model2);
+
+    const [result1, result2] = await Promise.all([savePromise1, savePromise2]);
+
+    // Both should succeed
+    expect(result1.uid).toBe('test-model-uid');
+    expect(result2.uid).toBe('test-model-uid-2');
+
+    // Repository save should be called twice (once for each model)
+    expect(mockRepository.getSaveCount()).toBe(2);
+  });
+
+  it('should work when model repository is not set', async () => {
+    // Create engine without repository
+    const engineWithoutRepo = new FlowEngine();
+    const testModel = engineWithoutRepo.createModel({
+      uid: 'test-model-without-repo',
+      use: 'FlowModel',
+      props: { title: 'Test Model' },
+    });
+
+    // Should return undefined without throwing
+    const result = await engineWithoutRepo.saveModel(testModel);
+    expect(result).toBeUndefined();
+  });
+
+  it('should pass options correctly to repository', async () => {
+    const saveSpy = vi.spyOn(mockRepository, 'save');
+
+    await engine.saveModel(model, { onlyStepParams: true });
+
+    expect(saveSpy).toHaveBeenCalledWith(model, { onlyStepParams: true });
+  });
+});

package/src/__tests__/flowI18n.test.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 { FlowI18n } from '../flowI18n';
+
+describe('FlowI18n', () => {
+  it('translates plain keys and templates', () => {
+    const i18n = new FlowI18n({ i18n: { t: (k: string, _o?: any) => (k === 'Hello' ? '你好' : k) } });
+    expect(i18n.translate('Hello')).toBe('你好');
+    expect(i18n.translate("{{ t('Hello') }}")).toBe('你好');
+  });
+
+  it('template compile ignores malformed options', () => {
+    const spy = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    const i18n = new FlowI18n({ i18n: { t: (k: string) => k } });
+    // malformed options will be treated as no options, key is translated directly
+    const s = (i18n as any).translate("{{ t('X', oops) }}");
+    expect(s).toBe('X');
+    spy.mockRestore();
+  });
+});

package/src/__tests__/flowModel.getFlows.test.ts

@@ -0,0 +1,61 @@
+/**
+ * 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 { FlowModel } from '../models/flowModel';
+
+describe('FlowModel.getFlow(s) with instance + global registries', () => {
+  class BaseModel extends FlowModel {}
+  class ChildModel extends BaseModel {}
+
+  it('merges static(global) and instance flows; instance overrides static', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ BaseModel, ChildModel });
+
+    const childGR = (ChildModel as typeof FlowModel).globalFlowRegistry;
+    childGR.addFlow('shared', {
+      title: 'FromChildStatic',
+      steps: { s: { title: 'S', handler: (ctx: any, params: any) => {} } },
+    } as any);
+    const parentGR = (BaseModel as typeof FlowModel).globalFlowRegistry;
+    parentGR.addFlow('baseOnly', {
+      title: 'FromBaseStatic',
+      steps: { p: { title: 'P', handler: (ctx: any, params: any) => {} } },
+    } as any);
+
+    const model = engine.createModel<ChildModel>({ use: 'ChildModel', uid: 'm1' });
+
+    // 实例添加 flow
+    model.flowRegistry.addFlow('instanceOnly', {
+      title: 'FromInstance',
+      steps: { i: { title: 'I', handler: (ctx: any, params: any) => {} } },
+    });
+
+    // 读取单个 flow
+    expect(model.getFlow('instanceOnly')!.title).toBe('FromInstance');
+    expect(model.getFlow('shared')!.title).toBe('FromChildStatic');
+    expect(model.getFlow('baseOnly')!.title).toBe('FromBaseStatic');
+
+    // 实例覆盖同名静态 flow
+    model.flowRegistry.addFlow('shared', {
+      title: 'FromInstanceOverride',
+      steps: { ii: { title: 'II', handler: (ctx: any, params: any) => {} } },
+    });
+    expect(model.getFlow('shared')!.title).toBe('FromInstanceOverride');
+
+    // getFlows 合并结果
+    const allFlows = model.getFlows();
+    expect(allFlows).toBeInstanceOf(Map);
+    expect(allFlows.has('instanceOnly')).toBe(true);
+    expect(allFlows.has('shared')).toBe(true);
+    expect(allFlows.has('baseOnly')).toBe(true);
+    expect(allFlows.get('shared')!.title).toBe('FromInstanceOverride');
+  });
+});

package/src/__tests__/flowModel.openView.navigation.test.ts

@@ -0,0 +1,78 @@
+/**
+ * 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 { FlowEngine } from '../flowEngine';
+import { FlowModel } from '../models/flowModel';
+
+describe('FlowModelContext.openView - navigation enforcement', () => {
+  function setup() {
+    const engine = new FlowEngine();
+    const parent = engine.createModel({ use: 'FlowModel', uid: 'parent-uid' });
+
+    // minimal child model stub used by ctx.openView
+    const child: any = {
+      uid: 'child-uid',
+      stepParams: {},
+      context: {
+        defineProperty: vi.fn(),
+      },
+      getStepParams: vi.fn(() => undefined),
+      setStepParams: vi.fn(),
+      save: vi.fn(async () => undefined),
+      dispatchEvent: vi.fn(async (_event: string, _params?: any) => undefined),
+    };
+
+    // inject loadModel so ctx.openView finds existing model and skips createModel('PopupActionModel')
+    (engine as any).loadModel = vi.fn(async ({ uid }: { uid: string }) => (uid ? child : null));
+
+    return { engine, parent, child };
+  }
+
+  it('forces options.navigation=false when options.defineProperties exists', async () => {
+    const { parent, child } = setup();
+
+    // call and then assert via recorded defineProperty calls
+
+    await (parent.context as any).openView('child-uid', {
+      mode: 'drawer',
+      navigation: true,
+      defineProperties: {
+        foo: { get: () => 'bar' },
+      },
+    });
+
+    // verify view.inputArgs.navigation is forced false (check the first set before it gets cleared)
+    const viewCalls = child.context.defineProperty.mock.calls.filter((args: any[]) => args?.[0] === 'view');
+    const firstView = viewCalls?.[0]?.[1]?.value;
+    expect(firstView?.inputArgs?.navigation).toBe(false);
+    // verify the params passed to dispatchEvent carry navigation=false
+    expect(child.dispatchEvent).toHaveBeenCalledTimes(1);
+    const dispatchedParams = child.dispatchEvent.mock.calls[0][1];
+    expect(dispatchedParams.navigation).toBe(false);
+  });
+
+  it('forces options.navigation=false when options.defineMethod exists', async () => {
+    const { parent, child } = setup();
+
+    await (parent.context as any).openView('child-uid', {
+      navigation: true,
+      defineMethod: {
+        test: vi.fn(),
+      },
+    });
+
+    const viewCalls = child.context.defineProperty.mock.calls.filter((args: any[]) => args?.[0] === 'view');
+    const firstView = viewCalls?.[0]?.[1]?.value;
+    expect(firstView?.inputArgs?.navigation).toBe(false);
+    expect(child.dispatchEvent).toHaveBeenCalledTimes(1);
+    const dispatchedParams = child.dispatchEvent.mock.calls[0][1];
+    expect(dispatchedParams.navigation).toBe(false);
+  });
+});