refactor

core/racing/application/use-cases/CreateSponsorUseCase.ts

@@ -8,13 +8,19 @@ import { Sponsor } from '../../domain/entities/Sponsor';
 import type { ISponsorRepository } from '../../domain/repositories/ISponsorRepository';
 import type { AsyncUseCase } from '@core/shared/application';
 import type { Logger } from '@core/shared/application';
-import { Result } from '@core/shared/result/Result';
-import { RacingDomainValidationError } from '../../domain/errors/RacingDomainError';
-import type { CreateSponsorCommand } from './CreateSponsorCommand';
+import { Result } from '@core/shared/application/Result';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 import type { CreateSponsorResultDTO } from '../dto/CreateSponsorResultDTO';
 
+export interface CreateSponsorCommand {
+  name: string;
+  contactEmail: string;
+  websiteUrl?: string;
+  logoUrl?: string;
+}
+
 export class CreateSponsorUseCase
-  implements AsyncUseCase<CreateSponsorCommand, Result<CreateSponsorResultDTO, RacingDomainValidationError>>
+  implements AsyncUseCase<CreateSponsorCommand, CreateSponsorResultDTO, 'VALIDATION_ERROR' | 'REPOSITORY_ERROR'>
 {
   constructor(
     private readonly sponsorRepository: ISponsorRepository,
@@ -23,7 +29,7 @@ export class CreateSponsorUseCase
 
   async execute(
     command: CreateSponsorCommand,
-  ): Promise<Result<CreateSponsorResultDTO, RacingDomainValidationError>> {
+  ): Promise<Result<CreateSponsorResultDTO, ApplicationErrorCode<'VALIDATION_ERROR' | 'REPOSITORY_ERROR', { message: string }>>> {
     this.logger.debug('Executing CreateSponsorUseCase', { command });
     const validation = this.validate(command);
     if (validation.isErr()) {
@@ -50,40 +56,40 @@ export class CreateSponsorUseCase
           id: sponsor.id,
           name: sponsor.name,
           contactEmail: sponsor.contactEmail,
-          websiteUrl: sponsor.websiteUrl,
-          logoUrl: sponsor.logoUrl,
           createdAt: sponsor.createdAt,
+          ...(sponsor.websiteUrl !== undefined ? { websiteUrl: sponsor.websiteUrl } : {}),
+          ...(sponsor.logoUrl !== undefined ? { logoUrl: sponsor.logoUrl } : {}),
         },
       };
       this.logger.debug('CreateSponsorUseCase completed successfully.', { result });
       return Result.ok(result);
     } catch (error) {
-      return Result.err(new RacingDomainValidationError(error instanceof Error ? error.message : 'Unknown error'));
+      return Result.err({ code: 'REPOSITORY_ERROR', details: { message: error instanceof Error ? error.message : 'Unknown error' } });
     }
   }
 
-  private validate(command: CreateSponsorCommand): Result<void, RacingDomainValidationError> {
+  private validate(command: CreateSponsorCommand): Result<void, ApplicationErrorCode<'VALIDATION_ERROR', { message: string }>> {
     this.logger.debug('Validating CreateSponsorCommand', { command });
     if (!command.name || command.name.trim().length === 0) {
       this.logger.warn('Validation failed: Sponsor name is required', { command });
-      return Result.err(new RacingDomainValidationError('Sponsor name is required'));
+      return Result.err({ code: 'VALIDATION_ERROR', details: { message: 'Sponsor name is required' } });
     }
     if (!command.contactEmail || command.contactEmail.trim().length === 0) {
       this.logger.warn('Validation failed: Sponsor contact email is required', { command });
-      return Result.err(new RacingDomainValidationError('Sponsor contact email is required'));
+      return Result.err({ code: 'VALIDATION_ERROR', details: { message: 'Sponsor contact email is required' } });
     }
     // Basic email validation
     const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
     if (!emailRegex.test(command.contactEmail)) {
       this.logger.warn('Validation failed: Invalid sponsor contact email format', { command });
-      return Result.err(new RacingDomainValidationError('Invalid sponsor contact email format'));
+      return Result.err({ code: 'VALIDATION_ERROR', details: { message: 'Invalid sponsor contact email format' } });
     }
     if (command.websiteUrl && command.websiteUrl.trim().length > 0) {
       try {
         new URL(command.websiteUrl);
       } catch {
         this.logger.warn('Validation failed: Invalid sponsor website URL', { command });
-        return Result.err(new RacingDomainValidationError('Invalid sponsor website URL'));
+        return Result.err({ code: 'VALIDATION_ERROR', details: { message: 'Invalid sponsor website URL' } });
       }
     }
     this.logger.debug('Validation successful.');