mmintel/gridpilot.gg
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

refactor use cases

Browse Source
This commit is contained in:
Marc Mintel
2025-12-21 01:31:31 +01:00
parent 8ecd638396
commit 22f28728ce
17 changed files with 402 additions and 286 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
core/social/application/use-cases/GetCurrentUserSocialUseCase.ts
View File

@@ -1,43 +1,65 @@
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 { ISocialGraphRepository } from '../../domain/repositories/ISocialGraphRepository';
import type { CurrentUserSocialDTO } from '../dto/CurrentUserSocialDTO';
import type { FriendDTO } from '../dto/FriendDTO';
import type {
CurrentUserSocialViewModel,
ICurrentUserSocialPresenter,
} from '../presenters/ISocialPresenters';
export interface GetCurrentUserSocialParams {
driverId: string;
}
export type GetCurrentUserSocialInput = GetCurrentUserSocialParams;
export interface GetCurrentUserSocialResult {
currentUser: CurrentUserSocialDTO;
friends: FriendDTO[];
}
export type GetCurrentUserSocialErrorCode = 'REPOSITORY_ERROR';
export type GetCurrentUserSocialApplicationError = ApplicationErrorCode<
GetCurrentUserSocialErrorCode,
{ message: string }
>;
/**
* Application-level use case to retrieve the current user's social context.
*
* Keeps orchestration in the social bounded context while delegating
* data access to domain repositories and presenting via a presenter.
* data access to domain repositories and presenting via an output port.
*/
export class GetCurrentUserSocialUseCase
implements AsyncUseCase<GetCurrentUserSocialParams, void> {
export class GetCurrentUserSocialUseCase {
constructor(
private readonly socialGraphRepository: ISocialGraphRepository,
public readonly presenter: ICurrentUserSocialPresenter,
private readonly logger: Logger,
private readonly output: UseCaseOutputPort<GetCurrentUserSocialResult>,
) {}
async execute(params: GetCurrentUserSocialParams): Promise<void> {
this.logger.debug('GetCurrentUserSocialUseCase: Starting execution', { params });
try {
const { driverId } = params;
async execute(
input: GetCurrentUserSocialInput,
): Promise<Result<void, GetCurrentUserSocialApplicationError>> {
this.logger.debug('GetCurrentUserSocialUseCase.execute: Starting execution', { input });
this.logger.debug(`GetCurrentUserSocialUseCase: Fetching friends for driverId: ${driverId}`);
try {
const { driverId } = input;
this.logger.debug(
'GetCurrentUserSocialUseCase.execute: Fetching friends for driverId',
{ driverId },
);
const friendsDomain = await this.socialGraphRepository.getFriends(driverId);
this.logger.debug('GetCurrentUserSocialUseCase: Successfully fetched friends from social graph repository', { friendsCount: friendsDomain.length });
this.logger.debug(
'GetCurrentUserSocialUseCase.execute: Successfully fetched friends from social graph repository',
{ friendsCount: friendsDomain.length },
);
if (friendsDomain.length === 0) {
this.logger.warn(`GetCurrentUserSocialUseCase: No friends found for driverId: ${driverId}`);
this.logger.warn(
`GetCurrentUserSocialUseCase.execute: No friends found for driverId: ${driverId}`,
);
}
const friends: FriendDTO[] = friendsDomain.map((friend) => ({
const friends: FriendDTO[] = friendsDomain.map(friend => ({
driverId: friend.id,
displayName: friend.name,
avatarUrl: '',
@@ -52,16 +74,32 @@ export class GetCurrentUserSocialUseCase
countryCode: '',
};
const viewModel: CurrentUserSocialViewModel = {
const result: GetCurrentUserSocialResult = {
currentUser,
friends,
};
this.presenter.present(viewModel);
this.logger.info('GetCurrentUserSocialUseCase: Successfully presented current user social data');
this.output.present(result);
this.logger.info(
'GetCurrentUserSocialUseCase.execute: Successfully presented current user social data',
);
return Result.ok(undefined);
} catch (error) {
this.logger.error('GetCurrentUserSocialUseCase: Error during execution', { error });
throw error;
const err = error instanceof Error ? error : new Error(String(error));
this.logger.error(
'GetCurrentUserSocialUseCase.execute: Error during execution',
err,
{ input },
);
return Result.err({
code: 'REPOSITORY_ERROR',
details: {
message: err.message,
},
} as GetCurrentUserSocialApplicationError);
}
}
}

93
core/social/application/use-cases/GetUserFeedUseCase.ts
View File

@@ -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;
}