From 71085d0ac4439b9d84544f3e52424788c91f11d2 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: Sat, 19 Sep 2026 19:40:35 +0900 Subject: [PATCH] feat(dakao): transfer existing users to new KakaoTalk IDs --- .../dakao/dakao-user-transfer.service.spec.ts | 122 ++++++++++++++++++ .../src/modules/dakao/dakao-user.service.ts | 46 +++++++ apps/api/src/modules/dakao/dakao.module.ts | 2 + .../modules/dakao/dakao.subscriber.spec.ts | 47 ++++++- .../api/src/modules/dakao/dakao.subscriber.ts | 11 ++ .../handlers/data-transfer.handler.spec.ts | 49 +++++++ .../dakao/handlers/data-transfer.handler.ts | 46 +++++++ .../dakao/parsers/command.parser.spec.ts | 13 ++ .../modules/dakao/parsers/command.parser.ts | 4 + docs/specs/kakao-user-data-transfer.md | 93 +++++++++++++ 10 files changed, 432 insertions(+), 1 deletion(-) create mode 100644 apps/api/src/modules/dakao/dakao-user-transfer.service.spec.ts create mode 100644 apps/api/src/modules/dakao/handlers/data-transfer.handler.spec.ts create mode 100644 apps/api/src/modules/dakao/handlers/data-transfer.handler.ts create mode 100644 docs/specs/kakao-user-data-transfer.md diff --git a/apps/api/src/modules/dakao/dakao-user-transfer.service.spec.ts b/apps/api/src/modules/dakao/dakao-user-transfer.service.spec.ts new file mode 100644 index 00000000..5ef5c0da --- /dev/null +++ b/apps/api/src/modules/dakao/dakao-user-transfer.service.spec.ts @@ -0,0 +1,122 @@ +import mongoose from 'mongoose'; +import { ConnectionService } from '../global/database/connection.service'; +import { RiotAccountService } from '../riot/riot-account.service'; +import { RiotAccountEnrichmentService } from '../riot/riot-account-enrichment.service'; +import { DakaoUserService } from './dakao-user.service'; + +const communityId = new mongoose.Types.ObjectId(); +const params = { + communityId, + kakaoTalkId: 'new-id', + previousNickname: '예전 닉', +}; + +function setup() { + const user = { + _id: new mongoose.Types.ObjectId(), + communityId, + kakaoTalkId: 'old-id', + kakaoTalkNickname: '예전 닉', + riotAccounts: [{ puuid: 'puuid', gameName: '소환사', tagLine: 'KR1' }], + role: 'member', + }; + const find = jest.fn().mockReturnValue({ + limit: jest + .fn() + .mockReturnValue({ exec: jest.fn().mockResolvedValue([user]) }), + }); + const findOne = jest + .fn() + .mockReturnValue({ exec: jest.fn().mockResolvedValue(null) }); + const update = jest + .fn() + .mockImplementation(async () => ({ ...user, kakaoTalkId: 'new-id' })); + const findOneAndUpdate = jest.fn().mockReturnValue({ exec: update }); + const service = new DakaoUserService( + { + getModel: jest + .fn() + .mockResolvedValue({ find, findOne, findOneAndUpdate }), + } as unknown as ConnectionService, + {} as RiotAccountService, + {} as RiotAccountEnrichmentService, + ); + return { service, user, find, findOne, findOneAndUpdate, update }; +} + +describe('DakaoUserService.transferKakaoTalkId', () => { + it('selects registered users by exact nickname in the current community and changes only the ID', async () => { + const { service, user, find, findOneAndUpdate } = setup(); + expect(await service.transferKakaoTalkId(params)).toBe('transferred'); + expect(find).toHaveBeenCalledWith({ + communityId, + kakaoTalkNickname: '예전 닉', + 'riotAccounts.0': { $exists: true }, + }); + expect(findOneAndUpdate).toHaveBeenCalledWith( + { + _id: user._id, + communityId, + kakaoTalkId: 'old-id', + kakaoTalkNickname: '예전 닉', + 'riotAccounts.0': { $exists: true }, + }, + { $set: { kakaoTalkId: 'new-id' } }, + { returnDocument: 'after' }, + ); + }); + + it.each([ + ['not-found', 0], + ['ambiguous', 2], + ] as const)('returns %s without mutation', async (status, count) => { + const { service, user, find, findOneAndUpdate } = setup(); + find.mockReturnValue({ + limit: () => ({ + exec: async () => Array.from({ length: count }, () => user), + }), + }); + expect(await service.transferKakaoTalkId(params)).toBe(status); + expect(findOneAndUpdate).not.toHaveBeenCalled(); + }); + + it('does not mutate an already linked user', async () => { + const { service, user, findOneAndUpdate } = setup(); + user.kakaoTalkId = 'new-id'; + expect(await service.transferKakaoTalkId(params)).toBe('already-linked'); + expect(findOneAndUpdate).not.toHaveBeenCalled(); + }); + + it('refuses an ID occupied by another user', async () => { + const { service, findOne, findOneAndUpdate } = setup(); + findOne.mockReturnValue({ + exec: async () => ({ _id: new mongoose.Types.ObjectId() }), + }); + expect(await service.transferKakaoTalkId(params)).toBe('id-conflict'); + expect(findOne).toHaveBeenCalledWith({ + communityId, + kakaoTalkId: 'new-id', + }); + expect(findOneAndUpdate).not.toHaveBeenCalled(); + }); + + it('reports a concurrent change instead of overwriting it', async () => { + const { service, update } = setup(); + update.mockResolvedValue(null); + expect(await service.transferKakaoTalkId(params)).toBe('changed'); + }); + + it('handles a concurrent ID collision', async () => { + const { service, update } = setup(); + update.mockRejectedValue({ code: 11000 }); + expect(await service.transferKakaoTalkId(params)).toBe('id-conflict'); + }); + + it('propagates unexpected database failures for retry', async () => { + const { service, update } = setup(); + update.mockRejectedValue(new Error('database unavailable')); + await expect(service.transferKakaoTalkId(params)).rejects.toThrow( + 'database unavailable', + ); + }); +}); diff --git a/apps/api/src/modules/dakao/dakao-user.service.ts b/apps/api/src/modules/dakao/dakao-user.service.ts index be5707a4..5395c93c 100644 --- a/apps/api/src/modules/dakao/dakao-user.service.ts +++ b/apps/api/src/modules/dakao/dakao-user.service.ts @@ -60,6 +60,14 @@ interface ResolvedRiotIdentity { const DEFAULT_RIOT_PLATFORM: RiotPlatformRoute = 'kr'; const DEFAULT_RIOT_REGION: RiotRegionalRoute = 'asia'; +export type KakaoDataTransferResult = + | 'transferred' + | 'already-linked' + | 'not-found' + | 'ambiguous' + | 'id-conflict' + | 'changed'; + @Injectable() export class DakaoUserService { private readonly logger = new Logger(DakaoUserService.name); @@ -127,6 +135,44 @@ export class DakaoUserService { }).exec(); } + public async transferKakaoTalkId(params: { + communityId: mongoose.Types.ObjectId; + kakaoTalkId: string; + previousNickname: string; + }): Promise { + const UserModel = await this.connectionService.getModel('user'); + const targetFilter = { + communityId: params.communityId, + kakaoTalkNickname: params.previousNickname, + 'riotAccounts.0': { $exists: true }, + }; + const candidates = await UserModel.find(targetFilter).limit(2).exec(); + if (candidates.length === 0) return 'not-found'; + if (candidates.length > 1) return 'ambiguous'; + + const user = candidates[0]; + if (user.kakaoTalkId === params.kakaoTalkId) return 'already-linked'; + const occupied = await this.findUserByKakaoTalkId(params); + if (occupied) return 'id-conflict'; + + try { + // Compare the previous ID so concurrent transfers cannot overwrite one another. + const updated = await UserModel.findOneAndUpdate( + { + ...targetFilter, + _id: user._id, + kakaoTalkId: user.kakaoTalkId ?? null, + }, + { $set: { kakaoTalkId: params.kakaoTalkId } }, + { returnDocument: 'after' }, + ).exec(); + return updated ? 'transferred' : 'changed'; + } catch (error) { + if ((error as { code?: number })?.code === 11000) return 'id-conflict'; + throw error; + } + } + public async resolveRiotAccount( context: ResolveContext, ): Promise { diff --git a/apps/api/src/modules/dakao/dakao.module.ts b/apps/api/src/modules/dakao/dakao.module.ts index 5ff93408..58c6b243 100644 --- a/apps/api/src/modules/dakao/dakao.module.ts +++ b/apps/api/src/modules/dakao/dakao.module.ts @@ -12,6 +12,7 @@ import { DakaoUserService } from './dakao-user.service'; import { DakaoSendResultSubscriber } from './dakao-send-result.subscriber'; import { DakaoUrlShortenerService } from './dakao-url-shortener.service'; import { AccountRegisterHandler } from './handlers/account-register.handler'; +import { DataTransferHandler } from './handlers/data-transfer.handler'; import { MatchCancelHandler } from './handlers/match-cancel.handler'; import { MatchJoinHandler } from './handlers/match-join.handler'; import { MatchListHandler } from './handlers/match-list.handler'; @@ -35,6 +36,7 @@ import { PrimaryAccountChangeHandler } from './handlers/primary-account-change.h DakaoUserService, DakaoUrlShortenerService, AccountRegisterHandler, + DataTransferHandler, MatchListHandler, MatchJoinHandler, MatchCancelHandler, diff --git a/apps/api/src/modules/dakao/dakao.subscriber.spec.ts b/apps/api/src/modules/dakao/dakao.subscriber.spec.ts index fa97773d..239f8876 100644 --- a/apps/api/src/modules/dakao/dakao.subscriber.spec.ts +++ b/apps/api/src/modules/dakao/dakao.subscriber.spec.ts @@ -16,6 +16,7 @@ function makeSubscriber(): DakaoSubscriber { {} as never, {} as never, {} as never, + {} as never, ); } @@ -39,6 +40,48 @@ const event = { } satisfies DakaoInboundEvent; describe('DakaoSubscriber', () => { + it('routes data transfer with the current sender ID and publishes its reply', async () => { + const subscriber = makeSubscriber(); + const segments = [{ kind: 'text', text: ' 데이터 이관 완료' }]; + const handle = jest.fn().mockResolvedValue(segments); + const sendMessage = jest.fn(); + const markProcessed = jest.fn(); + Object.assign(subscriber, { + dakaoUserService: { + resolveCommunityIdByDakaoProjectId: async () => event.projectId, + }, + dataTransferHandler: { handle }, + publisher: { sendMessage }, + inbox: { claim: async () => ({ status: 'claimed' }), markProcessed }, + }); + await ( + subscriber as unknown as { + handleEvent: (input: DakaoInboundEvent) => Promise; + } + ).handleEvent({ + ...event, + origin: { + ...event.origin, + chatLog: { + ...event.origin.chatLog, + message: '!내전 데이터이관 예전 닉', + }, + }, + }); + expect(handle).toHaveBeenCalledWith({ + communityId: event.projectId, + senderUserId: '12345', + senderNickname: '프리리', + previousNickname: '예전 닉', + }); + expect(sendMessage).toHaveBeenCalledWith({ + chatroomId: 'chatroom-1', + segments, + correlationId: 'log-1', + }); + expect(markProcessed).toHaveBeenCalled(); + }); + it('renders usage help with star emoticon command lines', () => { const subscriber = makeSubscriber() as unknown as { parseErrorReply: ( @@ -74,8 +117,10 @@ describe('DakaoSubscriber', () => { { kind: 'emoticon', id: '1200281_035', altText: '스타' }, { kind: 'text', - text: ' !내전 대표계정변경 소환사이름#태그', + text: ' !내전 대표계정변경 소환사이름#태그\u3000\n', }, + { kind: 'emoticon', id: '1200281_035', altText: '스타' }, + { kind: 'text', text: ' !내전 데이터이관 예전닉네임' }, ]); }); diff --git a/apps/api/src/modules/dakao/dakao.subscriber.ts b/apps/api/src/modules/dakao/dakao.subscriber.ts index 1df57846..a25cede8 100644 --- a/apps/api/src/modules/dakao/dakao.subscriber.ts +++ b/apps/api/src/modules/dakao/dakao.subscriber.ts @@ -7,6 +7,7 @@ import { DakaoInboundEvent, DakaoLong, DakaoSegment } from './dakao.types'; import { DakaoPublisher } from './dakao.publisher'; import { DakaoUserError, DakaoUserService } from './dakao-user.service'; import { AccountRegisterHandler } from './handlers/account-register.handler'; +import { DataTransferHandler } from './handlers/data-transfer.handler'; import { MatchCancelHandler } from './handlers/match-cancel.handler'; import { MatchJoinHandler } from './handlers/match-join.handler'; import { MatchListHandler } from './handlers/match-list.handler'; @@ -27,6 +28,7 @@ export class DakaoSubscriber implements OnModuleInit { '!내전 계정등록 소환사이름#태그', '!내전 선호포지션등록 포지션1,포지션2', '!내전 대표계정변경 소환사이름#태그', + '!내전 데이터이관 예전닉네임', ]; constructor( @@ -42,6 +44,7 @@ export class DakaoSubscriber implements OnModuleInit { private readonly matchCancelHandler: MatchCancelHandler, private readonly preferredPositionRegisterHandler: PreferredPositionRegisterHandler, private readonly primaryAccountChangeHandler: PrimaryAccountChangeHandler, + private readonly dataTransferHandler: DataTransferHandler, ) {} async onModuleInit() { @@ -119,6 +122,14 @@ export class DakaoSubscriber implements OnModuleInit { const command = parseCommand(event.origin.chatLog.message); switch (command.kind) { + case 'data-transfer': + segments = await this.dataTransferHandler.handle({ + communityId, + senderUserId: event.userId, + senderNickname, + previousNickname: command.previousNickname, + }); + break; case 'match-list': segments = await this.matchListHandler.handle({ communityId, diff --git a/apps/api/src/modules/dakao/handlers/data-transfer.handler.spec.ts b/apps/api/src/modules/dakao/handlers/data-transfer.handler.spec.ts new file mode 100644 index 00000000..9503377e --- /dev/null +++ b/apps/api/src/modules/dakao/handlers/data-transfer.handler.spec.ts @@ -0,0 +1,49 @@ +import mongoose from 'mongoose'; +import { + DakaoUserService, + KakaoDataTransferResult, +} from '../dakao-user.service'; +import { DataTransferHandler } from './data-transfer.handler'; + +const params = { + communityId: new mongoose.Types.ObjectId(), + senderUserId: 'new-id', + senderNickname: '현재 닉', + previousNickname: '예전 닉', +}; + +describe('DataTransferHandler', () => { + it.each<[KakaoDataTransferResult, string]>([ + ['transferred', '데이터 이관 완료'], + ['already-linked', '이미 현재 카카오톡 계정에 연결'], + ['not-found', '찾을 수 없습니다'], + ['ambiguous', '여러 명'], + ['id-conflict', '이미 다른 사용자'], + ['changed', '변경되었습니다'], + ])('replies to the sender for %s', async (result, message) => { + const transferKakaoTalkId = jest.fn().mockResolvedValue(result); + const handler = new DataTransferHandler({ + transferKakaoTalkId, + } as unknown as DakaoUserService); + expect(await handler.handle(params)).toEqual([ + { kind: 'mention', userId: 'new-id', displayText: '현재 닉' }, + { kind: 'text', text: expect.stringContaining(message) }, + ]); + expect(transferKakaoTalkId).toHaveBeenCalledWith({ + communityId: params.communityId, + kakaoTalkId: 'new-id', + previousNickname: '예전 닉', + }); + }); + + it('propagates unexpected failures', async () => { + const handler = new DataTransferHandler({ + transferKakaoTalkId: jest + .fn() + .mockRejectedValue(new Error('database unavailable')), + } as unknown as DakaoUserService); + await expect(handler.handle(params)).rejects.toThrow( + 'database unavailable', + ); + }); +}); diff --git a/apps/api/src/modules/dakao/handlers/data-transfer.handler.ts b/apps/api/src/modules/dakao/handlers/data-transfer.handler.ts new file mode 100644 index 00000000..09d9a07b --- /dev/null +++ b/apps/api/src/modules/dakao/handlers/data-transfer.handler.ts @@ -0,0 +1,46 @@ +import { Injectable } from '@nestjs/common'; +import mongoose from 'mongoose'; +import { + DakaoUserService, + KakaoDataTransferResult, +} from '../dakao-user.service'; +import { DakaoSegment } from '../dakao.types'; + +const RESULT_MESSAGES: Record = { + transferred: + '데이터 이관 완료. 기존 라이엇 계정과 내전 기록이 현재 카카오톡 계정에 연결되었습니다.', + 'already-linked': '이미 현재 카카오톡 계정에 연결된 사용자입니다.', + 'not-found': + '해당 예전 닉네임으로 라이엇 계정이 등록된 사용자를 찾을 수 없습니다.', + ambiguous: + '같은 예전 닉네임으로 등록된 사용자가 여러 명입니다. 운영자에게 문의해주세요.', + 'id-conflict': + '현재 카카오톡 계정에 이미 다른 사용자가 등록되어 있습니다. 운영자에게 문의해주세요.', + changed: '이관 중 사용자 정보가 변경되었습니다. 다시 시도해주세요.', +}; + +@Injectable() +export class DataTransferHandler { + constructor(private readonly dakaoUserService: DakaoUserService) {} + + public async handle(params: { + communityId: mongoose.Types.ObjectId; + senderUserId: string; + senderNickname: string; + previousNickname: string; + }): Promise { + const result = await this.dakaoUserService.transferKakaoTalkId({ + communityId: params.communityId, + kakaoTalkId: params.senderUserId, + previousNickname: params.previousNickname, + }); + return [ + { + kind: 'mention', + userId: params.senderUserId, + displayText: params.senderNickname, + }, + { kind: 'text', text: ` ${RESULT_MESSAGES[result]}` }, + ]; + } +} diff --git a/apps/api/src/modules/dakao/parsers/command.parser.spec.ts b/apps/api/src/modules/dakao/parsers/command.parser.spec.ts index baa233d5..00254c16 100644 --- a/apps/api/src/modules/dakao/parsers/command.parser.spec.ts +++ b/apps/api/src/modules/dakao/parsers/command.parser.spec.ts @@ -1,6 +1,19 @@ import { CommandParseError, parseCommand } from './command.parser'; describe('parseCommand', () => { + it('parses data transfer with the complete previous nickname', () => { + expect(parseCommand(' !내전 데이터이관 예전 닉.* ')).toEqual({ + kind: 'data-transfer', + previousNickname: '예전 닉.*', + }); + }); + + it('requires a previous nickname for data transfer', () => { + expect(() => parseCommand('!내전 데이터이관 ')).toThrow( + new CommandParseError('usage'), + ); + }); + it('parses match-list command (목록)', () => { expect(parseCommand('!내전 목록')).toEqual({ kind: 'match-list' }); }); diff --git a/apps/api/src/modules/dakao/parsers/command.parser.ts b/apps/api/src/modules/dakao/parsers/command.parser.ts index 92d7ced0..a3a2fee6 100644 --- a/apps/api/src/modules/dakao/parsers/command.parser.ts +++ b/apps/api/src/modules/dakao/parsers/command.parser.ts @@ -7,6 +7,7 @@ import { normalizeRiotIdPart } from '../riot-id.util'; export type DakaoCommand = | { kind: 'match-list' } + | { kind: 'data-transfer'; previousNickname: string } | { kind: 'account-register'; gameName: string; @@ -75,6 +76,9 @@ export function parseCommand(rawMessage: string): DakaoCommand { return parseCancelArgs(args); case '계정등록': return parseAccountRegisterArgs(args); + case '데이터이관': + if (!args) throw new CommandParseError('usage'); + return { kind: 'data-transfer', previousNickname: args }; case '대표계정변경': return parsePrimaryAccountChangeArgs(args); case '선호포지션등록': diff --git a/docs/specs/kakao-user-data-transfer.md b/docs/specs/kakao-user-data-transfer.md new file mode 100644 index 00000000..9ced33c0 --- /dev/null +++ b/docs/specs/kakao-user-data-transfer.md @@ -0,0 +1,93 @@ +# Spec: 카카오톡 방 이동 후 사용자 데이터 이관 + +## Objective + +`!내전 데이터이관 <예전 kakaoTalkNickname>` 명령으로 기존 user의 +`kakaoTalkId`를 명령 발신자의 현재 ID로 변경한다. 기존 user의 `_id`, +`riotAccounts`, 참가 기록, 권한과 기타 데이터는 유지한다. + +## Proposed Success Criteria + +- 현재 명령이 연결된 community 안에서만 조회한다. +- 인자 전체를 예전 닉네임으로 취급하여 공백이 포함된 닉네임을 지원한다. +- 닉네임은 앞뒤 인자 공백을 제거한 후 정확히 일치하는 값으로 조회한다. +- `riotAccounts`가 있는 기존 user를 이관 대상으로 삼는다. +- 대상 없음, 중복 닉네임, 다른 user의 현재 카카오 ID 점유는 변경 없이 안내한다. +- 성공 시 기존 user의 `kakaoTalkId`만 변경하고 발신자에게 완료를 안내한다. +- 동일 ID로 재시도하면 이미 연결된 상태로 안내한다. +- 동시 변경과 DB 중복 키 오류를 처리하며 새 user를 생성하거나 병합하지 않는다. + +## Tech Stack / Project Structure + +NestJS 11, TypeScript, Mongoose 9, Jest 30, pnpm workspace. +`apps/api/src/modules/dakao/`의 parser, handler, service, module 및 명령 라우팅을 사용한다. +테스트는 구현 옆 `*.spec.ts`, 명세는 `docs/specs/`에 둔다. + +## Commands + +- 관련 테스트: `pnpm --filter api test --runInBand dakao` +- 전체 API 테스트: `pnpm --filter api test --runInBand` +- 빌드: `pnpm --filter api build` +- 변경 파일 lint: `pnpm --filter api exec eslint ` +- 개발 실행: `pnpm --filter api start:debug` + +## Code Style + +기존 Injectable handler/service와 discriminated command union 패턴을 따른다. + +```typescript +return { kind: 'data-transfer', previousNickname: args }; +``` + +## Testing Strategy + +구현 전 실패 테스트를 작성한다. 파싱, 커뮤니티 범위, 성공 후 기존 데이터 보존, +대상 없음/중복, ID 충돌, 재시도, 동시 갱신 실패 및 라우팅/응답을 검증한다. +관련 테스트 후 전체 API 테스트와 빌드를 수행한다. + +## Boundaries + +- Always: 커뮤니티 범위 제한, 입력 검증, 기존 user 식별자 및 연결 데이터 보존. +- Ask first: 스키마 변경, 의존성 추가, 기존 user 병합/삭제. +- Never: 운영 DB 직접 수정, 비밀값 커밋, 실패 테스트 제거. + +## Confirmed Policy + +사용자 확인: `riotAccounts`가 등록된 user를 뜻한다. Riot 계정 검증 및 소유권 +확인은 하지 않으며 운영으로 통제한다. 예전 닉네임으로 조회하여 ID만 변경한다. + +## Implementation Plan and Tasks + +1. 이관 서비스: `dakao-user.service.ts` 및 전용 테스트 파일. + - 수락 조건: 기존 데이터 보존, 대상/충돌/재시도/동시 변경 처리. + - 검증: 실패 테스트 확인 후 서비스 테스트 통과. +2. 명령 parser 및 handler: 구현과 각각의 테스트 4개 파일. + - 수락 조건: 공백 포함 닉네임 파싱, 빈 입력 사용법, 결과별 한국어 응답. + - 검증: parser/handler 테스트 통과. 작업 1에 의존. +3. subscriber 및 module 연결: 구현 2개와 subscriber 테스트. + - 수락 조건: 현재 커뮤니티/발신자 ID 전달, 도움말 노출. + - 검증: Dakao 테스트, 전체 API 테스트, 빌드, 변경 파일 lint. 작업 2에 의존. + +위험: 동시에 이관되는 user는 기존 ID를 조건으로 갱신하여 덮어쓰기를 막고, +새 ID 동시 점유는 기존 unique 인덱스 오류를 충돌 응답으로 변환한다. +각 단계에서 테스트를 확인하고 다음 단계로 진행한다. + +## Verification Results + +- 서비스, parser/handler, subscriber 테스트는 기능 미구현 상태의 실패를 확인한 후 통과. +- Dakao: 16 suites / 92 tests 통과. +- API 전체: 99 suites / 634 tests 통과, 기존 테스트 2개 실패. + - `api-performance-report.spec.ts`: Windows `path.relative`의 역슬래시와 기대값 불일치. + - `secret.service.spec.ts`: 환경변수에 의존해 누락된 bootstrap secret의 기대 키 불일치. + - 두 테스트는 변경하지 않은 파일이며 별도 실행에서도 같은 실패 재현. +- API 빌드, 변경 TypeScript 파일 ESLint, `git diff --check` 통과. +- 로컬 실행 환경 Node 24.15.0; 저장소 엔진 요구사항은 Node 26. +- 실제 카카오톡 메시지 전송 및 운영 DB 이관은 실행하지 않음. +- 코드 검토: 커뮤니티 제한, 정확한 닉네임 조회, 등록 계정 필터, + ID만 갱신하는 조건부 업데이트, 충돌 응답, DI 및 명령 라우팅 확인. + +## Usage + +새 방에서 `!내전 데이터이관 예전 닉네임`을 실행한다. 따옴표 없이 공백을 포함한 +닉네임 전체를 입력할 수 있다. 새 ID로 이미 user가 생성되어 있으면 자동 병합하지 +않고 운영자 문의를 안내한다. 소유권 확인은 운영 정책으로 통제한다.