module cleanup

apps/api/src/domain/media/MediaProviders.ts

@@ -3,39 +3,82 @@ import { MediaService } from './MediaService';
 
 // Import core interfaces
 import { IAvatarGenerationRepository } from '@core/media/domain/repositories/IAvatarGenerationRepository';
+import { IMediaRepository } from '@core/media/domain/repositories/IMediaRepository';
+import { IAvatarRepository } from '@core/media/domain/repositories/IAvatarRepository';
 import { FaceValidationPort } from '@core/media/application/ports/FaceValidationPort';
 import { AvatarGenerationPort } from '@core/media/application/ports/AvatarGenerationPort';
+import { MediaStoragePort } from '@core/media/application/ports/MediaStoragePort';
 import type { Logger } from '@core/shared/application';
 
 // Import use cases
 import { RequestAvatarGenerationUseCase } from '@core/media/application/use-cases/RequestAvatarGenerationUseCase';
+import { UploadMediaUseCase } from '@core/media/application/use-cases/UploadMediaUseCase';
+import { GetMediaUseCase } from '@core/media/application/use-cases/GetMediaUseCase';
+import { DeleteMediaUseCase } from '@core/media/application/use-cases/DeleteMediaUseCase';
+import { GetAvatarUseCase } from '@core/media/application/use-cases/GetAvatarUseCase';
+import { UpdateAvatarUseCase } from '@core/media/application/use-cases/UpdateAvatarUseCase';
 
 // Define injection tokens
 export const AVATAR_GENERATION_REPOSITORY_TOKEN = 'IAvatarGenerationRepository';
+export const MEDIA_REPOSITORY_TOKEN = 'IMediaRepository';
+export const AVATAR_REPOSITORY_TOKEN = 'IAvatarRepository';
 export const FACE_VALIDATION_PORT_TOKEN = 'FaceValidationPort';
 export const AVATAR_GENERATION_PORT_TOKEN = 'AvatarGenerationPort';
+export const MEDIA_STORAGE_PORT_TOKEN = 'MediaStoragePort';
 export const LOGGER_TOKEN = 'Logger';
 
 // Use case tokens
 export const REQUEST_AVATAR_GENERATION_USE_CASE_TOKEN = 'RequestAvatarGenerationUseCase';
+export const UPLOAD_MEDIA_USE_CASE_TOKEN = 'UploadMediaUseCase';
+export const GET_MEDIA_USE_CASE_TOKEN = 'GetMediaUseCase';
+export const DELETE_MEDIA_USE_CASE_TOKEN = 'DeleteMediaUseCase';
+export const GET_AVATAR_USE_CASE_TOKEN = 'GetAvatarUseCase';
+export const UPDATE_AVATAR_USE_CASE_TOKEN = 'UpdateAvatarUseCase';
+
+import type { AvatarGenerationRequest } from '@core/media/domain/entities/AvatarGenerationRequest';
+import type { Media } from '@core/media/domain/entities/Media';
+import type { Avatar } from '@core/media/domain/entities/Avatar';
+import type { FaceValidationResult } from '@core/media/application/ports/FaceValidationPort';
+import type { AvatarGenerationResult } from '@core/media/application/ports/AvatarGenerationPort';
+import type { UploadResult } from '@core/media/application/ports/MediaStoragePort';
 
 // Mock implementations
 class MockAvatarGenerationRepository implements IAvatarGenerationRepository {
-  async save(_request: any): Promise<void> {}
-  async findById(_id: string): Promise<any | null> { return null; }
-  async findByUserId(_userId: string): Promise<any[]> { return []; }
-  async findLatestByUserId(_userId: string): Promise<any | null> { return null; }
-  async delete(_id: string): Promise<void> {}
+  async save(): Promise<void> {}
+  async findById(): Promise<AvatarGenerationRequest | null> { return null; }
+  async findByUserId(): Promise<AvatarGenerationRequest[]> { return []; }
+  async findLatestByUserId(): Promise<AvatarGenerationRequest | null> { return null; }
+  async delete(): Promise<void> {}
+}
+
+class MockMediaRepository implements IMediaRepository {
+  async save(): Promise<void> {}
+  async findById(): Promise<Media | null> { return null; }
+  async findByUploadedBy(): Promise<Media[]> { return []; }
+  async delete(): Promise<void> {}
+}
+
+class MockAvatarRepository implements IAvatarRepository {
+  async save(): Promise<void> {}
+  async findById(): Promise<Avatar | null> { return null; }
+  async findActiveByDriverId(): Promise<Avatar | null> { return null; }
+  async findByDriverId(): Promise<Avatar[]> { return []; }
+  async delete(): Promise<void> {}
 }
 
 class MockFaceValidationAdapter implements FaceValidationPort {
-  async validateFacePhoto(data: string): Promise<any> {
-    return { isValid: true, hasFace: true, faceCount: 1 };
+  async validateFacePhoto(): Promise<FaceValidationResult> {
+    return {
+      isValid: true,
+      hasFace: true,
+      faceCount: 1,
+      confidence: 0.95,
+    };
   }
 }
 
 class MockAvatarGenerationAdapter implements AvatarGenerationPort {
-  async generateAvatars(options: any): Promise<any> {
+  async generateAvatars(): Promise<AvatarGenerationResult> {
     return {
       success: true,
       avatars: [
@@ -47,11 +90,22 @@ class MockAvatarGenerationAdapter implements AvatarGenerationPort {
   }
 }
 
+class MockMediaStorageAdapter implements MediaStoragePort {
+  async uploadMedia(): Promise<UploadResult> {
+    return {
+      success: true,
+      url: 'https://cdn.example.com/media/mock-file.png',
+      filename: 'mock-file.png',
+    };
+  }
+  async deleteMedia(): Promise<void> {}
+}
+
 class MockLogger implements Logger {
-  debug(message: string, meta?: any): void {}
-  info(message: string, meta?: any): void {}
-  warn(message: string, meta?: any): void {}
-  error(message: string, error?: Error): void {}
+  debug(): void {}
+  info(): void {}
+  warn(): void {}
+  error(): void {}
 }
 
 export const MediaProviders: Provider[] = [
@@ -60,6 +114,14 @@ export const MediaProviders: Provider[] = [
     provide: AVATAR_GENERATION_REPOSITORY_TOKEN,
     useClass: MockAvatarGenerationRepository,
   },
+  {
+    provide: MEDIA_REPOSITORY_TOKEN,
+    useClass: MockMediaRepository,
+  },
+  {
+    provide: AVATAR_REPOSITORY_TOKEN,
+    useClass: MockAvatarRepository,
+  },
   {
     provide: FACE_VALIDATION_PORT_TOKEN,
     useClass: MockFaceValidationAdapter,
@@ -68,6 +130,10 @@ export const MediaProviders: Provider[] = [
     provide: AVATAR_GENERATION_PORT_TOKEN,
     useClass: MockAvatarGenerationAdapter,
   },
+  {
+    provide: MEDIA_STORAGE_PORT_TOKEN,
+    useClass: MockMediaStorageAdapter,
+  },
   {
     provide: LOGGER_TOKEN,
     useClass: MockLogger,
@@ -79,4 +145,34 @@ export const MediaProviders: Provider[] = [
       new RequestAvatarGenerationUseCase(avatarRepo, faceValidation, avatarGeneration, logger),
     inject: [AVATAR_GENERATION_REPOSITORY_TOKEN, FACE_VALIDATION_PORT_TOKEN, AVATAR_GENERATION_PORT_TOKEN, LOGGER_TOKEN],
   },
+  {
+    provide: UPLOAD_MEDIA_USE_CASE_TOKEN,
+    useFactory: (mediaRepo: IMediaRepository, mediaStorage: MediaStoragePort, logger: Logger) =>
+      new UploadMediaUseCase(mediaRepo, mediaStorage, logger),
+    inject: [MEDIA_REPOSITORY_TOKEN, MEDIA_STORAGE_PORT_TOKEN, LOGGER_TOKEN],
+  },
+  {
+    provide: GET_MEDIA_USE_CASE_TOKEN,
+    useFactory: (mediaRepo: IMediaRepository, logger: Logger) =>
+      new GetMediaUseCase(mediaRepo, logger),
+    inject: [MEDIA_REPOSITORY_TOKEN, LOGGER_TOKEN],
+  },
+  {
+    provide: DELETE_MEDIA_USE_CASE_TOKEN,
+    useFactory: (mediaRepo: IMediaRepository, mediaStorage: MediaStoragePort, logger: Logger) =>
+      new DeleteMediaUseCase(mediaRepo, mediaStorage, logger),
+    inject: [MEDIA_REPOSITORY_TOKEN, MEDIA_STORAGE_PORT_TOKEN, LOGGER_TOKEN],
+  },
+  {
+    provide: GET_AVATAR_USE_CASE_TOKEN,
+    useFactory: (avatarRepo: IAvatarRepository, logger: Logger) =>
+      new GetAvatarUseCase(avatarRepo, logger),
+    inject: [AVATAR_REPOSITORY_TOKEN, LOGGER_TOKEN],
+  },
+  {
+    provide: UPDATE_AVATAR_USE_CASE_TOKEN,
+    useFactory: (avatarRepo: IAvatarRepository, logger: Logger) =>
+      new UpdateAvatarUseCase(avatarRepo, logger),
+    inject: [AVATAR_REPOSITORY_TOKEN, LOGGER_TOKEN],
+  },
 ];