refactor Network

package.json

@@ -5,7 +5,7 @@
 	"module": "./dist/timi-web.mjs",
 	"style": "./dist/timi-web.css",
 	"private": false,
-	"version": "0.0.21",
+	"version": "0.0.22",
 	"license": "MIT",
 	"scripts": {
 		"dev": "vite",

src/store/index.ts

@@ -1,2 +1,2 @@
-export * from "./device";
-export * from "./user";
+export * from "./deviceStore";
+export * from "./userStore";

src/types/Model.ts

@@ -13,7 +13,7 @@ export type Model = {
 	deletedAt?: number;
 }
 
-export type Response<T> = {
+export type ApiResponse<T> = {
 	code: number;
 	msg?: string;
 	data: T;

src/utils/Network.ts

@@ -1,48 +1,69 @@
-import axios, { InternalAxiosRequestConfig } from "axios";
-import Cooker from "./Cooker";
-import type { Response } from "../types/Model";
-import Time from "./Time";
-import { userStore } from "../store/user";
+import axios, {type AxiosInstance, type AxiosResponse, type InternalAxiosRequestConfig} from "axios";
+import {ApiResponse} from "../types";
 
-type ErrorCallback = (response: Response<any>) => void;
+export type ErrorCallback = (response: ApiResponse<any>) => void;
+export type RequestInterceptor = (config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig;
+export interface ResponseObserverPayload {
+	config?: InternalAxiosRequestConfig;
+	status?: number;
+	response?: AxiosResponse;
+	error?: any;
+	serverResponse?: ApiResponse<any>;
+}
+export type ResponseObserver = (payload: ResponseObserverPayload) => void;
 
 let globalErrorCallback: ErrorCallback | null = null;
+let globalRequestInterceptor: RequestInterceptor | null = null;
+let globalResponseObserver: ResponseObserver | null = null;
 
 export const setGlobalErrorCallback = (callback: ErrorCallback) => {
 	globalErrorCallback = callback;
 };
 
-const userTokenInterceptors = async (config: InternalAxiosRequestConfig<any>) => {
-	let token = userStore.loginUser.token?.value;
-	const cookieToken = Cooker.get("Token");
-	if (token && token === cookieToken) {
-		config.headers.set({"Token": token});
-	} else {
-		if (cookieToken) {
-			token = cookieToken;
-			userStore.loginUser.token = {
-				value: token,
-				expireAt: Time.now() + Time.D
-			};
-		}
-		if (token) {
-			await userStore.login4Token({
-				value: token,
-				expireAt: Time.now() + Time.D
-			});
+export const setGlobalRequestInterceptor = (callback: RequestInterceptor | null) => {
+	globalRequestInterceptor = callback;
+};
+
+export const setGlobalResponseObserver = (callback: ResponseObserver | null) => {
+	globalResponseObserver = callback;
+};
+
+const notifyResponseObserver = (payload: ResponseObserverPayload) => {
+	if (!globalResponseObserver) {
+		return;
 	}
+	globalResponseObserver(payload);
+};
+
+const applyDefaultInterceptors = (instance: AxiosInstance) => {
+	instance.defaults.withCredentials = true;
+	instance.interceptors.request.use((config) => {
+		if (globalRequestInterceptor) {
+			return globalRequestInterceptor(config);
 		}
 		return config;
-};
-axios.defaults.withCredentials = true;
-axios.interceptors.response.use((axiosResp: any) => {
+	});
+	instance.interceptors.response.use((axiosResp: any) => {
 		if (!axiosResp.config.responseType) {
 			// 服务端返回
-		const serverResp = axiosResp.data as Response<any>;
+			const serverResp = axiosResp.data as ApiResponse<any>;
 			if (serverResp.code < 40000) {
+				notifyResponseObserver({
+					config: axiosResp?.config,
+					status: axiosResp?.status,
+					response: axiosResp,
+					serverResponse: serverResp
+				});
 				// 200 或 300 HTTP 状态段视为成功
 				return serverResp.data;
 			} else {
+				notifyResponseObserver({
+					config: axiosResp?.config,
+					status: axiosResp?.status,
+					response: axiosResp,
+					serverResponse: serverResp,
+					error: serverResp.msg
+				});
 				if (globalErrorCallback) {
 					globalErrorCallback(serverResp);
 				}
@@ -50,26 +71,49 @@ axios.interceptors.response.use((axiosResp: any) => {
 				return Promise.reject(serverResp.msg);
 			}
 		}
+		notifyResponseObserver({
+			config: axiosResp?.config,
+			status: axiosResp?.status,
+			response: axiosResp
+		});
 		return axiosResp.data;
-}, (error: any) => {
+	}, (error: any) => {
+		notifyResponseObserver({
+			config: error?.config,
+			status: error?.response?.status,
+			response: error?.response,
+			error
+		});
 		// 请求错误
 		if (error) {
 			if (error.response && error.response.status) {
 				throw error;
 			}
 			if (error.request) {
-			if (error.message.startsWith("timeout")) {
+				if (error.message && error.message.startsWith("timeout")) {
 					throw new Error("time out");
 				} else {
-				throw new Error(error.message);
+					throw new Error(error.message || "request error");
 				}
 			}
 		}
 		throw error;
-});
+	});
+};
+
+const axiosInstance = axios.create();
+applyDefaultInterceptors(axiosInstance);
+
+export const createServiceAxios = (baseURL?: string) => {
+	const instance = axios.create({ baseURL });
+	applyDefaultInterceptors(instance);
+	return instance;
+};
 
 export default {
-	axios,
-	userTokenInterceptors,
-	setGlobalErrorCallback
+	axios: axiosInstance,
+	setGlobalErrorCallback,
+	setGlobalRequestInterceptor,
+	setGlobalResponseObserver,
+	createServiceAxios
 };