Files
lolympus-tournament-support/apps/api/src/modules/dakao/dakao-outbox.service.ts
T

255 lines
7.8 KiB
TypeScript

import { Injectable, Logger } from '@nestjs/common';
import { randomUUID } from 'crypto';
import { ConnectionService } from '../global/database/connection.service';
import { NatsService } from '../global/nats/nats.service';
import { resolveDakaoNatsNames } from './dakao.nats-names';
import {
DakaoCommandEnvelope,
DakaoResultEnvelope,
DakaoResultSubjects,
} from './dakao.types';
const CHAT_SEND_MESSAGE_TYPE = 'chat.send-message';
const TERMINAL_STATES = ['sent', 'failed'] as const;
const DEFAULT_PUBLISH_LEASE_DURATION_MILLISECONDS = 60_000;
@Injectable()
export class DakaoOutboxService {
private readonly logger = new Logger(DakaoOutboxService.name);
private readonly chatSendMessageResultSubjects = {
succeeded: resolveDakaoNatsNames().subjects.chatSendMessageSucceeded,
failed: resolveDakaoNatsNames().subjects.chatSendMessageFailed,
};
constructor(
private readonly connectionService: ConnectionService,
private readonly natsService: NatsService,
) {}
public async enqueueAndPublish<TPayload>(params: {
subject: string;
eventId: string;
envelope: DakaoCommandEnvelope<TPayload>;
}): Promise<void> {
const OutboxModel =
await this.connectionService.getModel('dakaoOutboxMessage');
await OutboxModel.findOneAndUpdate(
{ eventId: params.eventId },
{
$setOnInsert: {
eventId: params.eventId,
eventSource: params.envelope.eventSource,
type: params.envelope.type,
subject: params.subject,
correlationId: params.envelope.correlationId,
resultSubjects: params.envelope.resultSubjects,
payload: params.envelope.payload as Record<string, unknown>,
state: 'pending',
publishAttempts: 0,
compensationState: 'none',
},
},
{ upsert: true, returnDocument: 'after', setDefaultsOnInsert: true },
).exec();
await this.publishCommand({
subject: params.subject,
eventId: params.eventId,
envelope: params.envelope,
});
}
private async publishCommand<TPayload>(params: {
subject: string;
eventId: string;
envelope: DakaoCommandEnvelope<TPayload>;
publishLeaseOwnerIdentifier?: string;
}): Promise<void> {
const OutboxModel =
await this.connectionService.getModel('dakaoOutboxMessage');
const updateFilter = {
eventId: params.eventId,
state: { $nin: TERMINAL_STATES },
...(params.publishLeaseOwnerIdentifier
? { publishLeaseOwnerIdentifier: params.publishLeaseOwnerIdentifier }
: {}),
};
try {
await this.natsService.publishJetStream(params.subject, params.envelope, {
messageId: params.eventId,
});
await OutboxModel.updateOne(
updateFilter,
{
$set: {
state: 'published',
publishedAt: new Date(),
},
$inc: { publishAttempts: 1 },
$unset: {
lastPublishError: '',
publishLeaseOwnerIdentifier: '',
publishLeaseExpiresAt: '',
},
},
).exec();
} catch (err) {
await OutboxModel.updateOne(
updateFilter,
{
$inc: { publishAttempts: 1 },
$set: {
lastPublishError: (err as Error)?.message ?? String(err),
},
$unset: {
publishLeaseOwnerIdentifier: '',
publishLeaseExpiresAt: '',
},
},
).exec();
this.logger.error(
`Failed to publish Dakao outbox eventId=${params.eventId}: ${
(err as Error)?.stack ?? err
}`,
);
}
}
public async applySendResult(params: {
subject: string;
envelope: DakaoResultEnvelope;
}): Promise<{ duplicate: boolean; terminalState?: 'sent' | 'failed' }> {
const ResultModel = await this.connectionService.getModel(
'dakaoSendResultEvent',
);
const OutboxModel =
await this.connectionService.getModel('dakaoOutboxMessage');
try {
await ResultModel.create({
eventId: params.envelope.eventId,
requestEventId: params.envelope.requestEventId,
eventSource: params.envelope.eventSource,
requestEventSource: params.envelope.requestEventSource,
type: params.envelope.type,
subject: params.subject,
status: params.envelope.status,
correlationId: params.envelope.correlationId,
handledAt: new Date(params.envelope.handledAt),
providerMessageId: params.envelope.providerMessageId,
error: params.envelope.error,
raw: params.envelope as unknown as Record<string, unknown>,
});
} catch (err) {
if ((err as { code?: number })?.code === 11000) {
return { duplicate: true };
}
throw err;
}
const terminalState =
params.envelope.status === 'succeeded' ? 'sent' : 'failed';
await OutboxModel.updateOne(
{
eventId: params.envelope.requestEventId,
state: { $nin: TERMINAL_STATES },
},
{
$set: {
state: terminalState,
terminalAt: new Date(),
resultEventId: params.envelope.eventId,
terminalError: params.envelope.error,
compensationState:
params.envelope.status === 'failed' ? 'pending' : 'none',
compensationReason: params.envelope.error?.code,
},
},
).exec();
return { duplicate: false, terminalState };
}
public async sweepStale(params?: {
staleMs?: number;
publishLeaseDurationMilliseconds?: number;
limit?: number;
}): Promise<number> {
const OutboxModel =
await this.connectionService.getModel('dakaoOutboxMessage');
const currentTimestamp = new Date();
const staleBefore = new Date(
currentTimestamp.getTime() - (params?.staleMs ?? 5 * 60 * 1000),
);
const publishLeaseOwnerIdentifier = `dakao-outbox-sweeper:${process.pid}:${randomUUID()}`;
const publishLeaseExpiresAt = new Date(
currentTimestamp.getTime() +
(params?.publishLeaseDurationMilliseconds ??
DEFAULT_PUBLISH_LEASE_DURATION_MILLISECONDS),
);
const rows = await OutboxModel.find({
state: { $in: ['pending', 'published'] },
updatedAt: { $lte: staleBefore },
$or: [
{ publishLeaseExpiresAt: { $exists: false } },
{ publishLeaseExpiresAt: { $lte: currentTimestamp } },
],
})
.sort({ updatedAt: 1 })
.limit(params?.limit ?? 20)
.lean()
.exec();
let swept = 0;
for (const row of rows) {
const claimedRow = await OutboxModel.findOneAndUpdate(
{
eventId: row.eventId,
state: { $in: ['pending', 'published'] },
$or: [
{ publishLeaseExpiresAt: { $exists: false } },
{ publishLeaseExpiresAt: { $lte: currentTimestamp } },
],
},
{
$set: {
publishLeaseOwnerIdentifier,
publishLeaseExpiresAt,
},
},
{ returnDocument: 'after' },
)
.lean()
.exec();
if (!claimedRow) continue;
await this.publishCommand({
subject: claimedRow.subject,
eventId: claimedRow.eventId,
publishLeaseOwnerIdentifier,
envelope: {
schema: 'dakao.command.v1',
eventId: claimedRow.eventId,
type: claimedRow.type,
eventSource: claimedRow.eventSource,
correlationId: claimedRow.correlationId,
resultSubjects:
claimedRow.resultSubjects ??
this.resolveDefaultResultSubjects(claimedRow.type),
payload: claimedRow.payload,
},
});
swept += 1;
}
return swept;
}
private resolveDefaultResultSubjects(
type: string,
): DakaoResultSubjects | undefined {
if (type !== CHAT_SEND_MESSAGE_TYPE) return undefined;
return this.chatSendMessageResultSubjects;
}
}