fix logger

adapters/analytics/persistence/inmemory/InMemoryAnalyticsSnapshotRepository.ts

@@ -6,13 +6,13 @@
 
 import type { IAnalyticsSnapshotRepository } from '../../domain/repositories/IAnalyticsSnapshotRepository';
 import { AnalyticsSnapshot, type SnapshotPeriod, type SnapshotEntityType } from '../../domain/entities/AnalyticsSnapshot';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import { Logger } from '@gridpilot/core/shared/application';
 
 export class InMemoryAnalyticsSnapshotRepository implements IAnalyticsSnapshotRepository {
   private snapshots: Map<string, AnalyticsSnapshot> = new Map();
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger) {
+  constructor(logger: Logger) {
     this.logger = logger;
     this.logger.info('InMemoryAnalyticsSnapshotRepository initialized.');
   }

adapters/analytics/persistence/inmemory/InMemoryEngagementRepository.ts

@@ -6,13 +6,14 @@
 
 import type { IEngagementRepository } from '../../domain/repositories/IEngagementRepository';
 import { EngagementEvent, type EngagementAction, type EngagementEntityType } from '../../domain/entities/EngagementEvent';
-import { ILogger } from '@gridpilot/shared/logging/ILogger';
+import { Logger } from '@gridpilot/core/shared/application';
+
 
 export class InMemoryEngagementRepository implements IEngagementRepository {
   private events: Map<string, EngagementEvent> = new Map();
-  private logger: ILogger;
+  private logger: Logger;
 
-  constructor(logger: ILogger) {
+  constructor(logger: Logger) {
     this.logger = logger;
     this.logger.info('InMemoryEngagementRepository initialized.');
   }

adapters/analytics/persistence/inmemory/InMemoryPageViewRepository.ts

@@ -6,13 +6,13 @@
 
 import type { IPageViewRepository } from '../../domain/repositories/IPageViewRepository';
 import { PageView, type EntityType } from '../../domain/entities/PageView';
-import { ILogger } from '@gridpilot/shared/logging/ILogger';
+import { Logger } from '@gridpilot/core/shared/application';
 
 export class InMemoryPageViewRepository implements IPageViewRepository {
   private pageViews: Map<string, PageView> = new Map();
-  private logger: ILogger;
+  private logger: Logger;
 
-  constructor(logger: ILogger) {
+  constructor(logger: Logger) {
     this.logger = logger;
     this.logger.info('InMemoryPageViewRepository initialized.');
   }

adapters/identity/persistence/inmemory/InMemoryAchievementRepository.ts

@@ -4,6 +4,7 @@
  * In-memory implementation of IAchievementRepository
  */
 
+import { Logger } from '@gridpilot/core/shared/application';
 import { 
   Achievement, 
   AchievementCategory,
@@ -14,14 +15,13 @@ import {
 } from '../../domain/entities/Achievement';
 import { UserAchievement } from '../../domain/entities/UserAchievement';
 import type { IAchievementRepository } from '../../domain/repositories/IAchievementRepository';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
 
 export class InMemoryAchievementRepository implements IAchievementRepository {
   private achievements: Map<string, Achievement> = new Map();
   private userAchievements: Map<string, UserAchievement> = new Map();
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger) {
+  constructor(logger: Logger) {
     this.logger = logger;
     this.logger.info('InMemoryAchievementRepository initialized.');
     // Seed with predefined achievements

adapters/identity/persistence/inmemory/InMemoryAuthRepository.ts

@@ -2,15 +2,16 @@ import { IAuthRepository } from '@gridpilot/core/identity/domain/repositories/IA
 import { IUserRepository, StoredUser } from '@gridpilot/core/identity/domain/repositories/IUserRepository';
 import { IPasswordHashingService } from '@gridpilot/core/identity/domain/services/PasswordHashingService';
 import { User } from '@gridpilot/core/identity/domain/entities/User';
-import { ILogger } from '@gridpilot/shared/logging/ILogger';
+
 import { EmailAddress } from '@gridpilot/core/identity/domain/value-objects/EmailAddress';
 import { randomUUID } from 'crypto';
+import { Logger } from '@gridpilot/core/shared/application';
 
 export class InMemoryAuthRepository implements IAuthRepository {
   constructor(
     private readonly userRepository: IUserRepository,
     private readonly passwordHashingService: IPasswordHashingService,
-    private readonly logger: ILogger,
+    private readonly logger: Logger,
   ) {}
 
   async findByEmail(email: EmailAddress): Promise<User | null> {

adapters/identity/persistence/inmemory/InMemorySponsorAccountRepository.ts

@@ -7,13 +7,13 @@
 import type { ISponsorAccountRepository } from '../../domain/repositories/ISponsorAccountRepository';
 import type { SponsorAccount } from '../../domain/entities/SponsorAccount';
 import type { UserId } from '../../domain/value-objects/UserId';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import { Logger } from '@gridpilot/core/shared/application';
 
 export class InMemorySponsorAccountRepository implements ISponsorAccountRepository {
   private accounts: Map<string, SponsorAccount> = new Map();
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, seedData?: SponsorAccount[]) {
+  constructor(logger: Logger, seedData?: SponsorAccount[]) {
     this.logger = logger;
     this.logger.info('InMemorySponsorAccountRepository initialized.');
     if (seedData) {

adapters/identity/persistence/inmemory/InMemoryUserRatingRepository.ts

@@ -6,13 +6,13 @@
 
 import { UserRating } from '../../domain/value-objects/UserRating';
 import type { IUserRatingRepository } from '../../domain/repositories/IUserRatingRepository';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import { Logger } from '@gridpilot/core/shared/application';
 
 export class InMemoryUserRatingRepository implements IUserRatingRepository {
   private ratings: Map<string, UserRating> = new Map();
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, seedData?: UserRating[]) {
+  constructor(logger: Logger, seedData?: UserRating[]) {
     this.logger = logger;
     this.logger.info('InMemoryUserRatingRepository initialized.');
     if (seedData) {

adapters/identity/persistence/inmemory/InMemoryUserRepository.ts

@@ -4,15 +4,15 @@
  * Stores users in memory for demo/development purposes.
  */
 
+import { Logger } from '@gridpilot/core/shared/application';
 import type { IUserRepository, StoredUser } from '../../domain/repositories/IUserRepository';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
 
 export class InMemoryUserRepository implements IUserRepository {
   private users: Map<string, StoredUser> = new Map();
   private emailIndex: Map<string, string> = new Map(); // email -> userId
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, initialUsers: StoredUser[] = []) {
+  constructor(logger: Logger, initialUsers: StoredUser[] = []) {
     this.logger = logger;
     this.logger.info('InMemoryUserRepository initialized.');
     for (const user of initialUsers) {

adapters/identity/session/CookieIdentitySessionAdapter.ts

@@ -4,15 +4,15 @@
  * Manages user session using cookies. This is a placeholder implementation.
  */
 
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
 import type { AuthenticatedUserDTO } from '@gridpilot/core/identity/application/dto/AuthenticatedUserDTO';
 import type { AuthSessionDTO } from '@gridpilot/core/identity/application/dto/AuthSessionDTO';
 import type { IdentitySessionPort } from '@gridpilot/core/identity/application/ports/IdentitySessionPort';
+import { Logger } from '@gridpilot/core/shared/application';
 
 export class CookieIdentitySessionAdapter implements IdentitySessionPort {
   private currentSession: AuthSessionDTO | null = null;
 
-  constructor(private readonly logger: ILogger) {
+  constructor(private readonly logger: Logger) {
     this.logger.info('CookieIdentitySessionAdapter initialized.');
     // In a real application, you would load the session from a cookie here
     // For demo, we'll start with no session.

adapters/logging/ConsoleLogger.ts

@@ -1,6 +1,6 @@
-import { ILogger } from './ILogger';
+import { Logger } from "@gridpilot/core/shared/application";
 
-export class ConsoleLogger implements ILogger {
+export class ConsoleLogger implements Logger {
   debug(message: string, ...args: any[]): void {
     console.debug(message, ...args);
   }

adapters/media/persistence/inmemory/InMemoryAvatarGenerationRepository.ts

@@ -1,12 +1,12 @@
 import { IAvatarGenerationRepository } from '@gridpilot/core/media/domain/repositories/IAvatarGenerationRepository';
 import { AvatarGenerationRequest } from '@gridpilot/core/media/domain/entities/AvatarGenerationRequest';
-import { ILogger } from '@gridpilot/shared/logging/ILogger';
+import { Logger } from '@gridpilot/core/shared/application';
 
 export class InMemoryAvatarGenerationRepository implements IAvatarGenerationRepository {
   private requests: Map<string, AvatarGenerationRequest> = new Map(); // Key: requestId
   private userRequests: Map<string, AvatarGenerationRequest[]> = new Map(); // Key: userId
 
-  constructor(private readonly logger: ILogger, initialRequests: AvatarGenerationRequest[] = []) {
+  constructor(private readonly logger: Logger, initialRequests: AvatarGenerationRequest[] = []) {
     this.logger.info('InMemoryAvatarGenerationRepository initialized.');
     for (const req of initialRequests) {
       this.requests.set(req.id, req);

adapters/media/ports/InMemoryFaceValidationAdapter.ts

@@ -1,8 +1,8 @@
 import type { FaceValidationPort, FaceValidationResult } from '@gridpilot/core/media/application/ports/FaceValidationPort';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryFaceValidationAdapter implements FaceValidationPort {
-  constructor(private readonly logger: ILogger) {
+  constructor(private readonly logger: Logger) {
     this.logger.info('InMemoryFaceValidationAdapter initialized.');
   }
 

adapters/media/ports/InMemoryImageServiceAdapter.ts

@@ -1,8 +1,8 @@
 import type { IImageServicePort } from '@gridpilot/racing/application/ports/IImageServicePort';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryImageServiceAdapter implements IImageServicePort {
-  constructor(private readonly logger: ILogger) {
+  constructor(private readonly logger: Logger) {
     this.logger.info('InMemoryImageServiceAdapter initialized.');
   }
 

adapters/notifications/persistence/inmemory/InMemoryNotificationPreferenceRepository.ts

@@ -1,11 +1,11 @@
 import { INotificationPreferenceRepository } from '@gridpilot/core/notifications/domain/repositories/INotificationPreferenceRepository';
 import { NotificationPreference } from '@gridpilot/core/notifications/domain/entities/NotificationPreference';
-import { ILogger } from '@gridpilot/shared/logging/ILogger';
+import { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryNotificationPreferenceRepository implements INotificationPreferenceRepository {
   private preferences: Map<string, NotificationPreference> = new Map();
 
-  constructor(private readonly logger: ILogger, initialPreferences: NotificationPreference[] = []) {
+  constructor(private readonly logger: Logger, initialPreferences: NotificationPreference[] = []) {
     this.logger.info('InMemoryNotificationPreferenceRepository initialized.');
     for (const pref of initialPreferences) {
       this.preferences.set(pref.id, pref);

adapters/notifications/persistence/inmemory/InMemoryNotificationRepository.ts

@@ -7,13 +7,13 @@
 import { Notification } from '../../domain/entities/Notification';
 import type { INotificationRepository } from '../../domain/repositories/INotificationRepository';
 import type { NotificationType } from '../../domain/types/NotificationTypes';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryNotificationRepository implements INotificationRepository {
   private notifications: Map<string, Notification> = new Map();
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, initialNotifications: Notification[] = []) {
+  constructor(logger: Logger, initialNotifications: Notification[] = []) {
     this.logger = logger;
     this.logger.info('InMemoryNotificationRepository initialized.');
     initialNotifications.forEach(notification => {

adapters/racing/persistence/inmemory/InMemoryCarRepository.ts

@@ -8,13 +8,13 @@
 import { v4 as uuidv4 } from 'uuid';
 import { Car, CarClass, CarLicense } from '@gridpilot/racing/domain/entities/Car';
 import type { ICarRepository } from '@gridpilot/racing/domain/repositories/ICarRepository';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryCarRepository implements ICarRepository {
   private cars: Map<string, Car>;
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, seedData?: Car[]) {
+  constructor(logger: Logger, seedData?: Car[]) {
     this.logger = logger;
     this.cars = new Map();
     

adapters/racing/persistence/inmemory/InMemoryDriverRepository.ts

@@ -1,12 +1,12 @@
 import { IDriverRepository } from '@gridpilot/racing/domain/repositories/IDriverRepository';
 import { Driver } from '@gridpilot/racing/domain/entities/Driver';
-import { ILogger } from '@gridpilot/shared/logging/ILogger';
+import { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryDriverRepository implements IDriverRepository {
   private drivers: Map<string, Driver> = new Map();
   private iracingIdIndex: Map<string, string> = new Map(); // iracingId -> driverId
 
-  constructor(private readonly logger: ILogger, initialDrivers: Driver[] = []) {
+  constructor(private readonly logger: Logger, initialDrivers: Driver[] = []) {
     this.logger.info('InMemoryDriverRepository initialized.');
     for (const driver of initialDrivers) {
       this.drivers.set(driver.id, driver);

adapters/racing/persistence/inmemory/InMemoryGameRepository.ts

@@ -1,11 +1,11 @@
 import { IGameRepository } from '@gridpilot/racing/domain/repositories/IGameRepository';
 import { Game } from '@gridpilot/racing/domain/entities/Game';
-import { ILogger } from '@gridpilot/shared/logging/ILogger';
+import { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryGameRepository implements IGameRepository {
   private games: Map<string, Game> = new Map();
 
-  constructor(private readonly logger: ILogger, initialGames: Game[] = []) {
+  constructor(private readonly logger: Logger, initialGames: Game[] = []) {
     this.logger.info('InMemoryGameRepository initialized.');
     for (const game of initialGames) {
       this.games.set(game.id, game);

adapters/racing/persistence/inmemory/InMemoryLeagueMembershipRepository.ts

@@ -1,12 +1,12 @@
 import { ILeagueMembershipRepository } from '@gridpilot/racing/domain/repositories/ILeagueMembershipRepository';
 import { LeagueMembership, JoinRequest } from '@gridpilot/racing/domain/entities/LeagueMembership';
-import { ILogger } from '@gridpilot/shared/logging/ILogger';
+import { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryLeagueMembershipRepository implements ILeagueMembershipRepository {
   private memberships: Map<string, LeagueMembership> = new Map(); // Key: `${leagueId}:${driverId}`
   private joinRequests: Map<string, JoinRequest> = new Map(); // Key: requestId
 
-  constructor(private readonly logger: ILogger, initialMemberships: LeagueMembership[] = [], initialJoinRequests: JoinRequest[] = []) {
+  constructor(private readonly logger: Logger, initialMemberships: LeagueMembership[] = [], initialJoinRequests: JoinRequest[] = []) {
     this.logger.info('InMemoryLeagueMembershipRepository initialized.');
     for (const membership of initialMemberships) {
       this.memberships.set(`${membership.leagueId}:${membership.driverId}`, membership);

adapters/racing/persistence/inmemory/InMemoryLeagueRepository.ts

@@ -1,11 +1,11 @@
 import { ILeagueRepository } from '@gridpilot/core/racing/domain/repositories/ILeagueRepository';
 import { League } from '@gridpilot/core/racing/domain/entities/League';
-import { ILogger } from '@gridpilot/shared/logging/ILogger';
+import { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryLeagueRepository implements ILeagueRepository {
   private leagues: Map<string, League> = new Map();
 
-  constructor(private readonly logger: ILogger, initialLeagues: League[] = []) {
+  constructor(private readonly logger: Logger, initialLeagues: League[] = []) {
     this.logger.info('InMemoryLeagueRepository initialized.');
     for (const league of initialLeagues) {
       this.leagues.set(league.id, league);

adapters/racing/persistence/inmemory/InMemoryLeagueScoringConfigRepository.ts

@@ -1,11 +1,11 @@
 import { ILeagueScoringConfigRepository } from '@gridpilot/racing/domain/repositories/ILeagueScoringConfigRepository';
 import { LeagueScoringConfig } from '@gridpilot/racing/domain/entities/LeagueScoringConfig';
-import { ILogger } from '@gridpilot/shared/logging/ILogger';
+import { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryLeagueScoringConfigRepository implements ILeagueScoringConfigRepository {
   private configs: Map<string, LeagueScoringConfig> = new Map(); // Key: seasonId
 
-  constructor(private readonly logger: ILogger, initialConfigs: LeagueScoringConfig[] = []) {
+  constructor(private readonly logger: Logger, initialConfigs: LeagueScoringConfig[] = []) {
     this.logger.info('InMemoryLeagueScoringConfigRepository initialized.');
     for (const config of initialConfigs) {
       this.configs.set(config.seasonId, config);

adapters/racing/persistence/inmemory/InMemoryLeagueStandingsRepository.ts

@@ -1,10 +1,10 @@
 import { ILeagueStandingsRepository, RawStanding } from '@gridpilot/core/league/application/ports/ILeagueStandingsRepository';
-import { ILogger } from '@gridpilot/shared/logging/ILogger';
+import { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryLeagueStandingsRepository implements ILeagueStandingsRepository {
   private standings: Map<string, RawStanding[]> = new Map(); // Key: leagueId
 
-  constructor(private readonly logger: ILogger, initialStandings: Record<string, RawStanding[]> = {}) {
+  constructor(private readonly logger: Logger, initialStandings: Record<string, RawStanding[]> = {}) {
     this.logger.info('InMemoryLeagueStandingsRepository initialized.');
     for (const leagueId in initialStandings) {
       // Ensure initialStandings[leagueId] is not undefined before setting

adapters/racing/persistence/inmemory/InMemoryLeagueWalletRepository.ts

@@ -6,13 +6,13 @@
 
 import type { LeagueWallet } from '../../domain/entities/LeagueWallet';
 import type { ILeagueWalletRepository } from '../../domain/repositories/ILeagueWalletRepository';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryLeagueWalletRepository implements ILeagueWalletRepository {
   private wallets: Map<string, LeagueWallet> = new Map();
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, seedData?: LeagueWallet[]) {
+  constructor(logger: Logger, seedData?: LeagueWallet[]) {
     this.logger = logger;
     this.logger.info('InMemoryLeagueWalletRepository initialized.');
     if (seedData) {

adapters/racing/persistence/inmemory/InMemoryLiveryRepository.ts

@@ -7,14 +7,14 @@
 import type { DriverLivery } from '../../domain/entities/DriverLivery';
 import type { LiveryTemplate } from '../../domain/entities/LiveryTemplate';
 import type { ILiveryRepository } from '../../domain/repositories/ILiveryRepository';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryLiveryRepository implements ILiveryRepository {
   private driverLiveries: Map<string, DriverLivery> = new Map();
   private templates: Map<string, LiveryTemplate> = new Map();
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, seedDriverLiveries?: DriverLivery[], seedTemplates?: LiveryTemplate[]) {
+  constructor(logger: Logger, seedDriverLiveries?: DriverLivery[], seedTemplates?: LiveryTemplate[]) {
     this.logger = logger;
     this.logger.info('InMemoryLiveryRepository initialized.');
     if (seedDriverLiveries) {

adapters/racing/persistence/inmemory/InMemoryPenaltyRepository.ts

@@ -6,13 +6,13 @@
 
 import type { Penalty } from '../../domain/entities/Penalty';
 import type { IPenaltyRepository } from '../../domain/repositories/IPenaltyRepository';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryPenaltyRepository implements IPenaltyRepository {
   private penalties: Map<string, Penalty> = new Map();
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, initialPenalties: Penalty[] = []) {
+  constructor(logger: Logger, initialPenalties: Penalty[] = []) {
     this.logger = logger;
     this.logger.info('InMemoryPenaltyRepository initialized.');
     initialPenalties.forEach(penalty => {

adapters/racing/persistence/inmemory/InMemoryProtestRepository.ts

@@ -1,11 +1,11 @@
 import { IProtestRepository } from '@gridpilot/racing/domain/repositories/IProtestRepository';
 import { Protest, ProtestStatus } from '@gridpilot/racing/domain/entities/Protest';
-import { ILogger } from '@gridpilot/shared/logging/ILogger';
+import { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryProtestRepository implements IProtestRepository {
   private protests: Map<string, Protest> = new Map();
 
-  constructor(private readonly logger: ILogger, initialProtests: Protest[] = []) {
+  constructor(private readonly logger: Logger, initialProtests: Protest[] = []) {
     this.logger.info('InMemoryProtestRepository initialized.');
     for (const protest of initialProtests) {
       this.protests.set(protest.id, protest);

adapters/racing/persistence/inmemory/InMemoryRaceEventRepository.ts

@@ -3,13 +3,13 @@
  */
 import type { IRaceEventRepository } from '../../domain/repositories/IRaceEventRepository';
 import type { RaceEvent } from '../../domain/entities/RaceEvent';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryRaceEventRepository implements IRaceEventRepository {
   private raceEvents: Map<string, RaceEvent> = new Map();
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, seedData?: RaceEvent[]) {
+  constructor(logger: Logger, seedData?: RaceEvent[]) {
     this.logger = logger;
     this.logger.info('InMemoryRaceEventRepository initialized.');
     if (seedData) {

adapters/racing/persistence/inmemory/InMemoryRaceRegistrationRepository.ts

@@ -1,11 +1,11 @@
 import { IRaceRegistrationRepository } from '@gridpilot/racing/domain/repositories/IRaceRegistrationRepository';
 import { RaceRegistration } from '@gridpilot/racing/domain/entities/RaceRegistration';
-import { ILogger } from '@gridpilot/shared/logging/ILogger';
+import { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryRaceRegistrationRepository implements IRaceRegistrationRepository {
   private registrations: Map<string, RaceRegistration> = new Map(); // Key: `${raceId}:${driverId}`
 
-  constructor(private readonly logger: ILogger, initialRegistrations: RaceRegistration[] = []) {
+  constructor(private readonly logger: Logger, initialRegistrations: RaceRegistration[] = []) {
     this.logger.info('InMemoryRaceRegistrationRepository initialized.');
     for (const reg of initialRegistrations) {
       this.registrations.set(reg.id, reg);

adapters/racing/persistence/inmemory/InMemoryRaceRepository.ts

@@ -1,11 +1,11 @@
 import { IRaceRepository } from '@gridpilot/racing/domain/repositories/IRaceRepository';
 import { Race, RaceStatus } from '@gridpilot/racing/domain/entities/Race';
-import { ILogger } from '@gridpilot/shared/logging/ILogger';
+import { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryRaceRepository implements IRaceRepository {
   private races: Map<string, Race> = new Map();
 
-  constructor(private readonly logger: ILogger, initialRaces: Race[] = []) {
+  constructor(private readonly logger: Logger, initialRaces: Race[] = []) {
     this.logger.info('InMemoryRaceRepository initialized.');
     for (const race of initialRaces) {
       this.races.set(race.id, race);

adapters/racing/persistence/inmemory/InMemoryResultRepository.ts

@@ -9,14 +9,14 @@ import { v4 as uuidv4 } from 'uuid';
 import { Result } from '@gridpilot/racing/domain/entities/Result';
 import type { IResultRepository } from '@gridpilot/racing/domain/repositories/IResultRepository';
 import type { IRaceRepository } from '@gridpilot/racing/domain/repositories/IRaceRepository';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryResultRepository implements IResultRepository {
   private results: Map<string, Result>;
   private raceRepository: IRaceRepository | null;
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, seedData?: Result[], raceRepository?: IRaceRepository | null) {
+  constructor(logger: Logger, seedData?: Result[], raceRepository?: IRaceRepository | null) {
     this.logger = logger;
     this.logger.info('InMemoryResultRepository initialized.');
     this.results = new Map();

adapters/racing/persistence/inmemory/InMemoryScoringRepositories.ts

@@ -13,9 +13,9 @@ import type { IChampionshipStandingRepository } from '@gridpilot/racing/domain/r
 import { ChampionshipStanding } from '@gridpilot/racing/domain/entities/ChampionshipStanding';
 import type { ChampionshipType } from '@gridpilot/racing/domain/types/ChampionshipType';
 import type { ParticipantRef } from '@gridpilot/racing/domain/types/ParticipantRef';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
-class SilentLogger implements ILogger {
+class SilentLogger implements Logger {
   debug(..._args: unknown[]): void {
     // console.debug(..._args);
   }
@@ -264,9 +264,9 @@ export function getLeagueScoringPresetById(
 
 export class InMemoryGameRepository implements IGameRepository {
   private games: Game[];
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, seedData?: Game[]) {
+  constructor(logger: Logger, seedData?: Game[]) {
     this.logger = logger;
     this.logger.info('InMemoryGameRepository initialized.');
     this.games = seedData ? [...seedData] : [];
@@ -314,9 +314,9 @@ export class InMemoryGameRepository implements IGameRepository {
 
 export class InMemorySeasonRepository implements ISeasonRepository {
   private seasons: Season[];
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, seedData?: Season[]) {
+  constructor(logger: Logger, seedData?: Season[]) {
     this.logger = logger;
     this.logger.info('InMemorySeasonRepository initialized.');
     this.seasons = seedData ? [...seedData] : [];
@@ -433,9 +433,9 @@ export class InMemoryLeagueScoringConfigRepository
   implements ILeagueScoringConfigRepository
 {
   private configs: LeagueScoringConfig[];
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, seedData?: LeagueScoringConfig[]) {
+  constructor(logger: Logger, seedData?: LeagueScoringConfig[]) {
     this.logger = logger;
     this.logger.info('InMemoryLeagueScoringConfigRepository initialized.');
     this.configs = seedData ? [...seedData] : [];
@@ -493,9 +493,9 @@ export class InMemoryChampionshipStandingRepository
   implements IChampionshipStandingRepository
 {
   private standings: ChampionshipStanding[] = [];
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, seedData?: ChampionshipStanding[]) {
+  constructor(logger: Logger, seedData?: ChampionshipStanding[]) {
     this.logger = logger;
     this.logger.info('InMemoryChampionshipStandingRepository initialized.');
     this.standings = seedData ? [...seedData] : [];

adapters/racing/persistence/inmemory/InMemorySeasonRepository.ts

@@ -1,11 +1,11 @@
 import { ISeasonRepository } from '@gridpilot/racing/domain/repositories/ISeasonRepository';
 import { Season } from '@gridpilot/racing/domain/entities/Season';
-import { ILogger } from '@gridpilot/shared/logging/ILogger';
+import { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemorySeasonRepository implements ISeasonRepository {
   private seasons: Map<string, Season> = new Map(); // Key: seasonId
 
-  constructor(private readonly logger: ILogger, initialSeasons: Season[] = []) {
+  constructor(private readonly logger: Logger, initialSeasons: Season[] = []) {
     this.logger.info('InMemorySeasonRepository initialized.');
     for (const season of initialSeasons) {
       this.seasons.set(season.id, season);

adapters/racing/persistence/inmemory/InMemorySeasonSponsorshipRepository.ts

@@ -6,13 +6,13 @@
 
 import type { SeasonSponsorship, SponsorshipTier } from '../../domain/entities/SeasonSponsorship';
 import type { ISeasonSponsorshipRepository } from '../../domain/repositories/ISeasonSponsorshipRepository';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemorySeasonSponsorshipRepository implements ISeasonSponsorshipRepository {
   private sponsorships: Map<string, SeasonSponsorship> = new Map();
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, seedData?: SeasonSponsorship[]) {
+  constructor(logger: Logger, seedData?: SeasonSponsorship[]) {
     this.logger = logger;
     this.logger.info('InMemorySeasonSponsorshipRepository initialized.');
     if (seedData) {

adapters/racing/persistence/inmemory/InMemorySessionRepository.ts

@@ -3,13 +3,13 @@
  */
 import type { ISessionRepository } from '../../domain/repositories/ISessionRepository';
 import type { Session } from '../../domain/entities/Session';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemorySessionRepository implements ISessionRepository {
   private sessions: Map<string, Session> = new Map();
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, seedData?: Session[]) {
+  constructor(logger: Logger, seedData?: Session[]) {
     this.logger = logger;
     this.logger.info('InMemorySessionRepository initialized.');
     if (seedData) {

adapters/racing/persistence/inmemory/InMemorySponsorRepository.ts

@@ -1,12 +1,12 @@
 import { ISponsorRepository } from '@gridpilot/core/racing/domain/repositories/ISponsorRepository';
 import { Sponsor } from '@gridpilot/core/racing/domain/entities/Sponsor';
-import { ILogger } from '@gridpilot/shared/logging/ILogger';
+import { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemorySponsorRepository implements ISponsorRepository {
   private sponsors: Map<string, Sponsor> = new Map();
   private emailIndex: Map<string, string> = new Map(); // contactEmail -> sponsorId
 
-  constructor(private readonly logger: ILogger, initialSponsors: Sponsor[] = []) {
+  constructor(private readonly logger: Logger, initialSponsors: Sponsor[] = []) {
     this.logger.info('InMemorySponsorRepository initialized.');
     for (const sponsor of initialSponsors) {
       this.sponsors.set(sponsor.id, sponsor);

adapters/racing/persistence/inmemory/InMemorySponsorshipPricingRepository.ts

@@ -5,7 +5,7 @@
 import type { ISponsorshipPricingRepository } from '../../domain/repositories/ISponsorshipPricingRepository';
 import { SponsorshipPricing } from '../../domain/value-objects/SponsorshipPricing';
 import type { SponsorableEntityType } from '../../domain/entities/SponsorshipRequest';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
 interface StorageKey {
   entityType: SponsorableEntityType;
@@ -14,9 +14,9 @@ interface StorageKey {
 
 export class InMemorySponsorshipPricingRepository implements ISponsorshipPricingRepository {
   private pricings: Map<string, { entityType: SponsorableEntityType; entityId: string; pricing: SponsorshipPricing }> = new Map();
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, seedData?: Array<{ entityType: SponsorableEntityType; entityId: string; pricing: SponsorshipPricing }>) {
+  constructor(logger: Logger, seedData?: Array<{ entityType: SponsorableEntityType; entityId: string; pricing: SponsorshipPricing }>) {
     this.logger = logger;
     this.logger.info('InMemorySponsorshipPricingRepository initialized.');
     if (seedData) {

adapters/racing/persistence/inmemory/InMemorySponsorshipRequestRepository.ts

@@ -1,11 +1,11 @@
 import { ISponsorshipRequestRepository } from '@gridpilot/racing/domain/repositories/ISponsorshipRequestRepository';
 import { SponsorshipRequest, SponsorableEntityType, SponsorshipRequestStatus } from '@gridpilot/racing/domain/entities/SponsorshipRequest';
-import { ILogger } from '@gridpilot/shared/logging/ILogger';
+import { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemorySponsorshipRequestRepository implements ISponsorshipRequestRepository {
   private requests: Map<string, SponsorshipRequest> = new Map();
 
-  constructor(private readonly logger: ILogger, initialRequests: SponsorshipRequest[] = []) {
+  constructor(private readonly logger: Logger, initialRequests: SponsorshipRequest[] = []) {
     this.logger.info('InMemorySponsorshipRequestRepository initialized.');
     for (const req of initialRequests) {
       this.requests.set(req.id, req);

adapters/racing/persistence/inmemory/InMemoryStandingRepository.ts

@@ -10,7 +10,7 @@ import type { IStandingRepository } from '@gridpilot/racing/domain/repositories/
 import type { IResultRepository } from '@gridpilot/racing/domain/repositories/IResultRepository';
 import type { IRaceRepository } from '@gridpilot/racing/domain/repositories/IRaceRepository';
 import type { ILeagueRepository } from '@gridpilot/racing/domain/repositories/ILeagueRepository';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
 /**
  * Points systems presets
@@ -32,10 +32,10 @@ export class InMemoryStandingRepository implements IStandingRepository {
   private resultRepository: IResultRepository | null;
   private raceRepository: IRaceRepository | null;
   private leagueRepository: ILeagueRepository | null;
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
   constructor(
-    logger: ILogger,
+    logger: Logger,
     seedData?: Standing[],
     resultRepository?: IResultRepository | null,
     raceRepository?: IRaceRepository | null,

adapters/racing/persistence/inmemory/InMemoryTeamMembershipRepository.ts

@@ -10,14 +10,14 @@ import type {
   TeamJoinRequest,
 } from '@gridpilot/racing/domain/types/TeamMembership';
 import type { ITeamMembershipRepository } from '@gridpilot/racing/domain/repositories/ITeamMembershipRepository';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryTeamMembershipRepository implements ITeamMembershipRepository {
   private membershipsByTeam: Map<string, TeamMembership[]>;
   private joinRequestsByTeam: Map<string, TeamJoinRequest[]>;
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, seedMemberships?: TeamMembership[], seedJoinRequests?: TeamJoinRequest[]) {
+  constructor(logger: Logger, seedMemberships?: TeamMembership[], seedJoinRequests?: TeamJoinRequest[]) {
     this.logger = logger;
     this.logger.info('InMemoryTeamMembershipRepository initialized.');
     this.membershipsByTeam = new Map();

adapters/racing/persistence/inmemory/InMemoryTeamRepository.ts

@@ -7,13 +7,13 @@
 
 import type { Team } from '@gridpilot/racing/domain/entities/Team';
 import type { ITeamRepository } from '@gridpilot/racing/domain/repositories/ITeamRepository';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryTeamRepository implements ITeamRepository {
   private teams: Map<string, Team>;
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, seedData?: Team[]) {
+  constructor(logger: Logger, seedData?: Team[]) {
     this.logger = logger;
     this.logger.info('InMemoryTeamRepository initialized.');
     this.teams = new Map();

adapters/racing/persistence/inmemory/InMemoryTrackRepository.ts

@@ -8,13 +8,13 @@
 import { v4 as uuidv4 } from 'uuid';
 import { Track, TrackCategory } from '@gridpilot/racing/domain/entities/Track';
 import type { ITrackRepository } from '@gridpilot/racing/domain/repositories/ITrackRepository';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryTrackRepository implements ITrackRepository {
   private tracks: Map<string, Track>;
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, seedData?: Track[]) {
+  constructor(logger: Logger, seedData?: Track[]) {
     this.logger = logger;
     this.logger.info('InMemoryTrackRepository initialized.');
     this.tracks = new Map();

adapters/racing/persistence/inmemory/InMemoryTransactionRepository.ts

@@ -6,13 +6,13 @@
 
 import type { Transaction, TransactionType } from '../../domain/entities/Transaction';
 import type { ITransactionRepository } from '../../domain/repositories/ITransactionRepository';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryTransactionRepository implements ITransactionRepository {
   private transactions: Map<string, Transaction> = new Map();
-  private readonly logger: ILogger;
+  private readonly logger: Logger;
 
-  constructor(logger: ILogger, seedData?: Transaction[]) {
+  constructor(logger: Logger, seedData?: Transaction[]) {
     this.logger = logger;
     this.logger.info('InMemoryTransactionRepository initialized.');
     if (seedData) {

adapters/racing/ports/InMemoryDriverRatingProvider.ts

@@ -1,8 +1,8 @@
 import type { DriverRatingProvider } from '@gridpilot/racing/application/ports/DriverRatingProvider';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryDriverRatingProvider implements DriverRatingProvider {
-  constructor(private readonly logger: ILogger) {
+  constructor(private readonly logger: Logger) {
     this.logger.info('InMemoryDriverRatingProvider initialized.');
   }
 

adapters/racing/services/InMemoryDriverStatsService.ts

@@ -1,8 +1,8 @@
 import type { IDriverStatsService, DriverStats } from '@gridpilot/racing/domain/services/IDriverStatsService';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryDriverStatsService implements IDriverStatsService {
-  constructor(private readonly logger: ILogger) {
+  constructor(private readonly logger: Logger) {
     this.logger.info('InMemoryDriverStatsService initialized.');
   }
 

adapters/racing/services/InMemoryRankingService.ts

@@ -1,8 +1,8 @@
 import type { IRankingService, DriverRanking } from '@gridpilot/racing/domain/services/IRankingService';
-import type { ILogger } from '@gridpilot/shared/logging/ILogger';
+import type { Logger } from '@gridpilot/shared/logging/Logger';
 
 export class InMemoryRankingService implements IRankingService {
-  constructor(private readonly logger: ILogger) {
+  constructor(private readonly logger: Logger) {
     this.logger.info('InMemoryRankingService initialized.');
   }