fix: close competition cutover integrity gaps

This commit is contained in:
dahyeon committed 2026-07-12 21:22:22 +00:00
1 parent 7ea2002975
commit 683d602d63
57 files changed
+4805 -1582

No files matched your search

@@ -294,16 +294,40 @@ describe('Legacy import Competition result cutover', () => {
it('cascades admin deletion through Competition facts and read models', async () => {
const fixture = createImportFixture();
const session = {
startTransaction: jest.fn(),
commitTransaction: jest.fn().mockResolvedValue(undefined),
abortTransaction: jest.fn().mockResolvedValue(undefined),
endSession: jest.fn().mockResolvedValue(undefined),
};
const competitionFactModel = deleteManyModel();
const competitionOutboxModel = deleteManyModel();
const assignmentModel = deleteManyModel();
const reservedCodeId = new mongoose.Types.ObjectId();
const usedCodeId = new mongoose.Types.ObjectId();
const assignmentModel = {
...deleteManyModel(),
find: jest.fn().mockReturnValue({
select: jest.fn().mockReturnValue({
session: jest.fn().mockReturnValue({
lean: jest.fn().mockReturnValue(
execResult([
{ tournamentCodeId: reservedCodeId, state: 'reserved' },
{ tournamentCodeId: usedCodeId, state: 'used' },
]),
),
}),
}),
}),
};
const competitionModel = {
...deleteManyModel(),
find: jest.fn().mockReturnValue({
select: jest.fn().mockReturnValue({
lean: jest
.fn()
.mockReturnValue(execResult([{ _id: fixture.competition._id }])),
session: jest.fn().mockReturnValue({
lean: jest
.fn()
.mockReturnValue(execResult([{ _id: fixture.competition._id }])),
}),
}),
}),
};
@@ -311,11 +335,44 @@ describe('Legacy import Competition result cutover', () => {
find: jest.fn().mockReturnValue({
select: jest
.fn()
.mockReturnValue(execResult([{ _id: fixture.match._id }])),
.mockReturnValue(sessionResult([{ _id: fixture.match._id }])),
}),
deleteMany: jest.fn().mockReturnValue(execResult({ deletedCount: 1 })),
deleteMany: jest.fn().mockReturnValue(sessionResult({ deletedCount: 1 })),
};
const tournamentCodeModel = {
find: jest.fn().mockReturnValue({
select: jest.fn().mockReturnValue({
session: jest.fn().mockReturnValue({
lean: jest.fn().mockReturnValue(
execResult([
{
_id: reservedCodeId,
state: 'reserved',
matchId: fixture.match._id,
},
{
_id: usedCodeId,
state: 'used',
matchId: fixture.match._id,
},
]),
),
}),
}),
}),
updateMany: jest
.fn()
.mockReturnValue(sessionResult({ matchedCount: 1, modifiedCount: 1 })),
};
const matchStatsModel = deleteManyModel();
const quarantineCollection = {
deleteMany: jest.fn().mockResolvedValue({ deletedCount: 1 }),
};
const connectionService = {
createSession: jest.fn().mockResolvedValue(session),
getConnection: jest.fn().mockResolvedValue({
collection: jest.fn().mockReturnValue(quarantineCollection),
}),
getModel: jest.fn((name: string) => {
const models: Record<string, unknown> = {
match: matchModel,
@@ -323,6 +380,8 @@ describe('Legacy import Competition result cutover', () => {
competitionFact: competitionFactModel,
competitionOutbox: competitionOutboxModel,
tournamentCodeAssignment: assignmentModel,
tournamentCode: tournamentCodeModel,
matchStats: matchStatsModel,
};
const model = models[name];
return model
@@ -330,15 +389,11 @@ describe('Legacy import Competition result cutover', () => {
: Promise.reject(new Error(`Unexpected model ${name}`));
}),
} as unknown as ConnectionService;
const matchStatsService = {
removeByMatches: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<MatchStatsService>;
const communityStatsService = {
invalidateCommunity: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<CommunityStatsService>;
const service = createService({
connectionService,
matchStatsService,
communityStatsService,
});
@@ -360,9 +415,98 @@ describe('Legacy import Competition result cutover', () => {
expect(competitionModel.deleteMany).toHaveBeenCalledWith({
_id: { $in: [fixture.competition._id] },
});
expect(matchStatsService.removeByMatches).toHaveBeenCalledWith([
fixture.match._id,
]);
expect(tournamentCodeModel.updateMany).toHaveBeenCalledTimes(2);
expect(matchStatsModel.deleteMany).toHaveBeenCalledWith({
matchId: { $in: [fixture.match._id] },
});
expect(session.commitTransaction).toHaveBeenCalledTimes(1);
expect(session.abortTransaction).not.toHaveBeenCalled();
expect(communityStatsService.invalidateCommunity).toHaveBeenCalledWith(
fixture.match.communityId,
);
});
it('aborts legacy deletion when an active assignment points to another Match code', async () => {
const harness = createBulkDeleteFailureHarness({
codeMatchId: new mongoose.Types.ObjectId(),
});
await expect(
harness.service.bulkDeleteLegacyMatches({
communityId: harness.fixture.match.communityId,
body: { matchIds: [harness.fixture.match._id.toString()] },
}),
).rejects.toThrow(/Tournament Code assignment/);
expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1);
expect(harness.session.commitTransaction).not.toHaveBeenCalled();
expect(harness.matchModel.deleteMany).not.toHaveBeenCalled();
expect(harness.competitionFactModel.deleteMany).not.toHaveBeenCalled();
});
it('aborts legacy deletion when a validated Tournament Code transition does not update exactly once', async () => {
const harness = createBulkDeleteFailureHarness({
updateResult: { matchedCount: 0, modifiedCount: 0 },
});
await expect(
harness.service.bulkDeleteLegacyMatches({
communityId: harness.fixture.match.communityId,
body: { matchIds: [harness.fixture.match._id.toString()] },
}),
).rejects.toThrow(/Tournament Code transition/);
expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1);
expect(harness.session.commitTransaction).not.toHaveBeenCalled();
expect(harness.matchModel.deleteMany).not.toHaveBeenCalled();
});
it('invalidates community caches again when a committed deletion is retried', async () => {
const harness = createBulkDeleteFailureHarness({});
harness.matchModel.find
.mockReset()
.mockReturnValueOnce({
select: jest
.fn()
.mockReturnValue(sessionResult([{ _id: harness.fixture.match._id }])),
})
.mockReturnValueOnce({
select: jest.fn().mockReturnValue(sessionResult([])),
});
harness.communityStatsService.invalidateCommunity
.mockRejectedValueOnce(new Error('Redis unavailable'))
.mockResolvedValueOnce(0);
await expect(
harness.service.bulkDeleteLegacyMatches({
communityId: harness.fixture.match.communityId,
body: { matchIds: [harness.fixture.match._id.toString()] },
}),
).rejects.toThrow('Redis unavailable');
await expect(
harness.service.bulkDeleteLegacyMatches({
communityId: harness.fixture.match.communityId,
body: { matchIds: [harness.fixture.match._id.toString()] },
}),
).resolves.toEqual({ deleted: 0 });
expect(
harness.communityStatsService.invalidateCommunity,
).toHaveBeenCalledTimes(2);
});
it('removes migration quarantine records in the same legacy deletion transaction', async () => {
const harness = createBulkDeleteFailureHarness({});
await harness.service.bulkDeleteLegacyMatches({
communityId: harness.fixture.match.communityId,
body: { matchIds: [harness.fixture.match._id.toString()] },
});
expect(harness.quarantineCollection.deleteMany).toHaveBeenCalledWith(
{ _id: { $in: [harness.fixture.match._id] } },
{ session: harness.session },
);
});
it('rebuilds a historical legacy Match into Competition facts without rewriting Match.result', async () => {
@@ -707,10 +851,135 @@ function execResult<T>(value: T) {
return { exec: jest.fn().mockResolvedValue(value) };
}
function sessionResult<T>(value: T) {
const query = {
exec: jest.fn().mockResolvedValue(value),
session: jest.fn(),
};
query.session.mockReturnValue(query);
return query;
}
function deleteManyModel() {
return {
deleteMany: jest
.fn()
.mockReturnValue(execResult({ acknowledged: true, deletedCount: 1 })),
.mockReturnValue(sessionResult({ acknowledged: true, deletedCount: 1 })),
};
}
function createBulkDeleteFailureHarness(options: {
codeMatchId?: mongoose.Types.ObjectId;
codeState?: 'reserved' | 'used';
assignmentState?: 'reserved' | 'used';
updateResult?: { matchedCount: number; modifiedCount: number };
}) {
const fixture = createImportFixture();
const session = {
startTransaction: jest.fn(),
commitTransaction: jest.fn().mockResolvedValue(undefined),
abortTransaction: jest.fn().mockResolvedValue(undefined),
endSession: jest.fn().mockResolvedValue(undefined),
};
const tournamentCodeId = new mongoose.Types.ObjectId();
const assignmentState = options.assignmentState ?? 'reserved';
const codeState = options.codeState ?? assignmentState;
const assignmentModel = {
...deleteManyModel(),
find: jest.fn().mockReturnValue({
select: jest.fn().mockReturnValue({
session: jest.fn().mockReturnValue({
lean: jest
.fn()
.mockReturnValue(
execResult([{ tournamentCodeId, state: assignmentState }]),
),
}),
}),
}),
};
const competitionModel = {
...deleteManyModel(),
find: jest.fn().mockReturnValue({
select: jest.fn().mockReturnValue({
session: jest.fn().mockReturnValue({
lean: jest
.fn()
.mockReturnValue(execResult([{ _id: fixture.competition._id }])),
}),
}),
}),
};
const matchModel = {
find: jest.fn().mockReturnValue({
select: jest
.fn()
.mockReturnValue(sessionResult([{ _id: fixture.match._id }])),
}),
deleteMany: jest.fn().mockReturnValue(sessionResult({ deletedCount: 1 })),
};
const tournamentCodeModel = {
find: jest.fn().mockReturnValue({
select: jest.fn().mockReturnValue({
session: jest.fn().mockReturnValue({
lean: jest.fn().mockReturnValue(
execResult([
{
_id: tournamentCodeId,
state: codeState,
matchId: options.codeMatchId ?? fixture.match._id,
},
]),
),
}),
}),
}),
updateMany: jest
.fn()
.mockReturnValue(
sessionResult(
options.updateResult ?? { matchedCount: 1, modifiedCount: 1 },
),
),
};
const competitionFactModel = deleteManyModel();
const competitionOutboxModel = deleteManyModel();
const matchStatsModel = deleteManyModel();
const quarantineCollection = {
deleteMany: jest.fn().mockResolvedValue({ deletedCount: 1 }),
};
const connectionService = {
createSession: jest.fn().mockResolvedValue(session),
getConnection: jest.fn().mockResolvedValue({
collection: jest.fn().mockReturnValue(quarantineCollection),
}),
getModel: jest.fn((name: string) => {
const models: Record<string, unknown> = {
match: matchModel,
competition: competitionModel,
competitionFact: competitionFactModel,
competitionOutbox: competitionOutboxModel,
tournamentCodeAssignment: assignmentModel,
tournamentCode: tournamentCodeModel,
matchStats: matchStatsModel,
};
const model = models[name];
return model
? Promise.resolve(model)
: Promise.reject(new Error(`Unexpected model ${name}`));
}),
} as unknown as ConnectionService;
const communityStatsService = {
invalidateCommunity: jest.fn().mockResolvedValue(0),
} as unknown as jest.Mocked<CommunityStatsService>;
const service = createService({ connectionService, communityStatsService });
return {
fixture,
session,
service,
matchModel,
competitionFactModel,
communityStatsService,
quarantineCollection,
};
}
@@ -2,6 +2,7 @@ import {
BadRequestException,
ConflictException,
Injectable,
InternalServerErrorException,
Logger,
NotFoundException,
} from '@nestjs/common';
@@ -381,60 +382,194 @@ export class LegacyImportService {
.filter((id) => mongoose.isValidObjectId(id))
.map((id) => new mongoose.Types.ObjectId(id));
if (ids.length === 0) return { deleted: 0 };
const MatchModel = await this.connectionService.getModel('match');
const targets = await MatchModel.find({
_id: { $in: ids },
communityId: params.communityId,
legacyImported: true,
})
.select({ _id: 1 })
.exec();
const targetIds = targets.map((match) => match._id);
if (targetIds.length === 0) return { deleted: 0 };
const [
MatchModel,
CompetitionModel,
CompetitionFactModel,
CompetitionOutboxModel,
AssignmentModel,
TournamentCodeModel,
MatchStatsModel,
connection,
] = await Promise.all([
this.connectionService.getModel('match'),
this.connectionService.getModel('competition'),
this.connectionService.getModel('competitionFact'),
this.connectionService.getModel('competitionOutbox'),
this.connectionService.getModel('tournamentCodeAssignment'),
this.connectionService.getModel('tournamentCode'),
this.connectionService.getModel('matchStats'),
this.connectionService.getConnection(),
]);
const competitions = await CompetitionModel.find({
matchId: { $in: targetIds },
})
.select({ _id: 1 })
.lean()
.exec();
const competitionIds = competitions.map(({ _id }) => _id);
if (competitionIds.length > 0) {
await Promise.all([
CompetitionFactModel.deleteMany({
competitionId: { $in: competitionIds },
}).exec(),
CompetitionOutboxModel.deleteMany({
competitionId: { $in: competitionIds },
}).exec(),
AssignmentModel.deleteMany({
competitionId: { $in: competitionIds },
}).exec(),
]);
await CompetitionModel.deleteMany({
_id: { $in: competitionIds },
}).exec();
const session = await this.connectionService.createSession();
if (!session) {
throw new InternalServerErrorException(
'A MongoDB transaction is required to delete legacy Matches.',
);
}
let deleted = 0;
try {
session.startTransaction();
const targets = await MatchModel.find({
_id: { $in: ids },
communityId: params.communityId,
legacyImported: true,
})
.select({ _id: 1 })
.session(session)
.exec();
const targetIds = targets.map((match) => match._id);
if (targetIds.length === 0) {
await session.commitTransaction();
} else {
const competitions = await CompetitionModel.find({
matchId: { $in: targetIds },
})
.select({ _id: 1 })
.session(session)
.lean()
.exec();
const competitionIds = competitions.map(({ _id }) => _id);
if (competitionIds.length > 0) {
const assignments = await AssignmentModel.find({
competitionId: { $in: competitionIds },
state: { $in: ['reserved', 'used'] },
})
.select({ tournamentCodeId: 1, state: 1 })
.session(session)
.lean()
.exec();
const assignmentCodeIds = assignments.map(
({ tournamentCodeId }) => tournamentCodeId,
);
const uniqueAssignmentCodeIds = new Set(
assignmentCodeIds.map((id) => id.toString()),
);
if (uniqueAssignmentCodeIds.size !== assignmentCodeIds.length) {
throw new ConflictException(
'Tournament Code assignments contain a duplicate active code identity.',
);
}
const tournamentCodes =
assignmentCodeIds.length === 0
? []
: await TournamentCodeModel.find({
_id: { $in: assignmentCodeIds },
})
.select({ _id: 1, state: 1, matchId: 1 })
.session(session)
.lean()
.exec();
const tournamentCodeById = new Map(
tournamentCodes.map((code) => [code._id.toString(), code]),
);
const targetIdSet = new Set(targetIds.map((id) => id.toString()));
for (const assignment of assignments) {
const code = tournamentCodeById.get(
assignment.tournamentCodeId.toString(),
);
if (
!code ||
code.state !== assignment.state ||
!code.matchId ||
!targetIdSet.has(code.matchId.toString())
) {
throw new ConflictException(
'Tournament Code assignment ownership or state does not match the target legacy Match.',
);
}
}
const releasedCodeIds = assignments
.filter(({ state }) => state === 'reserved')
.map(({ tournamentCodeId }) => tournamentCodeId);
const voidedCodeIds = assignments
.filter(({ state }) => state === 'used')
.map(({ tournamentCodeId }) => tournamentCodeId);
const terminalAt = new Date();
if (releasedCodeIds.length > 0) {
const released = await TournamentCodeModel.updateMany(
{
_id: { $in: releasedCodeIds },
matchId: { $in: targetIds },
state: 'reserved',
},
{
$set: { state: 'released', releasedAt: terminalAt },
$unset: legacyTournamentCodeBindingUnset(),
},
)
.session(session)
.exec();
assertExactTournamentCodeTransition(
released,
releasedCodeIds.length,
);
}
if (voidedCodeIds.length > 0) {
const voided = await TournamentCodeModel.updateMany(
{
_id: { $in: voidedCodeIds },
matchId: { $in: targetIds },
state: 'used',
},
{
$set: { state: 'voided', voidedAt: terminalAt },
$unset: legacyTournamentCodeBindingUnset(),
},
)
.session(session)
.exec();
assertExactTournamentCodeTransition(voided, voidedCodeIds.length);
}
await CompetitionFactModel.deleteMany({
competitionId: { $in: competitionIds },
})
.session(session)
.exec();
await CompetitionOutboxModel.deleteMany({
competitionId: { $in: competitionIds },
})
.session(session)
.exec();
await AssignmentModel.deleteMany({
competitionId: { $in: competitionIds },
})
.session(session)
.exec();
await CompetitionModel.deleteMany({
_id: { $in: competitionIds },
})
.session(session)
.exec();
}
await connection
.collection('competition_migration_quarantine')
.deleteMany({ _id: { $in: targetIds } }, { session });
const result = await MatchModel.deleteMany({
_id: { $in: targetIds },
communityId: params.communityId,
legacyImported: true,
})
.session(session)
.exec();
await MatchStatsModel.deleteMany({ matchId: { $in: targetIds } })
.session(session)
.exec();
deleted = result.deletedCount ?? 0;
await session.commitTransaction();
}
} catch (error) {
await session.abortTransaction().catch(() => undefined);
throw error;
} finally {
await session.endSession().catch(() => undefined);
}
const result = await MatchModel.deleteMany({
_id: { $in: targetIds },
communityId: params.communityId,
legacyImported: true,
}).exec();
await this.matchStatsService.removeByMatches(targetIds);
await this.communityStatsService.invalidateCommunity(params.communityId);
return { deleted: result.deletedCount ?? 0 };
return { deleted };
}
public async rebuildLegacyMatches(params: {
@@ -1322,6 +1457,29 @@ function optionalNumber(value: unknown): number | undefined {
: undefined;
}
function legacyTournamentCodeBindingUnset(): Record<string, 1> {
return {
matchId: 1,
gameNumber: 1,
bracketMatchId: 1,
reservedAt: 1,
};
}
function assertExactTournamentCodeTransition(
result: { matchedCount?: number; modifiedCount?: number },
expectedCount: number,
): void {
if (
result.matchedCount !== expectedCount ||
result.modifiedCount !== expectedCount
) {
throw new ConflictException(
'Tournament Code transition did not update every validated assignment.',
);
}
}
function deterministicObjectId(key: string): mongoose.Types.ObjectId {
return new mongoose.Types.ObjectId(
createHash('sha256').update(key).digest('hex').slice(0, 24),