wip

packages/media/application/ports/AvatarGenerationPort.ts

@@ -0,0 +1,35 @@
+/**
+ * Port: AvatarGenerationPort
+ * 
+ * Defines the contract for AI-powered avatar generation.
+ */
+
+import type { RacingSuitColor, AvatarStyle } from '../../domain/entities/AvatarGenerationRequest';
+
+export interface AvatarGenerationOptions {
+  facePhotoUrl: string;
+  prompt: string;
+  suitColor: RacingSuitColor;
+  style: AvatarStyle;
+  count: number;
+}
+
+export interface GeneratedAvatar {
+  url: string;
+  thumbnailUrl?: string;
+}
+
+export interface AvatarGenerationResult {
+  success: boolean;
+  avatars: GeneratedAvatar[];
+  errorMessage?: string;
+}
+
+export interface AvatarGenerationPort {
+  /**
+   * Generate racing avatars from a face photo
+   * @param options Generation options including face photo and styling preferences
+   * @returns Generated avatar URLs
+   */
+  generateAvatars(options: AvatarGenerationOptions): Promise<AvatarGenerationResult>;
+}

packages/media/application/ports/FaceValidationPort.ts

@@ -0,0 +1,20 @@
+/**
+ * Port: FaceValidationPort
+ * 
+ * Defines the contract for validating face photos.
+ */
+
+export interface FaceValidationResult {
+  isValid: boolean;
+  hasFace: boolean;
+  faceCount: number;
+  confidence: number;
+  errorMessage?: string;
+}
+
+export interface FaceValidationPort {
+  /**
+   * Validate that an image contains exactly one valid face
+   */
+  validateFacePhoto(imageData: string | Buffer): Promise<FaceValidationResult>;
+}

packages/media/application/use-cases/RequestAvatarGenerationUseCase.ts

@@ -0,0 +1,123 @@
+/**
+ * Use Case: RequestAvatarGenerationUseCase
+ * 
+ * Initiates the avatar generation process by validating the face photo
+ * and creating a generation request.
+ */
+
+import type { IAvatarGenerationRepository } from '../../domain/repositories/IAvatarGenerationRepository';
+import type { FaceValidationPort } from '../ports/FaceValidationPort';
+import type { AvatarGenerationPort } from '../ports/AvatarGenerationPort';
+import { AvatarGenerationRequest, type RacingSuitColor, type AvatarStyle } from '../../domain/entities/AvatarGenerationRequest';
+
+export interface RequestAvatarGenerationCommand {
+  userId: string;
+  facePhotoData: string; // Base64 encoded image data
+  suitColor: RacingSuitColor;
+  style?: AvatarStyle;
+}
+
+export interface RequestAvatarGenerationResult {
+  requestId: string;
+  status: 'validating' | 'generating' | 'completed' | 'failed';
+  avatarUrls?: string[];
+  errorMessage?: string;
+}
+
+export class RequestAvatarGenerationUseCase {
+  constructor(
+    private readonly avatarRepository: IAvatarGenerationRepository,
+    private readonly faceValidation: FaceValidationPort,
+    private readonly avatarGeneration: AvatarGenerationPort,
+  ) {}
+
+  async execute(command: RequestAvatarGenerationCommand): Promise<RequestAvatarGenerationResult> {
+    // Create the generation request
+    const requestId = this.generateId();
+    const request = AvatarGenerationRequest.create({
+      id: requestId,
+      userId: command.userId,
+      facePhotoUrl: `data:image/jpeg;base64,${command.facePhotoData}`,
+      suitColor: command.suitColor,
+      style: command.style,
+    });
+
+    // Mark as validating
+    request.markAsValidating();
+    await this.avatarRepository.save(request);
+
+    // Validate the face photo
+    const validationResult = await this.faceValidation.validateFacePhoto(command.facePhotoData);
+    
+    if (!validationResult.isValid) {
+      request.fail(validationResult.errorMessage || 'Face validation failed');
+      await this.avatarRepository.save(request);
+      return {
+        requestId,
+        status: 'failed',
+        errorMessage: validationResult.errorMessage || 'Please upload a clear photo of your face',
+      };
+    }
+
+    if (!validationResult.hasFace) {
+      request.fail('No face detected in the image');
+      await this.avatarRepository.save(request);
+      return {
+        requestId,
+        status: 'failed',
+        errorMessage: 'No face detected. Please upload a photo that clearly shows your face.',
+      };
+    }
+
+    if (validationResult.faceCount > 1) {
+      request.fail('Multiple faces detected');
+      await this.avatarRepository.save(request);
+      return {
+        requestId,
+        status: 'failed',
+        errorMessage: 'Multiple faces detected. Please upload a photo with only your face.',
+      };
+    }
+
+    // Mark as generating
+    request.markAsGenerating();
+    await this.avatarRepository.save(request);
+
+    // Generate avatars
+    const generationResult = await this.avatarGeneration.generateAvatars({
+      facePhotoUrl: request.facePhotoUrl,
+      prompt: request.buildPrompt(),
+      suitColor: request.suitColor,
+      style: request.style,
+      count: 3, // Generate 3 options
+    });
+
+    if (!generationResult.success) {
+      request.fail(generationResult.errorMessage || 'Avatar generation failed');
+      await this.avatarRepository.save(request);
+      return {
+        requestId,
+        status: 'failed',
+        errorMessage: generationResult.errorMessage || 'Failed to generate avatars. Please try again.',
+      };
+    }
+
+    // Complete with generated avatars
+    const avatarUrls = generationResult.avatars.map(a => a.url);
+    request.completeWithAvatars(avatarUrls);
+    await this.avatarRepository.save(request);
+
+    return {
+      requestId,
+      status: 'completed',
+      avatarUrls,
+    };
+  }
+
+  private generateId(): string {
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+      return crypto.randomUUID();
+    }
+    return 'avatar-' + Date.now().toString(36) + Math.random().toString(36).substr(2, 9);
+  }
+}

packages/media/application/use-cases/SelectAvatarUseCase.ts

@@ -0,0 +1,65 @@
+/**
+ * Use Case: SelectAvatarUseCase
+ * 
+ * Allows a user to select one of the generated avatars as their profile avatar.
+ */
+
+import type { IAvatarGenerationRepository } from '../../domain/repositories/IAvatarGenerationRepository';
+
+export interface SelectAvatarCommand {
+  requestId: string;
+  userId: string;
+  avatarIndex: number;
+}
+
+export interface SelectAvatarResult {
+  success: boolean;
+  selectedAvatarUrl?: string;
+  errorMessage?: string;
+}
+
+export class SelectAvatarUseCase {
+  constructor(
+    private readonly avatarRepository: IAvatarGenerationRepository,
+  ) {}
+
+  async execute(command: SelectAvatarCommand): Promise<SelectAvatarResult> {
+    const request = await this.avatarRepository.findById(command.requestId);
+
+    if (!request) {
+      return {
+        success: false,
+        errorMessage: 'Avatar generation request not found',
+      };
+    }
+
+    if (request.userId !== command.userId) {
+      return {
+        success: false,
+        errorMessage: 'You do not have permission to select this avatar',
+      };
+    }
+
+    if (request.status !== 'completed') {
+      return {
+        success: false,
+        errorMessage: 'Avatar generation is not yet complete',
+      };
+    }
+
+    try {
+      request.selectAvatar(command.avatarIndex);
+      await this.avatarRepository.save(request);
+
+      return {
+        success: true,
+        selectedAvatarUrl: request.selectedAvatarUrl,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        errorMessage: error instanceof Error ? error.message : 'Failed to select avatar',
+      };
+    }
+  }
+}