249 lines
7.7 KiB
TypeScript
249 lines
7.7 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;
|
|
}
|
|
}
|