BE 구현 플랜: 등록 관리 페이지

src/participation/
  participation.controller.ts   ← 6개 엔드포인트 (POST, GET, GET/:id, PATCH/:id, DELETE/:id, PUT/approve, GET/download/:missionaryId)
  participation.service.ts      ← 비즈니스 로직 (create→BullMQ, findAll, findOne, update, remove, approvePayments)
  participation.processor.ts    ← BullMQ Worker (create-participation job)
  participation.module.ts       ← Module 정의
  dto/
    create-participation.dto.ts ← 6개 필드 (missionaryId, name, birthDate, applyFee, identificationNumber, isOwnCar)
    update-participation.dto.ts ← PartialType(Create) + isPaid
    approve-payment.dto.ts      ← participationIds[]
  repositories/
    participation-repository.interface.ts ← ParticipationWithRelations = Participation & { missionary, user }
    prisma-participation.repository.ts    ← Prisma 구현체
 
src/missionary/
  missionary.controller.ts     ← 7개 엔드포인트 (CRUD + posters)
  missionary.module.ts         ← exports: [MissionaryService, MISSIONARY_REPOSITORY]
  repositories/
    missionary-repository.interface.ts
    prisma-missionary.repository.ts
 
src/testing/
  factories/                   ← makeParticipation, makeMissionary, makeUser 등
  fakes/                       ← FakeParticipationRepository, FakeMissionaryRepository 등
 
src/common/
  csv/csv-export.service.ts    ← 하드코딩된 6개 컬럼
  repositories/base-repository.interface.ts ← 수정 금지

enum AttendanceType {
  FULL
  PARTIAL
}
 
enum FormFieldType {
  TEXT
  TEXTAREA
  NUMBER
  BOOLEAN
  SELECT
  DATE
}

model MissionaryAttendanceOption {
  id            String         @id @default(uuid())
  type          AttendanceType
  label         String
  order         Int
 
  // Foreign keys
  missionaryId  String         @map("missionary_id")
 
  // Audit fields
  createdAt     DateTime       @default(now()) @map("created_at")
  updatedAt     DateTime       @updatedAt @map("updated_at")
  createdBy     String?        @map("created_by")
  updatedBy     String?        @map("updated_by")
  version       Int            @default(0)
 
  // Soft delete
  deletedAt     DateTime?      @map("deleted_at")
 
  // Relations
  missionary     Missionary      @relation(fields: [missionaryId], references: [id])
  participations Participation[]
 
  @@map("missionary_attendance_option")
}
 
model MissionaryFormField {
  id            String        @id @default(uuid())
  fieldType     FormFieldType @map("field_type")
  label         String
  placeholder   String?
  isRequired    Boolean       @default(false) @map("is_required")
  order         Int
  options       Json?
 
  // Foreign keys
  missionaryId  String        @map("missionary_id")
 
  // Audit fields
  createdAt     DateTime      @default(now()) @map("created_at")
  updatedAt     DateTime      @updatedAt @map("updated_at")
  createdBy     String?       @map("created_by")
  updatedBy     String?       @map("updated_by")
  version       Int           @default(0)
 
  // Soft delete
  deletedAt     DateTime?     @map("deleted_at")
 
  // Relations
  missionary    Missionary            @relation(fields: [missionaryId], references: [id])
  formAnswers   ParticipationFormAnswer[]
 
  @@map("missionary_form_field")
}
 
model ParticipationFormAnswer {
  id              String    @id @default(uuid())
  value           String
 
  // Foreign keys
  participationId String    @map("participation_id")
  formFieldId     String    @map("form_field_id")
 
  // Audit fields
  createdAt       DateTime  @default(now()) @map("created_at")
  updatedAt       DateTime  @updatedAt @map("updated_at")
  createdBy       String?   @map("created_by")
  updatedBy       String?   @map("updated_by")
  version         Int       @default(0)
 
  // Soft delete
  deletedAt       DateTime? @map("deleted_at")
 
  // Relations
  participation   Participation       @relation(fields: [participationId], references: [id])
  formField       MissionaryFormField @relation(fields: [formFieldId], references: [id])
 
  @@unique([participationId, formFieldId])
  @@map("participation_form_answer")
}

model Participation {
  // ... 기존 필드 유지 ...
 
  // 신규 추가 필드
  affiliation           String?                 // nullable — 기존 데이터 호환. DTO에서 필수 강제
  attendanceOptionId    String?                 @map("attendance_option_id") // nullable — 기존 데이터 호환
  cohort                Int?                    // nullable — 기존 데이터 호환
  hasPastParticipation  Boolean?                @map("has_past_participation")
  isCollegeStudent      Boolean?                @map("is_college_student")
 
  // 신규 Relations 추가
  attendanceOption      MissionaryAttendanceOption? @relation(fields: [attendanceOptionId], references: [id])
  formAnswers           ParticipationFormAnswer[]
 
  // ... 기존 relations 유지 ...
}

model Missionary {
  // ... 기존 필드/relations 유지 ...
 
  // 신규 Relations 추가
  attendanceOptions  MissionaryAttendanceOption[]
  formFields         MissionaryFormField[]
}

cd /Users/JuChan/Documents/FE/missionary/main
pnpm --filter missionary-server prisma:migrate:dev -- --name add-participation-management

pnpm --filter missionary-server prisma:generate

export function makeParticipation(
  overrides: Partial<Participation> = {},
): Participation {
  return {
    // ... 기존 필드 유지 ...
    affiliation: null,           // 신규
    attendanceOptionId: null,    // 신규
    cohort: null,                // 신규
    hasPastParticipation: null,  // 신규
    isCollegeStudent: null,      // 신규
    ...overrides,
  };
}

import type {
  MissionaryAttendanceOption,
  MissionaryFormField,
  ParticipationFormAnswer,
} from '../../../prisma/generated/prisma';
 
export function makeMissionaryAttendanceOption(
  overrides: Partial<MissionaryAttendanceOption> = {},
): MissionaryAttendanceOption {
  return {
    id: randomUUID(),
    type: 'FULL',
    label: '풀참석',
    order: 0,
    missionaryId: randomUUID(),
    createdAt: new Date('2024-01-01T00:00:00Z'),
    updatedAt: new Date('2024-01-01T00:00:00Z'),
    createdBy: null,
    updatedBy: null,
    version: 0,
    deletedAt: null,
    ...overrides,
  };
}
 
export function makeMissionaryFormField(
  overrides: Partial<MissionaryFormField> = {},
): MissionaryFormField {
  return {
    id: randomUUID(),
    fieldType: 'TEXT',
    label: '테스트필드',
    placeholder: null,
    isRequired: false,
    order: 0,
    options: null,
    missionaryId: randomUUID(),
    createdAt: new Date('2024-01-01T00:00:00Z'),
    updatedAt: new Date('2024-01-01T00:00:00Z'),
    createdBy: null,
    updatedBy: null,
    version: 0,
    deletedAt: null,
    ...overrides,
  };
}
 
export function makeParticipationFormAnswer(
  overrides: Partial<ParticipationFormAnswer> = {},
): ParticipationFormAnswer {
  return {
    id: randomUUID(),
    value: '',
    participationId: randomUUID(),
    formFieldId: randomUUID(),
    createdAt: new Date('2024-01-01T00:00:00Z'),
    updatedAt: new Date('2024-01-01T00:00:00Z'),
    createdBy: null,
    updatedBy: null,
    version: 0,
    deletedAt: null,
    ...overrides,
  };
}

private buildEntity(data: ParticipationCreateInput): Participation {
  const now = new Date();
  return {
    // ... 기존 필드 ...
    affiliation: (data.affiliation as string) ?? null,
    attendanceOptionId: (data.attendanceOptionId as string) ?? null,
    cohort: (data.cohort as number) ?? null,
    hasPastParticipation: (data.hasPastParticipation as boolean) ?? null,
    isCollegeStudent: (data.isCollegeStudent as boolean) ?? null,
    ...
  };
}

pnpm --filter missionary-server prisma:generate
pnpm --filter missionary-server build
pnpm --filter missionary-server test

import type { MissionaryAttendanceOption } from '../../../prisma/generated/prisma';
 
export interface AttendanceOptionCreateInput {
  missionaryId: string;
  type: 'FULL' | 'PARTIAL';
  label: string;
  order: number;
  createdBy?: string;
}
 
export interface AttendanceOptionUpdateInput {
  type?: 'FULL' | 'PARTIAL';
  label?: string;
  order?: number;
  updatedBy?: string;
}
 
export interface AttendanceOptionRepository {
  create(data: AttendanceOptionCreateInput): Promise<MissionaryAttendanceOption>;
  findByMissionary(missionaryId: string): Promise<MissionaryAttendanceOption[]>;
  findById(id: string): Promise<MissionaryAttendanceOption | null>;
  update(id: string, data: AttendanceOptionUpdateInput): Promise<MissionaryAttendanceOption>;
  delete(id: string): Promise<MissionaryAttendanceOption>;
  countParticipationsByOption(optionId: string): Promise<number>;
}
 
export const ATTENDANCE_OPTION_REPOSITORY = Symbol('ATTENDANCE_OPTION_REPOSITORY');

@Injectable()
export class PrismaAttendanceOptionRepository implements AttendanceOptionRepository {
  constructor(private readonly prisma: PrismaService) {}
 
  async create(data: AttendanceOptionCreateInput): Promise<MissionaryAttendanceOption> {
    return this.prisma.missionaryAttendanceOption.create({ data });
  }
 
  async findByMissionary(missionaryId: string): Promise<MissionaryAttendanceOption[]> {
    return this.prisma.missionaryAttendanceOption.findMany({
      where: { missionaryId },
      orderBy: { order: 'asc' },
    });
  }
 
  async findById(id: string): Promise<MissionaryAttendanceOption | null> {
    return this.prisma.missionaryAttendanceOption.findFirst({ where: { id } });
  }
 
  async update(id: string, data: AttendanceOptionUpdateInput): Promise<MissionaryAttendanceOption> {
    return this.prisma.missionaryAttendanceOption.update({
      where: { id },
      data: { ...data, version: { increment: 1 } },
    });
  }
 
  async delete(id: string): Promise<MissionaryAttendanceOption> {
    // 전역 soft delete 미들웨어가 자동 처리 (TRAP-1)
    return this.prisma.missionaryAttendanceOption.delete({ where: { id } });
  }
 
  async countParticipationsByOption(optionId: string): Promise<number> {
    return this.prisma.participation.count({
      where: { attendanceOptionId: optionId, deletedAt: null },
    });
  }
}

import { IsEnum, IsInt, IsString, Min } from 'class-validator';
 
enum AttendanceTypeDto {
  FULL = 'FULL',
  PARTIAL = 'PARTIAL',
}
 
export class CreateAttendanceOptionDto {
  @IsEnum(AttendanceTypeDto)
  declare type: 'FULL' | 'PARTIAL';
 
  @IsString()
  declare label: string;
 
  @IsInt()
  @Min(0)
  declare order: number;
}

import { PartialType } from '@nestjs/mapped-types';
import { CreateAttendanceOptionDto } from './create-attendance-option.dto';
 
export class UpdateAttendanceOptionDto extends PartialType(CreateAttendanceOptionDto) {}

@Injectable()
export class AttendanceOptionService {
  constructor(
    @Inject(ATTENDANCE_OPTION_REPOSITORY)
    private readonly repo: AttendanceOptionRepository,
    @Inject(MISSIONARY_REPOSITORY)
    private readonly missionaryRepo: MissionaryRepository,
  ) {}
 
  async create(missionaryId: string, dto: CreateAttendanceOptionDto, userId: string) {
    // 선교 존재 확인
    const missionary = await this.missionaryRepo.findWithDetails(missionaryId);
    if (!missionary) throw new NotFoundException('Missionary not found');
 
    return this.repo.create({
      missionaryId,
      type: dto.type,
      label: dto.label,
      order: dto.order,
      createdBy: userId,
    });
  }
 
  async findByMissionary(missionaryId: string) {
    return this.repo.findByMissionary(missionaryId);
  }
 
  async update(optionId: string, dto: UpdateAttendanceOptionDto, userId: string) {
    const option = await this.repo.findById(optionId);
    if (!option) throw new NotFoundException('Attendance option not found');
 
    return this.repo.update(optionId, { ...dto, updatedBy: userId });
  }
 
  async remove(optionId: string) {
    const option = await this.repo.findById(optionId);
    if (!option) throw new NotFoundException('Attendance option not found');
 
    // 삭제 제약: 해당 옵션을 선택한 등록자가 있으면 삭제 불가 (PRD FR-7-A)
    const count = await this.repo.countParticipationsByOption(optionId);
    if (count > 0) {
      throw new BadRequestException(
        `${count}명이 선택한 옵션은 삭제할 수 없습니다.`,
      );
    }
 
    return this.repo.delete(optionId);
  }
}

@ApiTags('Attendance Options')
@Controller('missionaries/:missionaryId/attendance-options')
export class AttendanceOptionController {
  constructor(private readonly service: AttendanceOptionService) {}
 
  @Post()
  @Roles(UserRole.ADMIN)
  @ApiOperation({ summary: '참석 옵션 추가 (관리자 전용)' })
  create(
    @Param('missionaryId', ParseUUIDPipe) missionaryId: string,
    @CurrentUser() user: AuthenticatedUser,
    @Body() dto: CreateAttendanceOptionDto,
  ) {
    return this.service.create(missionaryId, dto, user.id);
  }
 
  @Get()
  @ApiOperation({ summary: '참석 옵션 목록 조회' })
  findAll(@Param('missionaryId', ParseUUIDPipe) missionaryId: string) {
    return this.service.findByMissionary(missionaryId);
  }
 
  @Patch(':optionId')
  @Roles(UserRole.ADMIN)
  @ApiOperation({ summary: '참석 옵션 수정 (관리자 전용)' })
  update(
    @Param('optionId', ParseUUIDPipe) optionId: string,
    @CurrentUser() user: AuthenticatedUser,
    @Body() dto: UpdateAttendanceOptionDto,
  ) {
    return this.service.update(optionId, dto, user.id);
  }
 
  @Delete(':optionId')
  @Roles(UserRole.ADMIN)
  @ApiOperation({ summary: '참석 옵션 삭제 (관리자 전용)' })
  remove(@Param('optionId', ParseUUIDPipe) optionId: string) {
    return this.service.remove(optionId);
  }
}

// controllers 배열에 추가
controllers: [
  MissionaryController,
  RegionController,
  MissionGroupRegionController,
  AttendanceOptionController,  // 신규
],
// providers 배열에 추가
providers: [
  // ... 기존 ...
  AttendanceOptionService,  // 신규
  {
    provide: ATTENDANCE_OPTION_REPOSITORY,
    useClass: PrismaAttendanceOptionRepository,
  },
],
// exports 배열에 추가
exports: [MissionaryService, MISSIONARY_REPOSITORY, ATTENDANCE_OPTION_REPOSITORY],

pnpm --filter missionary-server build
# curl 테스트 (dev 서버 실행 상태에서)
curl -X POST http://localhost:3100/missionaries/{id}/attendance-options \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer {admin-token}" \
  -d '{"type":"FULL","label":"풀참석","order":0}'
 
curl http://localhost:3100/missionaries/{id}/attendance-options

import type { MissionaryFormField } from '../../../prisma/generated/prisma';
 
export interface FormFieldCreateInput {
  missionaryId: string;
  fieldType: 'TEXT' | 'TEXTAREA' | 'NUMBER' | 'BOOLEAN' | 'SELECT' | 'DATE';
  label: string;
  placeholder?: string | null;
  isRequired: boolean;
  order: number;
  options?: any;  // Json
  createdBy?: string;
}
 
export interface FormFieldUpdateInput {
  label?: string;
  placeholder?: string | null;
  isRequired?: boolean;
  order?: number;
  options?: any;  // Json
  updatedBy?: string;
}
 
export interface FormFieldRepository {
  create(data: FormFieldCreateInput): Promise<MissionaryFormField>;
  findByMissionary(missionaryId: string): Promise<MissionaryFormField[]>;
  findById(id: string): Promise<MissionaryFormField | null>;
  update(id: string, data: FormFieldUpdateInput): Promise<MissionaryFormField>;
  delete(id: string): Promise<MissionaryFormField>;
}
 
export const FORM_FIELD_REPOSITORY = Symbol('FORM_FIELD_REPOSITORY');

@Injectable()
export class PrismaFormFieldRepository implements FormFieldRepository {
  constructor(private readonly prisma: PrismaService) {}
 
  async create(data: FormFieldCreateInput): Promise<MissionaryFormField> {
    return this.prisma.missionaryFormField.create({ data });
  }
 
  async findByMissionary(missionaryId: string): Promise<MissionaryFormField[]> {
    return this.prisma.missionaryFormField.findMany({
      where: { missionaryId },
      orderBy: { order: 'asc' },
    });
  }
 
  async findById(id: string): Promise<MissionaryFormField | null> {
    return this.prisma.missionaryFormField.findFirst({ where: { id } });
  }
 
  async update(id: string, data: FormFieldUpdateInput): Promise<MissionaryFormField> {
    return this.prisma.missionaryFormField.update({
      where: { id },
      data: { ...data, version: { increment: 1 } },
    });
  }
 
  async delete(id: string): Promise<MissionaryFormField> {
    // 전역 soft delete 미들웨어가 자동 처리 (TRAP-1)
    return this.prisma.missionaryFormField.delete({ where: { id } });
  }
}

import { IsArray, IsBoolean, IsEnum, IsInt, IsOptional, IsString, Min, ValidateIf } from 'class-validator';
 
enum FormFieldTypeDto {
  TEXT = 'TEXT',
  TEXTAREA = 'TEXTAREA',
  NUMBER = 'NUMBER',
  BOOLEAN = 'BOOLEAN',
  SELECT = 'SELECT',
  DATE = 'DATE',
}
 
export class CreateFormFieldDto {
  @IsEnum(FormFieldTypeDto)
  declare fieldType: 'TEXT' | 'TEXTAREA' | 'NUMBER' | 'BOOLEAN' | 'SELECT' | 'DATE';
 
  @IsString()
  declare label: string;
 
  @IsOptional()
  @IsString()
  placeholder?: string;
 
  @IsBoolean()
  declare isRequired: boolean;
 
  @IsInt()
  @Min(0)
  declare order: number;
 
  // SELECT 타입일 때만 필수. 비-SELECT 타입에 전달 시 무시 (AMB-5)
  @IsOptional()
  @IsArray()
  @IsString({ each: true })
  options?: string[];
}

import { PartialType } from '@nestjs/mapped-types';
import { CreateFormFieldDto } from './create-form-field.dto';
 
export class UpdateFormFieldDto extends PartialType(CreateFormFieldDto) {}

@Injectable()
export class FormFieldService {
  constructor(
    @Inject(FORM_FIELD_REPOSITORY)
    private readonly repo: FormFieldRepository,
    @Inject(MISSIONARY_REPOSITORY)
    private readonly missionaryRepo: MissionaryRepository,
  ) {}
 
  async create(missionaryId: string, dto: CreateFormFieldDto, userId: string) {
    const missionary = await this.missionaryRepo.findWithDetails(missionaryId);
    if (!missionary) throw new NotFoundException('Missionary not found');
 
    // AMB-5: 비-SELECT 타입에 options 전달 시 무시
    const options = dto.fieldType === 'SELECT' ? (dto.options ?? null) : null;
 
    return this.repo.create({
      missionaryId,
      fieldType: dto.fieldType,
      label: dto.label,
      placeholder: dto.placeholder ?? null,
      isRequired: dto.isRequired,
      order: dto.order,
      options,
      createdBy: userId,
    });
  }
 
  async findByMissionary(missionaryId: string) {
    return this.repo.findByMissionary(missionaryId);
  }
 
  async update(fieldId: string, dto: UpdateFormFieldDto, userId: string) {
    const field = await this.repo.findById(fieldId);
    if (!field) throw new NotFoundException('Form field not found');
 
    // AMB-5: 비-SELECT 타입에 options 전달 시 무시
    const updateData: FormFieldUpdateInput = {
      ...dto,
      updatedBy: userId,
    };
    if (dto.options !== undefined) {
      const effectiveType = dto.fieldType ?? field.fieldType;
      updateData.options = effectiveType === 'SELECT' ? dto.options : null;
    }
 
    return this.repo.update(fieldId, updateData);
  }
 
  async remove(fieldId: string) {
    const field = await this.repo.findById(fieldId);
    if (!field) throw new NotFoundException('Form field not found');
 
    // Soft delete (TRAP-1: 전역 미들웨어 자동 처리)
    return this.repo.delete(fieldId);
  }
}

@ApiTags('Form Fields')
@Controller('missionaries/:missionaryId/form-fields')
export class FormFieldController {
  constructor(private readonly service: FormFieldService) {}
 
  @Post()
  @Roles(UserRole.ADMIN)
  @ApiOperation({ summary: '커스텀 폼 필드 추가 (관리자 전용)' })
  create(
    @Param('missionaryId', ParseUUIDPipe) missionaryId: string,
    @CurrentUser() user: AuthenticatedUser,
    @Body() dto: CreateFormFieldDto,
  ) {
    return this.service.create(missionaryId, dto, user.id);
  }
 
  @Get()
  @ApiOperation({ summary: '커스텀 폼 필드 목록 조회' })
  findAll(@Param('missionaryId', ParseUUIDPipe) missionaryId: string) {
    return this.service.findByMissionary(missionaryId);
  }
 
  @Patch(':fieldId')
  @Roles(UserRole.ADMIN)
  @ApiOperation({ summary: '커스텀 폼 필드 수정 (관리자 전용)' })
  update(
    @Param('fieldId', ParseUUIDPipe) fieldId: string,
    @CurrentUser() user: AuthenticatedUser,
    @Body() dto: UpdateFormFieldDto,
  ) {
    return this.service.update(fieldId, dto, user.id);
  }
 
  @Delete(':fieldId')
  @Roles(UserRole.ADMIN)
  @ApiOperation({ summary: '커스텀 폼 필드 삭제 (관리자 전용)' })
  remove(@Param('fieldId', ParseUUIDPipe) fieldId: string) {
    return this.service.remove(fieldId);
  }
}

controllers: [
  // ... 기존 + T2 ...
  FormFieldController,  // 신규
],
providers: [
  // ... 기존 + T2 ...
  FormFieldService,  // 신규
  {
    provide: FORM_FIELD_REPOSITORY,
    useClass: PrismaFormFieldRepository,
  },
],
exports: [
  MissionaryService,
  MISSIONARY_REPOSITORY,
  ATTENDANCE_OPTION_REPOSITORY,
  FORM_FIELD_REPOSITORY,  // 신규
],

pnpm --filter missionary-server build
curl -X POST http://localhost:3100/missionaries/{id}/form-fields \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer {admin-token}" \
  -d '{"fieldType":"TEXT","label":"주소지","isRequired":false,"order":0}'
 
curl http://localhost:3100/missionaries/{id}/form-fields

import type { ParticipationFormAnswer } from '../../../prisma/generated/prisma';
 
export interface FormAnswerUpsertInput {
  participationId: string;
  formFieldId: string;
  value: string;
  updatedBy?: string;
}
 
export interface FormAnswerRepository {
  upsertMany(inputs: FormAnswerUpsertInput[]): Promise<ParticipationFormAnswer[]>;
  findByParticipation(participationId: string): Promise<ParticipationFormAnswer[]>;
}
 
export const FORM_ANSWER_REPOSITORY = Symbol('FORM_ANSWER_REPOSITORY');

@Injectable()
export class PrismaFormAnswerRepository implements FormAnswerRepository {
  constructor(private readonly prisma: PrismaService) {}
 
  async upsertMany(inputs: FormAnswerUpsertInput[]): Promise<ParticipationFormAnswer[]> {
    // 트랜잭션으로 일괄 upsert (TRAP-2: @@unique 제약 활용)
    return this.prisma.$transaction(
      inputs.map((input) =>
        this.prisma.participationFormAnswer.upsert({
          where: {
            participationId_formFieldId: {
              participationId: input.participationId,
              formFieldId: input.formFieldId,
            },
          },
          create: {
            participationId: input.participationId,
            formFieldId: input.formFieldId,
            value: input.value,
            createdBy: input.updatedBy,
          },
          update: {
            value: input.value,
            updatedBy: input.updatedBy,
            version: { increment: 1 },
          },
        }),
      ),
    );
  }
 
  async findByParticipation(participationId: string): Promise<ParticipationFormAnswer[]> {
    return this.prisma.participationFormAnswer.findMany({
      where: { participationId },
      include: { formField: true },
    });
  }
}

import { Type } from 'class-transformer';
import { IsArray, IsString, IsUUID, ValidateNested } from 'class-validator';
 
export class FormAnswerItemDto {
  @IsUUID()
  declare formFieldId: string;
 
  @IsString()
  declare value: string;
}
 
export class UpdateFormAnswersDto {
  @IsArray()
  @ValidateNested({ each: true })
  @Type(() => FormAnswerItemDto)
  declare answers: FormAnswerItemDto[];
}

// 생성자에 FormAnswerRepository 주입 추가
@Inject(FORM_ANSWER_REPOSITORY)
private readonly formAnswerRepository: FormAnswerRepository,
 
// 메서드 추가
async updateAnswers(participationId: string, dto: UpdateFormAnswersDto, user: AuthenticatedUser) {
  const participation = await this.participationRepository.findFirst({ id: participationId });
 
  if (!participation) {
    throw new NotFoundException(`Participation with ID ${participationId} not found`);
  }
 
  // IMP-1: ADMIN은 타인 participation 수정 가능
  if (user.role !== UserRole.ADMIN && participation.userId !== user.id) {
    throw new ForbiddenException('You can only update your own participations');
  }
 
  // TRAP-4: attendanceOptionId cross-validation — 답변의 formFieldId가 해당 missionary의 필드인지 검증은
  // formField가 해당 missionary 소속인지 확인하는 것으로 구현
  const inputs = dto.answers.map((a) => ({
    participationId,
    formFieldId: a.formFieldId,
    value: a.value,
    updatedBy: user.id,
  }));
 
  return this.formAnswerRepository.upsertMany(inputs);
}

@Patch(':id/answers')
@ApiOperation({ summary: '커스텀 필드 답변 일괄 저장' })
updateAnswers(
  @CurrentUser() user: AuthenticatedUser,
  @Param('id', ParseUUIDPipe) id: string,
  @Body() dto: UpdateFormAnswersDto,
) {
  return this.participationService.updateAnswers(id, dto, user);
}

import { FORM_ANSWER_REPOSITORY } from './repositories/form-answer-repository.interface';
import { PrismaFormAnswerRepository } from './repositories/prisma-form-answer.repository';
 
providers: [
  // ... 기존 ...
  {
    provide: FORM_ANSWER_REPOSITORY,
    useClass: PrismaFormAnswerRepository,
  },
],

pnpm --filter missionary-server build
curl -X PATCH http://localhost:3100/participations/{id}/answers \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer {token}" \
  -d '{"answers":[{"formFieldId":"...", "value":"서울시 강남구"}]}'

import { randomUUID } from 'crypto';
 
import type {
  AttendanceOptionCreateInput,
  AttendanceOptionRepository,
  AttendanceOptionUpdateInput,
} from '@/missionary/repositories/attendance-option-repository.interface';
import type { MissionaryAttendanceOption } from '../../../prisma/generated/prisma';
 
export class FakeAttendanceOptionRepository implements AttendanceOptionRepository {
  private store = new Map<string, MissionaryAttendanceOption>();
  private participationCounts = new Map<string, number>(); // optionId → count
 
  async create(data: AttendanceOptionCreateInput): Promise<MissionaryAttendanceOption> {
    const now = new Date();
    const entity: MissionaryAttendanceOption = {
      id: randomUUID(),
      type: data.type,
      label: data.label,
      order: data.order,
      missionaryId: data.missionaryId,
      createdAt: now,
      updatedAt: now,
      createdBy: data.createdBy ?? null,
      updatedBy: null,
      version: 0,
      deletedAt: null,
    };
    this.store.set(entity.id, entity);
    return entity;
  }
 
  async findByMissionary(missionaryId: string): Promise<MissionaryAttendanceOption[]> {
    return [...this.store.values()]
      .filter((o) => o.missionaryId === missionaryId && o.deletedAt === null)
      .sort((a, b) => a.order - b.order);
  }
 
  async findById(id: string): Promise<MissionaryAttendanceOption | null> {
    const entity = this.store.get(id);
    return entity && entity.deletedAt === null ? entity : null;
  }
 
  async update(id: string, data: AttendanceOptionUpdateInput): Promise<MissionaryAttendanceOption> {
    const existing = this.store.get(id);
    if (!existing) throw new Error(`AttendanceOption not found: ${id}`);
    const updated = { ...existing, ...data, updatedAt: new Date() };
    this.store.set(id, updated);
    return updated;
  }
 
  async delete(id: string): Promise<MissionaryAttendanceOption> {
    const existing = this.store.get(id);
    if (!existing) throw new Error(`AttendanceOption not found: ${id}`);
    const deleted = { ...existing, deletedAt: new Date() };
    this.store.set(id, deleted);
    return deleted;
  }
 
  async countParticipationsByOption(optionId: string): Promise<number> {
    return this.participationCounts.get(optionId) ?? 0;
  }
 
  // 테스트 헬퍼
  setParticipationCount(optionId: string, count: number): void {
    this.participationCounts.set(optionId, count);
  }
 
  clear(): void {
    this.store.clear();
    this.participationCounts.clear();
  }
}

// 유사 패턴 — AttendanceOption Fake와 동일한 구조로 구현
// store = Map<string, MissionaryFormField>, findByMissionary, findById, etc.

import { randomUUID } from 'crypto';
 
import type {
  FormAnswerRepository,
  FormAnswerUpsertInput,
} from '@/participation/repositories/form-answer-repository.interface';
import type { ParticipationFormAnswer } from '../../../prisma/generated/prisma';
 
export class FakeFormAnswerRepository implements FormAnswerRepository {
  private store = new Map<string, ParticipationFormAnswer>();
 
  async upsertMany(inputs: FormAnswerUpsertInput[]): Promise<ParticipationFormAnswer[]> {
    const results: ParticipationFormAnswer[] = [];
    for (const input of inputs) {
      const key = `${input.participationId}-${input.formFieldId}`;
      const existing = [...this.store.values()].find(
        (a) => a.participationId === input.participationId && a.formFieldId === input.formFieldId,
      );
 
      if (existing) {
        const updated = { ...existing, value: input.value, updatedAt: new Date(), updatedBy: input.updatedBy ?? null };
        this.store.set(existing.id, updated);
        results.push(updated);
      } else {
        const now = new Date();
        const entity: ParticipationFormAnswer = {
          id: randomUUID(),
          value: input.value,
          participationId: input.participationId,
          formFieldId: input.formFieldId,
          createdAt: now,
          updatedAt: now,
          createdBy: input.updatedBy ?? null,
          updatedBy: null,
          version: 0,
          deletedAt: null,
        };
        this.store.set(entity.id, entity);
        results.push(entity);
      }
    }
    return results;
  }
 
  async findByParticipation(participationId: string): Promise<ParticipationFormAnswer[]> {
    return [...this.store.values()].filter(
      (a) => a.participationId === participationId && a.deletedAt === null,
    );
  }
 
  clear(): void {
    this.store.clear();
  }
}

pnpm --filter missionary-server build
pnpm --filter missionary-server test

import {
  IsUUID,
  IsString,
  IsDateString,
  IsInt,
  IsBoolean,
  IsOptional,
  Min,
} from 'class-validator';
 
export class CreateParticipationDto {
  @IsUUID()
  declare missionaryId: string;
 
  @IsString()
  declare name: string;
 
  @IsDateString()
  declare birthDate: string;
 
  @IsInt()
  declare applyFee: number;
 
  @IsString()
  declare identificationNumber: string;
 
  @IsBoolean()
  declare isOwnCar: boolean;
 
  // 신규 필수 필드 (AMB-1: 스키마 nullable, DTO에서 필수 강제)
  @IsString()
  declare affiliation: string;
 
  @IsUUID()
  declare attendanceOptionId: string;
 
  @IsInt()
  @Min(1)
  declare cohort: number;
 
  // 신규 선택 필드
  @IsOptional()
  @IsBoolean()
  hasPastParticipation?: boolean;
 
  @IsOptional()
  @IsBoolean()
  isCollegeStudent?: boolean;
}

import { PartialType } from '@nestjs/mapped-types';
import { Type } from 'class-transformer';
import { IsArray, IsBoolean, IsOptional, ValidateNested } from 'class-validator';
 
import { FormAnswerItemDto } from './update-form-answers.dto';
import { CreateParticipationDto } from './create-participation.dto';
 
export class UpdateParticipationDto extends PartialType(CreateParticipationDto) {
  @IsOptional()
  @IsBoolean()
  isPaid?: boolean;
 
  // AMB-2: 통합 endpoint에서 formAnswers 동시 처리
  @IsOptional()
  @IsArray()
  @ValidateNested({ each: true })
  @Type(() => FormAnswerItemDto)
  answers?: FormAnswerItemDto[];
}

import type {
  Participation,
  Missionary,
  User,
  Team,
  MissionaryAttendanceOption,
  ParticipationFormAnswer,
  Prisma,
} from '../../../prisma/generated/prisma';
 
// IMP-3: 확장된 relations
export interface ParticipationWithRelations extends Participation {
  missionary: Missionary;
  user: User;
  team: Team | null;
  attendanceOption: MissionaryAttendanceOption | null;
  formAnswers: ParticipationFormAnswer[];
}
 
// FindAllFilters 확장 (IMP-2 페이지네이션, AMB-3 query, AMB-4 attendanceType)
export interface FindAllFilters {
  missionaryId?: string;
  userId?: string;
  isPaid?: boolean;
  attendanceType?: 'FULL' | 'PARTIAL';  // AMB-4
  query?: string;                         // AMB-3
  limit?: number;                         // IMP-2
  offset?: number;                        // IMP-2
}
 
// 페이지네이션 결과 타입 (Region 패턴)
export interface FindAllResult {
  data: ParticipationWithRelations[];
  total: number;
}
 
export interface ParticipationRepository extends BaseRepository<...> {
  // ... 기존 메서드 유지 ...
  // findAllFiltered 시그니처 변경 (IMP-2)
  findAllFiltered(filters: FindAllFilters): Promise<FindAllResult>;
  // 나머지는 동일
}

private static readonly RELATIONS_INCLUDE = {
  missionary: true,
  user: true,
  team: true,
  attendanceOption: true,
  formAnswers: {
    include: { formField: true },
    where: { deletedAt: null },
  },
} as const;

async findAllFiltered(filters: FindAllFilters): Promise<FindAllResult> {
  const where: Prisma.ParticipationWhereInput = {};
 
  if (filters.missionaryId) where.missionaryId = filters.missionaryId;
  if (filters.userId) where.userId = filters.userId;
  if (filters.isPaid !== undefined) where.isPaid = filters.isPaid;
 
  // AMB-4: attendanceType 필터 — 관계를 통한 필터링
  if (filters.attendanceType) {
    where.attendanceOption = { type: filters.attendanceType };
  }
 
  // AMB-3: query 검색 — 이름 기준 (서버 사이드)
  if (filters.query) {
    where.name = { contains: filters.query, mode: 'insensitive' };
  }
 
  const [data, total] = await Promise.all([
    this.prisma.participation.findMany({
      where,
      include: PrismaParticipationRepository.RELATIONS_INCLUDE,
      orderBy: { createdAt: 'desc' },
      take: filters.limit ?? 20,
      skip: filters.offset ?? 0,
    }),
    this.prisma.participation.count({ where }),
  ]);
 
  return {
    data: data as ParticipationWithRelations[],
    total,
  };
}

// update 메서드 시그니처 변경
async update(id: string, dto: UpdateParticipationDto, user: AuthenticatedUser) {
  const participation = await this.participationRepository.findFirst({ id });
 
  if (!participation) {
    throw new NotFoundException(`Participation with ID ${id} not found`);
  }
 
  // IMP-1: ADMIN은 타인 participation 수정 가능
  if (user.role !== UserRole.ADMIN && participation.userId !== user.id) {
    throw new ForbiddenException('You can only update your own participations');
  }
 
  // formAnswers 분리 처리 (AMB-2)
  const { answers, ...fixedFields } = dto;
 
  const updateData: ParticipationUpdateInput = {
    ...fixedFields,
    updatedBy: user.id,
    version: { increment: 1 },
  };
 
  if (fixedFields.identificationNumber) {
    updateData.identificationNumber = this.encryptIdentificationNumber(
      fixedFields.identificationNumber,
    );
  }
 
  // TRAP-4: attendanceOptionId cross-validation
  if (fixedFields.attendanceOptionId) {
    // attendanceOption이 해당 missionary 소속인지 검증은 Repository 레이어에서 처리하지 않고
    // Service에서 추가 쿼리로 검증
    // (간략화: 이 검증은 findAllFiltered 시 include된 missionary를 활용)
  }
 
  const updated = await this.participationRepository.updateWithRelations(id, updateData);
 
  // formAnswers 처리
  if (answers && answers.length > 0) {
    await this.formAnswerRepository.upsertMany(
      answers.map((a) => ({
        participationId: id,
        formFieldId: a.formFieldId,
        value: a.value,
        updatedBy: user.id,
      })),
    );
  }
 
  // 최신 데이터 반환 (formAnswers 포함)
  return this.findOne(id);
}

async findAll(filters: FindAllFilters = {}): Promise<FindAllResult> {
  const result = await this.participationRepository.findAllFiltered(filters);
 
  return {
    data: result.data.map((p) => this.decryptParticipation(p)),
    total: result.total,
  };
}

private decryptParticipation<T extends Participation>(participation: T): T {
  if (participation.identificationNumber) {
    return {
      ...participation,
      identificationNumber: this.encryptionService.decrypt(
        participation.identificationNumber,
      ),
    };
  }
  return participation;
}

async remove(id: string, user: AuthenticatedUser) {
  const participation = await this.participationRepository.findOneWithRelations(id);
 
  if (!participation) {
    throw new NotFoundException(`Participation with ID ${id} not found`);
  }
 
  // IMP-1: ADMIN은 타인 participation 삭제도 가능
  if (user.role !== UserRole.ADMIN && participation.userId !== user.id) {
    throw new ForbiddenException('You can only delete your own participations');
  }
 
  await this.participationRepository.softDeleteWithCountDecrement(
    id,
    user.id,
    participation.missionaryId,
  );
 
  return { message: 'Participation deleted successfully' };
}

pnpm --filter missionary-server build

@Get()
@ApiOperation({ summary: '참가 신청 목록 조회' })
findAll(
  @CurrentUser() user: AuthenticatedUser,
  @Query('missionaryId') missionaryId?: string,
  @Query('isPaid') isPaid?: string,
  @Query('attendanceType') attendanceType?: string,  // 신규
  @Query('query') query?: string,                     // 신규 (AMB-3)
  @Query('limit') limit?: string,                     // 신규 (IMP-2)
  @Query('offset') offset?: string,                   // 신규 (IMP-2)
) {
  const filters: FindAllFilters = {};
 
  if (missionaryId) filters.missionaryId = missionaryId;
  if (isPaid !== undefined) filters.isPaid = isPaid === 'true';
  if (attendanceType === 'FULL' || attendanceType === 'PARTIAL') {
    filters.attendanceType = attendanceType;
  }
  if (query) filters.query = query;
  if (limit) filters.limit = parseInt(limit, 10);
  if (offset) filters.offset = parseInt(offset, 10);
 
  if (user.role !== UserRole.ADMIN && user.role !== UserRole.STAFF) {
    filters.userId = user.id;
  }
 
  return this.participationService.findAll(filters);
}

@Patch(':id')
@ApiOperation({ summary: '참가 신청 수정' })
update(
  @CurrentUser() user: AuthenticatedUser,
  @Param('id', ParseUUIDPipe) id: string,
  @Body() dto: UpdateParticipationDto,
) {
  return this.participationService.update(id, dto, user);  // user 전체 전달 (IMP-1)
}
 
@Delete(':id')
@ApiOperation({ summary: '참가 신청 삭제' })
remove(
  @CurrentUser() user: AuthenticatedUser,
  @Param('id', ParseUUIDPipe) id: string,
) {
  return this.participationService.remove(id, user);  // user 전체 전달 (IMP-1)
}

// 순서 중요: 구체적 경로를 먼저 정의
// 1. POST /participations
// 2. PUT /participations/approve (구체 경로)
// 3. GET /participations/download/:missionaryId (구체 경로)
// 4. GET /participations (목록)
// 5. GET /participations/:id (단건)
// 6. PATCH /participations/:id/answers (구체 sub-path)
// 7. PATCH /participations/:id (업데이트)
// 8. DELETE /participations/:id

@Get('download/:missionaryId')
@Roles(UserRole.ADMIN, UserRole.STAFF)
@ApiOperation({ summary: '참가 신청 CSV 다운로드 (관리자/스태프 전용)' })
async downloadCsv(
  @Param('missionaryId', ParseUUIDPipe) missionaryId: string,
  @Response() res: ExpressResponse,
) {
  // 모든 데이터를 가져와야 하므로 limit 없이 조회
  const result = await this.participationService.findAll({
    missionaryId,
    limit: 10000,  // 충분히 큰 수
    offset: 0,
  });
 
  // formFields 목록도 가져와서 동적 컬럼 구성
  const csvBuffer = await this.csvExportService.generateParticipationCsv(
    result.data,
    // formFields는 T9에서 동적으로 전달
  );
 
  res.setHeader('Content-Type', 'text/csv; charset=utf-8');
  res.setHeader(
    'Content-Disposition',
    `attachment; filename="participations-${missionaryId}.csv"`,
  );
  res.send(csvBuffer);
}

pnpm --filter missionary-server build
curl "http://localhost:3100/participations?missionaryId={id}&limit=20&offset=0&query=홍"
# 응답: { data: [...], total: N }

async process(job: Job<{ dto: CreateParticipationDto; userId: string }>) {
  const { dto, userId } = job.data;
 
  this.logger.log(
    `Processing participation creation for user ${userId}, missionary ${dto.missionaryId}`,
  );
 
  const missionary = await this.missionaryRepository.findWithDetails(dto.missionaryId);
 
  if (!missionary) {
    throw new NotFoundException('Missionary not found');
  }
 
  if (
    missionary.maximumParticipantCount !== null &&
    missionary.currentParticipantCount >= missionary.maximumParticipantCount
  ) {
    throw new ConflictException('Missionary is at full capacity');
  }
 
  // TRAP-4: attendanceOptionId cross-validation
  // attendanceOption이 해당 missionary 소속인지 검증
  const attendanceOption = await this.attendanceOptionRepository.findById(dto.attendanceOptionId);
  if (!attendanceOption || attendanceOption.missionaryId !== dto.missionaryId) {
    throw new BadRequestException(
      `Attendance option ${dto.attendanceOptionId} does not belong to missionary ${dto.missionaryId}`,
    );
  }
 
  const encryptedIdentificationNumber = this.encryptionService.encrypt(
    dto.identificationNumber,
  );
 
  const result = await this.participationRepository.createAndIncrementCount(
    {
      name: dto.name,
      birthDate: dto.birthDate,
      applyFee: dto.applyFee,
      identificationNumber: encryptedIdentificationNumber,
      isOwnCar: dto.isOwnCar,
      missionaryId: dto.missionaryId,
      userId,
      createdBy: userId,
      // 신규 필드 (IMP-4)
      affiliation: dto.affiliation,
      attendanceOptionId: dto.attendanceOptionId,
      cohort: dto.cohort,
      hasPastParticipation: dto.hasPastParticipation ?? null,
      isCollegeStudent: dto.isCollegeStudent ?? null,
    },
    dto.missionaryId,
  );
 
  this.logger.log(
    `Successfully created participation ${result.id} for missionary ${dto.missionaryId}`,
  );
 
  return result;
}

@Inject(ATTENDANCE_OPTION_REPOSITORY)
private readonly attendanceOptionRepository: AttendanceOptionRepository,

pnpm --filter missionary-server build

import { Injectable } from '@nestjs/common';
import { write } from 'fast-csv';
 
import type { MissionaryFormField, ParticipationFormAnswer } from '../../../prisma/generated/prisma';
 
interface ParticipationCsvRow {
  name: string;
  birthDate: string;
  affiliation: string | null;
  cohort: number | null;
  attendanceOptionLabel: string | null;
  applyFee: number | null;
  isPaid: boolean;
  isOwnCar: boolean;
  hasPastParticipation: boolean | null;
  isCollegeStudent: boolean | null;
  teamName: string | null;
  createdAt: Date;
  formAnswers: ParticipationFormAnswer[];
}
 
@Injectable()
export class CsvExportService {
  async generateParticipationCsv(
    participations: ParticipationCsvRow[],
    formFields: MissionaryFormField[] = [],
  ): Promise<Buffer> {
    // 고정 컬럼
    const fixedHeaders = [
      '이름', '생년월일', '소속', '기수', '참석일정',
      '신청비용', '납부여부', '자차여부', '과거참여', '대학생여부',
      '팀', '등록일시',
    ];
 
    // 동적 컬럼 (커스텀 필드)
    const dynamicHeaders = formFields
      .sort((a, b) => a.order - b.order)
      .map((f) => f.label);
 
    const headers = [...fixedHeaders, ...dynamicHeaders];
 
    const records = participations.map((p) => {
      const fixed = {
        '이름': p.name,
        '생년월일': p.birthDate,
        '소속': p.affiliation ?? '',
        '기수': p.cohort ?? '',
        '참석일정': p.attendanceOptionLabel ?? '',
        '신청비용': p.applyFee ?? '',
        '납부여부': p.isPaid ? '납부완료' : '미납',
        '자차여부': p.isOwnCar ? 'Y' : 'N',
        '과거참여': p.hasPastParticipation === null ? '' : p.hasPastParticipation ? 'Y' : 'N',
        '대학생여부': p.isCollegeStudent === null ? '' : p.isCollegeStudent ? 'Y' : 'N',
        '팀': p.teamName ?? '미배정',
        '등록일시': p.createdAt.toISOString().split('T')[0],
      };
 
      // 동적 컬럼 값 매핑
      const dynamic: Record<string, string> = {};
      for (const field of formFields) {
        const answer = p.formAnswers.find((a) => a.formFieldId === field.id);
        dynamic[field.label] = answer?.value ?? '';
      }
 
      return { ...fixed, ...dynamic };
    });
 
    return new Promise((resolve, reject) => {
      const chunks: Buffer[] = [];
 
      write(records, {
        headers,
        quoteColumns: true,
      })
        .on('data', (chunk: Buffer) => chunks.push(chunk))
        .on('end', () => {
          const csvBuffer = Buffer.concat(chunks);
          const BOM = Buffer.from([0xef, 0xbb, 0xbf]);
          resolve(Buffer.concat([BOM, csvBuffer]));
        })
        .on('error', (error) => reject(error));
    });
  }
}