277 lines
8.5 KiB
TypeScript
277 lines
8.5 KiB
TypeScript
import { SUCCESS_CODE, type ApiEnvelope } from '../types/api'
|
||
import { storage } from '../lib/storage'
|
||
|
||
export class ApiError extends Error {
|
||
code: number
|
||
constructor(code: number, message: string) {
|
||
super(message)
|
||
this.code = code
|
||
}
|
||
}
|
||
|
||
type RequestOptions = {
|
||
method?: string
|
||
body?: unknown
|
||
auth?: boolean
|
||
memberAuth?: boolean
|
||
providerToken?: string
|
||
query?: Record<string, string | number | boolean | undefined>
|
||
}
|
||
|
||
let refreshPromise: Promise<void> | null = null
|
||
|
||
async function refreshTokens() {
|
||
const refreshToken = storage.getRefreshToken()
|
||
if (!refreshToken) throw new ApiError(0, '缺少 refresh token')
|
||
const res = await fetch('/api/v1/auth/refresh', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({ refresh_token: refreshToken }),
|
||
})
|
||
const json = (await res.json()) as ApiEnvelope<{
|
||
access_token: string
|
||
refresh_token: string
|
||
uid: string
|
||
}>
|
||
if (json.code !== SUCCESS_CODE || !json.data) {
|
||
storage.clearSession()
|
||
// 通知 AuthProvider 清空狀態並導回登入。
|
||
if (typeof window !== 'undefined') {
|
||
window.dispatchEvent(new Event('haixun:session-expired'))
|
||
}
|
||
throw new ApiError(json.code, json.message || 'refresh failed')
|
||
}
|
||
storage.setAccessToken(json.data.access_token)
|
||
storage.setRefreshToken(json.data.refresh_token)
|
||
storage.setUid(json.data.uid)
|
||
}
|
||
|
||
async function parseEnvelope<T>(res: Response): Promise<ApiEnvelope<T>> {
|
||
const text = await res.text()
|
||
if (!text.trim()) {
|
||
if (!res.ok) {
|
||
const hint =
|
||
res.status === 404
|
||
? '後端找不到此 API，請確認已執行 make gen-api 並重啟 API（make restart-all）'
|
||
: res.status === 405
|
||
? '後端尚未支援此操作，請重啟 API 服務（make run 或 scripts/restart-all.sh）'
|
||
: res.status >= 500
|
||
? '後端 API 無法連線，請確認服務已啟動（scripts/start-all.sh 或 make -C haixun-backend start-all）'
|
||
: `HTTP ${res.status}`
|
||
throw new ApiError(res.status, hint)
|
||
}
|
||
return { code: SUCCESS_CODE, message: 'success', data: null as T }
|
||
}
|
||
try {
|
||
return JSON.parse(text) as ApiEnvelope<T>
|
||
} catch {
|
||
throw new ApiError(res.status || 0, text.slice(0, 200) || 'invalid response')
|
||
}
|
||
}
|
||
|
||
function buildURL(path: string, query?: RequestOptions['query']) {
|
||
const url = new URL(path, window.location.origin)
|
||
if (query) {
|
||
for (const [k, v] of Object.entries(query)) {
|
||
if (v !== undefined && v !== '') url.searchParams.set(k, String(v))
|
||
}
|
||
}
|
||
return url.pathname + url.search
|
||
}
|
||
|
||
async function request<T>(path: string, opts: RequestOptions = {}): Promise<T> {
|
||
const buildHeaders = () => {
|
||
const headers: Record<string, string> = { 'Content-Type': 'application/json' }
|
||
if (opts.auth) {
|
||
const token = storage.getAccessToken()
|
||
if (token) headers.Authorization = `Bearer ${token}`
|
||
}
|
||
if (opts.memberAuth) {
|
||
const token = storage.getAccessToken()
|
||
if (token) headers['X-Member-Authorization'] = `Bearer ${token}`
|
||
}
|
||
if (opts.providerToken) {
|
||
headers.Authorization = `Bearer ${opts.providerToken}`
|
||
}
|
||
return headers
|
||
}
|
||
|
||
const doFetch = () =>
|
||
fetch(buildURL(path, opts.query), {
|
||
method: opts.method ?? (opts.body ? 'POST' : 'GET'),
|
||
headers: buildHeaders(),
|
||
body: opts.body ? JSON.stringify(opts.body) : undefined,
|
||
})
|
||
|
||
let res = await doFetch()
|
||
let json = await parseEnvelope<T>(res)
|
||
|
||
if (json.code !== SUCCESS_CODE && res.status === 401 && opts.auth && storage.getRefreshToken()) {
|
||
if (!refreshPromise) {
|
||
refreshPromise = refreshTokens().finally(() => {
|
||
refreshPromise = null
|
||
})
|
||
}
|
||
try {
|
||
await refreshPromise
|
||
res = await doFetch()
|
||
json = await parseEnvelope<T>(res)
|
||
} catch {
|
||
/* fall through */
|
||
}
|
||
}
|
||
|
||
if (json.code !== SUCCESS_CODE) {
|
||
throw new ApiError(json.code, json.message || 'request failed')
|
||
}
|
||
return json.data as T
|
||
}
|
||
|
||
export const api = {
|
||
get: <T>(path: string, opts?: Omit<RequestOptions, 'method' | 'body'>) =>
|
||
request<T>(path, { ...opts, method: 'GET' }),
|
||
post: <T>(path: string, body?: unknown, opts?: Omit<RequestOptions, 'method' | 'body'>) =>
|
||
request<T>(path, { ...opts, method: 'POST', body }),
|
||
put: <T>(path: string, body?: unknown, opts?: Omit<RequestOptions, 'method' | 'body'>) =>
|
||
request<T>(path, { ...opts, method: 'PUT', body }),
|
||
patch: <T>(path: string, body?: unknown, opts?: Omit<RequestOptions, 'method' | 'body'>) =>
|
||
request<T>(path, { ...opts, method: 'PATCH', body }),
|
||
delete: <T>(path: string, opts?: Omit<RequestOptions, 'method' | 'body'>) =>
|
||
request<T>(path, { ...opts, method: 'DELETE' }),
|
||
}
|
||
|
||
async function readStreamErrorMessage(res: Response): Promise<string> {
|
||
const text = await res.text()
|
||
if (!text.trim()) {
|
||
if (res.status === 404) {
|
||
return '後端尚未載入島民 API，請重啟 API（make restart-all 或 scripts/restart-all.sh）'
|
||
}
|
||
return `HTTP ${res.status}`
|
||
}
|
||
try {
|
||
const json = JSON.parse(text) as { message?: string; code?: number }
|
||
if (json.message) return json.message
|
||
} catch {
|
||
return text.slice(0, 200) || `HTTP ${res.status}`
|
||
}
|
||
return `HTTP ${res.status}`
|
||
}
|
||
|
||
async function consumeAIEventStream(
|
||
res: Response,
|
||
onDelta: (text: string) => void,
|
||
onDone: (finishReason?: string) => void,
|
||
onError: (msg: string) => void,
|
||
signal?: AbortSignal,
|
||
) {
|
||
if (!res.ok || !res.body) {
|
||
onError(await readStreamErrorMessage(res))
|
||
return
|
||
}
|
||
|
||
const reader = res.body.getReader()
|
||
const decoder = new TextDecoder()
|
||
let buffer = ''
|
||
|
||
// 確保 onDone / onError 只會被呼叫一次：避免串流提前關閉時
|
||
// 外層 Promise 永遠不 settle（聊天輸入永久鎖死）。
|
||
let settled = false
|
||
const finishDone = (finishReason?: string) => {
|
||
if (settled) return
|
||
settled = true
|
||
onDone(finishReason)
|
||
}
|
||
const finishError = (msg: string) => {
|
||
if (settled) return
|
||
settled = true
|
||
onError(msg)
|
||
}
|
||
|
||
// 回傳 true 代表收到 done/error，串流應停止。
|
||
const handlePart = (part: string): boolean => {
|
||
const lines = part.split('\n')
|
||
let event = ''
|
||
const dataLines: string[] = []
|
||
for (const line of lines) {
|
||
if (line.startsWith('event:')) event = line.slice(6).trim()
|
||
else if (line.startsWith('data:')) dataLines.push(line.slice(5).replace(/^ /, ''))
|
||
}
|
||
const data = dataLines.join('\n').trim()
|
||
if (!data) return false
|
||
try {
|
||
const parsed = JSON.parse(data) as {
|
||
type?: string
|
||
text?: string
|
||
finish_reason?: string
|
||
message?: string
|
||
}
|
||
if (event === 'error' || parsed.type === 'error') {
|
||
finishError(parsed.message || 'stream error')
|
||
return true
|
||
}
|
||
if (parsed.type === 'delta' && parsed.text) onDelta(parsed.text)
|
||
if (parsed.type === 'done') {
|
||
finishDone(parsed.finish_reason)
|
||
return true
|
||
}
|
||
} catch {
|
||
/* ignore malformed chunk */
|
||
}
|
||
return false
|
||
}
|
||
|
||
try {
|
||
while (true) {
|
||
const { done, value } = await reader.read()
|
||
if (done) break
|
||
buffer += decoder.decode(value, { stream: true })
|
||
const parts = buffer.split('\n\n')
|
||
buffer = parts.pop() ?? ''
|
||
for (const part of parts) {
|
||
if (handlePart(part)) return
|
||
}
|
||
}
|
||
// 沖出殘餘 buffer（最後一段可能沒有結尾的空行）。
|
||
if (buffer.trim()) handlePart(buffer)
|
||
} catch (err) {
|
||
if (signal?.aborted) {
|
||
finishDone()
|
||
return
|
||
}
|
||
finishError(err instanceof Error ? err.message : '串流連線中斷')
|
||
return
|
||
}
|
||
|
||
// reader 正常結束但未收到明確的 done 事件：仍要 settle，避免卡死。
|
||
finishDone()
|
||
}
|
||
|
||
export async function streamIslanderChat(
|
||
body: { messages: { role: string; content: string }[]; context: string },
|
||
onDelta: (text: string) => void,
|
||
onDone: (finishReason?: string) => void,
|
||
onError: (msg: string) => void,
|
||
signal?: AbortSignal,
|
||
) {
|
||
const memberToken = storage.getAccessToken()
|
||
const headers: Record<string, string> = { 'Content-Type': 'application/json' }
|
||
if (memberToken) headers.Authorization = `Bearer ${memberToken}`
|
||
|
||
try {
|
||
const res = await fetch('/api/v1/ai/islander/chat/stream', {
|
||
method: 'POST',
|
||
headers,
|
||
body: JSON.stringify(body),
|
||
signal,
|
||
})
|
||
await consumeAIEventStream(res, onDelta, onDone, onError, signal)
|
||
} catch (err) {
|
||
if (signal?.aborted) {
|
||
onDone()
|
||
return
|
||
}
|
||
onError(err instanceof Error ? err.message : '無法連線島民 API')
|
||
}
|
||
}
|
||
|