@message-queue-toolkit/sqs/dist/sqs/AbstractSqsPublisher.js

SQS adapter for message-queue-toolkit

import { SendMessageCommand } from '@aws-sdk/client-sqs';
import { InternalError } from '@lokalise/node-core';
import { DeduplicationRequesterEnum, } from '@message-queue-toolkit/core';
import { resolveOutgoingMessageAttributes } from "../utils/messageUtils.js";
import { calculateOutgoingMessageSize } from "../utils/sqsUtils.js";
import { AbstractSqsService } from "./AbstractSqsService.js";
export const PAYLOAD_OFFLOADING_ATTRIBUTE_PREFIX = 'payloadOffloading.';
export const OFFLOADED_PAYLOAD_SIZE_ATTRIBUTE = `${PAYLOAD_OFFLOADING_ATTRIBUTE_PREFIX}size`;
export class AbstractSqsPublisher extends AbstractSqsService {
    messageSchemaContainer;
    isDeduplicationEnabled;
    messageGroupIdField;
    defaultMessageGroupId;
    initPromise;
    constructor(dependencies, options) {
        super(dependencies, options);
        this.messageSchemaContainer = this.resolvePublisherMessageSchemaContainer(options);
        this.isDeduplicationEnabled = !!options.enablePublisherDeduplication;
        this.messageGroupIdField = options.messageGroupIdField;
        this.defaultMessageGroupId = options.defaultMessageGroupId;
    }
    async publish(message, options = {}) {
        const messageSchemaResult = this.resolveSchema(message);
        if (messageSchemaResult.error) {
            throw messageSchemaResult.error;
        }
        // If it's not initted yet, do the lazy init
        if (!this.isInitted) {
            // avoid multiple concurrent inits
            if (!this.initPromise) {
                this.initPromise = this.init();
            }
            await this.initPromise;
            this.initPromise = undefined;
        }
        try {
            const messageProcessingStartTimestamp = Date.now();
            const parsedMessage = messageSchemaResult.result.parse(message);
            if (this.logMessages) {
                const messageType = this.resolveMessageTypeFromMessage(message) ?? 'unknown';
                const resolvedLogMessage = this.resolveMessageLog(message, messageType);
                this.logMessage(resolvedLogMessage);
            }
            message = this.updateInternalProperties(message);
            // Resolve FIFO options from original message BEFORE offloading
            // (offloaded payload won't have user fields needed for messageGroupIdField)
            const resolvedOptions = this.resolveFifoOptions(message, options);
            const maybeOffloadedPayloadMessage = await this.offloadMessagePayloadIfNeeded(message, () => calculateOutgoingMessageSize(message));
            if (this.isDeduplicationEnabledForMessage(parsedMessage) &&
                (await this.deduplicateMessage(parsedMessage, DeduplicationRequesterEnum.Publisher))
                    .isDuplicated) {
                this.handleMessageProcessed({
                    message: parsedMessage,
                    processingResult: { status: 'published', skippedAsDuplicate: true },
                    messageProcessingStartTimestamp,
                    queueName: this.queueName,
                });
                return;
            }
            await this.sendMessage(maybeOffloadedPayloadMessage, resolvedOptions);
            this.handleMessageProcessed({
                message: parsedMessage,
                processingResult: { status: 'published' },
                messageProcessingStartTimestamp,
                queueName: this.queueName,
            });
        }
        catch (error) {
            const err = error;
            this.handleError(err);
            throw new InternalError({
                message: `Error while publishing to SQS: ${err.message}`,
                errorCode: 'SQS_PUBLISH_ERROR',
                details: {
                    publisher: this.constructor.name,
                    queueArn: this.queueArn,
                    queueName: this.queueName,
                    messageType: this.resolveMessageTypeFromMessage(message) ?? 'unknown',
                },
                cause: err,
            });
        }
    }
    /* c8 ignore start */
    resolveNextFunction() {
        throw new Error('Not implemented for publisher');
    }
    resolveMessage(_message) {
        throw new Error('Not implemented for publisher');
    }
    processPrehandlers() {
        throw new Error('Not implemented for publisher');
    }
    preHandlerBarrier() {
        throw new Error('Not implemented for publisher');
    }
    processMessage() {
        throw new Error('Not implemented for publisher');
    }
    /* c8 ignore stop */
    isDeduplicationEnabledForMessage(message) {
        return this.isDeduplicationEnabled && super.isDeduplicationEnabledForMessage(message);
    }
    resolveSchema(message) {
        return this.messageSchemaContainer.resolveSchema(message);
    }
    async sendMessage(payload, options) {
        const attributes = resolveOutgoingMessageAttributes(payload);
        // Options are already resolved in publish() before offloading
        const command = new SendMessageCommand({
            QueueUrl: this.queueUrl,
            MessageBody: JSON.stringify(payload),
            MessageAttributes: attributes,
            ...options,
        });
        await this.sqsClient.send(command);
    }
    /**
     * Resolves FIFO-specific options (MessageGroupId, MessageDeduplicationId)
     */
    resolveFifoOptions(payload, options) {
        if (!this.isFifoQueue) {
            return options;
        }
        const resolvedOptions = { ...options };
        // Resolve MessageGroupId if not provided
        if (!resolvedOptions.MessageGroupId) {
            if (this.messageGroupIdField) {
                const messageGroupId = payload[this.messageGroupIdField];
                if (typeof messageGroupId === 'string') {
                    resolvedOptions.MessageGroupId = messageGroupId;
                }
            }
            // Fallback to default if still not set
            if (!resolvedOptions.MessageGroupId && this.defaultMessageGroupId) {
                resolvedOptions.MessageGroupId = this.defaultMessageGroupId;
            }
        }
        // Validate that MessageGroupId is present for FIFO queues
        if (!resolvedOptions.MessageGroupId) {
            throw new InternalError({
                message: 'MessageGroupId is required for FIFO queues. Provide it in publish options, configure messageGroupIdField, or set defaultMessageGroupId.',
                errorCode: 'FIFO_MESSAGE_GROUP_ID_REQUIRED',
                details: {
                    queueName: this.queueName,
                    queueUrl: this.queueUrl,
                    isFifoQueue: this.isFifoQueue,
                },
            });
        }
        return resolvedOptions;
    }
}
//# sourceMappingURL=AbstractSqsPublisher.js.map