@nocobase/flow-engine 2.0.31 → 2.0.32

package/lib/flowContext.js

@@ -57,6 +57,7 @@ __export(flowContext_exports, {
 });
 module.exports = __toCommonJS(flowContext_exports);
 var import_reactive = require("@formily/reactive");
+var import_axios = __toESM(require("axios"));
 var antd = __toESM(require("antd"));
 var import_lodash = __toESM(require("lodash"));
 var import_qs = __toESM(require("qs"));
@@ -81,6 +82,28 @@ var import_dayjs = __toESM(require("dayjs"));
 var import_runjsLibs = require("./runjsLibs");
 var import_runjsModuleLoader = require("./utils/runjsModuleLoader");
 var _proxy, _FlowContext_instances, createChildNodes_fn, findMetaByPath_fn, findMetaInDelegatesDeep_fn, findMetaInProperty_fn, resolvePathInMeta_fn, resolvePathInMetaAsync_fn, buildParentTitles_fn, toTreeNode_fn;
+function normalizePathname(pathname) {
+  return pathname.endsWith("/") ? pathname : `${pathname}/`;
+}
+__name(normalizePathname, "normalizePathname");
+function shouldBypassApiClient(url, app) {
+  try {
+    const requestUrl = new URL(url);
+    if (!["http:", "https:"].includes(requestUrl.protocol)) {
+      return false;
+    }
+    if (!(app == null ? void 0 : 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;
+  }
+}
+__name(shouldBypassApiClient, "shouldBypassApiClient");
 function isRecordRefLike(val) {
   return !!(val && typeof val === "object" && "collection" in val && "filterByTk" in val);
 }
@@ -2211,6 +2234,10 @@ const _BaseFlowEngineContext = class _BaseFlowEngineContext extends FlowContext
       return this.engine.getModel(modelName, searchInPreviousEngines);
     });
     this.defineMethod("request", (options) => {
+      const app = this.app;
+      if (typeof (options == null ? void 0 : options.url) === "string" && shouldBypassApiClient(options.url, app)) {
+        return import_axios.default.request(options);
+      }
       return this.api.request(options);
     });
     this.defineMethod(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/flow-engine",
-  "version": "2.0.31",
+  "version": "2.0.32",
   "private": false,
   "description": "A standalone flow engine for NocoBase, managing workflows, models, and actions.",
   "main": "lib/index.js",
@@ -8,9 +8,10 @@
   "dependencies": {
     "@formily/antd-v5": "1.x",
     "@formily/reactive": "2.x",
-    "@nocobase/sdk": "2.0.31",
-    "@nocobase/shared": "2.0.31",
+    "@nocobase/sdk": "2.0.32",
+    "@nocobase/shared": "2.0.32",
     "ahooks": "^3.7.2",
+    "axios": "^1.7.0",
     "dayjs": "^1.11.9",
     "dompurify": "^3.0.2",
     "lodash": "^4.x",
@@ -36,5 +37,5 @@
   ],
   "author": "NocoBase Team",
   "license": "Apache-2.0",
-  "gitHead": "085eec006c7be5fbc98dabfdab98ff358eab9d95"
+  "gitHead": "ad454bc0bc27dee7e931644200317d034c816e3e"
 }

package/src/__tests__/flowContext.test.ts

@@ -7,7 +7,8 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { describe, expect, it, vi } from 'vitest';
+import axios from 'axios';
+import { describe, expect, it, vi, afterEach } from 'vitest';
 import { FlowContext, FlowRuntimeContext, FlowRunJSContext, type PropertyMetaFactory } from '../flowContext';
 import { FlowEngine } from '../flowEngine';
 import { FlowModel } from '../models/flowModel';
@@ -1630,6 +1631,69 @@ describe('runAction delegation from runtime context', () => {
   });
 });
 
+describe('FlowContext request defaults', () => {
+  class RequestModel extends FlowModel {}
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  const createRequestContext = () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ RequestModel });
+
+    const apiRequest = vi.fn(async (options) => options);
+    const app = {
+      getApiUrl(pathname = '') {
+        return 'https://app.example.com/api/'.replace(/\/$/g, '') + '/' + pathname.replace(/^\//g, '');
+      },
+    };
+
+    engine.context.defineProperty('api', { value: { request: apiRequest } as any });
+    engine.context.defineProperty('app', { value: app });
+
+    const model = engine.createModel({ use: 'RequestModel' });
+    const ctx = new FlowRuntimeContext(model, 'flow');
+    const directAxiosRequest = vi.spyOn(axios, 'request').mockResolvedValue({ data: {} } as any);
+
+    return { ctx, apiRequest, directAxiosRequest };
+  };
+
+  it.each([
+    ['apiClient', 'users:list', 'api'],
+    ['apiClient', '/api/users:list', 'api'],
+    ['apiClient', 'https://app.example.com/api/users:list', 'api'],
+    ['direct axios', 'https://app.example.com/custom-api/users', 'axios'],
+  ])('should use %s for %s', async (_target, url, expected) => {
+    const { ctx, apiRequest, directAxiosRequest } = createRequestContext();
+
+    await ctx.request({ url, method: 'get' });
+
+    if (expected === 'api') {
+      expect(apiRequest).toHaveBeenCalledTimes(1);
+      expect(directAxiosRequest).not.toHaveBeenCalled();
+      return;
+    }
+
+    expect(directAxiosRequest).toHaveBeenCalledTimes(1);
+    expect(apiRequest).not.toHaveBeenCalled();
+  });
+
+  it('should use direct axios for cross-origin absolute urls', async () => {
+    const { ctx, apiRequest, directAxiosRequest } = createRequestContext();
+
+    await ctx.request({ url: 'https://api.example.com/users', method: 'get', skipAuth: false });
+
+    expect(directAxiosRequest).toHaveBeenCalledTimes(1);
+    expect(apiRequest).not.toHaveBeenCalled();
+    expect(directAxiosRequest.mock.calls[0][0]).toMatchObject({
+      url: 'https://api.example.com/users',
+      method: 'get',
+      skipAuth: false,
+    });
+  });
+});
+
 describe('FlowContext delayed meta loading', () => {
   // 测试场景：属性定义时 meta 为异步函数，首次访问时延迟加载
   // 输入：属性带有异步 meta 函数

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';
@@ -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);
@@ -3024,6 +3050,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(