refactor: use auto-generated API client (maa-copilot-client)

Author: guansss

package.json

@@ -40,10 +40,11 @@
     "eslint-plugin-react": "^7.33.2",
     "eslint-plugin-react-hooks": "^4.6.0",
     "fuse.js": "^6.6.2",
-    "jotai": "^1.7.3",
+    "jotai": "^2.7.0",
     "linkify-react": "^3.0.4",
     "linkifyjs": "^3.0.5",
     "lodash-es": "^4.17.21",
+    "maa-copilot-client": "https://github.com/MaaAssistantArknights/maa-copilot-client-ts.git#0.1.0-SNAPSHOT.726.3d19287",
     "normalize.css": "^8.0.1",
     "prettier": "^3.2.5",
     "react": "^18.0.0",
@@ -58,7 +59,7 @@
     "remark-breaks": "^3.0.2",
     "remark-gfm": "^3.0.1",
     "snakecase-keys": "^5.4.4",
-    "swr": "^2.0.0-rc.3",
+    "swr": "^2.2.5",
     "type-fest": "^4.10.2",
     "unfetch": "^4.2.0",
     "vite-tsconfig-paths": "^3.5.0"

src/App.tsx

@@ -1,16 +1,21 @@
+import { getDefaultStore } from 'jotai/vanilla'
 import { BrowserRouter } from 'react-router-dom'
 import { SWRConfig } from 'swr'
 
-import { Effects } from 'components/Effects'
+import { authAtom } from 'store/auth'
+import { TokenManager } from 'utils/token-manager'
 
 import { GlobalErrorBoundary } from './components/GlobalErrorBoundary'
 import { FCC } from './types'
 import { request } from './utils/fetcher'
 
+// jotai 在没有 Provider 时会使用默认的 store
+TokenManager.setAuthGetter(() => getDefaultStore().get(authAtom))
+TokenManager.setAuthSetter((v) => getDefaultStore().set(authAtom, v))
+
 export const App: FCC = ({ children }) => {
   return (
     <>
-      <Effects />
       <SWRConfig
         value={{
           fetcher: request,

src/apis/auth.ts

@@ -1,45 +1,75 @@
 import { Response } from 'models/network'
 import { jsonRequest } from 'utils/fetcher'
+import { UserApi } from 'utils/maa-copilot-client'
 
-export interface UserCredentials {
-  token: string
-  validBefore: string
-  refreshToken: string
-  refreshTokenValidBefore: string
-  userInfo: UserInfo
+export async function sendRegistrationEmail(req: { email: string }) {
+  await new UserApi({ sendToken: 'never' }).sendRegistrationToken({
+    sendRegistrationTokenDTO: req,
+  })
 }
 
-export interface UserInfo {
-  id: string
-  userName: string
-  role: string
-  activated: boolean
-  favoriteLists: Record<string, any>
-  uploadCount: number
+export async function register(req: {
+  email: string
+  registrationToken: string
+  username: string
+  password: string
+}) {
+  await new UserApi({ sendToken: 'never' }).register({
+    registerDTO: {
+      ...req,
+      userName: req.username,
+    },
+  })
 }
 
-export interface LoginResponse extends UserCredentials {}
+export async function login(req: { email: string; password: string }) {
+  const res = await new UserApi({
+    sendToken: 'never',
+    requireData: true,
+  }).login({
+    loginDTO: req,
+  })
+  return res.data
+}
 
-export const requestLogin = (email: string, password: string) => {
-  return jsonRequest<Response<LoginResponse>>('/user/login', {
-    method: 'POST',
-    json: {
-      email,
-      password,
+export async function refreshAccessToken(req: { refreshToken: string }) {
+  const res = await new UserApi({
+    sendToken: 'never',
+    requireData: true,
+  }).refresh({
+    refreshReq: req,
+  })
+  return res.data
+}
+
+export async function updateUserInfo(req: { username: string }) {
+  await new UserApi().updateInfo({
+    userInfoUpdateDTO: {
+      userName: req.username,
     },
   })
 }
 
-export interface RefreshResponse extends UserCredentials {}
+export async function updatePassword(req: {
+  originalPassword: string
+  newPassword: string
+}) {
+  await new UserApi().updatePassword({ passwordUpdateDTO: req })
+}
 
-export const requestRefresh = (token: string, refreshToken: string) => {
-  return jsonRequest<Response<RefreshResponse>>('/user/refresh', {
-    method: 'POST',
-    json: {
-      access_token: token,
-      refresh_token: refreshToken,
-    },
-    noToken: true,
+export async function sendResetPasswordEmail(req: { email: string }) {
+  await new UserApi({ sendToken: 'never' }).passwordResetRequest({
+    passwordResetVCodeDTO: req,
+  })
+}
+
+export function resetPassword(req: {
+  email: string
+  activeCode: string
+  password: string
+}) {
+  return new UserApi({ sendToken: 'never' }).passwordReset({
+    passwordResetDTO: req,
   })
 }
 
@@ -65,104 +95,3 @@ export const requestActivationCode = () => {
     },
   )
 }
-
-export interface RegisterResponse {}
-
-export const requestRegister = (
-  email: string,
-  registrationToken: string,
-  username: string,
-  password: string,
-) => {
-  return jsonRequest<Response<RegisterResponse>>('/user/register', {
-    method: 'POST',
-    json: {
-      email,
-      registration_token: registrationToken,
-      user_name: username,
-      password,
-    },
-  })
-}
-
-export interface EmailToenResponse {}
-
-export const reqeustRegistrationToken = (email: string) => {
-  return jsonRequest<Response<EmailToenResponse>>(
-    '/user/sendRegistrationToken',
-    {
-      method: 'POST',
-      json: {
-        email,
-      },
-    },
-  )
-}
-
-export interface UpdateInfoResponse {}
-
-export const requestUpdateInfo = ({
-  email,
-  username,
-}: {
-  email?: string
-  username?: string
-}) => {
-  return jsonRequest<Response<UpdateInfoResponse>>('/user/update/info', {
-    method: 'POST',
-    json: {
-      email,
-      user_name: username,
-    },
-  })
-}
-
-export interface UpdatePasswordResponse {}
-
-export const requestUpdatePassword = ({
-  original,
-  newPassword,
-}: {
-  original?: string
-  newPassword?: string
-}) => {
-  return jsonRequest<Response<UpdatePasswordResponse>>(
-    '/user/update/password',
-    {
-      method: 'POST',
-      json: {
-        original_password: original,
-        new_password: newPassword,
-      },
-    },
-  )
-}
-
-export interface ResetPasswordTokenResponse {}
-
-export const requestResetPasswordToken = (data: { email: string }) => {
-  return jsonRequest<Response<ResetPasswordTokenResponse>>(
-    '/user/password/reset_request',
-    {
-      method: 'POST',
-      json: data,
-    },
-  )
-}
-
-export interface ResetPasswordResponse {}
-
-export const requestResetPassword = (data: {
-  email: string
-  token: string
-  password: string
-}) => {
-  return jsonRequest<Response<ResetPasswordResponse>>('/user/password/reset', {
-    method: 'POST',
-    json: {
-      email: data.email,
-      active_code: data.token,
-      password: data.password,
-    },
-  })
-}