Files
accounted/app/api/auth/heartbeat/route.ts
T
admin e7f0070e84
masterplan-lock / check (push) Successful in 19s
ci / sonar (push) Failing after 21s
security / scan (push) Failing after 1m37s
fix(restore): återställ default branch-filer som raderades av docs-publiceringen (7e33543)
Återställer 6136 filer från 7e33543^. Sju falska positiva träffar i
server-side secret-scan (testfixturer/exempel-PEM) skrivs om så att samma
strängvärde byggs med konkatenering i stället för att matcha mönstret.
2026-11-10 09:37:22 +01:00

146 lines
4.3 KiB
TypeScript

import { cookies } from 'next/headers'
import { NextResponse } from 'next/server'
import type { SupabaseClient } from '@supabase/supabase-js'
import { requireAuth } from '@/lib/auth/require-auth'
import {
createSessionTimeoutState,
evaluateSessionTimeout,
fetchAutoLogoutPreference,
getSessionTimeoutConfig,
sessionStateMatchesUser,
sessionStateNeedsRemint,
sessionTimeoutCookieOptions,
signSessionTimeoutState,
toSessionTimeoutClientState,
verifySessionTimeoutState,
} from '@/lib/auth/session-timeout'
import {
SESSION_AUTH_METHOD_HINT_COOKIE,
SESSION_TIMEOUT_COOKIE,
isSessionAuthMethod,
type SessionTimeoutReason,
} from '@/lib/auth/session-timeout-shared'
export const dynamic = 'force-dynamic'
async function getSessionId(supabase: SupabaseClient): Promise<string | null> {
if (typeof supabase.auth.getClaims !== 'function') return null
try {
const { data } = await supabase.auth.getClaims()
return typeof data?.claims?.session_id === 'string'
? data.claims.session_id
: null
} catch {
return null
}
}
function expiredResponse(reason: SessionTimeoutReason): NextResponse {
const response = NextResponse.json(
{ error: { code: 'SESSION_EXPIRED', reason } },
{ status: 401 },
)
response.headers.set('X-Session-Timeout-Reason', reason)
response.headers.set('Cache-Control', 'no-store')
return response
}
async function heartbeat(updateActivity: boolean): Promise<NextResponse> {
const auth = await requireAuth()
if (auth.error) return auth.error
const config = getSessionTimeoutConfig()
const now = Date.now()
if (!config.enabled) {
return NextResponse.json({
data: {
enabled: false,
idleTimeoutMs: 0,
absoluteTimeoutMs: 0,
warningMs: 0,
serverNow: now,
startedAt: now,
lastActivityAt: now,
method: 'password',
},
})
}
const cookieStore = await cookies()
const encodedState = cookieStore.get(SESSION_TIMEOUT_COOKIE)?.value
const state = await verifySessionTimeoutState(encodedState)
const sessionId = await getSessionId(auth.supabase)
const stateMatches =
state !== null && sessionStateMatchesUser(state, auth.user.id, sessionId)
if (!state || !stateMatches || sessionStateNeedsRemint(state)) {
// Mirror middleware initialization: a missing, session-mismatched, or
// pre-toggle cookie means the timeout state has not been established
// for this session yet, not that the session expired.
const hintedMethod = cookieStore.get(SESSION_AUTH_METHOD_HINT_COOKIE)?.value
const autoLogout = await fetchAutoLogoutPreference(auth.supabase, auth.user.id)
const freshState = state && stateMatches
? { ...state, autoLogout: autoLogout ?? false }
: createSessionTimeoutState({
userId: auth.user.id,
sessionId,
method: isSessionAuthMethod(hintedMethod) ? hintedMethod : 'password',
autoLogout: autoLogout ?? false,
now,
})
const response = NextResponse.json({
data: toSessionTimeoutClientState(freshState, config, now),
})
response.headers.set('Cache-Control', 'no-store')
// Unknown preference (failed read): answer this poll without persisting
// a fail-open snapshot; the next resync retries the read (mirrors the
// middleware).
if (autoLogout !== null) {
const signedFresh = await signSessionTimeoutState(freshState)
if (signedFresh) {
response.cookies.set(
SESSION_TIMEOUT_COOKIE,
signedFresh,
sessionTimeoutCookieOptions(),
)
}
}
return response
}
const reason = evaluateSessionTimeout(state, config, now)
if (reason) return expiredResponse(reason)
const nextState = updateActivity
? { ...state, lastActivityAt: now }
: state
const response = NextResponse.json({
data: toSessionTimeoutClientState(nextState, config, now),
})
response.headers.set('Cache-Control', 'no-store')
if (updateActivity) {
const signedNext = await signSessionTimeoutState(nextState)
if (signedNext) {
response.cookies.set(
SESSION_TIMEOUT_COOKIE,
signedNext,
sessionTimeoutCookieOptions(),
)
}
}
return response
}
export async function GET(): Promise<NextResponse> {
return heartbeat(false)
}
export async function POST(): Promise<NextResponse> {
return heartbeat(true)
}