@lafken/queue 0.10.1

package/lib/main/queue/queue.d.ts

@@ -0,0 +1,65 @@
+import 'reflect-metadata';
+import type { FifoProps, StandardProps } from './queue.types';
+export declare const RESOURCE_TYPE: "QUEUE";
+/**
+ * Class decorator that registers a class as an SQS queue resource.
+ *
+ * The decorated class groups one or more consumer handlers (`@Standard`
+ * or `@Fifo`) that process messages from SQS queues.
+ *
+ * @param props - Optional resource configuration (e.g. a custom `name`).
+ *
+ * @example
+ * ```ts
+ * @Queue()
+ * export class NotificationQueue {
+ *   @Standard({ batchSize: 5 })
+ *   process(@Event(NotificationMessage) msg: NotificationMessage) { }
+ * }
+ * ```
+ */
+export declare const Queue: (props?: import("@lafken/common").ResourceProps | undefined) => (constructor: Function) => void;
+/**
+ * Method decorator that registers a handler as a **standard** SQS queue
+ * consumer.
+ *
+ * The decorated method becomes a Lambda function triggered by messages
+ * from a standard (non-FIFO) SQS queue. Configure delivery delay,
+ * batch size, visibility timeout, and other queue settings through
+ * the decorator props.
+ *
+ * @param props - Standard queue configuration (deliveryDelay, batchSize,
+ *                visibilityTimeout, retentionPeriod, lambda, etc.).
+ *
+ * @example
+ * ```ts
+ * @Queue()
+ * export class EmailQueue {
+ *   @Standard({ batchSize: 10, visibilityTimeout: 60 })
+ *   send(@Event(EmailPayload) msg: EmailPayload) { }
+ * }
+ * ```
+ */
+export declare const Standard: (props?: StandardProps | undefined) => (target: any, methodName: string, descriptor: PropertyDescriptor) => any;
+/**
+ * Method decorator that registers a handler as a **FIFO** SQS queue
+ * consumer.
+ *
+ * The decorated method becomes a Lambda function triggered by messages
+ * from a FIFO queue, which guarantees exactly-once processing and
+ * strict ordering. In addition to all standard queue options, FIFO
+ * queues support `contentBasedDeduplication`.
+ *
+ * @param props - FIFO queue configuration (contentBasedDeduplication,
+ *                batchSize, visibilityTimeout, lambda, etc.).
+ *
+ * @example
+ * ```ts
+ * @Queue()
+ * export class PaymentQueue {
+ *   @Fifo({ contentBasedDeduplication: true, batchSize: 1 })
+ *   process(@Event(PaymentMessage) msg: PaymentMessage) { }
+ * }
+ * ```
+ */
+export declare const Fifo: (props?: FifoProps | undefined) => (target: any, methodName: string, descriptor: PropertyDescriptor) => any;

package/lib/main/queue/queue.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fifo = exports.Standard = exports.Queue = exports.RESOURCE_TYPE = void 0;
+require("reflect-metadata");
+const common_1 = require("@lafken/common");
+exports.RESOURCE_TYPE = 'QUEUE';
+/**
+ * Class decorator that registers a class as an SQS queue resource.
+ *
+ * The decorated class groups one or more consumer handlers (`@Standard`
+ * or `@Fifo`) that process messages from SQS queues.
+ *
+ * @param props - Optional resource configuration (e.g. a custom `name`).
+ *
+ * @example
+ * ```ts
+ * @Queue()
+ * export class NotificationQueue {
+ *   @Standard({ batchSize: 5 })
+ *   process(@Event(NotificationMessage) msg: NotificationMessage) { }
+ * }
+ * ```
+ */
+exports.Queue = (0, common_1.createResourceDecorator)({
+    type: exports.RESOURCE_TYPE,
+    callerFileIndex: 5,
+});
+const getValueFromAttribute = (param, record) => {
+    const value = record.messageAttributes[param.name];
+    if (!value) {
+        return;
+    }
+    if (param.type === 'Number') {
+        return Number(value.stringValue);
+    }
+    return value.stringValue;
+};
+const getValueFormBody = (param, record) => {
+    const value = record.body;
+    if (!value || !param.parse) {
+        return value;
+    }
+    return JSON.parse(String(value))?.[param.name];
+};
+const argumentParser = {
+    [common_1.LambdaArgumentTypes.event]: ({ event, methodName, target }) => {
+        const queueEvent = event;
+        const data = [];
+        const params = Reflect.getMetadata(common_1.LambdaReflectKeys.event_param, target) || {};
+        const paramsByHandler = params[methodName];
+        if (!event || !queueEvent.Records || !paramsByHandler) {
+            return event;
+        }
+        for (const record of queueEvent.Records) {
+            const attributes = {};
+            if (paramsByHandler.type !== 'Object') {
+                continue;
+            }
+            for (const param of paramsByHandler.properties) {
+                attributes[param.destinationName] =
+                    param.source === 'attribute'
+                        ? getValueFromAttribute(param, record)
+                        : getValueFormBody(param, record);
+            }
+            data.push(attributes);
+        }
+        return data;
+    },
+};
+/**
+ * Method decorator that registers a handler as a **standard** SQS queue
+ * consumer.
+ *
+ * The decorated method becomes a Lambda function triggered by messages
+ * from a standard (non-FIFO) SQS queue. Configure delivery delay,
+ * batch size, visibility timeout, and other queue settings through
+ * the decorator props.
+ *
+ * @param props - Standard queue configuration (deliveryDelay, batchSize,
+ *                visibilityTimeout, retentionPeriod, lambda, etc.).
+ *
+ * @example
+ * ```ts
+ * @Queue()
+ * export class EmailQueue {
+ *   @Standard({ batchSize: 10, visibilityTimeout: 60 })
+ *   send(@Event(EmailPayload) msg: EmailPayload) { }
+ * }
+ * ```
+ */
+exports.Standard = (0, common_1.createLambdaDecorator)({
+    getLambdaMetadata: (props, methodName) => ({
+        ...props,
+        queueName: props.queueName || methodName,
+        name: methodName,
+        isFifo: false,
+    }),
+    argumentParser,
+});
+/**
+ * Method decorator that registers a handler as a **FIFO** SQS queue
+ * consumer.
+ *
+ * The decorated method becomes a Lambda function triggered by messages
+ * from a FIFO queue, which guarantees exactly-once processing and
+ * strict ordering. In addition to all standard queue options, FIFO
+ * queues support `contentBasedDeduplication`.
+ *
+ * @param props - FIFO queue configuration (contentBasedDeduplication,
+ *                batchSize, visibilityTimeout, lambda, etc.).
+ *
+ * @example
+ * ```ts
+ * @Queue()
+ * export class PaymentQueue {
+ *   @Fifo({ contentBasedDeduplication: true, batchSize: 1 })
+ *   process(@Event(PaymentMessage) msg: PaymentMessage) { }
+ * }
+ * ```
+ */
+exports.Fifo = (0, common_1.createLambdaDecorator)({
+    getLambdaMetadata: (props, methodName) => ({
+        ...props,
+        queueName: props.queueName || methodName,
+        name: methodName,
+        isFifo: true,
+    }),
+    argumentParser,
+});

package/lib/main/queue/queue.types.d.ts

@@ -0,0 +1,105 @@
+import type { LambdaMetadata, LambdaProps, QueueNames, ResourceOutputType } from '@lafken/common';
+/**
+ * Attributes that can be exported from an SQS queue resource.
+ *
+ * Based on Terraform `aws_sqs_queue` attribute reference:
+ * - `arn`: ARN of the SQS queue.
+ * - `id`: URL for the created Amazon SQS queue.
+ * - `url`: Same as `id`: the URL for the created Amazon SQS queue.
+ */
+export type QueueOutputAttributes = 'arn' | 'id' | 'url';
+export interface StandardProps {
+    /**
+     * Delivery delay in seconds.
+     *
+     * Specifies the amount of time to delay the delivery of a message
+     * to the queue after it is sent.
+     */
+    deliveryDelay?: number;
+    /**
+     * Maximum message size in bytes.
+     *
+     * Specifies the limit of message size that the queue can accept.
+     * Messages exceeding this size will be rejected.
+     */
+    maxMessageSizeBytes?: number;
+    /**
+     * Message retention period in seconds.
+     *
+     * The duration that messages are kept in the queue before being deleted.
+     */
+    retentionPeriod?: number;
+    /**
+     * Visibility timeout in seconds.
+     *
+     * The duration that a received message is hidden from other consumers
+     * while being processed.
+     */
+    visibilityTimeout?: number;
+    /**
+     * Maximum number of messages to retrieve in a single batch.
+     *
+     * Only applicable when consuming messages with a Lambda or batch processor.
+     */
+    batchSize?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
+    /**
+     * Maximum concurrency for Lambda consumers.
+     *
+     * Specifies the maximum number of Lambda functions that
+     * can process messages from the queue concurrently.
+     */
+    maxConcurrency?: number;
+    /**
+     * Maximum batching window in seconds.
+     *
+     * Defines the maximum amount of time to gather messages into a batch
+     * before sending them to the consumer.
+     */
+    maxBatchingWindow?: number;
+    /**
+     * Lambda configuration for processing messages from this queue.
+     */
+    lambda?: LambdaProps;
+    /**
+     * Name of the queue.
+     *
+     * If not specified, a default name based on the resource or class is used.
+     */
+    queueName?: QueueNames;
+    /**
+     * Defines which SQS queue attributes should be exported.
+     *
+     * Supported attributes are based on Terraform `aws_sqs_queue`
+     * attribute reference:
+     * - `arn`: ARN of the SQS queue.
+     * - `id`: URL for the created Amazon SQS queue.
+     * - `url`: Same as `id`: the URL for the created Amazon SQS queue.
+     *
+     * Each selected attribute can be exported through SSM Parameter Store (`type: 'ssm'`)
+     * or Terraform outputs (`type: 'output'`).
+     *
+     * @example
+     * {
+     *   outputs: [
+     *     { type: 'ssm', name: '/my-app/queue-arn', value: 'arn' },
+     *     { type: 'output', name: 'queue_url', value: 'url' }
+     *   ]
+     * }
+     */
+    outputs?: ResourceOutputType<QueueOutputAttributes>;
+}
+export interface FifoProps extends StandardProps {
+    /**
+     * Enable content-based deduplication.
+     *
+     * Specifies whether the queue should use the content of the message
+     * to generate the deduplication ID automatically. This ensures that
+     * messages with identical content are treated as duplicates and
+     * are not delivered multiple times within the deduplication interval.
+     */
+    contentBasedDeduplication?: boolean;
+}
+export interface QueueLambdaMetadata extends LambdaMetadata, Omit<FifoProps, 'queueName'> {
+    queueName: string;
+    isFifo: boolean;
+}

package/lib/main/queue/queue.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/resolver/index.d.ts

@@ -0,0 +1 @@
+export * from './resolver';

package/lib/resolver/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./resolver"), exports);

package/lib/resolver/queue/queue.d.ts

@@ -0,0 +1,19 @@
+import { SqsQueue } from '@cdktn/provider-aws/lib/sqs-queue';
+import { type AppModule } from '@lafken/resolver';
+import type { QueueProps } from './queue.types';
+declare const Queue_base: (new (...args: any[]) => {
+    isGlobal(module: import("@lafken/common").ModuleGlobalReferenceNames | (string & {}), id: string): void;
+    isDependent(resolveDependency: () => void): void;
+    readonly node: import("constructs").Node;
+    with(...mixins: import("constructs").IMixin[]): import("constructs").IConstruct;
+    toString(): string;
+}) & typeof SqsQueue;
+export declare class Queue extends Queue_base {
+    private props;
+    constructor(scope: AppModule, id: string, props: QueueProps);
+    private addEventSource;
+    private validateEventParams;
+    private getParams;
+    private validateParamType;
+}
+export {};

package/lib/resolver/queue/queue.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = void 0;
+const lambda_event_source_mapping_1 = require("@cdktn/provider-aws/lib/lambda-event-source-mapping");
+const sqs_queue_1 = require("@cdktn/provider-aws/lib/sqs-queue");
+const common_1 = require("@lafken/common");
+const resolver_1 = require("@lafken/resolver");
+const attributeAllowedTypes = new Set(['String', 'Number']);
+const bodyParsedTypes = new Set(['String', 'Object', 'Array']);
+const bodyUnparsedTypes = new Set(['String']);
+class Queue extends resolver_1.lafkenResource.make(sqs_queue_1.SqsQueue) {
+    props;
+    constructor(scope, id, props) {
+        const { handler } = props;
+        super(scope, `${id}-queue`, {
+            name: `${handler.queueName}${handler.isFifo ? '.fifo' : ''}`,
+            fifoQueue: handler.isFifo,
+            contentBasedDeduplication: handler.contentBasedDeduplication,
+            visibilityTimeoutSeconds: handler.visibilityTimeout,
+            messageRetentionSeconds: handler.retentionPeriod,
+            maxMessageSize: handler.maxMessageSizeBytes,
+            delaySeconds: handler.deliveryDelay,
+        });
+        this.props = props;
+        this.isGlobal(scope.id, `queue::${handler.queueName}`);
+        this.validateEventParams();
+        this.addEventSource(id);
+        new resolver_1.ResourceOutput(this, handler.outputs);
+    }
+    addEventSource(id) {
+        const { handler, resourceMetadata } = this.props;
+        const lambdaHandler = new resolver_1.LambdaHandler(this, `${id}-handler`, {
+            ...handler,
+            originalName: resourceMetadata.originalName,
+            filename: resourceMetadata.filename,
+            foldername: resourceMetadata.foldername,
+            suffix: 'queue',
+        });
+        new lambda_event_source_mapping_1.LambdaEventSourceMapping(this, 'event-mapping', {
+            batchSize: handler.batchSize,
+            eventSourceArn: this.arn,
+            functionName: lambdaHandler.arn,
+            maximumBatchingWindowInSeconds: handler.maxBatchingWindow,
+            functionResponseTypes: handler.isFifo ? ['ReportBatchItemFailures'] : undefined,
+            scalingConfig: handler.maxConcurrency
+                ? {
+                    maximumConcurrency: handler.maxConcurrency,
+                }
+                : undefined,
+            dependsOn: [lambdaHandler, this],
+        });
+    }
+    validateEventParams() {
+        const param = this.getParams();
+        if (!param) {
+            return;
+        }
+        let bodyCount = 0;
+        for (const property of param.properties) {
+            this.validateParamType(property);
+            if (property.source === 'body') {
+                bodyCount++;
+            }
+            if (bodyCount >= 2) {
+                throw new Error('Queue event only support one body param');
+            }
+        }
+    }
+    getParams() {
+        const { classResource, handler } = this.props;
+        const params = (0, common_1.getMetadataPrototypeByKey)(classResource, common_1.LambdaReflectKeys.event_param) || {};
+        return params[handler.name];
+    }
+    validateParamType(param) {
+        if (param.source === 'attribute' && !attributeAllowedTypes.has(param.type)) {
+            throw new Error(`Attribute params only support ${[...attributeAllowedTypes].join(', ')} values`);
+        }
+        if (param.source === 'body' && param.parse && !bodyParsedTypes.has(param.type)) {
+            throw new Error(`Body params only support ${[...bodyParsedTypes].join(', ')} values`);
+        }
+        if (param?.source === 'body' && !param.parse && !bodyUnparsedTypes.has(param.type)) {
+            throw new Error(`Body params only support ${[...bodyUnparsedTypes].join(', ')} values`);
+        }
+    }
+}
+exports.Queue = Queue;

package/lib/resolver/queue/queue.types.d.ts

@@ -0,0 +1,7 @@
+import type { ClassResource, ResourceMetadata } from '@lafken/common';
+import type { QueueLambdaMetadata } from '../../main';
+export interface QueueProps {
+    handler: QueueLambdaMetadata;
+    resourceMetadata: ResourceMetadata;
+    classResource: ClassResource;
+}

package/lib/resolver/queue/queue.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/resolver/resolver.d.ts

@@ -0,0 +1,6 @@
+import { type ClassResource } from '@lafken/common';
+import { type AppModule, type ResolverType } from '@lafken/resolver';
+export declare class QueueResolver implements ResolverType {
+    type: "QUEUE";
+    create(module: AppModule, resource: ClassResource): void;
+}

package/lib/resolver/resolver.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueResolver = void 0;
+const common_1 = require("@lafken/common");
+const resolver_1 = require("@lafken/resolver");
+const main_1 = require("../main");
+const queue_1 = require("./queue/queue");
+class QueueResolver {
+    type = main_1.RESOURCE_TYPE;
+    create(module, resource) {
+        const metadata = (0, common_1.getResourceMetadata)(resource);
+        const handlers = (0, common_1.getResourceHandlerMetadata)(resource);
+        resolver_1.lambdaAssets.initializeMetadata({
+            foldername: metadata.foldername,
+            filename: metadata.filename,
+            minify: metadata.minify,
+            className: metadata.originalName,
+            methods: handlers.map((handler) => handler.name),
+        });
+        for (const handler of handlers) {
+            new queue_1.Queue(module, `${metadata.name}-${handler.name}`, {
+                resourceMetadata: metadata,
+                classResource: resource,
+                handler,
+            });
+        }
+    }
+}
+exports.QueueResolver = QueueResolver;

package/lib/service/client/client.d.ts

@@ -0,0 +1,2 @@
+import { SQSClient } from '@aws-sdk/client-sqs';
+export declare const client: SQSClient;

package/lib/service/client/client.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.client = void 0;
+const client_sqs_1 = require("@aws-sdk/client-sqs");
+exports.client = new client_sqs_1.SQSClient();

package/lib/service/commands/send-message/send-message.d.ts

@@ -0,0 +1,7 @@
+import { SendMessageBase } from '../send-message-base/send-message-base';
+import type { SendMessageProps } from './send-message.types';
+export declare class SendMessage extends SendMessageBase {
+    private props;
+    constructor(props: SendMessageProps);
+    exec(): Promise<import("@aws-sdk/client-sqs").SendMessageCommandOutput>;
+}

package/lib/service/commands/send-message/send-message.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendMessage = void 0;
+const client_sqs_1 = require("@aws-sdk/client-sqs");
+const client_1 = require("../../client/client");
+const send_message_base_1 = require("../send-message-base/send-message-base");
+class SendMessage extends send_message_base_1.SendMessageBase {
+    props;
+    constructor(props) {
+        super();
+        this.props = props;
+    }
+    exec() {
+        const command = new client_sqs_1.SendMessageCommand({
+            QueueUrl: this.props.url,
+            MessageBody: this.getBody(this.props.body),
+            MessageAttributes: this.getAttributes(this.props.body),
+            DelaySeconds: this.props.delay,
+            MessageGroupId: this.props.groupId,
+            MessageDeduplicationId: this.props.deduplicationId,
+        });
+        return client_1.client.send(command);
+    }
+}
+exports.SendMessage = SendMessage;

package/lib/service/commands/send-message/send-message.types.d.ts

@@ -0,0 +1,14 @@
+export interface SendMessageProps {
+    url: string;
+    attributes?: Record<string, number | string>;
+    body?: any;
+    delay?: number;
+    /**
+     * only for fifo queues
+     */
+    deduplicationId?: string;
+    /**
+     * only for fifo queues
+     */
+    groupId?: string;
+}

package/lib/service/commands/send-message/send-message.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/service/commands/send-message-base/send-message-base.d.ts

@@ -0,0 +1,5 @@
+import type { MessageAttributeValue } from '@aws-sdk/client-sqs';
+export declare class SendMessageBase {
+    getAttributes(messageAttributes?: Record<string, number | string>): Record<string, MessageAttributeValue> | undefined;
+    getBody(body?: any): string | undefined;
+}

package/lib/service/commands/send-message-base/send-message-base.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendMessageBase = void 0;
+class SendMessageBase {
+    getAttributes(messageAttributes) {
+        if (!messageAttributes) {
+            return undefined;
+        }
+        const attributes = {};
+        for (const attributeKey in messageAttributes) {
+            const value = messageAttributes[attributeKey];
+            attributes[attributeKey] = {
+                StringValue: String(messageAttributes[attributeKey]),
+                DataType: typeof value === 'number' ? 'Number' : 'String',
+            };
+        }
+        return attributes;
+    }
+    getBody(body) {
+        if (!body) {
+            return undefined;
+        }
+        return JSON.stringify(body);
+    }
+}
+exports.SendMessageBase = SendMessageBase;

package/lib/service/commands/send-message-batch/send-message-batch.d.ts

@@ -0,0 +1,7 @@
+import { SendMessageBase } from '../send-message-base/send-message-base';
+import type { SendMessagesBatchProps } from './send-message-batch.types';
+export declare class SendMessageBatch extends SendMessageBase {
+    private props;
+    constructor(props: SendMessagesBatchProps);
+    exec(): Promise<import("@aws-sdk/client-sqs").SendMessageBatchCommandOutput>;
+}

package/lib/service/commands/send-message-batch/send-message-batch.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendMessageBatch = void 0;
+const client_sqs_1 = require("@aws-sdk/client-sqs");
+const client_1 = require("../../client/client");
+const send_message_base_1 = require("../send-message-base/send-message-base");
+class SendMessageBatch extends send_message_base_1.SendMessageBase {
+    props;
+    constructor(props) {
+        super();
+        this.props = props;
+    }
+    exec() {
+        const command = new client_sqs_1.SendMessageBatchCommand({
+            QueueUrl: this.props.url,
+            Entries: this.props.messages.map((message, index) => ({
+                Id: index.toString(),
+                MessageBody: this.getBody(message.body),
+                MessageAttributes: this.getAttributes(message.attributes),
+                DelaySeconds: message.delay,
+                MessageGroupId: message.groupId,
+                MessageDeduplicationId: message.deduplicationId,
+            })),
+        });
+        return client_1.client.send(command);
+    }
+}
+exports.SendMessageBatch = SendMessageBatch;

package/lib/service/commands/send-message-batch/send-message-batch.types.d.ts

@@ -0,0 +1,5 @@
+import type { SendMessageProps } from '../send-message/send-message.types';
+export interface SendMessagesBatchProps {
+    url: string;
+    messages: Omit<SendMessageProps, 'url'>[];
+}

package/lib/service/commands/send-message-batch/send-message-batch.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/service/index.d.ts

@@ -0,0 +1,6 @@
+import type { SendMessageProps } from './commands/send-message/send-message.types';
+import type { SendMessagesBatchProps } from './commands/send-message-batch/send-message-batch.types';
+export declare class QueueService {
+    static sendMessage(props: SendMessageProps): Promise<void>;
+    static sendBatchMessage(props: SendMessagesBatchProps): Promise<void>;
+}

package/lib/service/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueService = void 0;
+const send_message_1 = require("./commands/send-message/send-message");
+const send_message_batch_1 = require("./commands/send-message-batch/send-message-batch");
+class QueueService {
+    static async sendMessage(props) {
+        const queueCommand = new send_message_1.SendMessage(props);
+        await queueCommand.exec();
+    }
+    static async sendBatchMessage(props) {
+        const queueCommand = new send_message_batch_1.SendMessageBatch(props);
+        await queueCommand.exec();
+    }
+}
+exports.QueueService = QueueService;