feat: 支持自动续期

packages/app/src/stores/user.ts

@@ -13,7 +13,7 @@ import {
   getMembershipRenewalHint,
 } from '@mp-pilates/shared'
 import { wxLogin, isLoggedIn, logout as authLogout } from '../utils/auth'
-import { setUnauthorizedHandler } from '../utils/session'
+import { setUnauthorizedHandler, setRenewedHandler } from '../utils/session'
 import { get, put } from '../utils/request'
 import { ROUTES } from '../utils/routes'
 import { cacheSubscriptionMessageTemplateConfig, resetSubscriptionMessageTemplateCache } from '../utils/wechat-subscription'
@@ -34,6 +34,7 @@ export const useUserStore = defineStore('user', () => {
   const statsError = ref(false)
   let membershipRequestId = 0
   let statsRequestId = 0
+  let sessionId = 0
   const token = ref<string>(uni.getStorageSync('token') as string || '')
 
   // Getters
@@ -53,6 +54,7 @@ export const useUserStore = defineStore('user', () => {
   async function login() {
     try {
       const result = await wxLogin()
+      sessionId++
       token.value = result.token
       user.value = result.user
       await useInviteStore().refresh().catch(() => {})
@@ -93,39 +95,39 @@ export const useUserStore = defineStore('user', () => {
   async function fetchStats(): Promise<boolean> {
     if (!isLoggedIn()) return false
     const id = ++statsRequestId
-    const session = token.value
+    const session = sessionId
     statsLoading.value = true
     statsError.value = false
     try {
       const result = await get<UserStatsResponse>('/user/stats')
-      if (id !== statsRequestId || session !== token.value) return false
+      if (id !== statsRequestId || session !== sessionId) return false
       stats.value = result
       return true
     } catch {
-      if (id === statsRequestId && session === token.value) statsError.value = true
+      if (id === statsRequestId && session === sessionId) statsError.value = true
       return false
     } finally {
-      if (id === statsRequestId && session === token.value) statsLoading.value = false
+      if (id === statsRequestId && session === sessionId) statsLoading.value = false
     }
   }
 
   async function fetchMemberships(): Promise<boolean> {
     if (!isLoggedIn()) return false
     const id = ++membershipRequestId
-    const session = token.value
+    const session = sessionId
     membershipsLoading.value = true
     membershipsError.value = false
     try {
       const result = await get<MembershipWithCardType[]>('/membership/my')
-      if (id !== membershipRequestId || session !== token.value) return false
+      if (id !== membershipRequestId || session !== sessionId) return false
       memberships.value = [...result]
       membershipsLoaded.value = true
       return true
     } catch {
-      if (id === membershipRequestId && session === token.value) membershipsError.value = true
+      if (id === membershipRequestId && session === sessionId) membershipsError.value = true
       return false
     } finally {
-      if (id === membershipRequestId && session === token.value) membershipsLoading.value = false
+      if (id === membershipRequestId && session === sessionId) membershipsLoading.value = false
     }
   }
 
@@ -149,6 +151,7 @@ export const useUserStore = defineStore('user', () => {
   }
 
   function clearSession() {
+    sessionId++
     membershipRequestId++
     statsRequestId++
     membershipsLoading.value = false
@@ -171,6 +174,7 @@ export const useUserStore = defineStore('user', () => {
   }
 
   setUnauthorizedHandler(clearSession)
+  setRenewedHandler((renewedToken) => { token.value = renewedToken })
 
   return {
     membershipsLoading,

packages/app/src/utils/auth.ts

@@ -77,6 +77,7 @@ export async function wxLogin(): Promise<LoginResponse> {
             inviterId: inviterId || undefined,
           })
           uni.setStorageSync('token', result.token)
+          uni.setStorageSync('token_renewed_at', Date.now())
           if (result.isNewUser && inviterId) {
             uni.removeStorageSync('invite_inviter_id')
           }
@@ -105,4 +106,5 @@ export function isLoggedIn(): boolean {
 
 export function logout(): void {
   uni.removeStorageSync('token')
+  uni.removeStorageSync('token_renewed_at')
 }

packages/app/src/utils/request.ts

@@ -1,8 +1,10 @@
 import type { ApiResponse, PaginatedData } from '@mp-pilates/shared'
-import { notifyUnauthorized } from './session'
+import { notifyRenewed, notifyUnauthorized } from './session'
 
 // 统一使用线上服务地址
 const BASE_URL = 'https://focus.richarjiang.com/api'
+const RENEW_INTERVAL_MS = 24 * 60 * 60 * 1000
+let renewal: Promise<void> | null = null
 
 interface RequestOptions {
   readonly url: string
@@ -18,10 +20,8 @@ export class HttpRequestError extends Error {
   }
 }
 
-export function request<T>(options: RequestOptions): Promise<T> {
+function send<T>(options: RequestOptions, token: string): Promise<T> {
   return new Promise((resolve, reject) => {
-    const token = uni.getStorageSync('token') as string
-
     uni.request({
       url: `${BASE_URL}${options.url}`,
       method: options.method || 'GET',
@@ -33,7 +33,7 @@ export function request<T>(options: RequestOptions): Promise<T> {
       },
       success: (res) => {
         if (res.statusCode === 401) {
-          if (!options.url.startsWith('/auth/login')) {
+          if (token && uni.getStorageSync('token') === token && options.url !== '/auth/login') {
             notifyUnauthorized()
           }
           reject(new Error('Unauthorized'))
@@ -58,6 +58,35 @@ export function request<T>(options: RequestOptions): Promise<T> {
   })
 }
 
+async function renewIfDue(token: string): Promise<void> {
+  const lastRenewed = Number(uni.getStorageSync('token_renewed_at')) || 0
+  if (Date.now() - lastRenewed < RENEW_INTERVAL_MS) return
+
+  if (!renewal) {
+    renewal = send<{ token: string }>({ url: '/auth/renew', method: 'POST' }, token)
+      .then((result) => {
+        if (uni.getStorageSync('token') === token) notifyRenewed(result.token)
+      })
+      .finally(() => { renewal = null })
+  }
+  await renewal
+}
+
+export async function request<T>(options: RequestOptions): Promise<T> {
+  const token = uni.getStorageSync('token') as string || ''
+  if (token && options.url !== '/auth/renew' && options.url !== '/auth/login') {
+    try {
+      await renewIfDue(token)
+    } catch (err) {
+      // A network failure should not discard a still-valid session.
+      if (!uni.getStorageSync('token')) throw err
+    }
+  }
+  const currentToken = uni.getStorageSync('token') as string || ''
+  if (token && !currentToken && options.url !== '/auth/login') throw new Error('Unauthorized')
+  return send<T>(options, currentToken)
+}
+
 export function get<T>(url: string, data?: Record<string, unknown>): Promise<T> {
   return request<T>({ url, method: 'GET', data })
 }

packages/app/src/utils/session.ts

@@ -1,12 +1,23 @@
 const UNAUTHORIZED_TOAST_GAP_MS = 2000
 
 let unauthorizedHandler: (() => void) | null = null
+let renewedHandler: ((token: string) => void) | null = null
 let lastUnauthorizedAt = 0
 
 export function setUnauthorizedHandler(handler: () => void): void {
   unauthorizedHandler = handler
 }
 
+export function setRenewedHandler(handler: (token: string) => void): void {
+  renewedHandler = handler
+}
+
+export function notifyRenewed(token: string): void {
+  uni.setStorageSync('token', token)
+  uni.setStorageSync('token_renewed_at', Date.now())
+  renewedHandler?.(token)
+}
+
 /** Clear persisted token and in-memory session after the server rejects auth. */
 export function notifyUnauthorized(): void {
   const now = Date.now()
@@ -14,6 +25,7 @@ export function notifyUnauthorized(): void {
   lastUnauthorizedAt = now
 
   uni.removeStorageSync('token')
+  uni.removeStorageSync('token_renewed_at')
   unauthorizedHandler?.()
 
   if (shouldToast) {

packages/server/src/auth/__tests__/auth.service.spec.ts

@@ -240,6 +240,23 @@ describe('AuthService', () => {
 
   // ── bindPhone ──────────────────────────────────────────────────────────────
 
+  describe('renew', () => {
+    it('issues a fresh token using the current database role', async () => {
+      mockPrismaService.user.findUnique.mockResolvedValue({ ...mockUser, role: UserRole.ADMIN })
+
+      await expect(authService.renew(USER_ID)).resolves.toEqual({ token: JWT_TOKEN })
+      expect(mockJwtService.sign).toHaveBeenCalledWith({ sub: USER_ID, role: UserRole.ADMIN })
+    })
+
+    it('rejects deleted users', async () => {
+      mockPrismaService.user.findUnique.mockResolvedValue(null)
+
+      await expect(authService.renew(USER_ID)).rejects.toThrow(UnauthorizedException)
+      expect(mockJwtService.sign).not.toHaveBeenCalled()
+    })
+  })
+
+
   describe('bindPhone', () => {
     const encryptedData = 'encrypted_phone_data'
     const iv = 'init_vector'

packages/server/src/auth/auth.controller.ts

@@ -34,6 +34,13 @@ export class AuthController {
     )
   }
 
+  @Post('renew')
+  @UseGuards(JwtAuthGuard)
+  @HttpCode(HttpStatus.OK)
+  renew(@Request() req: AuthenticatedRequest): Promise<{ token: string }> {
+    return this.authService.renew(req.user.sub)
+  }
+
   @Post('phone')
   @UseGuards(JwtAuthGuard)
   @HttpCode(HttpStatus.OK)

packages/server/src/auth/auth.module.ts

@@ -24,7 +24,7 @@ import { BodyPortraitModule } from '../body-portrait/body-portrait.module'
       inject: [ConfigService],
       useFactory: (configService: ConfigService) => ({
         secret: configService.getOrThrow<string>('JWT_SECRET'),
-        signOptions: { expiresIn: '7d' },
+        signOptions: { expiresIn: '30d' },
       }),
     }),
   ],

packages/server/src/auth/auth.service.ts

@@ -190,4 +190,10 @@ export class AuthService {
     await this.portraitLifecycle?.onPhoneBound(userId)
     return updated
   }
+
+  async renew(userId: string): Promise<{ token: string }> {
+    const user = await this.prisma.user.findUnique({ where: { id: userId } })
+    if (!user) throw new UnauthorizedException('User no longer exists')
+    return { token: this.jwtService.sign({ sub: user.id, role: user.role as UserRole }) }
+  }
 }