GameTime/lib/application/app_bootstrap.dart

import '../infrastructure/local/local.dart';
import '../infrastructure/remote/remote.dart';
import '../infrastructure/security/security.dart';
import 'application.dart';

abstract interface class AppDependencies {
  AuthUseCases get authUseCases;
  ExerciseUseCases get exerciseUseCases;
  MediaUseCases get mediaUseCases;
  ProgramUseCases get programUseCases;
  WorkoutTemplateUseCases get workoutTemplateUseCases;
  ActiveWorkoutSessionUseCases get activeWorkoutSessionUseCases;
  ActiveExerciseStepUseCases get activeExerciseStepUseCases;
  CloseWorkoutSessionUseCase get closeWorkoutSessionUseCase;
  WorkoutHistoryUseCases get workoutHistoryUseCases;
}

final class AppBootstrap implements AppDependencies {
  AppBootstrap._({
    required this.database,
    required this.authUseCases,
    required this.exerciseUseCases,
    required this.mediaUseCases,
    required this.programUseCases,
    required this.workoutTemplateUseCases,
    required this.activeWorkoutSessionUseCases,
    required this.activeExerciseStepUseCases,
    required this.closeWorkoutSessionUseCase,
    required this.workoutHistoryUseCases,
    required this.syncGateway,
  });

  final AppDatabase database;
  @override
  final AuthUseCases authUseCases;
  @override
  final ExerciseUseCases exerciseUseCases;
  @override
  final MediaUseCases mediaUseCases;
  @override
  final ProgramUseCases programUseCases;
  @override
  final WorkoutTemplateUseCases workoutTemplateUseCases;
  @override
  final ActiveWorkoutSessionUseCases activeWorkoutSessionUseCases;
  @override
  final ActiveExerciseStepUseCases activeExerciseStepUseCases;
  @override
  final CloseWorkoutSessionUseCase closeWorkoutSessionUseCase;
  @override
  final WorkoutHistoryUseCases workoutHistoryUseCases;
  final SyncGateway syncGateway;

  static Future<AppBootstrap> create() async {
    final database = AppDatabase.open();
    await database.customSelect('SELECT 1').get();
    final exerciseRepository = DriftExerciseRepository(database);
    final mediaRepository = DriftMediaAssetRepository(database);
    final onlineAccountRepository = DriftOnlineAccountRepository(database);
    final programRepository = DriftProgramRepository(database);
    final templateRepository = DriftWorkoutTemplateRepository(database);
    final activeSessionRepository = DriftActiveSessionRepository(database);
    final historyRepository = DriftWorkoutHistoryRepository(database);
    final ids = LocalIdGenerator();
    const clock = SystemClock();
    const originDeviceId = 'local-device';
    final remoteAuthApi = HttpRemoteAuthApi(
      HttpApiClient(baseUrl: Uri.parse(HttpApiClient.defaultBaseUrl)),
    );

    return AppBootstrap._(
      database: database,
      authUseCases: AuthUseCases(
        tokenStore: const SecureStorageAuthTokenStore(),
        accountRepository: onlineAccountRepository,
        remoteAuthApi: remoteAuthApi,
        clock: clock,
        ids: ids,
      ),
      exerciseUseCases: ExerciseUseCases(
        repository: exerciseRepository,
        programRepository: programRepository,
        clock: clock,
        ids: ids,
        originDeviceId: originDeviceId,
      ),
      mediaUseCases: MediaUseCases(
        mediaRepository: mediaRepository,
        exerciseRepository: exerciseRepository,
        storage: const PathProviderLocalMediaStorage(),
        clock: clock,
        ids: ids,
        originDeviceId: originDeviceId,
      ),
      programUseCases: ProgramUseCases(
        programRepository: programRepository,
        exerciseRepository: exerciseRepository,
        templateRepository: templateRepository,
        clock: clock,
        ids: ids,
        originDeviceId: originDeviceId,
      ),
      workoutTemplateUseCases: WorkoutTemplateUseCases(
        templateRepository: templateRepository,
        programRepository: programRepository,
        clock: clock,
        ids: ids,
        originDeviceId: originDeviceId,
      ),
      activeWorkoutSessionUseCases: ActiveWorkoutSessionUseCases(
        sessionRepository: activeSessionRepository,
        templateRepository: templateRepository,
        clock: clock,
        ids: ids,
        originDeviceId: originDeviceId,
      ),
      activeExerciseStepUseCases: ActiveExerciseStepUseCases(
        sessionRepository: activeSessionRepository,
        clock: clock,
        ids: ids,
        originDeviceId: originDeviceId,
      ),
      closeWorkoutSessionUseCase: CloseWorkoutSessionUseCase(
        sessionRepository: activeSessionRepository,
        historyRepository: historyRepository,
        clock: clock,
        ids: ids,
        originDeviceId: originDeviceId,
      ),
      workoutHistoryUseCases: WorkoutHistoryUseCases(
        repository: historyRepository,
        clock: clock,
      ),
      syncGateway: const NoOpSyncGateway(),
    );
  }

  Future<void> dispose() => database.close();
}