Spaces:
Paused
Paused
| export const API_URL = (process.env.NEXT_PUBLIC_API_URL || "/api/backend").replace(/\/+$/, ""); | |
| const SESSION_TOKEN_KEY = "sm_presenter_access_token"; | |
| const SESSION_TOKEN_EXP_KEY = "sm_presenter_access_exp_ms"; | |
| const REFRESH_TOKEN_KEY = "sm_presenter_refresh_token"; | |
| export type AuthTokenResponse = { | |
| access_token: string; | |
| refresh_token?: string | null; | |
| expires_in?: number | null; | |
| user?: { id: number; email: string; is_admin?: boolean }; | |
| }; | |
| export class ApiError extends Error { | |
| status: number; | |
| constructor(status: number, message: string) { | |
| super(message); | |
| this.name = "ApiError"; | |
| this.status = status; | |
| } | |
| } | |
| let accessToken: string | null = null; | |
| let accessTokenExpMs: number | null = null; | |
| let refreshTokenMem: string | null = null; | |
| let refreshPromise: Promise<string | null> | null = null; | |
| const readStorageItem = (key: string): string | null => { | |
| if (typeof window === "undefined") return null; | |
| try { | |
| const localVal = window.localStorage.getItem(key); | |
| if (localVal) return localVal; | |
| } catch { | |
| // Ignore localStorage sandbox restrictions | |
| } | |
| try { | |
| return window.sessionStorage.getItem(key); | |
| } catch { | |
| return null; | |
| } | |
| }; | |
| const writeStorageItem = (key: string, value: string | null) => { | |
| if (typeof window === "undefined") return; | |
| for (const store of ["localStorage", "sessionStorage"] as const) { | |
| try { | |
| if (value) { | |
| window[store].setItem(key, value); | |
| } else { | |
| window[store].removeItem(key); | |
| } | |
| } catch { | |
| // Ignore storage quota or sandbox restrictions | |
| } | |
| } | |
| }; | |
| const decodeBase64Url = (value: string) => { | |
| const normalized = value.replace(/-/g, "+").replace(/_/g, "/"); | |
| const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "="); | |
| if (typeof atob === "function") { | |
| return atob(padded); | |
| } | |
| return Buffer.from(padded, "base64").toString("utf8"); | |
| }; | |
| const parseTokenExpMs = (token: string): number | null => { | |
| const parts = token.split("."); | |
| if (parts.length < 2) return null; | |
| try { | |
| const payload = JSON.parse(decodeBase64Url(parts[1])) as { exp?: number }; | |
| return typeof payload.exp === "number" ? payload.exp * 1000 : null; | |
| } catch { | |
| return null; | |
| } | |
| }; | |
| export const getToken = () => { | |
| if (!accessToken) { | |
| const stored = readStorageItem(SESSION_TOKEN_KEY); | |
| if (stored) { | |
| accessToken = stored; | |
| } | |
| } | |
| return accessToken; | |
| }; | |
| const getTokenExpMs = (token: string): number | null => { | |
| if (accessTokenExpMs !== null) { | |
| return accessTokenExpMs; | |
| } | |
| const storedExp = readStorageItem(SESSION_TOKEN_EXP_KEY); | |
| if (storedExp) { | |
| const parsed = Number(storedExp); | |
| if (Number.isFinite(parsed) && parsed > 0) { | |
| accessTokenExpMs = parsed; | |
| return parsed; | |
| } | |
| } | |
| return parseTokenExpMs(token); | |
| }; | |
| export const getRefreshToken = () => { | |
| if (!refreshTokenMem) { | |
| const stored = readStorageItem(REFRESH_TOKEN_KEY); | |
| if (stored) { | |
| refreshTokenMem = stored; | |
| } | |
| } | |
| return refreshTokenMem; | |
| }; | |
| export const hasValidToken = () => { | |
| const token = getToken(); | |
| if (!token) return false; | |
| const expMs = getTokenExpMs(token); | |
| if (!expMs) return false; | |
| return expMs - 5_000 > Date.now(); | |
| }; | |
| export const setToken = ( | |
| token: string, | |
| expiresInSeconds?: number | null, | |
| refreshToken?: string | null | |
| ) => { | |
| accessToken = token; | |
| writeStorageItem(SESSION_TOKEN_KEY, token); | |
| if (typeof expiresInSeconds === "number" && expiresInSeconds > 0) { | |
| accessTokenExpMs = Date.now() + expiresInSeconds * 1000; | |
| writeStorageItem(SESSION_TOKEN_EXP_KEY, String(accessTokenExpMs)); | |
| } else { | |
| accessTokenExpMs = null; | |
| writeStorageItem(SESSION_TOKEN_EXP_KEY, null); | |
| } | |
| if (refreshToken) { | |
| refreshTokenMem = refreshToken; | |
| writeStorageItem(REFRESH_TOKEN_KEY, refreshToken); | |
| } | |
| }; | |
| export const clearToken = () => { | |
| accessToken = null; | |
| accessTokenExpMs = null; | |
| refreshTokenMem = null; | |
| writeStorageItem(SESSION_TOKEN_KEY, null); | |
| writeStorageItem(SESSION_TOKEN_EXP_KEY, null); | |
| writeStorageItem(REFRESH_TOKEN_KEY, null); | |
| }; | |
| const parseErrorMessage = async (response: Response) => { | |
| const contentType = response.headers.get("content-type") || ""; | |
| if (contentType.includes("application/json")) { | |
| const payload = await response.json().catch(() => null); | |
| if (payload && typeof payload.detail === "string") { | |
| return payload.detail; | |
| } | |
| } | |
| const message = await response.text().catch(() => ""); | |
| return message || `Request failed (${response.status})`; | |
| }; | |
| export const refreshAccessToken = async (): Promise<string | null> => { | |
| if (refreshPromise) { | |
| return refreshPromise; | |
| } | |
| refreshPromise = (async () => { | |
| try { | |
| const headers = new Headers(); | |
| const storedRefresh = getRefreshToken(); | |
| let body: string | undefined; | |
| if (storedRefresh) { | |
| headers.set("X-Refresh-Token", storedRefresh); | |
| headers.set("Content-Type", "application/json"); | |
| body = JSON.stringify({ refresh_token: storedRefresh }); | |
| } | |
| const response = await fetch(`${API_URL}/auth/refresh`, { | |
| method: "POST", | |
| headers, | |
| body, | |
| credentials: "include", | |
| }); | |
| if (!response.ok) { | |
| clearToken(); | |
| return null; | |
| } | |
| const payload = (await response.json()) as AuthTokenResponse; | |
| if (!payload.access_token) { | |
| clearToken(); | |
| return null; | |
| } | |
| setToken(payload.access_token, payload.expires_in, payload.refresh_token); | |
| return payload.access_token; | |
| } catch { | |
| clearToken(); | |
| return null; | |
| } finally { | |
| refreshPromise = null; | |
| } | |
| })(); | |
| return refreshPromise; | |
| }; | |
| export const ensureAccessToken = async () => { | |
| const current = getToken(); | |
| if (current && hasValidToken()) { | |
| return current; | |
| } | |
| return refreshAccessToken(); | |
| }; | |
| type FetchMode = "json" | "blob" | "response"; | |
| const performFetch = async ( | |
| path: string, | |
| options: RequestInit = {}, | |
| allowRefresh = true | |
| ): Promise<Response> => { | |
| const headers = new Headers(options.headers || {}); | |
| const skipAuth = | |
| path.startsWith("/auth/login") || | |
| path.startsWith("/auth/signup") || | |
| path.startsWith("/auth/refresh") || | |
| path.startsWith("/setup"); | |
| const token = skipAuth ? null : getToken() || (allowRefresh ? await refreshAccessToken() : null); | |
| let targetUrl = `${API_URL}${path}`; | |
| if (token) { | |
| headers.set("Authorization", `Bearer ${token}`); | |
| headers.set("X-Presenter-Token", token); | |
| const separator = targetUrl.includes("?") ? "&" : "?"; | |
| targetUrl = `${targetUrl}${separator}_pt=${encodeURIComponent(token)}`; | |
| } | |
| if (!headers.has("Content-Type") && !(options.body instanceof FormData) && options.body !== undefined) { | |
| headers.set("Content-Type", "application/json"); | |
| } | |
| const response = await fetch(targetUrl, { | |
| ...options, | |
| headers, | |
| credentials: "include", | |
| }); | |
| if (response.status === 401 && allowRefresh && !skipAuth) { | |
| const refreshed = await refreshAccessToken(); | |
| if (refreshed) { | |
| return performFetch(path, options, false); | |
| } | |
| } | |
| if (!response.ok) { | |
| throw new ApiError(response.status, await parseErrorMessage(response)); | |
| } | |
| return response; | |
| }; | |
| export async function apiFetch<T>(path: string, options: RequestInit = {}, mode: FetchMode = "json"): Promise<T> { | |
| const response = await performFetch(path, options); | |
| if (mode === "response") { | |
| return response as T; | |
| } | |
| if (mode === "blob") { | |
| return (await response.blob()) as T; | |
| } | |
| if (response.status === 204) { | |
| return undefined as T; | |
| } | |
| return (await response.json()) as T; | |
| } | |
| export const authApi = { | |
| setupStatus: () => apiFetch<{ setup_required: boolean }>("/setup/status"), | |
| setup: (email: string, password: string) => | |
| apiFetch<AuthTokenResponse>("/setup", { | |
| method: "POST", | |
| body: JSON.stringify({ email, password }), | |
| }), | |
| login: (email: string, password: string) => | |
| apiFetch<AuthTokenResponse>("/auth/login", { | |
| method: "POST", | |
| body: JSON.stringify({ email, password }), | |
| }), | |
| signup: (email: string, password: string) => | |
| apiFetch<AuthTokenResponse>("/auth/signup", { | |
| method: "POST", | |
| body: JSON.stringify({ email, password }), | |
| }), | |
| logout: () => { | |
| const storedRefresh = getRefreshToken(); | |
| const headers: Record<string, string> = {}; | |
| let body: string | undefined; | |
| if (storedRefresh) { | |
| headers["X-Refresh-Token"] = storedRefresh; | |
| body = JSON.stringify({ refresh_token: storedRefresh }); | |
| } | |
| return apiFetch<{ status: string }>("/auth/logout", { | |
| method: "POST", | |
| headers, | |
| body, | |
| }); | |
| }, | |
| me: () => apiFetch<{ id: number; email: string; is_admin: boolean }>("/auth/me"), | |
| }; | |