@skyroc/axios

用户调用 request(config)
    │
    ▼
┌─────────────────────────┐
│   请求拦截器             │
│  • 生成 X-Request-Id    │
│  • 挂载 AbortController │
│  • 调用 onRequest 钩子   │
└────────────┬────────────┘
             ▼
      Axios 发送请求
             │
             ▼
┌──────────────────────────────────┐
│   响应拦截器（成功 / 失败两侧）    │
│  • transformResponse（解二进制信封）│
│  • 非 JSON 或业务成功  ──► response │
│  • 业务失败 / HTTP 错误            │
│    → onBackendFail（返回响应即补救）│
│    → onError → reject             │
└────────────┬─────────────────────┘
             ▼
┌─────────────────────────┐
│ createRequest:           │
│   JSON → transform(res) │
│   其他 → response.data   │
├─────────────────────────┤
│ createFlatRequest:       │
│   成功 → { data, error: null }  │
│   失败 → { data: null, error }  │
└─────────────────────────┘

// 1. 定义请求函数 —— 只关心「发请求 + 拿数据」
export function fetchUserList(params: Api.UserListParams) {
  return request<Api.UserList>({
    url: '/api/users',
    params
  });
}

// 2. 封装 Query Hook —— TanStack Query 接管状态
export function useUserListQuery(params: Api.UserListParams) {
  return useQuery({
    queryKey: ['users', params],
    queryFn: () => fetchUserList(params)
  });
}

// 3. 封装 Mutation Hook —— 写操作同理
export function useCreateUserMutation() {
  return useMutation({
    mutationFn: (data: Api.CreateUserParams) => request<Api.User>({ url: '/api/users', method: 'post', data })
  });
}

// 4. 在组件中使用
const UserList = () => {
  const { data, isLoading, error } = useUserListQuery({ page: 1 });
  const { mutate: createUser, isPending } = useCreateUserMutation();
  // ...
};

function createRequest<ResponseData, ApiData, State>(
  axiosConfig?: CreateAxiosDefaults,
  options?: Partial<RequestOption<ResponseData, ApiData, State>>
): RequestInstance<ApiData, State>;

interface BackendResponse<T = any> {
  code: number;
  data: T;
  msg: string;
}

const request = createRequest<BackendResponse>(
  { baseURL: 'https://api.example.com' },
  {
    isBackendSuccess: response => response.data.code === 200,
    transform: response => response.data.data,
    onRequest: async config => {
      config.headers.set('Authorization', `Bearer ${getToken()}`);
      return config;
    },
    onError: error => console.error(error.message)
  }
);

const userInfo = await request<Api.UserInfo>({ url: '/api/user' });

function createFlatRequest<ResponseData, ApiData, State>(
  axiosConfig?: CreateAxiosDefaults,
  options?: Partial<RequestOption<ResponseData, ApiData, State>>
): FlatRequestInstance<ResponseData, ApiData, State>;

// 成功
{ data: ApiData; error: null; response: AxiosResponse }
// 失败
{ data: null; error: AxiosError; response?: AxiosResponse }

const flatRequest = createFlatRequest<BackendResponse, BackendResponse['data']>(
  { baseURL: 'https://api.example.com' },
  {
    isBackendSuccess: response => response.data.code === 200,
    transform: response => response.data.data
  }
);

const { data, error } = await flatRequest({ url: '/api/users' });
if (error) {
  console.error(error.message);
  return;
}
console.log(data);

const request = createRequest<BackendResponse>(
  { baseURL: '/api' },
  {
    requestIdKey: false, // 关掉请求 ID，省一次预检
    retry: { retries: 2, retryDelay: attempt => attempt * 500 }
  }
);

import { BACKEND_ERROR_CODE } from '@skyroc/axios';

if (error.code === BACKEND_ERROR_CODE) {
  // 业务错误：HTTP 成功但 code 不正确
} else {
  // HTTP 错误或网络错误
}

declare module 'axios' {
  interface AxiosRequestConfig {
    // 必须是字符串键：axios 的 mergeConfig 用 Object.keys 遍历配置，
    // Symbol 键在 instance.request() 重新 merge 时会被丢掉，标记等于没打
    isTokenRefreshRetry?: boolean;
  }
}

createRequest<BackendResponse>(axiosConfig, {
  async onBackendFail(response, instance) {
    // 已经因为续签重发过一次的不再刷：钩子本身不设递归上限
    if (String(response.data.code) === '401' && !response.config.isTokenRefreshRetry) {
      const success = await refreshToken();
      if (success) {
        response.config.headers.set('Authorization', `Bearer ${getNewToken()}`);
        response.config.isTokenRefreshRetry = true;
        return instance.request(response.config);
      }
    }
    return null;
  }
});

// cancelAllRequest 取消所有由包管理的请求
request.cancelAllRequest();

// 自定义 signal 的请求不受 cancelAllRequest 影响
const controller = new AbortController();
request({ url: '/api/data', signal: controller.signal });
request.cancelAllRequest(); // 不会取消上面的请求
controller.abort(); // 手动取消

const data = await request<Api.User>({ url: '/user' }); // → Api.User
const blob = await request({ url: '/file', responseType: 'blob' }); // → Blob
const text = await request({ url: '/text', responseType: 'text' }); // → string

const request = createFlatRequest<BackendResponse, any, { token: string }>(axiosConfig, {
  defaultState: { token: '' }
});

request.state.token = 'new-token';