wip

packages/identity/infrastructure/providers/IracingDemoIdentityProviderAdapter.ts

@@ -0,0 +1,50 @@
+import { randomUUID } from 'crypto';
+import { createStaticRacingSeed } from '../../../testing-support';
+import type { IdentityProviderPort } from '../../application/ports/IdentityProviderPort';
+import type { StartAuthCommandDTO } from '../../application/dto/StartAuthCommandDTO';
+import type { AuthCallbackCommandDTO } from '../../application/dto/AuthCallbackCommandDTO';
+import type { AuthenticatedUserDTO } from '../../application/dto/AuthenticatedUserDTO';
+
+export class IracingDemoIdentityProviderAdapter implements IdentityProviderPort {
+  private readonly seedDriverId: string;
+
+  constructor() {
+    const seed = createStaticRacingSeed(42);
+    this.seedDriverId = seed.drivers[0]?.id ?? 'driver-1';
+  }
+
+  async startAuth(command: StartAuthCommandDTO): Promise<{ redirectUrl: string; state: string }> {
+    const state = randomUUID();
+
+    const params = new URLSearchParams();
+    params.set('code', 'dummy-code');
+    params.set('state', state);
+    if (command.returnTo) {
+      params.set('returnTo', command.returnTo);
+    }
+
+    return {
+      redirectUrl: `/auth/iracing/callback?${params.toString()}`,
+      state,
+    };
+  }
+
+  async completeAuth(command: AuthCallbackCommandDTO): Promise<AuthenticatedUserDTO> {
+    if (!command.code) {
+      throw new Error('Missing auth code');
+    }
+    if (!command.state) {
+      throw new Error('Missing auth state');
+    }
+
+    const user: AuthenticatedUserDTO = {
+      id: 'demo-user',
+      displayName: 'GridPilot Demo Driver',
+      iracingCustomerId: '000000',
+      primaryDriverId: this.seedDriverId,
+      avatarUrl: `/api/avatar/${this.seedDriverId}`,
+    };
+
+    return user;
+  }
+}

packages/identity/infrastructure/session/CookieIdentitySessionAdapter.ts

@@ -0,0 +1,59 @@
+import { cookies } from 'next/headers';
+import { randomUUID } from 'crypto';
+import type { AuthenticatedUserDTO } from '../../application/dto/AuthenticatedUserDTO';
+import type { AuthSessionDTO } from '../../application/dto/AuthSessionDTO';
+import type { IdentitySessionPort } from '../../application/ports/IdentitySessionPort';
+
+const SESSION_COOKIE = 'gp_demo_session';
+
+function parseCookieValue(raw: string | undefined): AuthSessionDTO | null {
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw) as AuthSessionDTO;
+    if (!parsed.expiresAt || Date.now() > parsed.expiresAt) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function serializeSession(session: AuthSessionDTO): string {
+  return JSON.stringify(session);
+}
+
+export class CookieIdentitySessionAdapter implements IdentitySessionPort {
+  async getCurrentSession(): Promise<AuthSessionDTO | null> {
+    const store = await cookies();
+    const raw = store.get(SESSION_COOKIE)?.value;
+    return parseCookieValue(raw);
+  }
+
+  async createSession(user: AuthenticatedUserDTO): Promise<AuthSessionDTO> {
+    const now = Date.now();
+    const expiresAt = now + 24 * 60 * 60 * 1000;
+
+    const session: AuthSessionDTO = {
+      user,
+      issuedAt: now,
+      expiresAt,
+      token: randomUUID(),
+    };
+
+    const store = await cookies();
+    store.set(SESSION_COOKIE, serializeSession(session), {
+      httpOnly: true,
+      sameSite: 'lax',
+      path: '/',
+      secure: process.env.NODE_ENV === 'production',
+    });
+
+    return session;
+  }
+
+  async clearSession(): Promise<void> {
+    const store = await cookies();
+    store.delete(SESSION_COOKIE);
+  }
+}