wip

apps/website/lib/currentDriver.ts

@@ -0,0 +1,20 @@
+'use client';
+
+import { useAuth } from '@/lib/auth/AuthContext';
+
+/**
+ * Returns the effective driver ID for the current session.
+ *
+ * Prefers the authenticated user's primaryDriverId when available,
+ * otherwise falls back to the demo default used across the alpha site.
+ */
+export function useEffectiveDriverId(): string {
+  const { session } = useAuth();
+  const user = session?.user as
+    | {
+        primaryDriverId?: string | null;
+      }
+    | undefined;
+
+  return user?.primaryDriverId ?? 'driver-1';
+}

apps/website/lib/di-container.ts

@@ -16,19 +16,55 @@ import type { ILeagueRepository } from '@gridpilot/racing/domain/repositories/IL
 import type { IRaceRepository } from '@gridpilot/racing/domain/repositories/IRaceRepository';
 import type { IResultRepository } from '@gridpilot/racing/domain/repositories/IResultRepository';
 import type { IStandingRepository } from '@gridpilot/racing/domain/repositories/IStandingRepository';
+import type { IPenaltyRepository } from '@gridpilot/racing/domain/repositories/IPenaltyRepository';
+import type {
+  ITeamRepository,
+  ITeamMembershipRepository,
+  IRaceRegistrationRepository,
+} from '@gridpilot/racing';
+import type { ILeagueMembershipRepository } from '@gridpilot/racing/domain/repositories/ILeagueMembershipRepository';
+import type { LeagueMembership, JoinRequest } from '@gridpilot/racing/domain/entities/LeagueMembership';
 import type { IFeedRepository } from '@gridpilot/social/domain/repositories/IFeedRepository';
 import type { ISocialGraphRepository } from '@gridpilot/social/domain/repositories/ISocialGraphRepository';
+import type { ImageServicePort } from '@gridpilot/media';
 
 import { InMemoryDriverRepository } from '@gridpilot/racing/infrastructure/repositories/InMemoryDriverRepository';
 import { InMemoryLeagueRepository } from '@gridpilot/racing/infrastructure/repositories/InMemoryLeagueRepository';
 import { InMemoryRaceRepository } from '@gridpilot/racing/infrastructure/repositories/InMemoryRaceRepository';
 import { InMemoryResultRepository } from '@gridpilot/racing/infrastructure/repositories/InMemoryResultRepository';
 import { InMemoryStandingRepository } from '@gridpilot/racing/infrastructure/repositories/InMemoryStandingRepository';
+import { InMemoryPenaltyRepository } from '@gridpilot/racing/infrastructure/repositories/InMemoryPenaltyRepository';
+import { InMemoryTeamRepository } from '@gridpilot/racing/infrastructure/repositories/InMemoryTeamRepository';
+import { InMemoryTeamMembershipRepository } from '@gridpilot/racing/infrastructure/repositories/InMemoryTeamMembershipRepository';
+import { InMemoryRaceRegistrationRepository } from '@gridpilot/racing/infrastructure/repositories/InMemoryRaceRegistrationRepository';
+import { InMemoryLeagueMembershipRepository } from '@gridpilot/racing/infrastructure/repositories/InMemoryLeagueMembershipRepository';
+import {
+  JoinLeagueUseCase,
+  RegisterForRaceUseCase,
+  WithdrawFromRaceUseCase,
+  IsDriverRegisteredForRaceQuery,
+  GetRaceRegistrationsQuery,
+  CreateTeamUseCase,
+  JoinTeamUseCase,
+  LeaveTeamUseCase,
+  ApproveTeamJoinRequestUseCase,
+  RejectTeamJoinRequestUseCase,
+  UpdateTeamUseCase,
+  GetAllTeamsQuery,
+  GetTeamDetailsQuery,
+  GetTeamMembersQuery,
+  GetTeamJoinRequestsQuery,
+  GetDriverTeamQuery,
+  GetLeagueStandingsQuery,
+  GetLeagueDriverSeasonStatsQuery,
+  GetAllLeaguesWithCapacityQuery,
+} from '@gridpilot/racing/application';
 import { createStaticRacingSeed, type RacingSeedData } from '@gridpilot/testing-support';
 import {
   InMemoryFeedRepository,
   InMemorySocialGraphRepository,
 } from '@gridpilot/social/infrastructure/inmemory/InMemorySocialAndFeed';
+import { DemoImageServiceAdapter } from '@gridpilot/demo-infrastructure';
 
 /**
  * Seed data for development
@@ -97,12 +133,41 @@ class DIContainer {
   private _raceRepository: IRaceRepository;
   private _resultRepository: IResultRepository;
   private _standingRepository: IStandingRepository;
+  private _penaltyRepository: IPenaltyRepository;
+  private _teamRepository: ITeamRepository;
+  private _teamMembershipRepository: ITeamMembershipRepository;
+  private _raceRegistrationRepository: IRaceRegistrationRepository;
+  private _leagueMembershipRepository: ILeagueMembershipRepository;
   private _feedRepository: IFeedRepository;
   private _socialRepository: ISocialGraphRepository;
+  private _imageService: ImageServicePort;
+
+  // Racing application use-cases / queries
+  private _joinLeagueUseCase: JoinLeagueUseCase;
+  private _registerForRaceUseCase: RegisterForRaceUseCase;
+  private _withdrawFromRaceUseCase: WithdrawFromRaceUseCase;
+  private _isDriverRegisteredForRaceQuery: IsDriverRegisteredForRaceQuery;
+  private _getRaceRegistrationsQuery: GetRaceRegistrationsQuery;
+  private _getLeagueStandingsQuery: GetLeagueStandingsQuery;
+  private _getLeagueDriverSeasonStatsQuery: GetLeagueDriverSeasonStatsQuery;
+  private _getAllLeaguesWithCapacityQuery: GetAllLeaguesWithCapacityQuery;
+
+  private _createTeamUseCase: CreateTeamUseCase;
+  private _joinTeamUseCase: JoinTeamUseCase;
+  private _leaveTeamUseCase: LeaveTeamUseCase;
+  private _approveTeamJoinRequestUseCase: ApproveTeamJoinRequestUseCase;
+  private _rejectTeamJoinRequestUseCase: RejectTeamJoinRequestUseCase;
+  private _updateTeamUseCase: UpdateTeamUseCase;
+  private _getAllTeamsQuery: GetAllTeamsQuery;
+  private _getTeamDetailsQuery: GetTeamDetailsQuery;
+  private _getTeamMembersQuery: GetTeamMembersQuery;
+  private _getTeamJoinRequestsQuery: GetTeamJoinRequestsQuery;
+  private _getDriverTeamQuery: GetDriverTeamQuery;
 
   private constructor() {
     // Create seed data
     const seedData = createSeedData();
+    const primaryDriverId = seedData.drivers[0]?.id ?? 'driver-1';
 
     // Initialize repositories with seed data
     this._driverRepository = new InMemoryDriverRepository(seedData.drivers);
@@ -123,9 +188,228 @@ class DIContainer {
       this._leagueRepository
     );
 
+    // Race registrations (start empty; populated via use-cases)
+    this._raceRegistrationRepository = new InMemoryRaceRegistrationRepository();
+
+    // Penalties (seeded in-memory adapter)
+    this._penaltyRepository = new InMemoryPenaltyRepository();
+
+    // League memberships seeded from static memberships with guaranteed owner roles
+    const seededMemberships: LeagueMembership[] = seedData.memberships.map((m) => ({
+      leagueId: m.leagueId,
+      driverId: m.driverId,
+      role: 'member',
+      status: 'active',
+      joinedAt: new Date(),
+    }));
+
+    // Ensure each league owner has an owner membership
+    for (const league of seedData.leagues) {
+      const existing = seededMemberships.find(
+        (m) => m.leagueId === league.id && m.driverId === league.ownerId,
+      );
+      if (!existing) {
+        seededMemberships.push({
+          leagueId: league.id,
+          driverId: league.ownerId,
+          role: 'owner',
+          status: 'active',
+          joinedAt: new Date(),
+        });
+      } else {
+        existing.role = 'owner';
+      }
+    }
+
+    // Ensure the primary demo driver owns at least one league in memberships
+    const hasPrimaryOwnerMembership = seededMemberships.some(
+      (m: LeagueMembership) => m.driverId === primaryDriverId && m.role === 'owner',
+    );
+    if (!hasPrimaryOwnerMembership && seedData.leagues.length > 0) {
+      const targetLeague =
+        seedData.leagues.find((l) => l.ownerId === primaryDriverId) ??
+        seedData.leagues[0];
+
+      const existingForPrimary = seededMemberships.find(
+        (m) => m.leagueId === targetLeague.id && m.driverId === primaryDriverId,
+      );
+
+      if (existingForPrimary) {
+        existingForPrimary.role = 'owner';
+      } else {
+        seededMemberships.push({
+          leagueId: targetLeague.id,
+          driverId: primaryDriverId,
+          role: 'owner',
+          status: 'active',
+          joinedAt: new Date(),
+        });
+      }
+    }
+
+    // Seed sample league admins for the primary driver's league (alpha demo)
+    const primaryLeagueForAdmins =
+      seedData.leagues.find((l) => l.ownerId === primaryDriverId) ??
+      seedData.leagues[0];
+
+    if (primaryLeagueForAdmins) {
+      const adminCandidates = seedData.drivers
+        .filter((d) => d.id !== primaryLeagueForAdmins.ownerId)
+        .slice(0, 2);
+
+      adminCandidates.forEach((driver) => {
+        const existing = seededMemberships.find(
+          (m) =>
+            m.leagueId === primaryLeagueForAdmins.id && m.driverId === driver.id,
+        );
+        if (existing) {
+          if (existing.role !== 'owner') {
+            existing.role = 'admin';
+          }
+        } else {
+          seededMemberships.push({
+            leagueId: primaryLeagueForAdmins.id,
+            driverId: driver.id,
+            role: 'admin',
+            status: 'active',
+            joinedAt: new Date(),
+          });
+        }
+      });
+    }
+
+    // Seed a few pending join requests for demo leagues
+    const seededJoinRequests: JoinRequest[] = [];
+    const demoLeagues = seedData.leagues.slice(0, 2);
+    const extraDrivers = seedData.drivers.slice(3, 8);
+
+    demoLeagues.forEach((league) => {
+      extraDrivers.forEach((driver, index) => {
+        seededJoinRequests.push({
+          id: `join-${league.id}-${driver.id}`,
+          leagueId: league.id,
+          driverId: driver.id,
+          requestedAt: new Date(Date.now() - (index + 1) * 24 * 60 * 60 * 1000),
+          message:
+            index % 2 === 0
+              ? 'Would love to race in this series!'
+              : 'Looking to join for the upcoming season.',
+        });
+      });
+    });
+
+    this._leagueMembershipRepository = new InMemoryLeagueMembershipRepository(
+      seededMemberships,
+      seededJoinRequests,
+    );
+
+    // Team repositories seeded from static memberships/teams
+    this._teamRepository = new InMemoryTeamRepository(
+      seedData.teams.map((t) => ({
+        id: t.id,
+        name: t.name,
+        tag: t.tag,
+        description: t.description,
+        ownerId: seedData.drivers[0]?.id ?? 'driver-1',
+        leagues: [t.primaryLeagueId],
+        createdAt: new Date(),
+      })),
+    );
+
+    this._teamMembershipRepository = new InMemoryTeamMembershipRepository(
+      seedData.memberships
+        .filter((m) => m.teamId)
+        .map((m) => ({
+          teamId: m.teamId!,
+          driverId: m.driverId,
+          role: 'driver',
+          status: 'active',
+          joinedAt: new Date(),
+        })),
+    );
+
+    // Application-layer use-cases and queries wired with repositories
+    this._joinLeagueUseCase = new JoinLeagueUseCase(this._leagueMembershipRepository);
+    this._registerForRaceUseCase = new RegisterForRaceUseCase(
+      this._raceRegistrationRepository,
+      this._leagueMembershipRepository,
+    );
+    this._withdrawFromRaceUseCase = new WithdrawFromRaceUseCase(
+      this._raceRegistrationRepository,
+    );
+    this._isDriverRegisteredForRaceQuery = new IsDriverRegisteredForRaceQuery(
+      this._raceRegistrationRepository,
+    );
+    this._getRaceRegistrationsQuery = new GetRaceRegistrationsQuery(
+      this._raceRegistrationRepository,
+    );
+    this._getLeagueStandingsQuery = new GetLeagueStandingsQuery(this._standingRepository);
+
+    this._getLeagueDriverSeasonStatsQuery = new GetLeagueDriverSeasonStatsQuery(
+      this._standingRepository,
+      this._resultRepository,
+      this._penaltyRepository,
+      {
+        getRating: (driverId: string) => {
+          const stats = driverStats[driverId];
+          if (!stats) {
+            return { rating: null, ratingChange: null };
+          }
+          // For alpha we expose current rating and a mock delta
+          const baseline = 1500;
+          const delta = stats.rating - baseline;
+          return {
+            rating: stats.rating,
+            ratingChange: delta !== 0 ? delta : null,
+          };
+        },
+      },
+    );
+
+    this._getAllLeaguesWithCapacityQuery = new GetAllLeaguesWithCapacityQuery(
+      this._leagueRepository,
+      this._leagueMembershipRepository,
+    );
+
+    this._createTeamUseCase = new CreateTeamUseCase(
+      this._teamRepository,
+      this._teamMembershipRepository,
+    );
+    this._joinTeamUseCase = new JoinTeamUseCase(
+      this._teamRepository,
+      this._teamMembershipRepository,
+    );
+    this._leaveTeamUseCase = new LeaveTeamUseCase(this._teamMembershipRepository);
+    this._approveTeamJoinRequestUseCase = new ApproveTeamJoinRequestUseCase(
+      this._teamMembershipRepository,
+    );
+    this._rejectTeamJoinRequestUseCase = new RejectTeamJoinRequestUseCase(
+      this._teamMembershipRepository,
+    );
+    this._updateTeamUseCase = new UpdateTeamUseCase(
+      this._teamRepository,
+      this._teamMembershipRepository,
+    );
+    this._getAllTeamsQuery = new GetAllTeamsQuery(this._teamRepository);
+    this._getTeamDetailsQuery = new GetTeamDetailsQuery(
+      this._teamRepository,
+      this._teamMembershipRepository,
+    );
+    this._getTeamMembersQuery = new GetTeamMembersQuery(this._teamMembershipRepository);
+    this._getTeamJoinRequestsQuery = new GetTeamJoinRequestsQuery(
+      this._teamMembershipRepository,
+    );
+    this._getDriverTeamQuery = new GetDriverTeamQuery(
+      this._teamRepository,
+      this._teamMembershipRepository,
+    );
+
     // Social and feed adapters backed by static seed
     this._feedRepository = new InMemoryFeedRepository(seedData);
     this._socialRepository = new InMemorySocialGraphRepository(seedData);
+
+    // Image service backed by demo adapter
+    this._imageService = new DemoImageServiceAdapter();
   }
 
   /**
@@ -168,6 +452,102 @@ class DIContainer {
     return this._standingRepository;
   }
 
+  get penaltyRepository(): IPenaltyRepository {
+    return this._penaltyRepository;
+  }
+
+  get raceRegistrationRepository(): IRaceRegistrationRepository {
+    return this._raceRegistrationRepository;
+  }
+
+  get leagueMembershipRepository(): ILeagueMembershipRepository {
+    return this._leagueMembershipRepository;
+  }
+
+  get joinLeagueUseCase(): JoinLeagueUseCase {
+    return this._joinLeagueUseCase;
+  }
+
+  get registerForRaceUseCase(): RegisterForRaceUseCase {
+    return this._registerForRaceUseCase;
+  }
+
+  get withdrawFromRaceUseCase(): WithdrawFromRaceUseCase {
+    return this._withdrawFromRaceUseCase;
+  }
+
+  get isDriverRegisteredForRaceQuery(): IsDriverRegisteredForRaceQuery {
+    return this._isDriverRegisteredForRaceQuery;
+  }
+
+  get getRaceRegistrationsQuery(): GetRaceRegistrationsQuery {
+    return this._getRaceRegistrationsQuery;
+  }
+
+  get getLeagueStandingsQuery(): GetLeagueStandingsQuery {
+    return this._getLeagueStandingsQuery;
+  }
+
+  get getLeagueDriverSeasonStatsQuery(): GetLeagueDriverSeasonStatsQuery {
+    return this._getLeagueDriverSeasonStatsQuery;
+  }
+
+  get getAllLeaguesWithCapacityQuery(): GetAllLeaguesWithCapacityQuery {
+    return this._getAllLeaguesWithCapacityQuery;
+  }
+
+  get createTeamUseCase(): CreateTeamUseCase {
+    return this._createTeamUseCase;
+  }
+
+  get joinTeamUseCase(): JoinTeamUseCase {
+    return this._joinTeamUseCase;
+  }
+
+  get leaveTeamUseCase(): LeaveTeamUseCase {
+    return this._leaveTeamUseCase;
+  }
+
+  get approveTeamJoinRequestUseCase(): ApproveTeamJoinRequestUseCase {
+    return this._approveTeamJoinRequestUseCase;
+  }
+
+  get rejectTeamJoinRequestUseCase(): RejectTeamJoinRequestUseCase {
+    return this._rejectTeamJoinRequestUseCase;
+  }
+
+  get updateTeamUseCase(): UpdateTeamUseCase {
+    return this._updateTeamUseCase;
+  }
+
+  get getAllTeamsQuery(): GetAllTeamsQuery {
+    return this._getAllTeamsQuery;
+  }
+
+  get getTeamDetailsQuery(): GetTeamDetailsQuery {
+    return this._getTeamDetailsQuery;
+  }
+
+  get getTeamMembersQuery(): GetTeamMembersQuery {
+    return this._getTeamMembersQuery;
+  }
+
+  get getTeamJoinRequestsQuery(): GetTeamJoinRequestsQuery {
+    return this._getTeamJoinRequestsQuery;
+  }
+
+  get getDriverTeamQuery(): GetDriverTeamQuery {
+    return this._getDriverTeamQuery;
+  }
+
+  get teamRepository(): ITeamRepository {
+    return this._teamRepository;
+  }
+
+  get teamMembershipRepository(): ITeamMembershipRepository {
+    return this._teamMembershipRepository;
+  }
+
   get feedRepository(): IFeedRepository {
     return this._feedRepository;
   }
@@ -175,6 +555,10 @@ class DIContainer {
   get socialRepository(): ISocialGraphRepository {
     return this._socialRepository;
   }
+
+  get imageService(): ImageServicePort {
+    return this._imageService;
+  }
 }
 
 /**
@@ -200,6 +584,102 @@ export function getStandingRepository(): IStandingRepository {
   return DIContainer.getInstance().standingRepository;
 }
 
+export function getPenaltyRepository(): IPenaltyRepository {
+  return DIContainer.getInstance().penaltyRepository;
+}
+
+export function getRaceRegistrationRepository(): IRaceRegistrationRepository {
+  return DIContainer.getInstance().raceRegistrationRepository;
+}
+
+export function getLeagueMembershipRepository(): ILeagueMembershipRepository {
+  return DIContainer.getInstance().leagueMembershipRepository;
+}
+
+export function getJoinLeagueUseCase(): JoinLeagueUseCase {
+  return DIContainer.getInstance().joinLeagueUseCase;
+}
+
+export function getRegisterForRaceUseCase(): RegisterForRaceUseCase {
+  return DIContainer.getInstance().registerForRaceUseCase;
+}
+
+export function getWithdrawFromRaceUseCase(): WithdrawFromRaceUseCase {
+  return DIContainer.getInstance().withdrawFromRaceUseCase;
+}
+
+export function getIsDriverRegisteredForRaceQuery(): IsDriverRegisteredForRaceQuery {
+  return DIContainer.getInstance().isDriverRegisteredForRaceQuery;
+}
+
+export function getGetRaceRegistrationsQuery(): GetRaceRegistrationsQuery {
+  return DIContainer.getInstance().getRaceRegistrationsQuery;
+}
+
+export function getGetLeagueStandingsQuery(): GetLeagueStandingsQuery {
+  return DIContainer.getInstance().getLeagueStandingsQuery;
+}
+
+export function getGetLeagueDriverSeasonStatsQuery(): GetLeagueDriverSeasonStatsQuery {
+  return DIContainer.getInstance().getLeagueDriverSeasonStatsQuery;
+}
+
+export function getGetAllLeaguesWithCapacityQuery(): GetAllLeaguesWithCapacityQuery {
+  return DIContainer.getInstance().getAllLeaguesWithCapacityQuery;
+}
+
+export function getTeamRepository(): ITeamRepository {
+  return DIContainer.getInstance().teamRepository;
+}
+
+export function getTeamMembershipRepository(): ITeamMembershipRepository {
+  return DIContainer.getInstance().teamMembershipRepository;
+}
+
+export function getCreateTeamUseCase(): CreateTeamUseCase {
+  return DIContainer.getInstance().createTeamUseCase;
+}
+
+export function getJoinTeamUseCase(): JoinTeamUseCase {
+  return DIContainer.getInstance().joinTeamUseCase;
+}
+
+export function getLeaveTeamUseCase(): LeaveTeamUseCase {
+  return DIContainer.getInstance().leaveTeamUseCase;
+}
+
+export function getApproveTeamJoinRequestUseCase(): ApproveTeamJoinRequestUseCase {
+  return DIContainer.getInstance().approveTeamJoinRequestUseCase;
+}
+
+export function getRejectTeamJoinRequestUseCase(): RejectTeamJoinRequestUseCase {
+  return DIContainer.getInstance().rejectTeamJoinRequestUseCase;
+}
+
+export function getUpdateTeamUseCase(): UpdateTeamUseCase {
+  return DIContainer.getInstance().updateTeamUseCase;
+}
+
+export function getGetAllTeamsQuery(): GetAllTeamsQuery {
+  return DIContainer.getInstance().getAllTeamsQuery;
+}
+
+export function getGetTeamDetailsQuery(): GetTeamDetailsQuery {
+  return DIContainer.getInstance().getTeamDetailsQuery;
+}
+
+export function getGetTeamMembersQuery(): GetTeamMembersQuery {
+  return DIContainer.getInstance().getTeamMembersQuery;
+}
+
+export function getGetTeamJoinRequestsQuery(): GetTeamJoinRequestsQuery {
+  return DIContainer.getInstance().getTeamJoinRequestsQuery;
+}
+
+export function getGetDriverTeamQuery(): GetDriverTeamQuery {
+  return DIContainer.getInstance().getDriverTeamQuery;
+}
+
 export function getFeedRepository(): IFeedRepository {
   return DIContainer.getInstance().feedRepository;
 }
@@ -208,6 +688,10 @@ export function getSocialRepository(): ISocialGraphRepository {
   return DIContainer.getInstance().socialRepository;
 }
 
+export function getImageService(): ImageServicePort {
+  return DIContainer.getInstance().imageService;
+}
+
 /**
  * Reset function for testing
  */

apps/website/lib/leagueMembership.ts

@@ -0,0 +1,89 @@
+'use client';
+
+import type {
+  LeagueMembership as DomainLeagueMembership,
+  MembershipRole,
+  MembershipStatus,
+} from '@gridpilot/racing/domain/entities/LeagueMembership';
+import { leagues, memberships as seedMemberships } from '@gridpilot/testing-support';
+
+/**
+ * Lightweight league membership model mirroring the domain type but with
+ * a stringified joinedAt for easier UI formatting.
+ */
+export interface LeagueMembership extends Omit<DomainLeagueMembership, 'joinedAt'> {
+  joinedAt: string;
+}
+
+const leagueMemberships = new Map<string, LeagueMembership[]>();
+
+/**
+ * Initialize league memberships once from static seed data.
+ *
+ * - All seeded memberships become active members.
+ * - League owners are guaranteed to have an owner membership.
+ */
+(function initializeLeagueMembershipsFromSeed() {
+  if (leagueMemberships.size > 0) {
+    return;
+  }
+
+  const byLeague = new Map<string, LeagueMembership[]>();
+
+  for (const membership of seedMemberships) {
+    const list = byLeague.get(membership.leagueId) ?? [];
+    const joinedAt = new Date().toISOString();
+
+    list.push({
+      leagueId: membership.leagueId,
+      driverId: membership.driverId,
+      role: 'member',
+      status: 'active',
+      joinedAt,
+    });
+
+    byLeague.set(membership.leagueId, list);
+  }
+
+  for (const league of leagues) {
+    const list = byLeague.get(league.id) ?? [];
+    const existingOwner = list.find((m) => m.driverId === league.ownerId);
+
+    if (existingOwner) {
+      existingOwner.role = 'owner';
+    } else {
+      const joinedAt = new Date().toISOString();
+      list.unshift({
+        leagueId: league.id,
+        driverId: league.ownerId,
+        role: 'owner',
+        status: 'active',
+        joinedAt,
+      });
+    }
+
+    byLeague.set(league.id, list);
+  }
+
+  for (const [leagueId, list] of byLeague.entries()) {
+    leagueMemberships.set(leagueId, list);
+  }
+})();
+
+export function getMembership(leagueId: string, driverId: string): LeagueMembership | null {
+  const list = leagueMemberships.get(leagueId);
+  if (!list) return null;
+  return list.find((m) => m.driverId === driverId) ?? null;
+}
+
+export function getLeagueMembers(leagueId: string): LeagueMembership[] {
+  return [...(leagueMemberships.get(leagueId) ?? [])];
+}
+
+export function isOwnerOrAdmin(leagueId: string, driverId: string): boolean {
+  const membership = getMembership(leagueId, driverId);
+  if (!membership) return false;
+  return membership.role === 'owner' || membership.role === 'admin';
+}
+
+export type { MembershipRole, MembershipStatus };

apps/website/lib/leagueRoles.ts

@@ -1,4 +1,4 @@
-import type { MembershipRole } from '@/lib/racingLegacyFacade';
+import type { MembershipRole } from '@gridpilot/racing/domain/entities/LeagueMembership';
 
 export type LeagueRole = MembershipRole;
 

apps/website/lib/racingLegacyFacade.ts

@@ -1,558 +0,0 @@
-/**
- * Website-local racing façade
- *
- * This module provides synchronous helper functions used by the alpha website
- * without depending on legacy exports from @gridpilot/racing/application.
- * It maintains simple in-memory state for memberships, teams, and registrations.
- */
-
-import type {
-  LeagueMembership as DomainLeagueMembership,
-  MembershipRole,
-  MembershipStatus,
-} from '@gridpilot/racing/domain/entities/LeagueMembership';
-import { getDriverAvatar, getTeamLogo, getLeagueBanner, memberships as seedMemberships, leagues as seedLeagues } from '@gridpilot/testing-support';
-
-export type { MembershipRole, MembershipStatus };
-
-export interface LeagueMembership extends Omit<DomainLeagueMembership, 'joinedAt'> {
-  joinedAt: string;
-}
-
-// Lightweight league join request model for the website
-export interface JoinRequest {
-  id: string;
-  leagueId: string;
-  driverId: string;
-  message?: string;
-  requestedAt: string;
-}
-
-import type {
-  Team,
-  TeamJoinRequest,
-  TeamMembership,
-  TeamRole,
-  TeamMembershipStatus,
-} from '@gridpilot/racing/domain/entities/Team';
-
-export type { Team, TeamJoinRequest, TeamMembership, TeamRole, TeamMembershipStatus };
-
-/**
- * Identity helpers
- *
- * For the alpha website we treat a single demo driver as the "current" user.
- */
-const CURRENT_DRIVER_ID = 'driver-1';
-
-export function getCurrentDriverId(): string {
-  return CURRENT_DRIVER_ID;
-}
-
-/**
- * In-memory stores
- */
-
-const leagueMemberships = new Map<string, LeagueMembership[]>();
-const leagueJoinRequests = new Map<string, JoinRequest[]>();
-
-const teams = new Map<string, Team>();
-const teamMemberships = new Map<string, TeamMembership[]>();
-const teamJoinRequests = new Map<string, TeamJoinRequest[]>();
-
-const raceRegistrations = new Map<string, Set<string>>();
-
-/**
- * Helper utilities
- */
-
-function ensureLeagueMembershipArray(leagueId: string): LeagueMembership[] {
-  let list = leagueMemberships.get(leagueId);
-  if (!list) {
-    list = [];
-    leagueMemberships.set(leagueId, list);
-  }
-  return list;
-}
-
-function ensureTeamMembershipArray(teamId: string): TeamMembership[] {
-  let list = teamMemberships.get(teamId);
-  if (!list) {
-    list = [];
-    teamMemberships.set(teamId, list);
-  }
-  return list;
-}
-
-function ensureRaceRegistrationSet(raceId: string): Set<string> {
-  let set = raceRegistrations.get(raceId);
-  if (!set) {
-    set = new Set<string>();
-    raceRegistrations.set(raceId, set);
-  }
-  return set;
-}
-
-let idCounter = 1;
-function generateId(prefix: string): string {
-  return `${prefix}-${idCounter++}`;
-}
-
-// Initialize league memberships from static seed data
-(function initializeLeagueMembershipsFromSeed() {
-  if (leagueMemberships.size > 0) {
-    return;
-  }
-
-  const membershipsByLeague = new Map<string, LeagueMembership[]>();
-
-  // Create base active memberships from seed
-  for (const membership of seedMemberships) {
-    const list = membershipsByLeague.get(membership.leagueId) ?? [];
-    const joinedAt = new Date(2024, 0, 1 + (idCounter % 28)).toISOString();
-
-    list.push({
-      leagueId: membership.leagueId,
-      driverId: membership.driverId,
-      role: 'member',
-      status: 'active',
-      joinedAt,
-    });
-
-    membershipsByLeague.set(membership.leagueId, list);
-  }
-
-  // Ensure league owners are represented as owners in memberships
-  for (const league of seedLeagues) {
-    const list = membershipsByLeague.get(league.id) ?? [];
-    const existingOwnerMembership = list.find((m) => m.driverId === league.ownerId);
-
-    if (existingOwnerMembership) {
-      existingOwnerMembership.role = 'owner';
-    } else {
-      const joinedAt = new Date(2024, 0, 1 + (idCounter % 28)).toISOString();
-      list.unshift({
-        leagueId: league.id,
-        driverId: league.ownerId,
-        role: 'owner',
-        status: 'active',
-        joinedAt,
-      });
-    }
-
-    membershipsByLeague.set(league.id, list);
-  }
-
-  // Store into facade-local maps
-  for (const [leagueId, list] of membershipsByLeague.entries()) {
-    leagueMemberships.set(leagueId, list);
-  }
-})();
-
-export function getDriverAvatarUrl(driverId: string): string {
-  return getDriverAvatar(driverId);
-}
-
-export function getTeamLogoUrl(teamId: string): string {
-  return getTeamLogo(teamId);
-}
-
-export function getLeagueBannerUrl(leagueId: string): string {
-  return getLeagueBanner(leagueId);
-}
-
-/**
- * League membership API
- */
-
-export function getMembership(leagueId: string, driverId: string): LeagueMembership | null {
-  const list = leagueMemberships.get(leagueId);
-  if (!list) return null;
-  return list.find((m) => m.driverId === driverId) ?? null;
-}
-
-export function getLeagueMembers(leagueId: string): LeagueMembership[] {
-  return [...(leagueMemberships.get(leagueId) ?? [])];
-}
-
-export function joinLeague(leagueId: string, driverId: string): void {
-  const existing = getMembership(leagueId, driverId);
-  if (existing && existing.status === 'active') {
-    throw new Error('Already a member of this league');
-  }
-
-  const list = ensureLeagueMembershipArray(leagueId);
-  const now = new Date();
-
-  if (existing) {
-    existing.status = 'active';
-    existing.joinedAt = now.toISOString();
-    return;
-  }
-
-  list.push({
-    leagueId,
-    driverId,
-    role: list.length === 0 ? 'owner' : 'member',
-    status: 'active',
-    joinedAt: now.toISOString(),
-  });
-}
-
-export function leaveLeague(leagueId: string, driverId: string): void {
-  const list = ensureLeagueMembershipArray(leagueId);
-  const membership = list.find((m) => m.driverId === driverId);
-  if (!membership) {
-    throw new Error('Not a member of this league');
-  }
-  if (membership.role === 'owner') {
-    throw new Error('League owner cannot leave the league');
-  }
-  const idx = list.indexOf(membership);
-  if (idx >= 0) {
-    list.splice(idx, 1);
-  }
-}
-
-export function requestToJoin(leagueId: string, driverId: string): void {
-  const existing = getMembership(leagueId, driverId);
-  if (existing && existing.status === 'active') {
-    throw new Error('Already a member of this league');
-  }
-
-  const requests = leagueJoinRequests.get(leagueId) ?? [];
-  const now = new Date().toISOString();
-  const request: JoinRequest = {
-    id: generateId('league-request'),
-    leagueId,
-    driverId,
-    requestedAt: now,
-  };
-  requests.push(request);
-  leagueJoinRequests.set(leagueId, requests);
-}
-
-export function isOwnerOrAdmin(leagueId: string, driverId: string): boolean {
-  const membership = getMembership(leagueId, driverId);
-  if (!membership) return false;
-  return membership.role === 'owner' || membership.role === 'admin';
-}
-
-/**
- * League admin API (join requests and membership management)
- */
-
-export function getJoinRequests(leagueId: string): JoinRequest[] {
-  return [...(leagueJoinRequests.get(leagueId) ?? [])];
-}
-
-export function approveJoinRequest(requestId: string): void {
-  for (const [leagueId, requests] of leagueJoinRequests.entries()) {
-    const idx = requests.findIndex((r) => r.id === requestId);
-    if (idx >= 0) {
-      const request = requests[idx];
-      requests.splice(idx, 1);
-      leagueJoinRequests.set(leagueId, requests);
-      joinLeague(leagueId, request.driverId);
-      return;
-    }
-  }
-  throw new Error('Join request not found');
-}
-
-export function rejectJoinRequest(requestId: string): void {
-  for (const [leagueId, requests] of leagueJoinRequests.entries()) {
-    const idx = requests.findIndex((r) => r.id === requestId);
-    if (idx >= 0) {
-      requests.splice(idx, 1);
-      leagueJoinRequests.set(leagueId, requests);
-      return;
-    }
-  }
-  throw new Error('Join request not found');
-}
-
-export function removeMember(leagueId: string, driverId: string, performedBy: string): void {
-  const performer = getMembership(leagueId, performedBy);
-  if (!performer || (performer.role !== 'owner' && performer.role !== 'admin')) {
-    throw new Error('Only owners or admins can remove members');
-  }
-
-  const list = ensureLeagueMembershipArray(leagueId);
-  const membership = list.find((m) => m.driverId === driverId);
-  if (!membership) {
-    throw new Error('Member not found');
-  }
-  if (membership.role === 'owner') {
-    throw new Error('Cannot remove the league owner');
-  }
-  const idx = list.indexOf(membership);
-  if (idx >= 0) {
-    list.splice(idx, 1);
-  }
-}
-
-export function updateMemberRole(
-  leagueId: string,
-  driverId: string,
-  newRole: MembershipRole,
-  performedBy: string,
-): void {
-  const performer = getMembership(leagueId, performedBy);
-  if (!performer || performer.role !== 'owner') {
-    throw new Error('Only the league owner can update roles');
-  }
-
-  const list = ensureLeagueMembershipArray(leagueId);
-  const membership = list.find((m) => m.driverId === driverId);
-  if (!membership) {
-    throw new Error('Member not found');
-  }
-  if (membership.role === 'owner') {
-    throw new Error('Cannot change the owner role');
-  }
-  membership.role = newRole;
-}
-
-/**
- * Team API
- */
-
-export function createTeam(initial: Pick<Team, 'name' | 'tag' | 'description' | 'leagues'>): Team {
-  const id = generateId('team');
-  const now = new Date();
-  const team: Team = {
-    id,
-    name: initial.name,
-    tag: initial.tag,
-    description: initial.description,
-    leagues: initial.leagues,
-    ownerId: CURRENT_DRIVER_ID,
-    createdAt: now,
-  };
-  teams.set(id, team);
-
-  const members = ensureTeamMembershipArray(id);
-  members.push({
-    teamId: id,
-    driverId: CURRENT_DRIVER_ID,
-    role: 'owner',
-    status: 'active',
-    joinedAt: now,
-  });
-
-  return team;
-}
-
-export function getAllTeams(): Team[] {
-  return [...teams.values()];
-}
-
-export function getTeam(teamId: string): Team | null {
-  return teams.get(teamId) ?? null;
-}
-
-export function updateTeam(teamId: string, updates: Partial<Pick<Team, 'name' | 'tag' | 'description' | 'leagues'>>, updatedBy: string): void {
-  const team = teams.get(teamId);
-  if (!team) {
-    throw new Error('Team not found');
-  }
-  const membership = getTeamMembership(teamId, updatedBy);
-  if (!membership || (membership.role !== 'owner' && membership.role !== 'manager')) {
-    throw new Error('Only owners or managers can update team');
-  }
-
-  teams.set(teamId, {
-    ...team,
-    ...updates,
-  });
-}
-
-export function getTeamMembers(teamId: string): TeamMembership[] {
-  return [...(teamMemberships.get(teamId) ?? [])];
-}
-
-export function getTeamMembership(teamId: string, driverId: string): TeamMembership | null {
-  const list = teamMemberships.get(teamId);
-  if (!list) return null;
-  return list.find((m) => m.driverId === driverId) ?? null;
-}
-
-export function getDriverTeam(driverId: string): { team: Team; membership: TeamMembership } | null {
-  for (const [teamId, memberships] of teamMemberships.entries()) {
-    const membership = memberships.find((m) => m.driverId === driverId && m.status === 'active');
-    if (membership) {
-      const team = teams.get(teamId);
-      if (team) {
-        return { team, membership };
-      }
-    }
-  }
-  return null;
-}
-
-export function isTeamOwnerOrManager(teamId: string, driverId: string): boolean {
-  const membership = getTeamMembership(teamId, driverId);
-  if (!membership) return false;
-  return membership.role === 'owner' || membership.role === 'manager';
-}
-
-export function joinTeam(teamId: string, driverId: string): void {
-  const team = teams.get(teamId);
-  if (!team) {
-    throw new Error('Team not found');
-  }
-  const existing = getTeamMembership(teamId, driverId);
-  if (existing && existing.status === 'active') {
-    throw new Error('Already a member of this team');
-  }
-
-  const list = ensureTeamMembershipArray(teamId);
-  const now = new Date();
-
-  if (existing) {
-    existing.status = 'active';
-    existing.joinedAt = now;
-    return;
-  }
-
-  list.push({
-    teamId,
-    driverId,
-    role: list.length === 0 ? 'owner' : 'driver',
-    status: 'active',
-    joinedAt: now,
-  });
-}
-
-export function leaveTeam(teamId: string, driverId: string): void {
-  const list = ensureTeamMembershipArray(teamId);
-  const membership = list.find((m) => m.driverId === driverId);
-  if (!membership) {
-    throw new Error('Not a member of this team');
-  }
-  if (membership.role === 'owner') {
-    throw new Error('Team owner cannot leave the team');
-  }
-  const idx = list.indexOf(membership);
-  if (idx >= 0) {
-    list.splice(idx, 1);
-  }
-}
-
-export function requestToJoinTeam(teamId: string, driverId: string, message?: string): void {
-  const existing = getTeamMembership(teamId, driverId);
-  if (existing && existing.status === 'active') {
-    throw new Error('Already a member of this team');
-  }
-
-  const requests = teamJoinRequests.get(teamId) ?? [];
-  const now = new Date();
-  const request: TeamJoinRequest = {
-    id: generateId('team-request'),
-    teamId,
-    driverId,
-    message,
-    requestedAt: now,
-  };
-  requests.push(request);
-  teamJoinRequests.set(teamId, requests);
-}
-
-export function getTeamJoinRequests(teamId: string): TeamJoinRequest[] {
-  return [...(teamJoinRequests.get(teamId) ?? [])];
-}
-
-export function approveTeamJoinRequest(requestId: string): void {
-  for (const [teamId, requests] of teamJoinRequests.entries()) {
-    const idx = requests.findIndex((r) => r.id === requestId);
-    if (idx >= 0) {
-      const request = requests[idx];
-      requests.splice(idx, 1);
-      teamJoinRequests.set(teamId, requests);
-      joinTeam(teamId, request.driverId);
-      return;
-    }
-  }
-  throw new Error('Join request not found');
-}
-
-export function rejectTeamJoinRequest(requestId: string): void {
-  for (const [teamId, requests] of teamJoinRequests.entries()) {
-    const idx = requests.findIndex((r) => r.id === requestId);
-    if (idx >= 0) {
-      requests.splice(idx, 1);
-      teamJoinRequests.set(teamId, requests);
-      return;
-    }
-  }
-  throw new Error('Join request not found');
-}
-
-export function removeTeamMember(teamId: string, driverId: string, performedBy: string): void {
-  const performerMembership = getTeamMembership(teamId, performedBy);
-  if (!performerMembership || (performerMembership.role !== 'owner' && performerMembership.role !== 'manager')) {
-    throw new Error('Only owners or managers can remove members');
-  }
-
-  const list = ensureTeamMembershipArray(teamId);
-  const membership = list.find((m) => m.driverId === driverId);
-  if (!membership) {
-    throw new Error('Member not found');
-  }
-  if (membership.role === 'owner') {
-    throw new Error('Cannot remove the team owner');
-  }
-  const idx = list.indexOf(membership);
-  if (idx >= 0) {
-    list.splice(idx, 1);
-  }
-}
-
-export function updateTeamMemberRole(teamId: string, driverId: string, newRole: TeamRole, performedBy: string): void {
-  const performerMembership = getTeamMembership(teamId, performedBy);
-  if (!performerMembership || (performerMembership.role !== 'owner' && performerMembership.role !== 'manager')) {
-    throw new Error('Only owners or managers can update roles');
-  }
-
-  const membership = getTeamMembership(teamId, driverId);
-  if (!membership) {
-    throw new Error('Member not found');
-  }
-  if (membership.role === 'owner') {
-    throw new Error('Cannot change the owner role');
-  }
-  membership.role = newRole;
-}
-
-/**
- * Race registration API
- */
-
-export function isRegistered(raceId: string, driverId: string): boolean {
-  const set = raceRegistrations.get(raceId);
-  if (!set) return false;
-  return set.has(driverId);
-}
-
-export function registerForRace(raceId: string, driverId: string, _leagueId: string): void {
-  const set = ensureRaceRegistrationSet(raceId);
-  if (set.has(driverId)) {
-    throw new Error('Already registered for this race');
-  }
-  set.add(driverId);
-}
-
-export function withdrawFromRace(raceId: string, driverId: string): void {
-  const set = raceRegistrations.get(raceId);
-  if (!set || !set.has(driverId)) {
-    throw new Error('Not registered for this race');
-  }
-  set.delete(driverId);
-}
-
-export function getRegisteredDrivers(raceId: string): string[] {
-  const set = raceRegistrations.get(raceId);
-  if (!set) return [];
-  return [...set.values()];
-}