gridpilot.gg/apps/api/src/domain/bootstrap/BootstrapProviders.ts

import { Provider } from '@nestjs/common';
import { SOCIAL_FEED_REPOSITORY_TOKEN, SOCIAL_GRAPH_REPOSITORY_TOKEN } from '../../persistence/social/SocialPersistenceTokens';
import { ACHIEVEMENT_REPOSITORY_TOKEN } from '../../persistence/achievement/AchievementPersistenceTokens';
import { EnsureInitialData } from '../../../../../adapters/bootstrap/EnsureInitialData';
import type { RacingSeedDependencies } from '../../../../../adapters/bootstrap/SeedRacingData';
import { SignupWithEmailUseCase, type SignupWithEmailResult } from '@core/identity/application/use-cases/SignupWithEmailUseCase';
import {
  CreateAchievementUseCase,
  type CreateAchievementResult,
  type IAchievementRepository,
} from '@core/identity/application/use-cases/achievement/CreateAchievementUseCase';
import type { IUserRepository } from '@core/identity/domain/repositories/IUserRepository';
import type { IdentitySessionPort } from '@core/identity/application/ports/IdentitySessionPort';
import type { Logger } from '@core/shared/application';
import type { UseCaseOutputPort } from '@core/shared/application/UseCaseOutputPort';
import { CookieIdentitySessionAdapter } from '../../../../../adapters/identity/session/CookieIdentitySessionAdapter';
import { USER_REPOSITORY_TOKEN as IDENTITY_USER_REPOSITORY_TOKEN } from '../../persistence/identity/IdentityPersistenceTokens';

// Define tokens
export const USER_REPOSITORY_TOKEN = 'IUserRepository_Bootstrap';
// ACHIEVEMENT_REPOSITORY_TOKEN is now imported from AchievementPersistenceTokens
export const IDENTITY_SESSION_PORT_TOKEN = 'IdentitySessionPort_Bootstrap';
export const SIGNUP_USE_CASE_TOKEN = 'SignupWithEmailUseCase_Bootstrap';
export const CREATE_ACHIEVEMENT_USE_CASE_TOKEN = 'CreateAchievementUseCase_Bootstrap';

export const RACING_SEED_DEPENDENCIES_TOKEN = 'RacingSeedDependencies';
export const ENSURE_INITIAL_DATA_TOKEN = 'EnsureInitialData_Bootstrap';

// Adapter classes for output ports
class SignupWithEmailOutputAdapter implements UseCaseOutputPort<SignupWithEmailResult> {
  present(result: SignupWithEmailResult): void {
    // Bootstrap doesn't need to handle output, just log success
    console.log('[Bootstrap] Signup completed', result);
  }
}

class CreateAchievementOutputAdapter implements UseCaseOutputPort<CreateAchievementResult> {
  present(result: CreateAchievementResult): void {
    // Bootstrap doesn't need to handle output, just log success
    console.log('[Bootstrap] Achievement created', result);
  }
}

export const BootstrapProviders: Provider[] = [
  {
    provide: RACING_SEED_DEPENDENCIES_TOKEN,
    useFactory: (
      driverRepository: RacingSeedDependencies['driverRepository'],
      leagueRepository: RacingSeedDependencies['leagueRepository'],
      seasonRepository: RacingSeedDependencies['seasonRepository'],
      leagueScoringConfigRepository: RacingSeedDependencies['leagueScoringConfigRepository'],
      seasonSponsorshipRepository: RacingSeedDependencies['seasonSponsorshipRepository'],
      sponsorshipRequestRepository: RacingSeedDependencies['sponsorshipRequestRepository'],
      leagueWalletRepository: RacingSeedDependencies['leagueWalletRepository'],
      transactionRepository: RacingSeedDependencies['transactionRepository'],
      protestRepository: RacingSeedDependencies['protestRepository'],
      penaltyRepository: RacingSeedDependencies['penaltyRepository'],
      raceRepository: RacingSeedDependencies['raceRepository'],
      resultRepository: RacingSeedDependencies['resultRepository'],
      standingRepository: RacingSeedDependencies['standingRepository'],
      leagueMembershipRepository: RacingSeedDependencies['leagueMembershipRepository'],
      raceRegistrationRepository: RacingSeedDependencies['raceRegistrationRepository'],
      teamRepository: RacingSeedDependencies['teamRepository'],
      teamMembershipRepository: RacingSeedDependencies['teamMembershipRepository'],
      sponsorRepository: RacingSeedDependencies['sponsorRepository'],
      feedRepository: RacingSeedDependencies['feedRepository'],
      socialGraphRepository: RacingSeedDependencies['socialGraphRepository'],
    ): RacingSeedDependencies => ({
      driverRepository,
      leagueRepository,
      seasonRepository,
      leagueScoringConfigRepository,
      seasonSponsorshipRepository,
      sponsorshipRequestRepository,
      leagueWalletRepository,
      transactionRepository,
      protestRepository,
      penaltyRepository,
      raceRepository,
      resultRepository,
      standingRepository,
      leagueMembershipRepository,
      raceRegistrationRepository,
      teamRepository,
      teamMembershipRepository,
      sponsorRepository,
      feedRepository,
      socialGraphRepository,
    }),
    inject: [
      'IDriverRepository',
      'ILeagueRepository',
      'ISeasonRepository',
      'ILeagueScoringConfigRepository',
      'ISeasonSponsorshipRepository',
      'ISponsorshipRequestRepository',
      'ILeagueWalletRepository',
      'ITransactionRepository',
      'IProtestRepository',
      'IPenaltyRepository',
      'IRaceRepository',
      'IResultRepository',
      'IStandingRepository',
      'ILeagueMembershipRepository',
      'IRaceRegistrationRepository',
      'ITeamRepository',
      'ITeamMembershipRepository',
      'ISponsorRepository',
      SOCIAL_FEED_REPOSITORY_TOKEN,
      SOCIAL_GRAPH_REPOSITORY_TOKEN,
    ],
  },
  {
    provide: USER_REPOSITORY_TOKEN,
    useFactory: (userRepository: IUserRepository) => userRepository,
    inject: [IDENTITY_USER_REPOSITORY_TOKEN],
  },
  // Achievement repository is now provided by AchievementPersistenceModule
  {
    provide: IDENTITY_SESSION_PORT_TOKEN,
    useFactory: (logger: Logger) => new CookieIdentitySessionAdapter(logger),
    inject: ['Logger'],
  },
  {
    provide: SIGNUP_USE_CASE_TOKEN,
    useFactory: (
      userRepository: IUserRepository, 
      sessionPort: IdentitySessionPort,
      logger: Logger
    ) => {
      return new SignupWithEmailUseCase(
        userRepository, 
        sessionPort, 
        logger,
        new SignupWithEmailOutputAdapter()
      );
    },
    inject: [USER_REPOSITORY_TOKEN, IDENTITY_SESSION_PORT_TOKEN, 'Logger'],
  },
  {
    provide: CREATE_ACHIEVEMENT_USE_CASE_TOKEN,
    useFactory: (
      achievementRepository: IAchievementRepository,
      logger: Logger
    ) => {
      return new CreateAchievementUseCase(
        achievementRepository,
        logger,
        new CreateAchievementOutputAdapter()
      );
    },
    inject: [ACHIEVEMENT_REPOSITORY_TOKEN, 'Logger'],
  },
  {
    provide: ENSURE_INITIAL_DATA_TOKEN,
    useFactory: (
      signupUseCase: SignupWithEmailUseCase,
      createAchievementUseCase: CreateAchievementUseCase,
      logger: Logger,
    ) => {
      return new EnsureInitialData(signupUseCase, createAchievementUseCase, logger);
    },
    inject: [SIGNUP_USE_CASE_TOKEN, CREATE_ACHIEVEMENT_USE_CASE_TOKEN, 'Logger'],
  },
];