@liujitcn/kratos-uni-app-core 0.0.1

package/src/utils/auth.ts

@@ -0,0 +1,67 @@
+// 访问 token 缓存的 key
+const ACCESS_TOKEN_KEY = 'access_token'
+// 访问 token 缓存的 key的有效期
+const ACCESS_TOKEN_EXPIRES_IN = 'expiresIn'
+// 刷新 token 缓存的 key
+const REFRESH_TOKEN_KEY = 'refresh_token'
+
+const TOKEN_REFRESH_THRESHOLD = 5 * 60 * 1000
+
+function getToken(): string {
+  return uni.getStorageSync(ACCESS_TOKEN_KEY) || ''
+}
+
+function setToken(token: string) {
+  uni.setStorageSync(ACCESS_TOKEN_KEY, token)
+}
+
+function getTokenExpiresIn(): number {
+  const s = uni.getStorageSync(ACCESS_TOKEN_EXPIRES_IN) || ''
+  return Number(s)
+}
+
+function setTokenExpiresIn(expires_in: number) {
+  // 获取当前时间（毫秒）
+  const d = new Date().getTime() + expires_in * 1000
+  uni.setStorageSync(ACCESS_TOKEN_EXPIRES_IN, String(d))
+}
+
+function getRefreshToken(): string {
+  return uni.getStorageSync(REFRESH_TOKEN_KEY) || ''
+}
+
+function setRefreshToken(token: string) {
+  uni.setStorageSync(REFRESH_TOKEN_KEY, token)
+}
+
+function clearToken() {
+  uni.removeStorageSync(ACCESS_TOKEN_KEY)
+  uni.removeStorageSync(REFRESH_TOKEN_KEY)
+  uni.removeStorageSync(ACCESS_TOKEN_EXPIRES_IN)
+}
+
+/** 判断本地访问令牌是否仍在有效期内。 */
+function hasValidToken(): boolean {
+  const token = getToken()
+  const expiresIn = getTokenExpiresIn()
+  return Boolean(token && expiresIn && expiresIn > new Date().getTime())
+}
+
+/** 判断访问令牌是否即将过期，供请求层提前刷新。 */
+function shouldRefreshToken(): boolean {
+  const expiresIn = getTokenExpiresIn()
+  const remain = expiresIn - new Date().getTime()
+  return Boolean(getToken() && expiresIn && remain <= TOKEN_REFRESH_THRESHOLD)
+}
+
+export {
+  getToken,
+  setToken,
+  clearToken,
+  getRefreshToken,
+  setRefreshToken,
+  setTokenExpiresIn,
+  getTokenExpiresIn,
+  hasValidToken,
+  shouldRefreshToken,
+}

package/src/utils/file.ts

@@ -0,0 +1,95 @@
+import type { FileInfo, MultiUploadFileResponse } from '../rpc/base/v1/file'
+import { formatSrc } from './index'
+
+// 文件上传-兼容小程序端、H5端、App端
+export const uploadFile = async (fileType: string, filePath: string): Promise<FileInfo> => {
+  const res = await uni.uploadFile({
+    url: '/v1/base/file',
+    name: 'file',
+    filePath: filePath,
+    formData: {
+      fileType: fileType,
+    },
+  })
+  if (res.statusCode === 200) {
+    return JSON.parse(res.data) as FileInfo
+  } else {
+    throw new Error('上传失败')
+  }
+}
+
+// 文件上传-兼容小程序端、H5端、App端
+export const uploadFileList = async (
+  fileType: string,
+  filePaths: string[],
+): Promise<FileInfo[]> => {
+  const fileInfoArr: FileInfo[] = []
+  // 使用 Promise.all 等待所有上传完成
+  await Promise.all(
+    filePaths.map(async (filePath) => {
+      try {
+        const res = await uni.uploadFile({
+          url: '/v1/base/file',
+          name: 'file',
+          filePath: filePath,
+          formData: {
+            fileType: fileType,
+          },
+        })
+        if (res.statusCode === 200) {
+          const data = JSON.parse(res.data) as FileInfo
+          fileInfoArr.push(data)
+        } else {
+          console.error('上传失败，状态码:', res.statusCode)
+        }
+      } catch (error) {
+        console.error('上传异常:', error)
+      }
+    }),
+  )
+  return fileInfoArr
+}
+
+// 多文件上传-兼容小程序端、H5端、App端
+export const multiUploadFile = async (fileType: string, files: any): Promise<FileInfo[]> => {
+  const res = await uni.uploadFile({
+    url: '/v1/base/file/multi',
+    name: 'file',
+    filePath: '',
+    files: files,
+    formData: {
+      fileType: fileType,
+    },
+  })
+  if (res.statusCode === 200) {
+    const data = JSON.parse(res.data) as MultiUploadFileResponse
+    return data.files
+  } else {
+    await uni.showToast({ icon: 'error', title: '上传失败' })
+    return []
+  }
+}
+
+export const getFileInfo = (url: string): FileInfo => {
+  // 处理路径分隔符（兼容Windows和Unix系统）
+  const parts = url.split(/[\\/]/)
+  // 获取文件名部分（包含扩展名）
+  const fullName = parts.pop() || ''
+
+  if (!fullName) return { name: '', extname: '', url: url } // 空文件名处理
+
+  // 查找最后一个点号的位置
+  const dotIndex = fullName.lastIndexOf('.')
+
+  // 排除隐藏文件（如.gitignore）和无扩展名情况
+  if (dotIndex > 0) {
+    return {
+      name: fullName,
+      extname: fullName.slice(dotIndex),
+      url: formatSrc(url),
+    }
+  }
+
+  // 无合法扩展名时返回完整文件名
+  return { name: fullName, extname: '', url: url }
+}

package/src/utils/http.ts

@@ -0,0 +1,430 @@
+/**
+ * 添加拦截器:
+ *   拦截 request 请求
+ *   拦截 uploadFile 文件上传
+ *
+ */
+
+import {
+  clearToken,
+  getRefreshToken,
+  getToken,
+  hasValidToken,
+  setRefreshToken,
+  setToken,
+  setTokenExpiresIn,
+  shouldRefreshToken,
+} from './auth'
+import { saveCurrentRoute } from './navigation'
+
+const apiBasePath = import.meta.env.VITE_APP_BASE_API || '/api'
+const apiTargetUrl = import.meta.env.VITE_APP_API_URL || ''
+const normalizedApiBasePath = apiBasePath.startsWith('/') ? apiBasePath : `/${apiBasePath}`
+
+/**
+ * H5 开发环境优先走同源代理，避免浏览器直接请求后端产生跨域。
+ * 其它平台继续使用显式配置的后端地址。
+ */
+const requestOrigin =
+  typeof window !== 'undefined' && window.location?.protocol?.startsWith('http')
+    ? ''
+    : apiTargetUrl.replace(/\/$/, '')
+const baseURL = `${requestOrigin}${normalizedApiBasePath}`
+export const requestBaseURL = baseURL
+const SESSION_URL = '/v1/base/session'
+const REFRESH_TOKEN_URL = '/v1/base/token'
+const CAPTCHA_URL = '/v1/base/captcha'
+const CONFIG_URL = '/v1/base/config'
+const PASSWORD_PUBLIC_KEY_URL = '/v1/base/password-public-key'
+const LEGACY_AUTH_URL = '/auth'
+const LEGACY_REFRESH_TOKEN_URL = `${LEGACY_AUTH_URL}/token`
+const LEGACY_CAPTCHA_URL = '/login/captcha'
+// 认证公共接口不携带旧 token，同时保留旧路径兼容迁移期间的灰度访问。
+const NO_AUTH_URL_SET = new Set([
+  SESSION_URL,
+  REFRESH_TOKEN_URL,
+  CAPTCHA_URL,
+  CONFIG_URL,
+  PASSWORD_PUBLIC_KEY_URL,
+  LEGACY_AUTH_URL,
+  LEGACY_CAPTCHA_URL,
+  LEGACY_REFRESH_TOKEN_URL,
+])
+const AUTH_EXPIRED_EXCLUDED_URL_SET = new Set([
+  SESSION_URL,
+  CAPTCHA_URL,
+  CONFIG_URL,
+  PASSWORD_PUBLIC_KEY_URL,
+  LEGACY_AUTH_URL,
+  LEGACY_CAPTCHA_URL,
+])
+
+const AUTH_SILENT_LOGOUT_EVENT = 'auth:silent-logout'
+
+export type AuthMode = 'none' | 'optional' | 'required'
+
+type HttpRequestOptions = UniApp.RequestOptions & {
+  /** none: 游客接口；optional: 可选登录；required: 必须登录。 */
+  authMode?: AuthMode
+}
+
+// 添加拦截器
+const httpInterceptor = {
+  // 拦截前触发
+  invoke(options: UniApp.RequestOptions) {
+    const authMode = (options as HttpRequestOptions).authMode
+    // 1. 相对接口地址只拼接一次基础路径，兼容 HMR 等场景下拦截器重复注册。
+    if (
+      !options.url.startsWith('http') &&
+      options.url !== baseURL &&
+      !options.url.startsWith(`${baseURL}/`)
+    ) {
+      options.url = baseURL + options.url
+    }
+    // 2. 请求超时，普通请求默认 10s；流式等长连接可自行传入更长超时。
+    options.timeout = options.timeout || 10000
+    // 3. 添加小程序端请求头标识
+    options.header = {
+      ...options.header,
+      'source-client': 'miniapp',
+    }
+    // 4. 添加 token 请求头标识
+    const accessToken = getToken()
+    if (authMode !== 'none' && options.header.Authorization !== 'no-auth' && accessToken) {
+      options.header.Authorization = accessToken
+    } else {
+      delete options.header.Authorization
+    }
+  },
+}
+uni.addInterceptor('request', httpInterceptor)
+uni.addInterceptor('uploadFile', httpInterceptor)
+
+/**
+ * 请求函数
+ * @param  UniApp.RequestOptions
+ * @returns Promise
+ *  1. 返回 Promise 对象
+ *  2. 获取数据成功
+ *    2.1 提取核心数据 res.data
+ *    2.2 添加类型，支持泛型
+ *  3. 获取数据失败
+ *    3.1 401/403错误 -> 清理用户信息，跳转到登录页
+ *    3.2 其他错误 -> 根据后端错误信息轻提示
+ *    3.3 网络错误 -> 提示用户换网络
+ */
+type Data = {
+  code?: string | number
+  message?: string
+  reason?: string | number
+}
+
+// 新错误模型下，认证与鉴权只保留两类顶层原因。
+const authErrorCodeSet = new Set(['401', '403'])
+const authErrorReasonSet = new Set(['UNAUTHENTICATED', 'PERMISSION_DENIED'])
+
+function isAuthErrorResponse(data: unknown) {
+  if (!data || typeof data !== 'object') {
+    return false
+  }
+
+  const response = data as Data
+  const code = response.code !== undefined ? String(response.code) : ''
+  const reason = response.reason !== undefined ? String(response.reason) : ''
+
+  return (
+    authErrorCodeSet.has(code) || authErrorCodeSet.has(reason) || authErrorReasonSet.has(reason)
+  )
+}
+
+// 当前请求属于公共认证接口时，不应自动附带旧登录态。
+function isNoAuthRequest(url: string) {
+  return NO_AUTH_URL_SET.has(url)
+}
+
+// 登录与验证码接口失败时，只提示本次请求失败，不触发重新登录流程。
+function shouldSkipAuthExpiredPrompt(url: string) {
+  return AUTH_EXPIRED_EXCLUDED_URL_SET.has(url)
+}
+
+function resolveAuthMode(options: HttpRequestOptions, url: string): AuthMode {
+  if (options.authMode) {
+    return options.authMode
+  }
+  if (options.header?.Authorization === 'no-auth' || isNoAuthRequest(url)) {
+    return 'none'
+  }
+  return 'required'
+}
+
+// 2.2 添加类型，支持泛型
+export const http = <T>(options: HttpRequestOptions) => {
+  // 1. 返回 Promise 对象
+  return new Promise<T>((resolve, reject) => {
+    const sendRequest = async (retriedAsAnonymous = false) => {
+      try {
+        const requestOptions = { ...options, header: { ...options.header } }
+        const requestUrl = String(requestOptions.url)
+        const authMode = resolveAuthMode(requestOptions, requestUrl)
+        let accessToken = ''
+        try {
+          accessToken = await getAccessTokenByMode(
+            retriedAsAnonymous && authMode === 'optional' ? 'none' : authMode,
+          )
+        } catch (error) {
+          if (authMode === 'optional' && !retriedAsAnonymous) {
+            silentClearAuthData()
+            void sendRequest(true)
+            return
+          }
+          throw error
+        }
+        if (accessToken) {
+          requestOptions.header = {
+            ...requestOptions.header,
+            Authorization: accessToken,
+          }
+        } else {
+          delete requestOptions.header.Authorization
+        }
+        uni.request({
+          ...requestOptions,
+          // 响应成功
+          success(res) {
+            const responseData = res.data as Data
+            // 状态码 2xx， axios 就是这样设计的
+            if (res.statusCode >= 200 && res.statusCode < 300) {
+              if (isAuthErrorResponse(responseData)) {
+                if (authMode === 'optional' && !retriedAsAnonymous) {
+                  silentClearAuthData()
+                  void sendRequest(true)
+                  return
+                }
+                handleAuthExpiredByMode(authMode, requestUrl, responseData)
+                reject(res)
+                return
+              }
+              // 2.1 提取核心数据 res.data
+              resolve(res.data as T)
+            } else if (res.statusCode === 401 || res.statusCode === 403) {
+              // 401/403 错误 -> 清理用户信息，跳转到登录页
+              if (authMode === 'optional' && !retriedAsAnonymous) {
+                silentClearAuthData()
+                void sendRequest(true)
+                return
+              }
+              handleAuthExpiredByMode(authMode, requestUrl, responseData)
+              reject(res)
+            } else {
+              // 其他错误 -> 根据后端错误信息轻提示
+              void uni.showToast({
+                icon: 'none',
+                title: responseData.message || '请求错误',
+              })
+              reject(res)
+            }
+          },
+          // 响应失败
+          fail(err) {
+            void uni.showToast({
+              icon: 'none',
+              title: '网络错误，换个网络试试',
+            })
+            reject(err)
+          },
+        })
+      } catch (error) {
+        reject(error)
+      }
+    }
+
+    void sendRequest()
+  })
+}
+
+// 刷新 Token 的锁
+let isRefreshing = false
+let refreshTokenPromise: Promise<void> | null = null
+let isPromptingRelogin = false
+
+/** 获取请求可用访问令牌，供 direct stream 等非 uni.request 场景复用。 */
+export async function getRequestAccessToken(authMode: AuthMode = 'required') {
+  return getAccessTokenByMode(authMode)
+}
+
+/** 触发登录失效处理，供 direct stream 等非 uni.request 场景复用。 */
+export function handleAuthExpired(authMode: AuthMode = 'required') {
+  if (authMode === 'required') {
+    void promptRelogin()
+    return
+  }
+  silentClearAuthData()
+}
+
+// 刷新 Token 处理
+function handleTokenRefresh(authMode: AuthMode) {
+  if (refreshTokenPromise) {
+    return refreshTokenPromise
+  }
+  isRefreshing = true
+  refreshTokenPromise = refreshAccessToken()
+    .catch(async (error) => {
+      if (authMode === 'required') {
+        await promptRelogin()
+      } else {
+        silentClearAuthData()
+      }
+      throw error
+    })
+    .finally(() => {
+      isRefreshing = false
+      refreshTokenPromise = null
+    })
+  return refreshTokenPromise
+}
+
+async function getAccessTokenByMode(authMode: AuthMode) {
+  if (authMode === 'none') {
+    return ''
+  }
+
+  if (!getToken()) {
+    if (authMode === 'required') {
+      await promptRelogin()
+      throw new Error('auth required')
+    }
+    return ''
+  }
+
+  if (shouldRefreshToken()) {
+    await handleTokenRefresh(authMode)
+  }
+
+  if (hasValidToken()) {
+    return getToken()
+  }
+
+  if (authMode === 'required') {
+    await promptRelogin()
+    throw new Error('auth expired')
+  }
+
+  silentClearAuthData()
+  return ''
+}
+
+async function refreshAccessToken() {
+  const refreshToken = getRefreshToken()
+  if (!refreshToken) {
+    throw new Error('refresh token missing')
+  }
+
+  const response = await new Promise<UniApp.RequestSuccessCallbackResult>((resolve, reject) => {
+    uni.request({
+      url: REFRESH_TOKEN_URL,
+      method: 'POST',
+      data: { refresh_token: refreshToken },
+      header: {
+        'source-client': 'miniapp',
+      },
+      success: resolve,
+      fail: reject,
+    })
+  })
+
+  const responseData = response.data as
+    | Data
+    | {
+        token_type?: string
+        access_token?: string
+        refresh_token?: string
+        expires_in?: number
+      }
+
+  if (
+    response.statusCode < 200 ||
+    response.statusCode >= 300 ||
+    isAuthErrorResponse(responseData)
+  ) {
+    throw response
+  }
+
+  const {
+    token_type,
+    access_token,
+    refresh_token: nextRefreshToken,
+    expires_in,
+  } = responseData as {
+    token_type?: string
+    access_token?: string
+    refresh_token?: string
+    expires_in?: number
+  }
+
+  if (!token_type || !access_token || !nextRefreshToken || !expires_in) {
+    throw new Error('refresh token response invalid')
+  }
+
+  setToken(`${token_type} ${access_token}`)
+  setRefreshToken(nextRefreshToken)
+  setTokenExpiresIn(expires_in)
+}
+
+async function promptRelogin() {
+  if (isPromptingRelogin) {
+    return
+  }
+  isPromptingRelogin = true
+  try {
+    const modalRes = await uni.showModal({
+      title: '提示',
+      content: '当前页面已失效，请重新登录',
+      showCancel: false,
+      confirmText: '重新登录',
+    })
+
+    if (!modalRes.confirm) {
+      return
+    }
+
+    // 小程序端确认弹窗关闭到页面跳转之间留一个极短缓冲，避免按钮点击后路由不生效。
+    await new Promise((resolve) => setTimeout(resolve, 80))
+    await clearUserData()
+  } finally {
+    isPromptingRelogin = false
+  }
+}
+
+function handleAuthExpiredByMode(authMode: AuthMode, url: string, responseData: Data) {
+  if (authMode === 'required' && !shouldSkipAuthExpiredPrompt(url)) {
+    void promptRelogin()
+    return
+  }
+
+  silentClearAuthData()
+  if (authMode !== 'optional') {
+    void uni.showToast({
+      icon: 'none',
+      title: responseData.message || '请求错误',
+    })
+  }
+}
+
+function silentClearAuthData() {
+  clearToken()
+  uni.removeStorageSync('user')
+  uni.$emit(AUTH_SILENT_LOGOUT_EVENT)
+}
+
+async function clearUserData() {
+  clearToken()
+  uni.removeStorageSync('user')
+  saveCurrentRoute()
+  // token 失效时直接重启页面栈，避免小程序历史页残留。
+  uni.reLaunch({
+    url: '/pages/login/login',
+    fail: () => {
+      uni.redirectTo({ url: '/pages/login/login' })
+    },
+  })
+}

package/src/utils/index.ts

@@ -0,0 +1,79 @@
+const baseURL = import.meta.env.VITE_APP_STATIC_URL
+
+/**
+ * 解析静态资源访问前缀
+ * @returns 静态资源访问前缀
+ */
+const resolveStaticOrigin = () => {
+  // H5 开发环境优先走当前站点，由 Vite 代理转发静态资源。
+  if (typeof window !== 'undefined' && window.location?.protocol?.startsWith('http')) {
+    return window.location.origin
+  }
+  if (baseURL) {
+    return baseURL.replace(/\/$/, '')
+  }
+  if (typeof window !== 'undefined' && window.location?.origin) {
+    return window.location.origin
+  }
+  return ''
+}
+/**
+ * 日期格式化函数
+ * @param date 日期对象
+ * @param format 日期格式，默认为 YYYY-MM-DD HH:mm:ss
+ */
+export const formatDate = (date: Date, format = 'YYYY-MM-DD HH:mm:ss') => {
+  // 获取年月日时分秒，通过 padStart 补 0
+  const year = String(date.getFullYear())
+  const month = String(date.getMonth() + 1).padStart(2, '0')
+  const day = String(date.getDate()).padStart(2, '0')
+  const hours = String(date.getHours()).padStart(2, '0')
+  const minutes = String(date.getMinutes()).padStart(2, '0')
+  const seconds = String(date.getSeconds()).padStart(2, '0')
+
+  // 返回格式化后的结果
+  return format
+    .replace('YYYY', year)
+    .replace('MM', month)
+    .replace('DD', day)
+    .replace('HH', hours)
+    .replace('mm', minutes)
+    .replace('ss', seconds)
+}
+
+/**
+ * 金额格式化函数
+ * @param price 金额
+ */
+export const formatPrice = (price: number) => {
+  if (!price) {
+    return '0.00'
+  }
+  return (price / 100).toFixed(2)
+}
+
+/**
+ * 图片地址格式化函数
+ * @param src 图片地址
+ */
+export const formatSrc = (src: string) => {
+  if (!src) {
+    return src
+  }
+  // 已经是绝对地址时直接返回，避免重复拼接。
+  if (/^https?:\/\//.test(src)) {
+    return src
+  }
+
+  const staticOrigin = resolveStaticOrigin()
+  if (!staticOrigin) {
+    return src
+  }
+
+  // 以 / 开头的后端静态资源路径需要固定挂到站点根路径，不能受 /app base 影响。
+  if (src.startsWith('/')) {
+    return `${staticOrigin}${src}`
+  }
+
+  return `${staticOrigin}/${src.replace(/^\/+/, '')}`
+}