wip

apps/website/lib/auth/AuthContext.tsx

@@ -0,0 +1,121 @@
+'use client';
+
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useState,
+  type ReactNode,
+} from 'react';
+import { useRouter } from 'next/navigation';
+
+import type { AuthSession } from './AuthService';
+
+type AuthContextValue = {
+  session: AuthSession | null;
+  loading: boolean;
+  login: (returnTo?: string) => void;
+  logout: () => Promise<void>;
+};
+
+const AuthContext = createContext<AuthContextValue | undefined>(undefined);
+
+interface AuthProviderProps {
+  initialSession?: AuthSession | null;
+  children: ReactNode;
+}
+
+export function AuthProvider({ initialSession = null, children }: AuthProviderProps) {
+  const router = useRouter();
+  const [session, setSession] = useState<AuthSession | null>(initialSession);
+  const [loading, setLoading] = useState(false);
+
+  useEffect(() => {
+    if (initialSession) return;
+
+    let cancelled = false;
+
+    async function loadSession() {
+      try {
+        const res = await fetch('/api/auth/session', {
+          method: 'GET',
+          credentials: 'include',
+        });
+
+        if (!res.ok) {
+          if (!cancelled) setSession(null);
+          return;
+        }
+
+        const data = (await res.json()) as { session: AuthSession | null };
+
+        if (!cancelled) {
+          setSession(data.session ?? null);
+        }
+      } catch {
+        if (!cancelled) {
+          setSession(null);
+        }
+      }
+    }
+
+    loadSession();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [initialSession]);
+
+  const login = useCallback(
+    (returnTo?: string) => {
+      const search = new URLSearchParams();
+      if (returnTo) {
+        search.set('returnTo', returnTo);
+      }
+
+      const target = search.toString()
+        ? `/auth/iracing?${search.toString()}`
+        : '/auth/iracing';
+
+      router.push(target);
+    },
+    [router],
+  );
+
+  const logout = useCallback(async () => {
+    setLoading(true);
+    try {
+      await fetch('/api/auth/logout', {
+        method: 'POST',
+        credentials: 'include',
+      });
+      setSession(null);
+      router.push('/');
+      router.refresh();
+    } finally {
+      setLoading(false);
+    }
+  }, [router]);
+
+  const value = useMemo(
+    () => ({
+      session,
+      loading,
+      login,
+      logout,
+    }),
+    [session, loading, login, logout],
+  );
+
+  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
+}
+
+export function useAuth(): AuthContextValue {
+  const ctx = useContext(AuthContext);
+  if (!ctx) {
+    throw new Error('useAuth must be used within an AuthProvider');
+  }
+  return ctx;
+}

apps/website/lib/auth/AuthService.ts

@@ -0,0 +1,27 @@
+export interface AuthUser {
+  id: string;
+  displayName: string;
+  iracingCustomerId?: string;
+  primaryDriverId?: string;
+  avatarUrl?: string;
+}
+
+export interface AuthSession {
+  user: AuthUser;
+  issuedAt: number;
+  expiresAt: number;
+  token: string;
+}
+
+export interface AuthService {
+  getCurrentSession(): Promise<AuthSession | null>;
+  startIracingAuthRedirect(
+    returnTo?: string,
+  ): Promise<{ redirectUrl: string; state: string }>;
+  loginWithIracingCallback(params: {
+    code: string;
+    state: string;
+    returnTo?: string;
+  }): Promise<AuthSession>;
+  logout(): Promise<void>;
+}

apps/website/lib/auth/InMemoryAuthService.ts

@@ -0,0 +1,96 @@
+import { cookies } from 'next/headers';
+import { randomUUID } from 'crypto';
+
+import type { AuthService, AuthSession, AuthUser } from './AuthService';
+import { createStaticRacingSeed } from '@gridpilot/testing-support';
+
+const SESSION_COOKIE = 'gp_demo_session';
+const STATE_COOKIE = 'gp_demo_auth_state';
+
+function parseCookieValue(raw: string | undefined): AuthSession | null {
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw) as AuthSession;
+    if (!parsed.expiresAt || Date.now() > parsed.expiresAt) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function serializeSession(session: AuthSession): string {
+  return JSON.stringify(session);
+}
+
+export class InMemoryAuthService implements AuthService {
+  private readonly seedDriverId: string;
+
+  constructor() {
+    const seed = createStaticRacingSeed(42);
+    this.seedDriverId = seed.drivers[0]?.id ?? 'driver-1';
+  }
+
+  async getCurrentSession(): Promise<AuthSession | null> {
+    const store = await cookies();
+    const raw = store.get(SESSION_COOKIE)?.value;
+    return parseCookieValue(raw);
+  }
+
+  async startIracingAuthRedirect(
+    returnTo?: string,
+  ): Promise<{ redirectUrl: string; state: string }> {
+    const state = randomUUID();
+
+    const params = new URLSearchParams();
+    params.set('code', 'dummy-code');
+    params.set('state', state);
+    if (returnTo) {
+      params.set('returnTo', returnTo);
+    }
+
+    return {
+      redirectUrl: `/auth/iracing/callback?${params.toString()}`,
+      state,
+    };
+  }
+
+  async loginWithIracingCallback(params: {
+    code: string;
+    state: string;
+    returnTo?: string;
+  }): Promise<AuthSession> {
+    if (!params.code) {
+      throw new Error('Missing auth code');
+    }
+    if (!params.state) {
+      throw new Error('Missing auth state');
+    }
+
+    const user: AuthUser = {
+      id: 'demo-user',
+      displayName: 'GridPilot Demo Driver',
+      iracingCustomerId: '000000',
+      primaryDriverId: this.seedDriverId,
+      avatarUrl: `/api/avatar/${this.seedDriverId}`,
+    };
+
+    const now = Date.now();
+    const expiresAt = now + 24 * 60 * 60 * 1000;
+
+    const session: AuthSession = {
+      user,
+      issuedAt: now,
+      expiresAt,
+      token: randomUUID(),
+    };
+
+    return session;
+  }
+
+  async logout(): Promise<void> {
+    // Intentionally does nothing; cookie deletion is handled by route handlers.
+    return;
+  }
+}

apps/website/lib/auth/index.ts

@@ -0,0 +1,11 @@
+import type { AuthService } from './AuthService';
+import { InMemoryAuthService } from './InMemoryAuthService';
+
+let authService: AuthService | null = null;
+
+export function getAuthService(): AuthService {
+  if (!authService) {
+    authService = new InMemoryAuthService();
+  }
+  return authService;
+}