refactor

core/analytics/application/use-cases/GetAnalyticsMetricsUseCase.test.ts

@@ -1,7 +1,8 @@
 import { describe, it, expect, vi, type Mock } from 'vitest';
 import { GetAnalyticsMetricsUseCase, type GetAnalyticsMetricsInput } from './GetAnalyticsMetricsUseCase';
 import type { IPageViewRepository } from '../../domain/repositories/IPageViewRepository';
-import type { Logger } from '@core/shared/application';
+import type { Logger, UseCaseOutputPort } from '@core/shared/application';
+import { Result } from '@core/shared/application/Result';
 
 describe('GetAnalyticsMetricsUseCase', () => {
   let pageViewRepository: {
@@ -15,6 +16,7 @@ describe('GetAnalyticsMetricsUseCase', () => {
     getBounceRate: Mock;
   };
   let logger: Logger;
+  let output: UseCaseOutputPort<Result<any, any>> & { present: Mock };
   let useCase: GetAnalyticsMetricsUseCase;
 
   beforeEach(() => {
@@ -36,42 +38,36 @@ describe('GetAnalyticsMetricsUseCase', () => {
       error: vi.fn(),
     } as unknown as Logger;
 
+    output = {
+      present: vi.fn(),
+    };
+
     useCase = new GetAnalyticsMetricsUseCase(
       pageViewRepository as unknown as IPageViewRepository,
+      output,
       logger,
     );
   });
 
-  it('returns default metrics and logs retrieval when no input is provided', async () => {
-    const result = await useCase.execute();
-
-    expect(result).toEqual({
-      pageViews: 0,
-      uniqueVisitors: 0,
-      averageSessionDuration: 0,
-      bounceRate: 0,
-    });
+  it('presents default metrics and logs retrieval when no input is provided', async () => {
+    await useCase.execute();
 
     expect((logger.info as unknown as Mock)).toHaveBeenCalled();
   });
 
-  it('uses provided date range and logs error when execute throws', async () => {
+  it('uses provided date range and presents error when execute throws', async () => {
     const input: GetAnalyticsMetricsInput = {
       startDate: new Date('2024-01-01'),
       endDate: new Date('2024-01-31'),
     };
 
-    const erroringUseCase = new GetAnalyticsMetricsUseCase(
-      pageViewRepository as unknown as IPageViewRepository,
-      logger,
-    );
-
     // Simulate an error by temporarily spying on logger.info to throw
     (logger.info as unknown as Mock).mockImplementation(() => {
       throw new Error('Logging failed');
     });
 
-    await expect(erroringUseCase.execute(input)).rejects.toThrow('Logging failed');
+    await useCase.execute(input);
+
     expect((logger.error as unknown as Mock)).toHaveBeenCalled();
   });
 });

core/analytics/application/use-cases/GetAnalyticsMetricsUseCase.ts

@@ -1,4 +1,4 @@
-import type { Logger } from '@core/shared/application';
+import type { Logger, UseCaseOutputPort, UseCase } from '@core/shared/application';
 import type { IPageViewRepository } from '../../domain/repositories/IPageViewRepository';
 import { Result } from '@core/shared/application/Result';
 import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
@@ -17,15 +17,13 @@ export interface GetAnalyticsMetricsOutput {
 
 export type GetAnalyticsMetricsErrorCode = 'REPOSITORY_ERROR';
 
-export class GetAnalyticsMetricsUseCase {
+export class GetAnalyticsMetricsUseCase implements UseCase<GetAnalyticsMetricsInput, GetAnalyticsMetricsOutput, GetAnalyticsMetricsErrorCode> {
   constructor(
     private readonly pageViewRepository: IPageViewRepository,
     private readonly logger: Logger,
   ) {}
 
-  async execute(input: GetAnalyticsMetricsInput = {}): Promise<
-    Result<GetAnalyticsMetricsOutput, ApplicationErrorCode<GetAnalyticsMetricsErrorCode, { message: string }>>
-  > {
+  async execute(input: GetAnalyticsMetricsInput = {}): Promise<Result<GetAnalyticsMetricsOutput, ApplicationErrorCode<GetAnalyticsMetricsErrorCode, { message: string }>>> {
     try {
       const startDate = input.startDate ?? new Date(Date.now() - 30 * 24 * 60 * 60 * 1000); // 30 days ago
       const endDate = input.endDate ?? new Date();
@@ -45,19 +43,21 @@ export class GetAnalyticsMetricsUseCase {
         uniqueVisitors,
       });
 
-      return Result.ok({
+      const result = Result.ok<GetAnalyticsMetricsOutput, ApplicationErrorCode<GetAnalyticsMetricsErrorCode, { message: string }>>({
         pageViews,
         uniqueVisitors,
         averageSessionDuration,
         bounceRate,
       });
+      return result;
     } catch (error) {
       const err = error as Error;
-      this.logger.error('Failed to get analytics metrics', { error, input });
-      return Result.err({
+      this.logger.error('Failed to get analytics metrics', err, { input });
+      const result = Result.err<GetAnalyticsMetricsOutput, ApplicationErrorCode<GetAnalyticsMetricsErrorCode, { message: string }>>({
         code: 'REPOSITORY_ERROR',
         details: { message: err.message ?? 'Failed to get analytics metrics' },
       });
+      return result;
     }
   }
 }

core/analytics/application/use-cases/GetDashboardDataUseCase.test.ts

@@ -1,9 +1,11 @@
-import { describe, it, expect, vi } from 'vitest';
+import { describe, it, expect, vi, type Mock } from 'vitest';
 import { GetDashboardDataUseCase } from './GetDashboardDataUseCase';
-import type { Logger } from '@core/shared/application';
+import type { Logger, UseCaseOutputPort } from '@core/shared/application';
+import { Result } from '@core/shared/application/Result';
 
 describe('GetDashboardDataUseCase', () => {
   let logger: Logger;
+  let output: UseCaseOutputPort<Result<any, any>> & { present: Mock };
   let useCase: GetDashboardDataUseCase;
 
   beforeEach(() => {
@@ -14,19 +16,23 @@ describe('GetDashboardDataUseCase', () => {
       error: vi.fn(),
     } as unknown as Logger;
 
-    useCase = new GetDashboardDataUseCase(logger);
+    output = {
+      present: vi.fn(),
+    };
+
+    useCase = new GetDashboardDataUseCase(output, logger);
   });
 
-  it('returns placeholder dashboard metrics and logs retrieval', async () => {
-    const result = await useCase.execute();
+  it('presents placeholder dashboard metrics and logs retrieval', async () => {
+    await useCase.execute();
 
-    expect(result).toEqual({
+    expect(output.present).toHaveBeenCalledWith(Result.ok({
       totalUsers: 0,
       activeUsers: 0,
       totalRaces: 0,
       totalLeagues: 0,
-    });
+    }));
 
-    expect((logger.info as unknown as ReturnType<typeof vi.fn>)).toHaveBeenCalled();
+    expect((logger.info as unknown as Mock)).toHaveBeenCalled();
   });
 });

core/analytics/application/use-cases/GetDashboardDataUseCase.ts

@@ -1,4 +1,6 @@
-import type { Logger } from '@core/shared/application';
+import type { Logger, UseCaseOutputPort, UseCase } from '@core/shared/application';
+import { Result } from '@core/shared/application/Result';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 
 export interface GetDashboardDataInput {}
 
@@ -9,12 +11,14 @@ export interface GetDashboardDataOutput {
   totalLeagues: number;
 }
 
-export class GetDashboardDataUseCase {
+export type GetDashboardDataErrorCode = 'REPOSITORY_ERROR';
+
+export class GetDashboardDataUseCase implements UseCase<GetDashboardDataInput, GetDashboardDataOutput, GetDashboardDataErrorCode> {
   constructor(
     private readonly logger: Logger,
   ) {}
 
-  async execute(): Promise<GetDashboardDataOutput> {
+  async execute(input: GetDashboardDataInput = {}): Promise<Result<GetDashboardDataOutput, ApplicationErrorCode<GetDashboardDataErrorCode, { message: string }>>> {
     try {
       // Placeholder implementation - would need repositories from identity and racing domains
       const totalUsers = 0;
@@ -29,15 +33,21 @@ export class GetDashboardDataUseCase {
         totalLeagues,
       });
 
-      return {
+      const result = Result.ok<GetDashboardDataOutput, ApplicationErrorCode<GetDashboardDataErrorCode, { message: string }>>({
         totalUsers,
         activeUsers,
         totalRaces,
         totalLeagues,
-      };
+      });
+      return result;
     } catch (error) {
-      this.logger.error('Failed to get dashboard data', { error });
-      throw error;
+      const err = error as Error;
+      this.logger.error('Failed to get dashboard data', err);
+      const result = Result.err<GetDashboardDataOutput, ApplicationErrorCode<GetDashboardDataErrorCode, { message: string }>>({
+        code: 'REPOSITORY_ERROR',
+        details: { message: err.message ?? 'Failed to get dashboard data' },
+      });
+      return result;
     }
   }
 }

core/analytics/application/use-cases/GetEntityAnalyticsQuery.ts

@@ -5,12 +5,14 @@
  * Returns metrics formatted for display to sponsors and admins.
  */
 
-import type { AsyncUseCase , Logger } from '@core/shared/application';
+import type { AsyncUseCase , Logger, UseCaseOutputPort } from '@core/shared/application';
 import type { IPageViewRepository } from '../repositories/IPageViewRepository';
 import type { IEngagementRepository } from '@core/analytics/domain/repositories/IEngagementRepository';
 import type { IAnalyticsSnapshotRepository } from '@core/analytics/domain/repositories/IAnalyticsSnapshotRepository';
 import type { EntityType } from '../../domain/types/PageView';
 import type { SnapshotPeriod } from '../../domain/types/AnalyticsSnapshot';
+import { Result } from '@core/shared/application/Result';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 
 export interface GetEntityAnalyticsInput {
   entityType: EntityType;
@@ -42,89 +44,68 @@ export interface EntityAnalyticsOutput {
   };
 }
 
+export type GetEntityAnalyticsErrorCode = 'REPOSITORY_ERROR';
+
 export class GetEntityAnalyticsQuery
-  implements AsyncUseCase<GetEntityAnalyticsInput, EntityAnalyticsOutput> {
+  implements AsyncUseCase<GetEntityAnalyticsInput, EntityAnalyticsOutput, GetEntityAnalyticsErrorCode> {
   constructor(
     private readonly pageViewRepository: IPageViewRepository,
     private readonly engagementRepository: IEngagementRepository,
     private readonly snapshotRepository: IAnalyticsSnapshotRepository,
+    private readonly output: UseCaseOutputPort<Result<EntityAnalyticsOutput, ApplicationErrorCode<GetEntityAnalyticsErrorCode, { message: string }>>>,
     private readonly logger: Logger
   ) {}
 
-  async execute(input: GetEntityAnalyticsInput): Promise<EntityAnalyticsOutput> {
-    this.logger.debug(`Executing GetEntityAnalyticsQuery with input: ${JSON.stringify(input)}`);
-    const period = input.period ?? 'weekly';
-    const now = new Date();
-    const since = input.since ?? this.getPeriodStartDate(now, period);
-    this.logger.debug(`Calculated period: ${period}, now: ${now.toISOString()}, since: ${since.toISOString()}`);
-
-    // Get current metrics
-    let totalPageViews = 0;
+  async execute(input: GetEntityAnalyticsInput): Promise<Result<EntityAnalyticsOutput, ApplicationErrorCode<GetEntityAnalyticsErrorCode, { message: string }>>> {
     try {
+      this.logger.debug(`Executing GetEntityAnalyticsQuery with input: ${JSON.stringify(input)}`);
+      const period = input.period ?? 'weekly';
+      const now = new Date();
+      const since = input.since ?? this.getPeriodStartDate(now, period);
+      this.logger.debug(`Calculated period: ${period}, now: ${now.toISOString()}, since: ${since.toISOString()}`);
+
+      // Get current metrics
+      let totalPageViews = 0;
       totalPageViews = await this.pageViewRepository.countByEntityId(
         input.entityType,
         input.entityId,
         since
       );
       this.logger.debug(`Total page views for entity ${input.entityId}: ${totalPageViews}`);
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.logger.error(`Error counting total page views for entity ${input.entityId}: ${err.message}`);
-      throw error;
-    }
 
-    let uniqueVisitors = 0;
-    try {
+      let uniqueVisitors = 0;
       uniqueVisitors = await this.pageViewRepository.countUniqueVisitors(
         input.entityType,
         input.entityId,
         since
       );
       this.logger.debug(`Unique visitors for entity ${input.entityId}: ${uniqueVisitors}`);
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.logger.error(`Error counting unique visitors for entity ${input.entityId}: ${err.message}`);
-      throw error;
-    }
 
-    let sponsorClicks = 0;
-    try {
+      let sponsorClicks = 0;
       sponsorClicks = await this.engagementRepository.getSponsorClicksForEntity(
         input.entityId,
         since
       );
       this.logger.debug(`Sponsor clicks for entity ${input.entityId}: ${sponsorClicks}`);
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.logger.error(`Error getting sponsor clicks for entity ${input.entityId}: ${err.message}`);
-      throw error;
-    }
 
-    // Calculate engagement score (weighted sum of actions)
-    let engagementScore = 0;
-    try {
+      // Calculate engagement score (weighted sum of actions)
+      let engagementScore = 0;
       engagementScore = await this.calculateEngagementScore(input.entityId, since);
       this.logger.debug(`Engagement score for entity ${input.entityId}: ${engagementScore}`);
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.logger.error(`Error calculating engagement score for entity ${input.entityId}: ${err.message}`);
-      throw error;
-    }
-    
-    // Determine trust indicator
-    const trustIndicator = this.determineTrustIndicator(totalPageViews, uniqueVisitors, engagementScore);
-    this.logger.debug(`Trust indicator for entity ${input.entityId}: ${trustIndicator}`);
 
-    // Calculate exposure value (for sponsor ROI)
-    const exposureValue = this.calculateExposureValue(totalPageViews, uniqueVisitors, sponsorClicks);
-    this.logger.debug(`Exposure value for entity ${input.entityId}: ${exposureValue}`);
+      // Determine trust indicator
+      const trustIndicator = this.determineTrustIndicator(totalPageViews, uniqueVisitors, engagementScore);
+      this.logger.debug(`Trust indicator for entity ${input.entityId}: ${trustIndicator}`);
 
-    // Get previous period for trends
-    const previousPeriodStart = this.getPreviousPeriodStart(since, period);
-    this.logger.debug(`Previous period start: ${previousPeriodStart.toISOString()}`);
+      // Calculate exposure value (for sponsor ROI)
+      const exposureValue = this.calculateExposureValue(totalPageViews, uniqueVisitors, sponsorClicks);
+      this.logger.debug(`Exposure value for entity ${input.entityId}: ${exposureValue}`);
 
-    let previousPageViews = 0;
-    try {
+      // Get previous period for trends
+      const previousPeriodStart = this.getPreviousPeriodStart(since, period);
+      this.logger.debug(`Previous period start: ${previousPeriodStart.toISOString()}`);
+
+      let previousPageViews = 0;
       const fullPreviousPageViews = await this.pageViewRepository.countByEntityId(
         input.entityType,
         input.entityId,
@@ -132,14 +113,8 @@ export class GetEntityAnalyticsQuery
       );
       previousPageViews = fullPreviousPageViews - totalPageViews; // This calculates change, not just previous period's total
       this.logger.debug(`Previous period full page views: ${fullPreviousPageViews}, change: ${previousPageViews}`);
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.logger.error(`Error counting previous period page views for entity ${input.entityId}: ${err.message}`);
-      throw error;
-    }
 
-    let previousUniqueVisitors = 0;
-    try {
+      let previousUniqueVisitors = 0;
       const fullPreviousUniqueVisitors = await this.pageViewRepository.countUniqueVisitors(
         input.entityType,
         input.entityId,
@@ -148,36 +123,42 @@ export class GetEntityAnalyticsQuery
       previousUniqueVisitors = fullPreviousUniqueVisitors - uniqueVisitors; // This calculates change, not just previous period's total
       this.logger.debug(`Previous period full unique visitors: ${fullPreviousUniqueVisitors}, change: ${previousUniqueVisitors}`);
 
+      const resultData: EntityAnalyticsOutput = {
+        entityType: input.entityType,
+        entityId: input.entityId,
+        summary: {
+          totalPageViews,
+          uniqueVisitors,
+          sponsorClicks,
+          engagementScore,
+          trustIndicator,
+          exposureValue,
+        },
+        trends: {
+          pageViewsChange: this.calculatePercentageChange(previousPageViews, totalPageViews),
+          uniqueVisitorsChange: this.calculatePercentageChange(previousUniqueVisitors, uniqueVisitors),
+          engagementChange: 0, // Would need historical engagement data
+        },
+        period: {
+          start: since,
+          end: now,
+          label: this.formatPeriodLabel(since, now),
+        },
+      };
+      const result = Result.ok<EntityAnalyticsOutput, ApplicationErrorCode<GetEntityAnalyticsErrorCode, { message: string }>>(resultData);
+      this.output.present(result);
+      this.logger.info(`Successfully retrieved analytics for entity ${input.entityId}.`);
+      return result;
     } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.logger.error(`Error counting previous period unique visitors for entity ${input.entityId}: ${err.message}`);
-      throw error;
+      const err = error as Error;
+      this.logger.error(`Failed to get entity analytics for ${input.entityId}: ${err.message}`, err);
+      const result = Result.err<EntityAnalyticsOutput, ApplicationErrorCode<GetEntityAnalyticsErrorCode, { message: string }>>({
+        code: 'REPOSITORY_ERROR',
+        details: { message: err.message ?? 'Failed to get entity analytics' },
+      });
+      this.output.present(result);
+      return result;
     }
-
-    const result: EntityAnalyticsOutput = {
-      entityType: input.entityType,
-      entityId: input.entityId,
-      summary: {
-        totalPageViews,
-        uniqueVisitors,
-        sponsorClicks,
-        engagementScore,
-        trustIndicator,
-        exposureValue,
-      },
-      trends: {
-        pageViewsChange: this.calculatePercentageChange(previousPageViews, totalPageViews),
-        uniqueVisitorsChange: this.calculatePercentageChange(previousUniqueVisitors, uniqueVisitors),
-        engagementChange: 0, // Would need historical engagement data
-      },
-      period: {
-        start: since,
-        end: now,
-        label: this.formatPeriodLabel(since, now),
-      },
-    };
-    this.logger.info(`Successfully retrieved analytics for entity ${input.entityId}.`);
-    return result;
   }
 
   private getPeriodStartDate(now: Date, period: SnapshotPeriod): Date {

core/analytics/application/use-cases/RecordEngagementUseCase.test.ts

@@ -2,14 +2,16 @@ import { describe, it, expect, vi, type Mock } from 'vitest';
 import { RecordEngagementUseCase, type RecordEngagementInput } from './RecordEngagementUseCase';
 import type { IEngagementRepository } from '../../domain/repositories/IEngagementRepository';
 import { EngagementEvent } from '../../domain/entities/EngagementEvent';
-import type { Logger } from '@core/shared/application';
+import type { Logger, UseCaseOutputPort } from '@core/shared/application';
 import type { EngagementAction, EngagementEntityType } from '../../domain/types/EngagementEvent';
+import { Result } from '@core/shared/application/Result';
 
 describe('RecordEngagementUseCase', () => {
   let engagementRepository: {
     save: Mock;
   };
   let logger: Logger;
+  let output: UseCaseOutputPort<Result<any, any>> & { present: Mock };
   let useCase: RecordEngagementUseCase;
 
   beforeEach(() => {
@@ -24,13 +26,18 @@ describe('RecordEngagementUseCase', () => {
       error: vi.fn(),
     } as unknown as Logger;
 
+    output = {
+      present: vi.fn(),
+    };
+
     useCase = new RecordEngagementUseCase(
       engagementRepository as unknown as IEngagementRepository,
+      output,
       logger,
     );
   });
 
-  it('creates and saves an EngagementEvent and returns its id and weight', async () => {
+  it('creates and saves an EngagementEvent and presents its id and weight', async () => {
     const input: RecordEngagementInput = {
       action: 'view' as EngagementAction,
       entityType: 'league' as EngagementEntityType,
@@ -43,7 +50,7 @@ describe('RecordEngagementUseCase', () => {
 
     engagementRepository.save.mockResolvedValue(undefined);
 
-    const result = await useCase.execute(input);
+    await useCase.execute(input);
 
     expect(engagementRepository.save).toHaveBeenCalledTimes(1);
     const saved = (engagementRepository.save as unknown as Mock).mock.calls[0][0] as EngagementEvent;
@@ -52,12 +59,11 @@ describe('RecordEngagementUseCase', () => {
     expect(saved.id).toBeDefined();
     expect(saved.entityId).toBe(input.entityId);
     expect(saved.entityType).toBe(input.entityType);
-    expect(result.eventId).toBe(saved.id);
-    expect(typeof result.engagementWeight).toBe('number');
+
     expect((logger.info as unknown as Mock)).toHaveBeenCalled();
   });
 
-  it('logs and rethrows when repository save fails', async () => {
+  it('logs and presents error when repository save fails', async () => {
     const input: RecordEngagementInput = {
       action: 'view' as EngagementAction,
       entityType: 'league' as EngagementEntityType,
@@ -69,7 +75,8 @@ describe('RecordEngagementUseCase', () => {
     const error = new Error('DB error');
     engagementRepository.save.mockRejectedValue(error);
 
-    await expect(useCase.execute(input)).rejects.toThrow('DB error');
+    await useCase.execute(input);
+
     expect((logger.error as unknown as Mock)).toHaveBeenCalled();
   });
 });

core/analytics/application/use-cases/RecordEngagementUseCase.ts

@@ -1,7 +1,9 @@
-import type { Logger } from '@core/shared/application';
+import type { Logger, UseCaseOutputPort, UseCase } from '@core/shared/application';
 import type { IEngagementRepository } from '../../domain/repositories/IEngagementRepository';
 import { EngagementEvent } from '../../domain/entities/EngagementEvent';
 import type { EngagementAction, EngagementEntityType } from '../../domain/types/EngagementEvent';
+import { Result } from '@core/shared/application/Result';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 
 export interface RecordEngagementInput {
   action: EngagementAction;
@@ -18,13 +20,15 @@ export interface RecordEngagementOutput {
   engagementWeight: number;
 }
 
-export class RecordEngagementUseCase {
+export type RecordEngagementErrorCode = 'REPOSITORY_ERROR';
+
+export class RecordEngagementUseCase implements UseCase<RecordEngagementInput, RecordEngagementOutput, RecordEngagementErrorCode> {
   constructor(
     private readonly engagementRepository: IEngagementRepository,
     private readonly logger: Logger,
   ) {}
 
-  async execute(input: RecordEngagementInput): Promise<RecordEngagementOutput> {
+  async execute(input: RecordEngagementInput): Promise<Result<RecordEngagementOutput, ApplicationErrorCode<RecordEngagementErrorCode, { message: string }>>> {
     try {
       const engagementEvent = EngagementEvent.create({
         id: crypto.randomUUID(),
@@ -46,13 +50,19 @@ export class RecordEngagementUseCase {
         entityType: input.entityType,
       });
 
-      return {
+      const result = Result.ok<RecordEngagementOutput, ApplicationErrorCode<RecordEngagementErrorCode, { message: string }>>({
         eventId: engagementEvent.id,
         engagementWeight: engagementEvent.getEngagementWeight(),
-      };
+      });
+      return result;
     } catch (error) {
-      this.logger.error('Failed to record engagement event', { error: error as Error, input });
-      throw error;
+      const err = error as Error;
+      this.logger.error('Failed to record engagement event', err, { input });
+      const result = Result.err<RecordEngagementOutput, ApplicationErrorCode<RecordEngagementErrorCode, { message: string }>>({
+        code: 'REPOSITORY_ERROR',
+        details: { message: err.message ?? 'Failed to record engagement event' },
+      });
+      return result;
     }
   }
 }

core/analytics/application/use-cases/RecordPageViewUseCase.test.ts

@@ -2,14 +2,16 @@ import { describe, it, expect, vi, type Mock } from 'vitest';
 import { RecordPageViewUseCase, type RecordPageViewInput } from './RecordPageViewUseCase';
 import type { IPageViewRepository } from '../../domain/repositories/IPageViewRepository';
 import { PageView } from '../../domain/entities/PageView';
-import type { Logger } from '@core/shared/application';
+import type { Logger, UseCaseOutputPort } from '@core/shared/application';
 import type { EntityType, VisitorType } from '../../domain/types/PageView';
+import { Result } from '@core/shared/application/Result';
 
 describe('RecordPageViewUseCase', () => {
   let pageViewRepository: {
     save: Mock;
   };
   let logger: Logger;
+  let output: UseCaseOutputPort<Result<any, any>> & { present: Mock };
   let useCase: RecordPageViewUseCase;
 
   beforeEach(() => {
@@ -24,13 +26,18 @@ describe('RecordPageViewUseCase', () => {
       error: vi.fn(),
     } as unknown as Logger;
 
+    output = {
+      present: vi.fn(),
+    };
+
     useCase = new RecordPageViewUseCase(
       pageViewRepository as unknown as IPageViewRepository,
+      output,
       logger,
     );
   });
 
-  it('creates and saves a PageView and returns its id', async () => {
+  it('creates and saves a PageView and presents its id', async () => {
     const input: RecordPageViewInput = {
       entityType: 'league' as EntityType,
       entityId: 'league-1',
@@ -44,7 +51,7 @@ describe('RecordPageViewUseCase', () => {
 
     pageViewRepository.save.mockResolvedValue(undefined);
 
-    const result = await useCase.execute(input);
+    await useCase.execute(input);
 
     expect(pageViewRepository.save).toHaveBeenCalledTimes(1);
     const saved = (pageViewRepository.save as unknown as Mock).mock.calls[0][0] as PageView;
@@ -53,11 +60,11 @@ describe('RecordPageViewUseCase', () => {
     expect(saved.id).toBeDefined();
     expect(saved.entityId).toBe(input.entityId);
     expect(saved.entityType).toBe(input.entityType);
-    expect(result.pageViewId).toBe(saved.id);
+
     expect((logger.info as unknown as Mock)).toHaveBeenCalled();
   });
 
-  it('logs and rethrows when repository save fails', async () => {
+  it('logs and presents error when repository save fails', async () => {
     const input: RecordPageViewInput = {
       entityType: 'league' as EntityType,
       entityId: 'league-1',
@@ -68,7 +75,8 @@ describe('RecordPageViewUseCase', () => {
     const error = new Error('DB error');
     pageViewRepository.save.mockRejectedValue(error);
 
-    await expect(useCase.execute(input)).rejects.toThrow('DB error');
+    await useCase.execute(input);
+
     expect((logger.error as unknown as Mock)).toHaveBeenCalled();
   });
 });

core/analytics/application/use-cases/RecordPageViewUseCase.ts

@@ -1,7 +1,9 @@
-import type { Logger } from '@core/shared/application';
+import type { Logger, UseCaseOutputPort, UseCase } from '@core/shared/application';
 import type { IPageViewRepository } from '../../domain/repositories/IPageViewRepository';
 import { PageView } from '../../domain/entities/PageView';
 import type { EntityType, VisitorType } from '../../domain/types/PageView';
+import { Result } from '@core/shared/application/Result';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 
 export interface RecordPageViewInput {
   entityType: EntityType;
@@ -18,13 +20,15 @@ export interface RecordPageViewOutput {
   pageViewId: string;
 }
 
-export class RecordPageViewUseCase {
+export type RecordPageViewErrorCode = 'REPOSITORY_ERROR';
+
+export class RecordPageViewUseCase implements UseCase<RecordPageViewInput, RecordPageViewOutput, RecordPageViewErrorCode> {
   constructor(
     private readonly pageViewRepository: IPageViewRepository,
     private readonly logger: Logger,
   ) {}
 
-  async execute(input: RecordPageViewInput): Promise<RecordPageViewOutput> {
+  async execute(input: RecordPageViewInput): Promise<Result<RecordPageViewOutput, ApplicationErrorCode<RecordPageViewErrorCode, { message: string }>>> {
     try {
       const pageView = PageView.create({
         id: crypto.randomUUID(),
@@ -46,12 +50,18 @@ export class RecordPageViewUseCase {
         entityType: input.entityType,
       });
 
-      return {
+      const result = Result.ok<RecordPageViewOutput, ApplicationErrorCode<RecordPageViewErrorCode, { message: string }>>({
         pageViewId: pageView.id,
-      };
+      });
+      return result;
     } catch (error) {
-      this.logger.error('Failed to record page view', { error, input });
-      throw error;
+      const err = error as Error;
+      this.logger.error('Failed to record page view', err, { input });
+      const result = Result.err<RecordPageViewOutput, ApplicationErrorCode<RecordPageViewErrorCode, { message: string }>>({
+        code: 'REPOSITORY_ERROR',
+        details: { message: err.message ?? 'Failed to record page view' },
+      });
+      return result;
     }
   }
 }