From 6cd213a462ea03c8a1268b7646465ea371b374a2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EB=B0=95=EB=8B=A4=ED=98=84=20=28Dahyeon=20Park=29?= Date: Mon, 13 Apr 2026 01:12:00 +0900 Subject: [PATCH] feat(api): add community endpoints --- .../modules/community/community.controller.ts | 107 ++++++++++ .../src/modules/community/community.module.ts | 10 + .../modules/community/community.service.ts | 196 ++++++++++++++++++ .../community/dto/create-community.dto.ts | 47 +++++ .../community/dto/transfer-ownership.dto.ts | 6 + 5 files changed, 366 insertions(+) create mode 100644 apps/api/src/modules/community/community.controller.ts create mode 100644 apps/api/src/modules/community/community.module.ts create mode 100644 apps/api/src/modules/community/community.service.ts create mode 100644 apps/api/src/modules/community/dto/create-community.dto.ts create mode 100644 apps/api/src/modules/community/dto/transfer-ownership.dto.ts diff --git a/apps/api/src/modules/community/community.controller.ts b/apps/api/src/modules/community/community.controller.ts new file mode 100644 index 00000000..be0f5327 --- /dev/null +++ b/apps/api/src/modules/community/community.controller.ts @@ -0,0 +1,107 @@ +import { + Body, + Controller, + BadRequestException, + ForbiddenException, + Get, + Param, + Patch, + Post, + Req, + UseGuards, +} from '@nestjs/common'; +import type { Request } from 'express'; +import mongoose from 'mongoose'; +import { AllowPublicAccess } from '../auth/allow-public-access.decorator'; +import { CurrentUser } from '../auth/current-user.decorator'; +import { Roles } from '../auth/roles.decorator'; +import { RolesGuard } from '../auth/roles.guard'; +import { ParseObjectIdPipe } from '../common/parse-object-id.pipe'; +import type { UserDocument } from '../global/database/schema'; +import '../auth/auth-request'; +import { CommunityService } from './community.service'; +import { CreateCommunityDto } from './dto/create-community.dto'; +import { TransferOwnershipDto } from './dto/transfer-ownership.dto'; + +@Controller('communities') +export class CommunityController { + constructor(private readonly communityService: CommunityService) {} + + @Post() + @AllowPublicAccess() + public async createCommunity( + @Body() body: CreateCommunityDto, + @Req() req: Request, + ) { + if (!req.identity && !body.owner) { + throw new BadRequestException( + 'owner is required when not authenticated.', + ); + } + return this.communityService.createCommunityWithOwner({ + ...body, + identityId: req.identity?._id, + }); + } + + @Get(':communityId') + @AllowPublicAccess() + public async getCommunity( + @Param('communityId', ParseObjectIdPipe) + communityId: mongoose.Types.ObjectId, + ) { + return this.communityService.getById(communityId); + } + + @Patch(':communityId/members/:userId/promote') + @Roles('owner') + @UseGuards(RolesGuard) + public async promoteToAdmin( + @CurrentUser() currentUser: UserDocument, + @Param('communityId', ParseObjectIdPipe) + communityId: mongoose.Types.ObjectId, + @Param('userId', ParseObjectIdPipe) targetUserId: mongoose.Types.ObjectId, + ) { + this.assertOwnerOfCommunity(currentUser, communityId); + return this.communityService.promoteToAdmin({ communityId, targetUserId }); + } + + @Patch(':communityId/members/:userId/demote') + @Roles('owner') + @UseGuards(RolesGuard) + public async demoteToMember( + @CurrentUser() currentUser: UserDocument, + @Param('communityId', ParseObjectIdPipe) + communityId: mongoose.Types.ObjectId, + @Param('userId', ParseObjectIdPipe) targetUserId: mongoose.Types.ObjectId, + ) { + this.assertOwnerOfCommunity(currentUser, communityId); + return this.communityService.demoteToMember({ communityId, targetUserId }); + } + + @Patch(':communityId/transfer-ownership') + @Roles('owner') + @UseGuards(RolesGuard) + public async transferOwnership( + @CurrentUser() currentUser: UserDocument, + @Param('communityId', ParseObjectIdPipe) + communityId: mongoose.Types.ObjectId, + @Body() body: TransferOwnershipDto, + ) { + this.assertOwnerOfCommunity(currentUser, communityId); + return this.communityService.transferOwnership({ + communityId, + currentOwnerUserId: currentUser._id, + newOwnerUserId: new mongoose.Types.ObjectId(body.newOwnerUserId), + }); + } + + private assertOwnerOfCommunity( + user: UserDocument, + communityId: mongoose.Types.ObjectId, + ): void { + if (!user.communityId.equals(communityId)) { + throw new ForbiddenException('You do not belong to this community.'); + } + } +} diff --git a/apps/api/src/modules/community/community.module.ts b/apps/api/src/modules/community/community.module.ts new file mode 100644 index 00000000..24e60fd7 --- /dev/null +++ b/apps/api/src/modules/community/community.module.ts @@ -0,0 +1,10 @@ +import { Module } from '@nestjs/common'; +import { CommunityController } from './community.controller'; +import { CommunityService } from './community.service'; + +@Module({ + controllers: [CommunityController], + providers: [CommunityService], + exports: [CommunityService], +}) +export class CommunityModule {} diff --git a/apps/api/src/modules/community/community.service.ts b/apps/api/src/modules/community/community.service.ts new file mode 100644 index 00000000..44a52e42 --- /dev/null +++ b/apps/api/src/modules/community/community.service.ts @@ -0,0 +1,196 @@ +import { + BadRequestException, + Injectable, + InternalServerErrorException, + NotFoundException, +} from '@nestjs/common'; +import mongoose from 'mongoose'; +import { ConnectionService } from '../global/database/connection.service'; +import { + CommunityDocument, + UserDocument, +} from '../global/database/schema'; + +export interface CreateCommunityInput { + name: string; + description?: string; + identityId?: mongoose.Types.ObjectId; + owner?: { + kakaoTalkId?: string; + kakaoTalkNickname?: string; + discordId?: string; + discordNickname?: string; + }; +} + +@Injectable() +export class CommunityService { + constructor(private readonly connectionService: ConnectionService) {} + + public async getById( + communityId: mongoose.Types.ObjectId, + ): Promise { + const CommunityModel = await this.connectionService.getModel('community'); + const community = await CommunityModel.findById(communityId).exec(); + if (!community) throw new NotFoundException('Community not found.'); + return community; + } + + public async createCommunityWithOwner(input: CreateCommunityInput): Promise<{ + community: CommunityDocument; + owner: UserDocument; + }> { + const CommunityModel = await this.connectionService.getModel('community'); + const UserModel = await this.connectionService.getModel('user'); + + const communityId = new mongoose.Types.ObjectId(); + const ownerUserId = new mongoose.Types.ObjectId(); + + const session = await this.connectionService.createSession(); + if (!session) { + throw new InternalServerErrorException('Failed to start DB session.'); + } + + try { + session.startTransaction(); + + const [community] = await CommunityModel.create( + [ + { + _id: communityId, + name: input.name, + description: input.description ?? '', + ownerUserId, + }, + ], + { session }, + ); + + const [owner] = await UserModel.create( + [ + { + _id: ownerUserId, + communityId, + identityId: input.identityId, + role: 'owner', + kakaoTalkId: input.owner?.kakaoTalkId, + kakaoTalkNickname: input.owner?.kakaoTalkNickname, + discordId: input.owner?.discordId, + discordNickname: input.owner?.discordNickname, + }, + ], + { session }, + ); + + await session.commitTransaction(); + return { community, owner }; + } catch (err) { + await session.abortTransaction(); + throw err; + } finally { + await session.endSession(); + } + } + + public async promoteToAdmin(params: { + communityId: mongoose.Types.ObjectId; + targetUserId: mongoose.Types.ObjectId; + }): Promise { + return this.changeNonOwnerRole({ ...params, nextRole: 'admin' }); + } + + public async demoteToMember(params: { + communityId: mongoose.Types.ObjectId; + targetUserId: mongoose.Types.ObjectId; + }): Promise { + return this.changeNonOwnerRole({ ...params, nextRole: 'member' }); + } + + public async transferOwnership(params: { + communityId: mongoose.Types.ObjectId; + currentOwnerUserId: mongoose.Types.ObjectId; + newOwnerUserId: mongoose.Types.ObjectId; + }): Promise<{ + community: CommunityDocument; + previousOwner: UserDocument; + newOwner: UserDocument; + }> { + if (params.currentOwnerUserId.equals(params.newOwnerUserId)) { + throw new BadRequestException('New owner is already the current owner.'); + } + + const CommunityModel = await this.connectionService.getModel('community'); + const UserModel = await this.connectionService.getModel('user'); + + const session = await this.connectionService.createSession(); + if (!session) { + throw new InternalServerErrorException('Failed to start DB session.'); + } + + try { + session.startTransaction(); + + const community = await CommunityModel.findById( + params.communityId, + ).session(session); + if (!community) throw new NotFoundException('Community not found.'); + if (!community.ownerUserId.equals(params.currentOwnerUserId)) { + throw new BadRequestException('Acting user is not the current owner.'); + } + + const [previousOwner, newOwner] = await Promise.all([ + UserModel.findById(params.currentOwnerUserId).session(session), + UserModel.findById(params.newOwnerUserId).session(session), + ]); + if (!previousOwner) + throw new NotFoundException('Previous owner user not found.'); + if (!newOwner) throw new NotFoundException('New owner user not found.'); + if (!newOwner.communityId.equals(params.communityId)) { + throw new BadRequestException( + 'New owner does not belong to this community.', + ); + } + + community.ownerUserId = newOwner._id; + previousOwner.role = 'admin'; + newOwner.role = 'owner'; + + await Promise.all([ + community.save({ session }), + previousOwner.save({ session }), + newOwner.save({ session }), + ]); + + await session.commitTransaction(); + return { community, previousOwner, newOwner }; + } catch (err) { + await session.abortTransaction(); + throw err; + } finally { + await session.endSession(); + } + } + + private async changeNonOwnerRole(params: { + communityId: mongoose.Types.ObjectId; + targetUserId: mongoose.Types.ObjectId; + nextRole: 'admin' | 'member'; + }): Promise { + const UserModel = await this.connectionService.getModel('user'); + const user = await UserModel.findById(params.targetUserId); + if (!user) throw new NotFoundException('Target user not found.'); + if (!user.communityId.equals(params.communityId)) { + throw new BadRequestException( + 'Target user does not belong to this community.', + ); + } + if (user.role === 'owner') { + throw new BadRequestException( + 'Owner role must be changed via transferOwnership.', + ); + } + user.role = params.nextRole; + await user.save(); + return user; + } +} diff --git a/apps/api/src/modules/community/dto/create-community.dto.ts b/apps/api/src/modules/community/dto/create-community.dto.ts new file mode 100644 index 00000000..e175b7fb --- /dev/null +++ b/apps/api/src/modules/community/dto/create-community.dto.ts @@ -0,0 +1,47 @@ +import { Type } from 'class-transformer'; +import { + IsOptional, + IsString, + MaxLength, + MinLength, + ValidateNested, +} from 'class-validator'; + +class CreateCommunityOwnerDto { + @IsOptional() + @IsString() + @MaxLength(64) + kakaoTalkId?: string; + + @IsOptional() + @IsString() + @MaxLength(64) + kakaoTalkNickname?: string; + + @IsOptional() + @IsString() + @MaxLength(64) + discordId?: string; + + @IsOptional() + @IsString() + @MaxLength(64) + discordNickname?: string; +} + +export class CreateCommunityDto { + @IsString() + @MinLength(1) + @MaxLength(64) + name!: string; + + @IsOptional() + @IsString() + @MaxLength(1024) + description?: string; + + @IsOptional() + @ValidateNested() + @Type(() => CreateCommunityOwnerDto) + owner?: CreateCommunityOwnerDto; +} diff --git a/apps/api/src/modules/community/dto/transfer-ownership.dto.ts b/apps/api/src/modules/community/dto/transfer-ownership.dto.ts new file mode 100644 index 00000000..90d472ec --- /dev/null +++ b/apps/api/src/modules/community/dto/transfer-ownership.dto.ts @@ -0,0 +1,6 @@ +import { IsMongoId } from 'class-validator'; + +export class TransferOwnershipDto { + @IsMongoId() + newOwnerUserId!: string; +}