refactor use cases

core/social/application/use-cases/GetUserFeedUseCase.ts

@@ -1,71 +1,74 @@
-import type { AsyncUseCase , Logger } from '@core/shared/application';
+import type { Logger , UseCaseOutputPort } from '@core/shared/application';
+import { Result } from '@core/shared/application/Result';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 import type { IFeedRepository } from '../../domain/repositories/IFeedRepository';
-import type { FeedItemDTO } from '../dto/FeedItemDTO';
 import type { FeedItem } from '../../domain/types/FeedItem';
-import type {
-  IUserFeedPresenter,
-  UserFeedViewModel,
-} from '../presenters/ISocialPresenters';
 
 export interface GetUserFeedParams {
   driverId: string;
   limit?: number;
 }
 
-export class GetUserFeedUseCase
-  implements AsyncUseCase<GetUserFeedParams, void> {
+export type GetUserFeedInput = GetUserFeedParams;
+
+export interface GetUserFeedResult {
+  items: FeedItem[];
+}
+
+export type GetUserFeedErrorCode = 'REPOSITORY_ERROR';
+
+export type GetUserFeedApplicationError = ApplicationErrorCode<
+  GetUserFeedErrorCode,
+  { message: string }
+>;
+
+export class GetUserFeedUseCase {
   constructor(
     private readonly feedRepository: IFeedRepository,
-    public readonly presenter: IUserFeedPresenter,
     private readonly logger: Logger,
+    private readonly output: UseCaseOutputPort<GetUserFeedResult>,
   ) {}
 
-  async execute(params: GetUserFeedParams): Promise<void> {
-    const { driverId, limit } = params;
-    this.logger.debug('Executing GetUserFeedUseCase', { driverId, limit });
+  async execute(
+    input: GetUserFeedInput,
+  ): Promise<Result<void, GetUserFeedApplicationError>> {
+    const { driverId, limit } = input;
+    this.logger.debug('GetUserFeedUseCase.execute started', { driverId, limit });
 
     try {
       const items = await this.feedRepository.getFeedForDriver(driverId, limit);
-      this.logger.info('Successfully retrieved user feed', { driverId, itemCount: items.length });
+
+      this.logger.info('GetUserFeedUseCase.execute succeeded', {
+        driverId,
+        itemCount: items.length,
+      });
+
       if (items.length === 0) {
         this.logger.warn(`No feed items found for driverId: ${driverId}`);
       }
-      const dtoItems = items.map(mapFeedItemToDTO);
 
-      const viewModel: UserFeedViewModel = {
-        items: dtoItems,
+      const result: GetUserFeedResult = {
+        items,
       };
 
-      this.presenter.present(viewModel);
+      this.output.present(result);
+
+      return Result.ok(undefined);
     } catch (error) {
-      this.logger.error('Failed to retrieve user feed', error);
-      throw error; // Re-throw the error so it can be handled upstream
+      const err = error instanceof Error ? error : new Error(String(error));
+
+      this.logger.error(
+        'GetUserFeedUseCase.execute failed',
+        err,
+        { input },
+      );
+
+      return Result.err({
+        code: 'REPOSITORY_ERROR',
+        details: {
+          message: err.message,
+        },
+      } as GetUserFeedApplicationError);
     }
   }
-}
-
-function mapFeedItemToDTO(item: FeedItem): FeedItemDTO {
-  const mappedType = (item.type as string).replace(/-/g, '_') as FeedItemDTO['type'];
-
-  const dto: FeedItemDTO = {
-    id: item.id,
-    timestamp:
-      item.timestamp instanceof Date
-        ? item.timestamp.toISOString()
-        : new Date(item.timestamp).toISOString(),
-    type: mappedType,
-    headline: item.headline,
-  };
-
-  if (item.actorFriendId !== undefined) dto.actorFriendId = item.actorFriendId;
-  if (item.actorDriverId !== undefined) dto.actorDriverId = item.actorDriverId;
-  if (item.leagueId !== undefined) dto.leagueId = item.leagueId;
-  if (item.raceId !== undefined) dto.raceId = item.raceId;
-  if (item.teamId !== undefined) dto.teamId = item.teamId;
-  if (item.position !== undefined) dto.position = item.position;
-  if (item.body !== undefined) dto.body = item.body;
-  if (item.ctaLabel !== undefined) dto.ctaLabel = item.ctaLabel;
-  if (item.ctaHref !== undefined) dto.ctaHref = item.ctaHref;
-
-  return dto;
 }