Posts and comments cleanup read and write operations | triggered by w…

…orks well

server/src/application/comment/create/create-comment.request.ts

@@ -1,19 +1,12 @@
-
 import { UseCaseRequest } from '@application/shared';
 import { TriggeredBy } from '@domain/shared/entities/triggered-by';
-// import { InvalidParameterException } from '@domain/shared/exceptions';
 
 class CreateCommentRequest extends UseCaseRequest {
-
   readonly postId: string;
   readonly content: string;
 
   // Constructor Section
-  constructor(
-    triggeredBy: TriggeredBy,
-    postId: string,
-    content: string,
-  ) {
+  constructor(triggeredBy: TriggeredBy, postId: string, content: string) {
     super(triggeredBy);
     this.postId = postId;
     this.content = content;
@@ -24,15 +17,13 @@ class CreateCommentRequest extends UseCaseRequest {
     postId: string,
     content: string,
   ): CreateCommentRequest {
-    return new CreateCommentRequest(
-      triggeredBy,
-      postId,
-      content,
-    );
-  } 
+    return new CreateCommentRequest(triggeredBy, postId, content);
+  }
 
-  // Validate here using EnsureClass
   protected validatePayload(): void {
+    if (!this.postId || !this.content || !this.triggeredBy) {
+      throw new Error('Invalid request payload provided');
+    }
   }
 }
 

server/src/application/comment/create/create-comment.usecase.ts

@@ -1,17 +1,39 @@
 import { BaseUseCase, UseCase } from '@application/shared';
 import { CreateCommentRequest } from './create-comment.request';
-import { CommentDetailsResponseDto } from '@contracts/dtos/comments';
-	
-@UseCase()
-class CreateCommentUseCase extends BaseUseCase<CreateCommentRequest,CommentDetailsResponseDto> {
+import { CommentResponseDto } from '@contracts/dtos/comments';
+import { Comment, CommentRepository } from '@domain/entities';
+import { Long } from 'typeorm';
+import { Logger } from '@domain/shared';
 
-  constructor() {
-	super();
+@UseCase()
+class CreateCommentUseCase extends BaseUseCase<
+  CreateCommentRequest,
+  CommentResponseDto
+> {
+  private readonly _commentRepository: CommentRepository;
+  constructor(commentRepository: CommentRepository) {
+    super();
+    this._commentRepository = commentRepository;
   }
 
-  public async performOperation({  }: CreateCommentRequest): Promise<CommentDetailsResponseDto> {
-	throw new Error('Method not implemented.');
+  public async performOperation(
+    request: CreateCommentRequest,
+  ): Promise<CommentResponseDto> {
+    const comment: Comment = Comment.create(
+      null,
+      request.postId,
+      null,
+      request.triggeredBy.toString(),
+      null,
+      request.content,
+      new Date(),
+      new Date(),
+      null,
+    );
+
+    const createdComment = await this._commentRepository.create(comment);
+    return CommentResponseDto.fromEntity(createdComment);
   }
 }
 
-export { CreateCommentUseCase };
+export { CreateCommentUseCase };

server/src/application/comment/delete/delete-comment.usecase.ts

@@ -1,16 +1,15 @@
 import { BaseUseCase, UseCase } from '@application/shared';
 import { DeleteCommentRequest } from './delete-comment.request';
-
-@UseCase()
-class DeleteCommentUseCase extends BaseUseCase<DeleteCommentRequest,bool> {
 
+@UseCase()
+class DeleteCommentUseCase extends BaseUseCase<DeleteCommentRequest, boolean> {
   constructor() {
-	super();
+    super();
   }
 
-  public async performOperation({  }: DeleteCommentRequest): Promise<bool> {
-	throw new Error('Method not implemented.');
+  public async performOperation({}: DeleteCommentRequest): Promise<boolean> {
+    throw new Error('Method not implemented.');
   }
 }
 
-export { DeleteCommentUseCase };
+export { DeleteCommentUseCase };

server/src/application/comment/edit/edit-comment.usecase.ts

@@ -1,16 +1,19 @@
 import { BaseUseCase, UseCase } from '@application/shared';
 import { EditCommentRequest } from './edit-comment.request';
-
-@UseCase()
-class EditCommentUseCase extends BaseUseCase<EditCommentRequest,CommentDetailsResponseDto> {
+import { CommentDetailsResponseDto } from '@contracts/dtos/comments';
 
+@UseCase()
+class EditCommentUseCase extends BaseUseCase<
+  EditCommentRequest,
+  CommentDetailsResponseDto
+> {
   constructor() {
-	super();
+    super();
   }
 
-  public async performOperation({  }: EditCommentRequest): Promise<CommentDetailsResponseDto> {
-	throw new Error('Method not implemented.');
+  public async performOperation({}: EditCommentRequest): Promise<CommentDetailsResponseDto> {
+    throw new Error('Method not implemented.');
   }
 }
 
-export { EditCommentUseCase };
+export { EditCommentUseCase };

server/src/application/comment/get-by-post-id/get-by-post-id-comment.request.ts

@@ -1,10 +1,8 @@
-
 import { UseCaseRequest } from '@application/shared';
 import { TriggeredBy } from '@domain/shared/entities/triggered-by';
 // import { InvalidParameterException } from '@domain/shared/exceptions';
 
-class GetByPostIdCommentRequest extends UseCaseRequest {
-
+class FindCommentsByPostIdRequest extends UseCaseRequest {
   readonly postId: string;
   readonly pageSize: number;
   readonly pageNumber: number;
@@ -27,18 +25,17 @@ class GetByPostIdCommentRequest extends UseCaseRequest {
     postId: string,
     pageSize: number,
     pageNumber: number,
-  ): GetByPostIdCommentRequest {
-    return new GetByPostIdCommentRequest(
+  ): FindCommentsByPostIdRequest {
+    return new FindCommentsByPostIdRequest(
       triggeredBy,
       postId,
       pageSize,
       pageNumber,
     );
-  } 
+  }
 
   // Validate here using EnsureClass
-  protected validatePayload(): void {
-  }
+  protected validatePayload(): void {}
 }
 
-export { GetByPostIdCommentRequest };
+export { FindCommentsByPostIdRequest };

server/src/application/comment/get-by-post-id/get-by-post-id-comment.usecase.ts

@@ -1,16 +1,30 @@
 import { BaseUseCase, UseCase } from '@application/shared';
-import { GetByPostIdCommentRequest } from './get-by-post-id-comment.request';
-
-@UseCase()
-class GetByPostIdCommentUseCase extends BaseUseCase<GetByPostIdCommentRequest,CommentResponseDto> {
+import { FindCommentsByPostIdRequest } from './get-by-post-id-comment.request';
+import { CommentResponseDto } from '@contracts/dtos/comments';
+import { CommentRepository } from '@domain/entities';
+import { Long } from 'typeorm';
+import { Logger } from '@domain/shared';
 
-  constructor() {
-	super();
+@UseCase()
+class FindCommentsByPostIdUseCase extends BaseUseCase<
+  FindCommentsByPostIdRequest,
+  CommentResponseDto[]
+> {
+  private readonly _commentRepository: CommentRepository;
+  constructor(commentRepository: CommentRepository) {
+    super();
+    this._commentRepository = commentRepository;
   }
 
-  public async performOperation({  }: GetByPostIdCommentRequest): Promise<CommentResponseDto> {
-	throw new Error('Method not implemented.');
+  public async performOperation(
+    request: FindCommentsByPostIdRequest,
+  ): Promise<CommentResponseDto[]> {
+    Logger.info('Get comments by post id');
+    const comments = await this._commentRepository.findByPostId(request.postId);
+    Logger.info('Get comments by post id', comments);
+
+    return comments.map(comment => CommentResponseDto.fromEntity(comment));
   }
 }
 
-export { GetByPostIdCommentUseCase };
+export { FindCommentsByPostIdUseCase };

server/src/application/comment/get-detail/get-detail-comment.usecase.ts

@@ -1,16 +1,19 @@
 import { BaseUseCase, UseCase } from '@application/shared';
 import { GetDetailCommentRequest } from './get-detail-comment.request';
-
-@UseCase()
-class GetDetailCommentUseCase extends BaseUseCase<GetDetailCommentRequest,CommentDetailsResponseDto> {
+import { CommentDetailsResponseDto } from '@contracts/dtos/comments';
 
+@UseCase()
+class GetDetailCommentUseCase extends BaseUseCase<
+  GetDetailCommentRequest,
+  CommentDetailsResponseDto
+> {
   constructor() {
-	super();
+    super();
   }
 
-  public async performOperation({  }: GetDetailCommentRequest): Promise<CommentDetailsResponseDto> {
-	throw new Error('Method not implemented.');
+  public async performOperation({}: GetDetailCommentRequest): Promise<CommentDetailsResponseDto> {
+    throw new Error('Method not implemented.');
   }
 }
 
-export { GetDetailCommentUseCase };
+export { GetDetailCommentUseCase };

server/src/application/post/create/create-post.use-case.ts

@@ -3,7 +3,6 @@ import { PostRepository } from '@domain/entities/posts/post.repository';
 import { PostDetailsResponseDto } from '@contracts/dtos/posts/post-details.response';
 import { CreatePostRequest } from './create-post.request';
 import { Post } from '@domain/entities';
-import { Logger } from '@domain/shared';
 
 @UseCase()
 class CreatePostUseCase extends BaseUseCase<
@@ -12,14 +11,11 @@ class CreatePostUseCase extends BaseUseCase<
 > {
   private readonly _postRepository: PostRepository;
 
-  constructor(
-    postRepository: PostRepository,
-  ) {
+  constructor(postRepository: PostRepository) {
     super();
     this._postRepository = postRepository;
   }
 
-
   public async performOperation(
     request: CreatePostRequest,
   ): Promise<PostDetailsResponseDto> {
@@ -36,9 +32,7 @@ class CreatePostUseCase extends BaseUseCase<
       null,
       null,
     );
-    Logger.info('CreatePostUseCase.performOperation', post);
     const createdPost = await this._postRepository.createPost(post);
-    Logger.info('Done', createdPost);
     if (createdPost) {
       return PostDetailsResponseDto.fromEntity(createdPost);
     }

server/src/application/post/find-all/find-all-post.usecase.ts

@@ -2,8 +2,6 @@ import { BaseUseCase, UseCase } from '@application/shared';
 import { FindAllPostRequest } from './find-all-post.request';
 import { PostResponseDto } from '@contracts/dtos/posts';
 import { PostRepository } from '@domain/entities/posts/post.repository';
-import { log } from 'console';
-import { Logger } from '@domain/shared';
 
 @UseCase()
 class FindAllPostUseCase extends BaseUseCase<
@@ -19,21 +17,17 @@ class FindAllPostUseCase extends BaseUseCase<
   public async performOperation(
     request: FindAllPostRequest,
   ): Promise<PostResponseDto[]> {
-    Logger.info('FindAllPostUseCase.performOperation');
     const { pageSize, pageNumber } = request;
     const posts = await this._postRepository.findAll(
       pageSize || 10,
       pageNumber || 1,
     );
 
-    Logger.info('posts from usecase', posts);
     const postDtos = await Promise.all(
       posts.map(async post => {
         return await PostResponseDto.fromEntity(post);
       }),
     );
-    Logger.info('postsDtos from usecase', postDtos);
-
     return postDtos;
   }
 }

server/src/application/shared/base-usecase.ts

@@ -1,9 +1,8 @@
 import { performance } from 'node:perf_hooks';
 
 import { UseCaseRequest } from './usecase.request';
-import { injectable } from 'inversify';
+import { Logger } from '@domain/shared';
 
-@injectable()
 abstract class BaseUseCase<IRequest extends UseCaseRequest, IResponse> {
   public async execute(request: IRequest): Promise<IResponse> {
     try {
@@ -12,6 +11,7 @@ abstract class BaseUseCase<IRequest extends UseCaseRequest, IResponse> {
       const response = await this.performOperation(request);
       const endTime = performance.now();
       const useCaseExecutionTime = endTime - startTime;
+      Logger.debug(`Use case execution time: ${useCaseExecutionTime}ms`);
       return response;
     } catch (error) {
       throw error;

server/src/contracts/dtos/comments/comment.response.ts

@@ -1,23 +1,27 @@
-import { Comment } from '@domain/entities';
-import { Nullable } from '@domain/shared/types';
+import { Comment, User } from '@domain/entities';
+import { Nullable } from '@domain/shared';
 import { UserResponseDto } from '@dtos/users';
 
 export class CommentResponseDto {
   constructor(
     public id: string,
     public content: string,
-    public author: UserResponseDto,
+    public authorId: string,
+    public author: Nullable<UserResponseDto>,
     public postId: string,
-    public createdAt: Nullable<Date>,
+    public createdAt: Date,
+    public updatedAt: Date,
   ) {}
 
   public static fromEntity(entity: Comment): CommentResponseDto {
     return new CommentResponseDto(
-      entity.id!,
+      entity.id as string,
       entity.content,
-      UserResponseDto.fromEntity(entity.author as any),
+      entity.authorId,
+      UserResponseDto.fromEntity(entity.author as User),
       entity.postId,
       entity.createdAt,
+      entity.updatedAt,
     );
   }
 }

server/src/domain/entities/comments/comment.repository.ts

@@ -1,12 +1,12 @@
 import { Comment } from '@domain/entities';
 
-interface ICommentRepository {
-  create(comment: Comment): Promise<Comment>;
-  findByPostId(postId: string): Promise<Comment[]>;
-  findById(commentId: string): Promise<Comment | null>;
-  findByAuthor(authorId: string): Promise<Comment[]>;
-  delete(commentId: string): Promise<void>;
-  update(comment: Comment): Promise<Comment>;
+abstract class CommentRepository {
+  abstract create(comment: Comment): Promise<Comment>;
+  abstract findByPostId(postId: string): Promise<Comment[]>;
+  abstract findById(commentId: string): Promise<Comment | null>;
+  abstract findByAuthor(authorId: string): Promise<Comment[]>;
+  abstract delete(commentId: string): Promise<boolean>;
+  abstract update(comment: Comment): Promise<Comment>;
 }
 
-export { ICommentRepository };
+export { CommentRepository };