@infly/libs 2.0.26 → 2.0.37

package/module/REST.js

@@ -1,27 +1,106 @@
 import axios from "axios";
 import Uts from "./Uts.js";
 import TokenService from "./TokenService.js";
+import { resolveInternalServiceURL } from "./cjs/request-url-rules.cjs";
 
 const baseURL = process.env.VUE_APP_BASE_API;
 const { env } = Uts.getEnv() || {};
 const isTestEnv = Uts.contain(["localhost", "infly-test"], env);
-const isProdAPI = Uts.contain(["https://api.sutpay.com"], baseURL);
+
+// 若接口地址是 localhost/127.0.0.1，则自动替换为当前页面访问主机。
+// 协议、端口、路径保持不变，便于局域网联调时免改环境变量。
+function remapLocalhostToCurrentHost(url) {
+  const normalized = Uts.normalizeEnvUrl(url);
+  if (!normalized) {
+    return normalized;
+  }
+
+  if (typeof window === "undefined" || !window.location || !window.location.hostname) {
+    return normalized;
+  }
+
+  try {
+    const parsed = new URL(normalized);
+    const isLocalHost = ["localhost", "127.0.0.1"].includes(parsed.hostname);
+    if (!isLocalHost) {
+      return normalized;
+    }
+
+    parsed.hostname = window.location.hostname;
+    return parsed.toString();
+  } catch (e) {
+    return normalized;
+  }
+}
+
+// 解析 axios 最终使用的 baseURL。
+// 优先级：config.baseURL > process.env.VUE_APP_BASE_API，再执行 localhost 主机替换。
+function resolveServiceBaseURL(customBaseURL) {
+  const targetBaseURL = Uts.normalizeEnvUrl(customBaseURL || baseURL);
+  return remapLocalhostToCurrentHost(targetBaseURL);
+}
+
+/**
+ * 对任意通知函数加去重包装
+ * @param {Function} fn - 原始通知函数，接受字符串或 { message, type, ... }
+ * @param {Number} ttl - 去重时间窗（ms），默认 500
+ * @returns {Function} 去重后的通知函数
+ */
+export function createNotifyDedup(fn, ttl = 500) {
+  const recentMsgs = new Set();
+  return function dedupedNotify(msgOrOptions) {
+    const message = typeof msgOrOptions === "string" ? msgOrOptions : msgOrOptions?.message;
+    if (message && recentMsgs.has(message)) return;
+    if (message) {
+      recentMsgs.add(message);
+      setTimeout(() => recentMsgs.delete(message), ttl);
+    }
+    return fn(msgOrOptions);
+  };
+}
 
 /**
  * 创建封装的 axios 实例
  * @param {Object} config 配置项
- * @param {Function|String} config.getToken 获取 token 的函数或值
+ * @param {String} config.getTokenFunc 获取 token 的 TokenService 方法名，默认 "getToken"
  * @param {Function} config.onLogout 登出回调
- * @param {Function} config.onNotify 通知回调
+ * @param {Object} config.notify  Message-like 对象（如 ElementUI Message），传入后自动应用去重并构建 onNotify
+ * @param {Function} config.onNotify 自定义通知回调；若传入 Message-like 对象也可自动识别
  * @returns {AxiosInstance}
  */
 export function createService(config) {
   const {
+    baseURL: customBaseURL,
+    defaultField = "admin",
+    serviceField = defaultField,
     logoutAction = "user/logout", // 退出登录的action方法
     onLogout,
-    onNotify
+    notify,
+    onNotify: rawOnNotify,
+    getTokenFunc = "getToken",
+    internalServiceURLRules = []
   } = config || {};
-  const service = axios.create({ baseURL });
+  // 统一在 REST 内部处理 baseURL，避免业务项目重复实现主机替换逻辑。
+  const resolvedBaseURL = resolveServiceBaseURL(customBaseURL);
+  const isProdAPI = Uts.contain(["https://api.sutpay.com"], resolvedBaseURL);
+  const service = axios.create({ baseURL: resolvedBaseURL });
+
+  // 统一处理 notify 与 onNotify：
+  // - 优先使用显式传入的 notify
+  // - 若 onNotify 是 Message-like 对象（带 .error/.success 等类型方法），也当作 notify 处理
+  // 两种写法都自动应用去重，拦截器与调用方 .catch() 共用同一个去重包装
+  const notifyTarget = notify || (rawOnNotify && typeof rawOnNotify["error"] === "function" ? rawOnNotify : null);
+  let onNotify = notifyTarget ? null : rawOnNotify;
+
+  if (notifyTarget) {
+    ["success", "warning", "info", "error"].forEach((type) => {
+      if (typeof notifyTarget[type] === "function") {
+        notifyTarget[type] = createNotifyDedup(notifyTarget[type].bind(notifyTarget));
+      }
+    });
+    onNotify = ({ message, type = "error", duration }) =>
+      notifyTarget[type]?.(message) ?? notifyTarget({ message, type, duration });
+  }
 
   /**
    * 发送通知
@@ -37,13 +116,13 @@ export function createService(config) {
   // 涉及到store和request循环依赖，导致store为undefined，所以不要引入store来处理而是通过闭包形式
   const handleLogout = () => {
     if (Uts.isFunction(onLogout)) {
-      onLogout(logoutAction);
+      onLogout(logoutAction, { redirectLogin: true });
     }
   };
 
   service.interceptors.request.use(
-    config => {
-      const Token = TokenService.getToken();
+    (config) => {
+      const Token = TokenService[getTokenFunc]();
 
       if (Token) {
         config.headers["Authorization"] = " JWT " + Token;
@@ -57,33 +136,64 @@ export function createService(config) {
         });
       }
 
+      const internalServiceURL = resolveInternalServiceURL(config.url, internalServiceURLRules);
+      if (internalServiceURL) {
+        config.url = internalServiceURL.url;
+        config.baseURL = resolveServiceBaseURL(internalServiceURL.baseURL);
+      }
+
+      if (serviceField !== defaultField) {
+        config.url = config.url.replace(`/${defaultField}/`, `/${serviceField}/`);
+      }
+
+      Uts.filterCommaFields(config?.data);
+
+      Uts.filterCommaFields(config?.params);
+
       return config;
     },
-    error => {
+    (error) => {
       return Promise.reject(error);
     }
   );
 
   service.interceptors.response.use(
-    response => {
-      return response.data || {};
+    (response) => {
+      const { data } = response || {};
+      return Uts.transArrayBufferToObj(data);
     },
-    error => {
-      const { response } = error || {};
-      const { status } = response || {};
+    (error) => {
+      const { response, request } = error || {};
+      const { status, data } = response || {};
+      const { error: bufferError } = Uts.transArrayBufferToObj(data) ?? {};
+      const { error: dataError, detail, message } = data || {};
+      const errorMsg = bufferError || dataError || detail || message || `请求失败(${status})`;
 
-      if ([401, 403].includes(status)) {
-        handleNotify({
-          message: `登录信息已过期(${status}), 请重新登录！`,
-          type: "error"
-        });
-        handleLogout();
-      } else if ([500, 502].includes(status)) {
-        handleNotify({
-          message: `服务器异常(${status})，请联系开发人员`,
-          type: "error"
-        });
-      }
+      // 添加标识，表示错误已被拦截器处理
+      error.handledByInterceptor = true;
+
+      // HTTP 状态码 → 固定提示语映射（400 直接用后端返回的 errorMsg）
+      const STATUS_MESSAGES = {
+        400: errorMsg,
+        401: "登录信息已过期，请重新登录",
+        403: "您没有权限访问，请联系管理员",
+        500: errorMsg || "服务器内部错误，请联系开发人员",
+        502: "网关错误，请稍后重试或联系开发人员",
+        503: "服务暂时不可用，请稍后重试",
+        504: "网关超时，请稍后重试或联系开发人员"
+      };
+
+      // 按优先级确定最终提示语，合并为一次 handleNotify 调用
+      const notifyMsg =
+        STATUS_MESSAGES[status] ??
+        (response ? errorMsg : null) ??
+        (request ? "网络请求失败，请检查网络连接" : null) ??
+        (error.message || "请求配置错误");
+
+      handleNotify({ message: notifyMsg, type: "error" });
+
+      // 401 副作用：自动登出（不受弹窗逻辑影响）
+      if (status === 401) handleLogout();
 
       return Promise.reject(error);
     }

package/module/Router.js

@@ -0,0 +1,15 @@
+export const resetRouter = (RouterInstance, router, constantRoutes) => {
+  const newRouter = createRouter(RouterInstance, constantRoutes);
+  router.matcher = newRouter.matcher; // reset router
+};
+
+export const updateRouter = resetRouter
+
+export const createRouter = (RouterInstance, constantRoutes) =>
+  new RouterInstance({
+    // mode: 'history', // require service support
+    scrollBehavior: () => ({
+      y: 0
+    }),
+    routes: constantRoutes || []
+  });