@nocobase/flow-engine 2.1.0-alpha.4 → 2.1.0-alpha.45

package/src/executor/__tests__/flowExecutor.test.ts

@@ -81,6 +81,34 @@ describe('FlowExecutor', () => {
     expect(result.step2).toBe('step2-ok');
   });
 
+  it('runFlow warns and skips steps without use or handler', async () => {
+    const flows = {
+      referenceSettings: {
+        steps: {
+          target: {},
+        },
+      },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+    const model = createModelWithFlows('m-empty-step', flows);
+    const loggerChildSpy = vi.spyOn(engine.logger, 'child').mockReturnValue(engine.logger);
+    const loggerWarnSpy = vi.spyOn(engine.logger, 'warn').mockImplementation(() => {});
+    const loggerErrorSpy = vi.spyOn(engine.logger, 'error').mockImplementation(() => {});
+
+    try {
+      const result = await engine.executor.runFlow(model, 'referenceSettings');
+
+      expect(result).toEqual({});
+      expect(loggerWarnSpy).toHaveBeenCalledWith(
+        "BaseModel.applyFlow: Step 'target' in flow 'referenceSettings' has neither 'use' nor 'handler'. Skipping.",
+      );
+      expect(loggerErrorSpy).not.toHaveBeenCalled();
+    } finally {
+      loggerChildSpy.mockRestore();
+      loggerWarnSpy.mockRestore();
+      loggerErrorSpy.mockRestore();
+    }
+  });
+
   it("dispatchEvent('beforeRender') executes flows in sort order and caches result (when options specify)", async () => {
     const calls: string[] = [];
     const mkFlow = (key: string, sort: number) => ({
@@ -232,6 +260,37 @@ describe('FlowExecutor', () => {
     expect(calls.sort()).toEqual(['a', 'b']);
   });
 
+  it('dispatchEvent sequential exposes abortedByExitAll metadata on result array', async () => {
+    const flows = {
+      stopClose: {
+        on: { eventName: 'close' },
+        steps: {
+          only: {
+            handler: vi.fn().mockImplementation((ctx) => {
+              ctx.exit();
+            }),
+          },
+        },
+      },
+      afterClose: {
+        on: { eventName: 'close', phase: 'afterAllFlows' },
+        steps: {
+          only: {
+            handler: vi.fn(),
+          },
+        },
+      },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const model = createModelWithFlows('m-close-meta', flows);
+
+    const result = await engine.executor.dispatchEvent(model, 'close', {}, { sequential: true });
+
+    expect(Array.isArray(result)).toBe(true);
+    expect((result as any).__abortedByExitAll).toBe(true);
+    expect(flows.afterClose.steps.only.handler).not.toHaveBeenCalled();
+  });
+
   it('dispatchEvent sequential respects sort order and stops on errors', async () => {
     const calls: string[] = [];
     const mkFlow = (key: string, sort: number, opts?: { throw?: boolean }) => ({
@@ -288,6 +347,32 @@ describe('FlowExecutor', () => {
     expect(handler).toHaveBeenCalledTimes(2); // 每个 flow 各 1 次，共 2 次
   });
 
+  it("dispatchEvent('beforeRender') keeps aborted flag on end event when cache hits", async () => {
+    const handler = vi.fn().mockImplementation((ctx) => {
+      ctx.exitAll();
+    });
+    const flows = {
+      abortFlow: { steps: { s: { handler } } },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+    const model = createModelWithFlows('m-br-cache-aborted', flows);
+
+    const endEvents: any[] = [];
+    const onEnd = (payload: any) => {
+      endEvents.push(payload);
+    };
+    engine.emitter.on('model:event:beforeRender:end', onEnd);
+
+    await engine.executor.dispatchEvent(model, 'beforeRender', undefined, { sequential: true, useCache: true });
+    await engine.executor.dispatchEvent(model, 'beforeRender', undefined, { sequential: true, useCache: true });
+
+    engine.emitter.off('model:event:beforeRender:end', onEnd);
+
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(endEvents).toHaveLength(2);
+    expect(endEvents[0]?.aborted).toBe(true);
+    expect(endEvents[1]?.aborted).toBe(true);
+  });
+
   it('dispatchEvent supports sequential execution order and exitAll break', async () => {
     const calls: string[] = [];
     const mkFlow = (key: string, sort: number, opts?: { exitAll?: boolean }) => ({

package/src/flow-registry/DetachedFlowRegistry.ts

@@ -0,0 +1,46 @@
+/**
+ * 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 _ from 'lodash';
+import { FlowDefinition } from '../FlowDefinition';
+import { FlowDefinitionOptions } from '../types';
+import { BaseFlowRegistry, IFlowRepository } from './BaseFlowRegistry';
+
+export type FlowRegistryData = Record<string, Omit<FlowDefinitionOptions, 'key'> & { key?: string }>;
+
+export class DetachedFlowRegistry extends BaseFlowRegistry {
+  constructor(flows: FlowRegistryData = {}) {
+    super();
+    this.addFlows(_.cloneDeep(flows));
+  }
+
+  saveFlow(_flow: FlowDefinition): void {}
+
+  destroyFlow(flowKey: string): void {
+    this.removeFlow(flowKey);
+  }
+}
+
+export function serializeFlowRegistry(registry: Pick<IFlowRepository, 'getFlows'>): FlowRegistryData {
+  const flows: FlowRegistryData = {};
+  for (const [key, flow] of registry.getFlows()) {
+    flows[key] = _.cloneDeep(flow.toData());
+  }
+  return flows;
+}
+
+export function replaceFlowRegistry(
+  registry: Pick<IFlowRepository, 'getFlows' | 'removeFlow' | 'addFlows'>,
+  flows: FlowRegistryData,
+) {
+  for (const key of Array.from(registry.getFlows().keys())) {
+    registry.removeFlow(key);
+  }
+  registry.addFlows(_.cloneDeep(flows));
+}

package/src/flow-registry/__tests__/detachedFlowRegistry.test.ts

@@ -0,0 +1,47 @@
+/**
+ * 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, test } from 'vitest';
+import { DetachedFlowRegistry, replaceFlowRegistry, serializeFlowRegistry } from '../DetachedFlowRegistry';
+
+describe('DetachedFlowRegistry', () => {
+  test('keeps flow edits detached and can replace another registry', () => {
+    const source = {
+      flow1: {
+        title: 'Flow 1',
+        steps: {
+          step1: { title: 'Step 1' } as any,
+        },
+      },
+    };
+    const registry = new DetachedFlowRegistry(source);
+
+    source.flow1.title = 'Changed outside';
+    expect(registry.getFlow('flow1')?.title).toBe('Flow 1');
+
+    const flow = registry.getFlow('flow1');
+    expect(flow).toBeDefined();
+    if (!flow) {
+      throw new Error('flow1 should exist');
+    }
+    flow.title = 'Draft title';
+    const serialized = serializeFlowRegistry(registry);
+    serialized.flow1.title = 'Changed serialized';
+    expect(registry.getFlow('flow1')?.title).toBe('Draft title');
+
+    const target = new DetachedFlowRegistry({ stale: { title: 'Stale', steps: {} } });
+    replaceFlowRegistry(target, serializeFlowRegistry(registry));
+
+    expect(target.hasFlow('stale')).toBe(false);
+    expect(target.getFlow('flow1')?.title).toBe('Draft title');
+
+    target.destroyFlow('flow1');
+    expect(target.hasFlow('flow1')).toBe(false);
+  });
+});

package/src/flow-registry/index.ts

@@ -10,3 +10,4 @@
 export * from './BaseFlowRegistry';
 export * from './InstanceFlowRegistry';
 export * from './GlobalFlowRegistry';
+export * from './DetachedFlowRegistry';

package/src/flowContext.ts

@@ -11,6 +11,7 @@ import { ISchema } from '@formily/json-schema';
 import { observable } from '@formily/reactive';
 import { APIClient, RequestOptions } from '@nocobase/sdk';
 import type { Router } from '@remix-run/router';
+import axios from 'axios';
 import { MessageInstance } from 'antd/es/message/interface';
 import * as antd from 'antd';
 import type { HookAPI } from 'antd/es/modal/useModal';
@@ -27,7 +28,7 @@ import { ContextPathProxy } from './ContextPathProxy';
 import { DataSource, DataSourceManager } from './data-source';
 import { FlowEngine } from './flowEngine';
 import { FlowI18n } from './flowI18n';
-import { JSRunner, JSRunnerOptions } from './JSRunner';
+import { JSRunner, JSRunnerOptions, shouldPreprocessRunJSTemplates } from './JSRunner';
 import type { FlowModel } from './models/flowModel';
 import type { ForkFlowModel } from './models/forkFlowModel';
 import { FlowResource, FlowSQLRepository } from './resources';
@@ -58,6 +59,31 @@ import dayjs from 'dayjs';
 import { externalReactRender, setupRunJSLibs } from './runjsLibs';
 import { runjsImportAsync, runjsImportModule, runjsRequireAsync } from './utils/runjsModuleLoader';
 
+function normalizePathname(pathname: string) {
+  return pathname.endsWith('/') ? pathname : `${pathname}/`;
+}
+
+function shouldBypassApiClient(url: string, app?: { getApiUrl?: (pathname?: string) => string }) {
+  try {
+    const requestUrl = new URL(url);
+    if (!['http:', 'https:'].includes(requestUrl.protocol)) {
+      return false;
+    }
+
+    if (!app?.getApiUrl) {
+      return true;
+    }
+
+    const apiUrl = new URL(app.getApiUrl());
+    const apiPath = normalizePathname(apiUrl.pathname);
+    const requestPath = normalizePathname(requestUrl.pathname);
+
+    return requestUrl.origin !== apiUrl.origin || !requestPath.startsWith(apiPath);
+  } catch {
+    return false;
+  }
+}
+
 // Helper: detect a RecordRef-like object
 function isRecordRefLike(val: any): boolean {
   return !!(val && typeof val === 'object' && 'collection' in val && 'filterByTk' in val);
@@ -2980,8 +3006,10 @@ export class FlowContext {
 }
 
 class BaseFlowEngineContext extends FlowContext {
+  declare t: (key: any, options?: any) => string;
   declare router: Router;
   declare dataSourceManager: DataSourceManager;
+  declare isDarkTheme: boolean;
   declare requireAsync: (url: string) => Promise<any>;
   declare importAsync: (url: string) => Promise<any>;
   declare createJSRunner: (options?: JSRunnerOptions) => Promise<JSRunner>;
@@ -3008,6 +3036,7 @@ class BaseFlowEngineContext extends FlowContext {
   declare runAction: (actionName: string, params?: Record<string, any>) => Promise<any> | any;
   declare engine: FlowEngine;
   declare api: APIClient;
+  declare locale: string;
   declare viewer: FlowViewer;
   declare view: FlowView;
   declare modal: HookAPI;
@@ -3024,6 +3053,10 @@ class BaseFlowEngineContext extends FlowContext {
       return this.engine.getModel(modelName, searchInPreviousEngines);
     });
     this.defineMethod('request', (options: RequestOptions) => {
+      const app = this.app as { getApiUrl?: (pathname?: string) => string } | undefined;
+      if (typeof options?.url === 'string' && shouldBypassApiClient(options.url, app)) {
+        return axios.request(options);
+      }
       return this.api.request(options);
     });
     this.defineMethod(
@@ -3035,8 +3068,10 @@ class BaseFlowEngineContext extends FlowContext {
           ...(runnerOptions || {}),
           globals: mergedGlobals,
         });
-        // Enable by default; use `preprocessTemplates: false` to explicitly disable.
-        const shouldPreprocessTemplates = preprocessTemplates !== false;
+        const shouldPreprocessTemplates = shouldPreprocessRunJSTemplates({
+          version: runnerOptions?.version,
+          preprocessTemplates,
+        });
         const jsCode = await prepareRunJsCode(String(code ?? ''), { preprocessTemplates: shouldPreprocessTemplates });
         return runner.run(jsCode);
       },
@@ -3112,6 +3147,15 @@ export class FlowEngineContext extends BaseFlowEngineContext {
     this.defineMethod('t', (keyOrTemplate: string, options?: any) => {
       return i18n.translate(keyOrTemplate, options);
     });
+    this.defineProperty('locale', {
+      get: () => this.api?.auth?.locale || this.i18n?.language,
+      cache: false,
+      meta: Object.assign(() => ({ type: 'string', title: this.t('Current language'), sort: 970 }), {
+        title: escapeT('Current language'),
+        sort: 970,
+        hasChildren: false,
+      }),
+    });
     this.defineMethod('renderJson', function (template: any) {
       return this.resolveJsonTemplate(template);
     });
@@ -3537,6 +3581,9 @@ export class FlowEngineContext extends BaseFlowEngineContext {
       },
     });
     this.defineMethod('aclCheck', function (params) {
+      if (this.skipAclCheck) {
+        return true;
+      }
       return this.acl.aclCheck(params);
     });
     this.defineMethod('createResource', function (this: BaseFlowEngineContext, resourceType) {