172 lines
5.0 KiB
TypeScript
172 lines
5.0 KiB
TypeScript
import { Injectable, Logger } from '@nestjs/common';
|
|
import { ConnectionService } from '../global/database/connection.service';
|
|
import { NatsService } from '../global/nats/nats.service';
|
|
import { DakaoCommandEnvelope, DakaoResultEnvelope } from './dakao.types';
|
|
|
|
const TERMINAL_STATES = ['sent', 'failed'] as const;
|
|
|
|
@Injectable()
|
|
export class DakaoOutboxService {
|
|
private readonly logger = new Logger(DakaoOutboxService.name);
|
|
|
|
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,
|
|
payload: params.envelope.payload as Record<string, unknown>,
|
|
state: 'pending',
|
|
publishAttempts: 0,
|
|
compensationState: 'none',
|
|
},
|
|
},
|
|
{ upsert: true, returnDocument: 'after', setDefaultsOnInsert: true },
|
|
).exec();
|
|
|
|
try {
|
|
await this.natsService.publishJetStream(params.subject, params.envelope, {
|
|
messageId: params.eventId,
|
|
});
|
|
await OutboxModel.updateOne(
|
|
{
|
|
eventId: params.eventId,
|
|
state: { $nin: TERMINAL_STATES },
|
|
},
|
|
{
|
|
$set: {
|
|
state: 'published',
|
|
publishedAt: new Date(),
|
|
},
|
|
$inc: { publishAttempts: 1 },
|
|
$unset: { lastPublishError: '' },
|
|
},
|
|
).exec();
|
|
} catch (err) {
|
|
await OutboxModel.updateOne(
|
|
{
|
|
eventId: params.eventId,
|
|
state: { $nin: TERMINAL_STATES },
|
|
},
|
|
{
|
|
$inc: { publishAttempts: 1 },
|
|
$set: {
|
|
lastPublishError: (err as Error)?.message ?? String(err),
|
|
},
|
|
},
|
|
).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;
|
|
limit?: number;
|
|
}): Promise<number> {
|
|
const OutboxModel =
|
|
await this.connectionService.getModel('dakaoOutboxMessage');
|
|
const staleBefore = new Date(
|
|
Date.now() - (params?.staleMs ?? 5 * 60 * 1000),
|
|
);
|
|
const rows = await OutboxModel.find({
|
|
state: { $in: ['pending', 'published'] },
|
|
updatedAt: { $lte: staleBefore },
|
|
})
|
|
.sort({ updatedAt: 1 })
|
|
.limit(params?.limit ?? 20)
|
|
.lean()
|
|
.exec();
|
|
|
|
for (const row of rows) {
|
|
await this.enqueueAndPublish({
|
|
subject: row.subject,
|
|
eventId: row.eventId,
|
|
envelope: {
|
|
schema: 'dakao.command.v1',
|
|
eventId: row.eventId,
|
|
type: row.type,
|
|
eventSource: row.eventSource,
|
|
correlationId: row.correlationId,
|
|
payload: row.payload,
|
|
},
|
|
});
|
|
}
|
|
|
|
return rows.length;
|
|
}
|
|
}
|