fix: close competition cutover integrity gaps
This commit is contained in:
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),
|
||||
|
||||
Reference in new issue
Block a user