프로젝트·파일 API

import { IsString, MinLength } from 'class-validator';

export class CreateProjectDto {
  @IsString()
  @MinLength(3)
  name: string;
}

import { CreateProjectDto } from './create-project.dto';

// 이름만 바꾸므로 생성 DTO의 검증 규칙을 그대로 물려받습니다.
export class UpdateProjectDto extends CreateProjectDto {}

import { IsOptional, IsString, MaxLength, MinLength } from 'class-validator';

export class CreateFileDto {
  @IsString()
  @MinLength(1)
  name: string;

  @IsString()
  @MinLength(1)
  path: string; // 예: '/src/main.ts'

  @IsOptional()
  @IsString()
  type?: string; // 예: 'typescript'

  @IsOptional()
  @IsString()
  @MaxLength(100_000)
  content?: string;
}

export class UpdateFileContentDto {
  @IsString()
  @MaxLength(100_000)
  content: string;
}

export class RenameFileDto {
  @IsString()
  @MinLength(1)
  newName: string;
}

import { IsString, MinLength } from 'class-validator';

export class CreateFolderDto {
  @IsString()
  @MinLength(1)
  name: string;

  @IsString()
  @MinLength(1)
  path: string; // 예: '/src'
}

export class RenameFolderDto {
  @IsString()
  @MinLength(1)
  newName: string;
}

import {
  Injectable,
  InternalServerErrorException,
  Logger,
  NotFoundException,
} from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from '../auth/entities/user.entity';
import { CreateFileDto } from '../file/dto/file.dto';
import { File } from '../file/entities/file.entity';
import { CreateFolderDto } from '../folder/dto/folder.dto';
import { Folder } from '../folder/entities/folder.entity';
import { CreateProjectDto } from './dto/create-project.dto';
import { Project } from './entities/project.entity';

@Injectable()
export class ProjectService {
  private readonly logger = new Logger(ProjectService.name);

  constructor(
    @InjectRepository(Project)
    private readonly projectsRepository: Repository<Project>,
    @InjectRepository(File)
    private readonly filesRepository: Repository<File>,
    @InjectRepository(Folder)
    private readonly foldersRepository: Repository<Folder>,
  ) {}

  // --- 프로젝트 ---

  async createProject(createProjectDto: CreateProjectDto, user: User): Promise<Project> {
    // owner에 user 객체를 넣으면 응답에 비밀번호 해시까지 실리므로 ID만 저장합니다.
    const newProject = this.projectsRepository.create({
      name: createProjectDto.name,
      ownerId: user.id,
    });
    return this.projectsRepository.save(newProject);
  }

  findAllUserProjects(userId: string): Promise<Project[]> {
    return this.projectsRepository.find({
      where: { ownerId: userId },
      order: { updatedAt: 'DESC' },
    });
  }

  async findProjectById(projectId: string, userId: string): Promise<Project> {
    const project = await this.projectsRepository.findOne({
      where: { id: projectId, ownerId: userId },
      relations: { files: true, folders: true }, // 파일과 폴더를 함께 불러옵니다.
    });
    if (!project) {
      throw new NotFoundException('Project not found or you do not have access.');
    }
    return project;
  }

  async updateProject(projectId: string, userId: string, name: string): Promise<Project> {
    const project = await this.findOwnedProject(projectId, userId);
    project.name = name;
    return this.projectsRepository.save(project);
  }

  async deleteProject(projectId: string, userId: string): Promise<void> {
    // 파일과 폴더는 엔티티의 onDelete: 'CASCADE'에 따라 DB가 함께 지웁니다.
    const result = await this.projectsRepository.delete({ id: projectId, ownerId: userId });
    if (!result.affected) {
      throw new NotFoundException('Project not found or you do not have access.');
    }
  }

  // --- 파일 ---

  async createFile(projectId: string, userId: string, dto: CreateFileDto): Promise<File> {
    await this.findOwnedProject(projectId, userId);
    const newFile = this.filesRepository.create({
      name: dto.name,
      path: this.normalizePath(dto.path),
      type: dto.type ?? null,
      content: dto.content ?? '',
      projectId,
    });
    return this.filesRepository.save(newFile);
  }

  async findFileById(projectId: string, fileId: string, userId: string): Promise<File> {
    await this.findOwnedProject(projectId, userId);
    // URL의 프로젝트 안에서만 파일을 찾습니다.
    const file = await this.filesRepository.findOneBy({ id: fileId, projectId });
    if (!file) {
      throw new NotFoundException('File not found or you do not have access.');
    }
    return file;
  }

  async updateFileContent(
    projectId: string,
    fileId: string,
    userId: string,
    content: string,
  ): Promise<File> {
    const file = await this.findFileById(projectId, fileId, userId);
    file.content = content;
    return this.filesRepository.save(file);
  }

  async renameFile(
    projectId: string,
    fileId: string,
    userId: string,
    newName: string,
  ): Promise<File> {
    const file = await this.findFileById(projectId, fileId, userId);
    file.name = newName;
    return this.filesRepository.save(file);
  }

  async deleteFile(projectId: string, fileId: string, userId: string): Promise<void> {
    const file = await this.findFileById(projectId, fileId, userId);
    await this.filesRepository.remove(file);
  }

  // --- 폴더 ---

  async createFolder(projectId: string, userId: string, dto: CreateFolderDto): Promise<Folder> {
    await this.findOwnedProject(projectId, userId);
    const newFolder = this.foldersRepository.create({
      name: dto.name,
      path: this.normalizePath(dto.path),
      projectId,
    });
    return this.foldersRepository.save(newFolder);
  }

  async renameFolder(
    projectId: string,
    folderId: string,
    userId: string,
    newName: string,
  ): Promise<Folder> {
    const folder = await this.findFolderById(projectId, folderId, userId);
    folder.name = newName;
    return this.foldersRepository.save(folder);
  }

  async deleteFolder(projectId: string, folderId: string, userId: string): Promise<void> {
    const folder = await this.findFolderById(projectId, folderId, userId);
    // "/src"를 지우면 "/src" 자체와 "/src/"로 시작하는 경로를 함께 지웁니다.
    const paths = { exactPath: folder.path, prefixPath: `${folder.path}/%` };

    try {
      await this.projectsRepository.manager.transaction(async (manager) => {
        await manager
          .createQueryBuilder()
          .delete()
          .from(File)
          .where('projectId = :projectId', { projectId })
          .andWhere('(path = :exactPath OR path LIKE :prefixPath)', paths)
          .execute();

        await manager
          .createQueryBuilder()
          .delete()
          .from(Folder)
          .where('projectId = :projectId', { projectId })
          .andWhere('(path = :exactPath OR path LIKE :prefixPath)', paths)
          .execute();
      });
    } catch (error) {
      // 트랜잭션이 실패하면 두 삭제가 모두 취소됩니다.
      const reason = error instanceof Error ? error.message : String(error);
      this.logger.error(
        `Failed to delete folder tree (projectId=${projectId}, folderId=${folderId}): ${reason}`,
      );
      throw new InternalServerErrorException('Failed to delete folder tree. Please retry.');
    }
  }

  // --- 내부 도우미 ---

  private async findOwnedProject(projectId: string, userId: string): Promise<Project> {
    const project = await this.projectsRepository.findOneBy({ id: projectId, ownerId: userId });
    if (!project) {
      throw new NotFoundException('Project not found or you do not have access.');
    }
    return project;
  }

  private async findFolderById(projectId: string, folderId: string, userId: string): Promise<Folder> {
    await this.findOwnedProject(projectId, userId);
    const folder = await this.foldersRepository.findOneBy({ id: folderId, projectId });
    if (!folder) {
      throw new NotFoundException('Folder not found or you do not have access.');
    }
    return folder;
  }

  private normalizePath(path: string): string {
    return path.startsWith('/') ? path : `/${path}`;
  }
}

import {
  Body,
  Controller,
  Delete,
  Get,
  HttpCode,
  HttpStatus,
  Param,
  ParseUUIDPipe,
  Patch,
  Post,
  Req,
  UseGuards,
} from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';
import { User } from '../auth/entities/user.entity';
import { CreateFileDto, RenameFileDto, UpdateFileContentDto } from '../file/dto/file.dto';
import { CreateFolderDto, RenameFolderDto } from '../folder/dto/folder.dto';
import { CreateProjectDto } from './dto/create-project.dto';
import { UpdateProjectDto } from './dto/update-project.dto';
import { ProjectService } from './project.service';

type AuthRequest = { user: User };

@Controller('projects')
@UseGuards(AuthGuard('jwt')) // 이 controller의 모든 API에 JWT 인증을 적용합니다.
export class ProjectController {
  constructor(private readonly projectService: ProjectService) {}

  @Post()
  createProject(@Body() createProjectDto: CreateProjectDto, @Req() req: AuthRequest) {
    return this.projectService.createProject(createProjectDto, req.user);
  }

  @Get()
  getAllUserProjects(@Req() req: AuthRequest) {
    return this.projectService.findAllUserProjects(req.user.id);
  }

  @Get(':projectId')
  getProjectDetails(
    @Param('projectId', ParseUUIDPipe) projectId: string,
    @Req() req: AuthRequest,
  ) {
    return this.projectService.findProjectById(projectId, req.user.id);
  }

  @Patch(':projectId')
  updateProject(
    @Param('projectId', ParseUUIDPipe) projectId: string,
    @Body() updateProjectDto: UpdateProjectDto,
    @Req() req: AuthRequest,
  ) {
    return this.projectService.updateProject(projectId, req.user.id, updateProjectDto.name);
  }

  @Delete(':projectId')
  @HttpCode(HttpStatus.NO_CONTENT) // 204 No Content
  async deleteProject(
    @Param('projectId', ParseUUIDPipe) projectId: string,
    @Req() req: AuthRequest,
  ) {
    await this.projectService.deleteProject(projectId, req.user.id);
  }

  // --- 파일 API ---

  @Post(':projectId/files')
  createFile(
    @Param('projectId', ParseUUIDPipe) projectId: string,
    @Body() createFileDto: CreateFileDto,
    @Req() req: AuthRequest,
  ) {
    return this.projectService.createFile(projectId, req.user.id, createFileDto);
  }

  @Get(':projectId/files/:fileId')
  getFile(
    @Param('projectId', ParseUUIDPipe) projectId: string,
    @Param('fileId', ParseUUIDPipe) fileId: string,
    @Req() req: AuthRequest,
  ) {
    return this.projectService.findFileById(projectId, fileId, req.user.id);
  }

  @Patch(':projectId/files/:fileId/content')
  updateFileContent(
    @Param('projectId', ParseUUIDPipe) projectId: string,
    @Param('fileId', ParseUUIDPipe) fileId: string,
    @Body() updateFileContentDto: UpdateFileContentDto,
    @Req() req: AuthRequest,
  ) {
    return this.projectService.updateFileContent(
      projectId,
      fileId,
      req.user.id,
      updateFileContentDto.content,
    );
  }

  @Patch(':projectId/files/:fileId/rename')
  renameFile(
    @Param('projectId', ParseUUIDPipe) projectId: string,
    @Param('fileId', ParseUUIDPipe) fileId: string,
    @Body() renameFileDto: RenameFileDto,
    @Req() req: AuthRequest,
  ) {
    return this.projectService.renameFile(projectId, fileId, req.user.id, renameFileDto.newName);
  }

  @Delete(':projectId/files/:fileId')
  @HttpCode(HttpStatus.NO_CONTENT)
  async deleteFile(
    @Param('projectId', ParseUUIDPipe) projectId: string,
    @Param('fileId', ParseUUIDPipe) fileId: string,
    @Req() req: AuthRequest,
  ) {
    await this.projectService.deleteFile(projectId, fileId, req.user.id);
  }

  // --- 폴더 API ---

  @Post(':projectId/folders')
  createFolder(
    @Param('projectId', ParseUUIDPipe) projectId: string,
    @Body() createFolderDto: CreateFolderDto,
    @Req() req: AuthRequest,
  ) {
    return this.projectService.createFolder(projectId, req.user.id, createFolderDto);
  }

  @Patch(':projectId/folders/:folderId/rename')
  renameFolder(
    @Param('projectId', ParseUUIDPipe) projectId: string,
    @Param('folderId', ParseUUIDPipe) folderId: string,
    @Body() renameFolderDto: RenameFolderDto,
    @Req() req: AuthRequest,
  ) {
    return this.projectService.renameFolder(
      projectId,
      folderId,
      req.user.id,
      renameFolderDto.newName,
    );
  }

  @Delete(':projectId/folders/:folderId')
  @HttpCode(HttpStatus.NO_CONTENT)
  async deleteFolder(
    @Param('projectId', ParseUUIDPipe) projectId: string,
    @Param('folderId', ParseUUIDPipe) folderId: string,
    @Req() req: AuthRequest,
  ) {
    await this.projectService.deleteFolder(projectId, folderId, req.user.id);
  }
}