add decks crud

src/modules/decks/decks.controller.ts

@@ -0,0 +1,60 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Patch,
+  Post,
+  Query,
+  Req,
+  Request,
+  UseGuards,
+} from '@nestjs/common'
+import { DecksService } from './decks.service'
+import { CreateDeckDto } from './dto/create-deck.dto'
+import { UpdateDeckDto } from './dto/update-deck.dto'
+import { CommandBus } from '@nestjs/cqrs'
+import { CreateDeckCommand } from './use-cases'
+import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard'
+import { GetAllDecksCommand } from './use-cases/get-all-decks-use-case'
+import { GetAllDecksDto } from './dto/get-all-decks.dto'
+import { GetDeckByIdCommand } from './use-cases/get-deck-by-id-use-case'
+import { DeleteDeckByIdCommand } from './use-cases/delete-deck-by-id-use-case'
+import { UpdateDeckCommand } from './use-cases/update-deck-use-case'
+
+@Controller('decks')
+export class DecksController {
+  constructor(private readonly decksService: DecksService, private commandBus: CommandBus) {}
+
+  @UseGuards(JwtAuthGuard)
+  @Post()
+  create(@Request() req, @Body() createDeckDto: CreateDeckDto) {
+    const userId = req.user.id
+    return this.commandBus.execute(new CreateDeckCommand({ ...createDeckDto, userId: userId }))
+  }
+
+  @UseGuards(JwtAuthGuard)
+  @Get()
+  findAll(@Query() query: GetAllDecksDto, @Req() req) {
+    return this.commandBus.execute(new GetAllDecksCommand({ ...query, userId: req.user.id }))
+  }
+
+  @UseGuards(JwtAuthGuard)
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.commandBus.execute(new GetDeckByIdCommand(id))
+  }
+
+  @UseGuards(JwtAuthGuard)
+  @Patch(':id')
+  update(@Param('id') id: string, @Body() updateDeckDto: UpdateDeckDto, @Req() req) {
+    return this.commandBus.execute(new UpdateDeckCommand(id, updateDeckDto, req.user.id))
+  }
+
+  @UseGuards(JwtAuthGuard)
+  @Delete(':id')
+  remove(@Param('id') id: string, @Req() req) {
+    return this.commandBus.execute(new DeleteDeckByIdCommand(id, req.user.id))
+  }
+}

src/modules/decks/decks.module.ts

@@ -0,0 +1,26 @@
+import { Module } from '@nestjs/common'
+import { DecksService } from './decks.service'
+import { DecksController } from './decks.controller'
+import { CqrsModule } from '@nestjs/cqrs'
+import { CreateDeckHandler } from './use-cases'
+import { DecksRepository } from './infrastructure/decks.repository'
+import { GetAllDecksHandler } from './use-cases/get-all-decks-use-case'
+import { GetDeckByIdHandler } from './use-cases/get-deck-by-id-use-case'
+import { DeleteDeckByIdHandler } from './use-cases/delete-deck-by-id-use-case'
+import { UpdateDeckHandler } from './use-cases/update-deck-use-case'
+
+const commandHandlers = [
+  CreateDeckHandler,
+  GetAllDecksHandler,
+  GetDeckByIdHandler,
+  DeleteDeckByIdHandler,
+  UpdateDeckHandler,
+]
+
+@Module({
+  imports: [CqrsModule],
+  controllers: [DecksController],
+  providers: [DecksService, DecksRepository, ...commandHandlers],
+  exports: [CqrsModule],
+})
+export class DecksModule {}

src/modules/decks/decks.service.ts

@@ -0,0 +1,4 @@
+import { Injectable } from '@nestjs/common'
+
+@Injectable()
+export class DecksService {}

src/modules/decks/dto/create-deck.dto.ts

@@ -0,0 +1,16 @@
+import { IsBoolean, IsOptional, IsString, Length } from 'class-validator'
+
+export class CreateDeckDto {
+  @Length(3, 30)
+  name: string
+
+  @IsOptional()
+  @IsString()
+  cover?: string
+
+  @IsOptional()
+  @IsBoolean()
+  isPrivate?: boolean
+
+  userId: string
+}

src/modules/decks/dto/get-all-decks.dto.ts

@@ -0,0 +1,15 @@
+import { IsOptional, IsUUID, Length } from 'class-validator'
+import { IsOptionalOrEmptyString } from '../../../infrastructure/decorators/is-optional-or-empty-string'
+import { PaginationDto } from '../../../infrastructure/common/pagination/pagination.dto'
+
+export class GetAllDecksDto extends PaginationDto {
+  @IsOptional()
+  @Length(3, 30)
+  name?: string
+
+  @IsOptionalOrEmptyString()
+  @IsUUID(4)
+  authorId?: string
+
+  userId: string
+}

src/modules/decks/dto/update-deck.dto.ts

@@ -0,0 +1,16 @@
+import { PartialType } from '@nestjs/mapped-types'
+import { CreateDeckDto } from './create-deck.dto'
+import { IsOptionalOrEmptyString } from '../../../infrastructure/decorators/is-optional-or-empty-string'
+import { IsBoolean } from 'class-validator'
+
+export class UpdateDeckDto extends PartialType(CreateDeckDto) {
+  @IsOptionalOrEmptyString()
+  name: string
+
+  @IsOptionalOrEmptyString()
+  @IsBoolean()
+  isPrivate: boolean
+
+  @IsOptionalOrEmptyString()
+  cover: string
+}

src/modules/decks/entities/deck.entity.ts

@@ -0,0 +1 @@
+export class Deck {}

src/modules/decks/infrastructure/decks.repository.ts

@@ -0,0 +1,126 @@
+import { Injectable, InternalServerErrorException, Logger } from '@nestjs/common'
+import { PrismaService } from '../../../prisma.service'
+import { GetAllDecksDto } from '../dto/get-all-decks.dto'
+import {
+  DEFAULT_PAGE_NUMBER,
+  DEFAULT_PAGE_SIZE,
+} from '../../../infrastructure/common/pagination/pagination.constants'
+
+@Injectable()
+export class DecksRepository {
+  constructor(private prisma: PrismaService) {}
+  private readonly logger = new Logger(DecksRepository.name)
+  async createDeck({
+    name,
+    userId,
+    cover,
+    isPrivate,
+  }: {
+    name: string
+    userId: string
+    cover?: string
+    isPrivate?: boolean
+  }) {
+    try {
+      return await this.prisma.deck.create({
+        data: {
+          user: {
+            connect: {
+              id: userId,
+            },
+          },
+
+          name,
+          cover,
+          isPrivate,
+        },
+      })
+    } catch (e) {
+      this.logger.error(e?.message)
+      throw new InternalServerErrorException(e?.message)
+    }
+  }
+
+  async findAllDecks({
+    name = undefined,
+    authorId = undefined,
+    userId,
+    currentPage = DEFAULT_PAGE_NUMBER,
+    pageSize = DEFAULT_PAGE_SIZE,
+  }: GetAllDecksDto) {
+    try {
+      return await this.prisma.deck.findMany({
+        where: {
+          name: {
+            contains: name,
+          },
+          user: {
+            id: authorId || undefined,
+          },
+          OR: [
+            {
+              AND: [
+                {
+                  isPrivate: true,
+                },
+                {
+                  userId: userId,
+                },
+              ],
+            },
+            {
+              isPrivate: false,
+            },
+          ],
+        },
+        skip: (currentPage - 1) * pageSize,
+        take: pageSize,
+      })
+    } catch (e) {
+      this.logger.error(e?.message)
+      throw new InternalServerErrorException(e?.message)
+    }
+  }
+  public async findDeckById(id: string) {
+    try {
+      return await this.prisma.deck.findUnique({
+        where: {
+          id,
+        },
+      })
+    } catch (e) {
+      this.logger.error(e?.message)
+      throw new InternalServerErrorException(e?.message)
+    }
+  }
+
+  public async deleteDeckById(id: string) {
+    try {
+      return await this.prisma.deck.delete({
+        where: {
+          id,
+        },
+      })
+    } catch (e) {
+      this.logger.error(e?.message)
+      throw new InternalServerErrorException(e?.message)
+    }
+  }
+
+  public async updateDeckById(
+    id: string,
+    data: { name?: string; cover?: string; isPrivate?: boolean }
+  ) {
+    try {
+      return await this.prisma.deck.update({
+        where: {
+          id,
+        },
+        data,
+      })
+    } catch (e) {
+      this.logger.error(e?.message)
+      throw new InternalServerErrorException(e?.message)
+    }
+  }
+}

src/modules/decks/use-cases/create-deck-use-case.ts

@@ -0,0 +1,16 @@
+import { CommandHandler, ICommandHandler } from '@nestjs/cqrs'
+import { CreateDeckDto } from '../dto/create-deck.dto'
+import { DecksRepository } from '../infrastructure/decks.repository'
+
+export class CreateDeckCommand {
+  constructor(public readonly deck: CreateDeckDto) {}
+}
+
+@CommandHandler(CreateDeckCommand)
+export class CreateDeckHandler implements ICommandHandler<CreateDeckCommand> {
+  constructor(private readonly deckRepository: DecksRepository) {}
+
+  async execute(command: CreateDeckCommand) {
+    return await this.deckRepository.createDeck(command.deck)
+  }
+}

src/modules/decks/use-cases/delete-deck-by-id-use-case.ts

@@ -0,0 +1,21 @@
+import { CommandHandler, ICommandHandler } from '@nestjs/cqrs'
+import { DecksRepository } from '../infrastructure/decks.repository'
+import { BadRequestException, NotFoundException } from '@nestjs/common'
+
+export class DeleteDeckByIdCommand {
+  constructor(public readonly id: string, public readonly userId: string) {}
+}
+
+@CommandHandler(DeleteDeckByIdCommand)
+export class DeleteDeckByIdHandler implements ICommandHandler<DeleteDeckByIdCommand> {
+  constructor(private readonly deckRepository: DecksRepository) {}
+
+  async execute(command: DeleteDeckByIdCommand) {
+    const deck = await this.deckRepository.findDeckById(command.id)
+    if (!deck) throw new NotFoundException(`Deck with id ${command.id} not found`)
+    if (deck.userId !== command.userId) {
+      throw new BadRequestException(`You can't delete a deck that you don't own`)
+    }
+    return await this.deckRepository.deleteDeckById(command.id)
+  }
+}

src/modules/decks/use-cases/get-all-decks-use-case.ts

@@ -0,0 +1,16 @@
+import { CommandHandler, ICommandHandler } from '@nestjs/cqrs'
+import { DecksRepository } from '../infrastructure/decks.repository'
+import { GetAllDecksDto } from '../dto/get-all-decks.dto'
+
+export class GetAllDecksCommand {
+  constructor(public readonly params: GetAllDecksDto) {}
+}
+
+@CommandHandler(GetAllDecksCommand)
+export class GetAllDecksHandler implements ICommandHandler<GetAllDecksCommand> {
+  constructor(private readonly deckRepository: DecksRepository) {}
+
+  async execute(command: GetAllDecksCommand) {
+    return await this.deckRepository.findAllDecks(command.params)
+  }
+}

src/modules/decks/use-cases/get-deck-by-id-use-case.ts

@@ -0,0 +1,15 @@
+import { CommandHandler, ICommandHandler } from '@nestjs/cqrs'
+import { DecksRepository } from '../infrastructure/decks.repository'
+
+export class GetDeckByIdCommand {
+  constructor(public readonly id: string) {}
+}
+
+@CommandHandler(GetDeckByIdCommand)
+export class GetDeckByIdHandler implements ICommandHandler<GetDeckByIdCommand> {
+  constructor(private readonly deckRepository: DecksRepository) {}
+
+  async execute(command: GetDeckByIdCommand) {
+    return await this.deckRepository.findDeckById(command.id)
+  }
+}

src/modules/decks/use-cases/index.ts

@@ -0,0 +1 @@
+export * from './create-deck-use-case'

src/modules/decks/use-cases/update-deck-use-case.ts

@@ -0,0 +1,27 @@
+import { CommandHandler, ICommandHandler } from '@nestjs/cqrs'
+import { DecksRepository } from '../infrastructure/decks.repository'
+import { UpdateDeckDto } from '../dto/update-deck.dto'
+import { BadRequestException, NotFoundException } from '@nestjs/common'
+
+export class UpdateDeckCommand {
+  constructor(
+    public readonly deckId: string,
+    public readonly deck: UpdateDeckDto,
+    public readonly userId: string
+  ) {}
+}
+
+@CommandHandler(UpdateDeckCommand)
+export class UpdateDeckHandler implements ICommandHandler<UpdateDeckCommand> {
+  constructor(private readonly deckRepository: DecksRepository) {}
+
+  async execute(command: UpdateDeckCommand) {
+    const deck = await this.deckRepository.findDeckById(command.deckId)
+    if (!deck) throw new NotFoundException(`Deck with id ${command.deckId} not found`)
+    if (deck.userId !== command.userId) {
+      throw new BadRequestException(`You can't change a deck that you don't own`)
+    }
+
+    return await this.deckRepository.updateDeckById(command.deckId, command.deck)
+  }
+}

src/modules/users/api/users.controller.ts

@@ -11,7 +11,7 @@ import {
 } from '@nestjs/common'
 import { UsersService } from '../services/users.service'
 import { CreateUserDto } from '../dto/create-user.dto'
-import { Pagination } from '../../../infrastructure/common/pagination.service'
+import { Pagination } from '../../../infrastructure/common/pagination/pagination.service'
 import { BaseAuthGuard } from '../../auth/guards/base-auth.guard'
 import { CommandBus } from '@nestjs/cqrs'
 import { CreateUserCommand } from '../../auth/use-cases'