@nocobase/flow-engine 2.0.0-alpha.2

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);
+  });
+});

package/src/__tests__/flowRuntimeContext.test.ts

@@ -0,0 +1,187 @@
+/**
+ * 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 { ContextPathProxy } from '../ContextPathProxy';
+import { FlowRuntimeContext } from '../flowContext';
+import { FlowEngine } from '../flowEngine';
+import { FlowModel } from '../models/flowModel';
+
+describe('FlowRuntimeContext', () => {
+  let engine: FlowEngine;
+  let model: FlowModel;
+
+  beforeEach(() => {
+    engine = new FlowEngine();
+    model = engine.createModel({ use: 'FlowModel' });
+  });
+
+  it('should support nested property access in runtime mode', () => {
+    const ctx = new FlowRuntimeContext(model, 'flow1');
+    ctx.defineProperty('steps', { value: { step1: { result: 42 } } });
+    ctx.defineProperty('runId', { value: 'abc123' });
+
+    expect(ctx.steps.step1.result).toBe(42);
+    expect(ctx.runId).toBe('abc123');
+    expect(ctx.steps.step2).toBeUndefined();
+    expect(ctx.steps.step1.notExist).toBeUndefined();
+    expect(ctx.notFound).toBeUndefined();
+  });
+
+  it('should return string template in settings mode', () => {
+    const ctx = new FlowRuntimeContext(model, 'flow1', 'settings');
+    ctx.defineProperty('runId', { value: 'mock' });
+    ctx.defineProperty('steps', { value: {} });
+    expect(ctx.runId.toString()).toBe('{{ctx.runId}}');
+    expect(`${ctx.runId}`).toBe('{{ctx.runId}}');
+    expect(ctx.runId).instanceOf(ContextPathProxy);
+    expect(ctx.notFound).toBeUndefined();
+    expect(`${ctx.steps.step1.result}`).toBe('{{ctx.steps.step1.result}}');
+  });
+
+  it('should throw on exit()', () => {
+    const ctx = new FlowRuntimeContext(model, 'flow1', 'runtime');
+    expect(() => ctx.exit()).toThrow();
+  });
+});
+
+describe('FlowRuntimeContext.runAction', () => {
+  let engine: FlowEngine;
+  let model: FlowModel;
+  let ctx: FlowRuntimeContext;
+
+  beforeEach(() => {
+    engine = new FlowEngine();
+    model = engine.createModel({ use: 'FlowModel' });
+    ctx = new FlowRuntimeContext(model, 'unitFlow');
+  });
+
+  it('executes a registered action by name and returns result', async () => {
+    engine.registerActions({
+      hello: {
+        name: 'hello',
+        handler: (_ctx, params) => ({ ok: true, params }),
+      },
+    });
+
+    const res = await ctx.runAction('hello', { x: 1 });
+    expect(res).toEqual({ ok: true, params: { x: 1 } });
+  });
+
+  it('merges defaultParams and resolves expressions when useRawParams is falsy', async () => {
+    engine.registerActions({
+      combine: {
+        name: 'combine',
+        defaultParams: {
+          a: 1,
+          uidFromDefault: '{{ ctx.model.uid }}',
+        },
+        handler: (_ctx, params) => params,
+      },
+    });
+
+    const res = await ctx.runAction('combine', {
+      b: 2,
+      uidFromParam: '{{ ctx.model.uid }}',
+    });
+
+    expect(res).toEqual({
+      a: 1,
+      b: 2,
+      uidFromDefault: model.uid,
+      uidFromParam: model.uid,
+    });
+  });
+
+  it('does not resolve expressions when useRawParams=true', async () => {
+    engine.registerActions({
+      raw: {
+        name: 'raw',
+        defaultParams: {
+          fromDefault: '{{ ctx.model.uid }}',
+        },
+        useRawParams: true,
+        handler: (_ctx, params) => params,
+      },
+    });
+
+    const res = await ctx.runAction('raw', {
+      fromParam: '{{ ctx.model.uid }}',
+      n: 123,
+    });
+    expect(res).toEqual({
+      fromDefault: '{{ ctx.model.uid }}',
+      fromParam: '{{ ctx.model.uid }}',
+      n: 123,
+    });
+  });
+
+  it('supports useRawParams as function', async () => {
+    engine.registerActions({
+      decide: {
+        name: 'decide',
+        defaultParams: { d: '{{ ctx.model.uid }}' },
+        useRawParams: () => Promise.resolve(true),
+        handler: (_ctx, params) => params,
+      },
+    });
+
+    const res = await ctx.runAction('decide', { p: '{{ ctx.model.uid }}' });
+    expect(res).toEqual({ d: '{{ ctx.model.uid }}', p: '{{ ctx.model.uid }}' });
+  });
+
+  it('throws if action not found', async () => {
+    await expect(ctx.runAction('no-such-action')).rejects.toThrow(/not found/i);
+  });
+});
+
+describe('Flow run with step that triggers another action', () => {
+  it('step action calls ctx.runAction to invoke another action', async () => {
+    const engine = new FlowEngine();
+    const model = engine.createModel({ use: 'FlowModel' });
+
+    // second action: merges defaults and resolves expressions
+    engine.registerActions({
+      second: {
+        name: 'second',
+        defaultParams: { a: 1, uidDefault: '{{ ctx.model.uid }}' },
+        handler: (_ctx, params) => ({ from: 'second', ...params }),
+      },
+    });
+
+    // first action: triggers second via ctx.runAction
+    engine.registerActions({
+      first: {
+        name: 'first',
+        handler: async (ctx) => {
+          return await ctx.runAction('second', {
+            b: 2,
+            uidFromFirst: '{{ ctx.model.uid }}',
+          });
+        },
+      },
+    });
+
+    // Define a flow with a single step using 'first'
+    model.flowRegistry.addFlow('chainFlow', {
+      title: 'Chain Flow',
+      steps: {
+        s1: { use: 'first' },
+      },
+    });
+
+    const res = await engine.executor.runFlow(model, 'chainFlow');
+    expect(res.s1).toEqual({
+      from: 'second',
+      a: 1,
+      b: 2,
+      uidDefault: model.uid,
+      uidFromFirst: model.uid,
+    });
+  });
+});