// auth-routes.ts: sign in with an OAuth provider, keep the person in a signed cookie, sign out. Fastify version. // oauth-state.ts, session.ts and db.ts are the framework-free files from the general guide. import type { FastifyPluginAsync } from 'fastify'; import type { Db } from './db.ts'; import { newNonce, newVerifier, challengeOf, signState, verifyState, STATE_COOKIE, VERIFIER_COOKIE, STATE_TTL_MS } from './oauth-state.ts'; import { signSession, SESSION_COOKIE, SESSION_TTL_MS } from './session.ts'; /** What the routes need from the provider: its consent page, and the person behind a code. */ export interface OAuthProvider { name: string; /** The provider's consent page URL, with your client id, redirect URI, scopes and this state. Add code_challenge= and code_challenge_method=S256 (PKCE). */ authorizeUrl(state: string, codeChallenge: string): string; /** Exchanges the code for a token, then reads who signed in. Send code_verifier= in the token request. */ identify(code: string, codeVerifier: string): Promise<{ providerUserId: string; email: string | null }>; } export interface AuthRoutesOptions { db: Pick; provider: OAuthProvider; } // HttpOnly: no script can read it. Secure: HTTPS only. SameSite=Lax: not sent on a cross-site POST. // @fastify/cookie takes maxAge in seconds. const base = { httpOnly: true, secure: true, sameSite: 'lax' } as const; const signInCookie = { ...base, path: '/api/auth', maxAge: STATE_TTL_MS / 1000 }; // the state nonce and the PKCE verifier const sessionCookie = { ...base, path: '/', maxAge: SESSION_TTL_MS / 1000 }; // A cookie with the __Host- prefix is cleared only by a Set-Cookie that is also Secure with Path=/. const clearOptions = (path: string) => ({ ...base, path }); export const authRoutes: FastifyPluginAsync = async (app, { db, provider }) => { // To the provider's consent page, with a signed state and PKCE challenge; their secrets go in cookies. app.get('/api/auth/start', async (_request, reply) => { const nonce = newNonce(); const verifier = newVerifier(); reply.setCookie(STATE_COOKIE, nonce, signInCookie); reply.setCookie(VERIFIER_COOKIE, verifier, signInCookie); const url = provider.authorizeUrl(signState(nonce, Date.now() + STATE_TTL_MS), challengeOf(verifier)); return reply.header('cache-control', 'no-store').redirect(url); }); // Back from the provider: check the state and the verifier against their cookies, find or create the user, set the session cookie. // The schema makes Fastify answer 400 when a value is repeated, so the handler never gets an array. app.get<{ Querystring: { code?: string; state?: string; error?: string } }>( '/api/auth/callback', { schema: { querystring: { type: 'object', properties: { code: { type: 'string' }, state: { type: 'string' }, error: { type: 'string' } } } } }, async (request, reply) => { reply.header('cache-control', 'no-store'); // Every way out clears both cookies: each sign-in attempt gets one try. reply.clearCookie(STATE_COOKIE, clearOptions('/api/auth')); reply.clearCookie(VERIFIER_COOKIE, clearOptions('/api/auth')); const { code, state, error } = request.query; if (error) return reply.redirect('/?error=denied'); // the person said no on the provider's page const nonce = verifyState(state, Date.now()); const verifier = request.cookies[VERIFIER_COOKIE]; if (!nonce || nonce !== request.cookies[STATE_COOKIE] || !code || !verifier) return reply.redirect('/?error=bad_state'); try { const who = await provider.identify(code, verifier); const userId = await db.upsertUser({ provider: provider.name, providerUserId: who.providerUserId, email: who.email }); reply.setCookie(SESSION_COOKIE, signSession({ userId, expiresAt: Date.now() + SESSION_TTL_MS }), sessionCookie); return reply.redirect('/app'); } catch (err) { request.log.error({ err }, 'sign-in failed'); // your log only; the visitor gets a short code return reply.redirect('/?error=signin_failed'); } }, ); // Sign out: POST from your own site only (requireSession checks the Origin). The cookie was the session. app.post('/api/auth/logout', { preHandler: app.requireSession }, async (_request, reply) => { reply.header('cache-control', 'no-store'); reply.clearCookie(SESSION_COOKIE, clearOptions('/')); return reply.code(204).send(); }); };