@lafkn/queue 0.1.0

package/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Aníbal Emilio Jorquera Cornejo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,129 @@
+# @lafkn/queue
+
+`@lafkn/queue` simplifies the creation and management of Amazon SQS queues and their integration with AWS Lambda. It provides decorators to define Standard and FIFO queues, configure their properties, and map message attributes and body content directly to your handler parameters.
+
+## Installation
+
+```bash
+npm install @lafkn/queue
+```
+
+## Configuration
+
+Add the `QueueResolver` from the `@lafkn/queue/resolver` library to your application configuration.
+
+```typescript
+import { QueueResolver } from '@lafkn/queue/resolver';
+
+createApp({
+  name: 'awesome-app',
+  resolvers: [
+    new QueueResolver(),
+  ],
+  // ...
+});
+
+@Queue()
+class GreetingQueue {
+  // ...
+}
+
+const greetingModule = createModule({
+  name: 'greeting',
+  resources: [
+    GreetingQueue
+  ]
+});
+```
+
+## Features
+
+### Defining a Queue Resource
+
+Use the `@Queue` decorator to define a class that contains queue-processing methods.
+
+```typescript
+import { Queue, Standard, Fifo } from '@lafkn/queue';
+
+@Queue()
+export class NotificationService {
+  // ... queue handlers
+}
+```
+
+### Standard Queues
+
+Use the `@Standard` decorator to define a handler for a specific Standard SQS queue. You can configure properties such as visibility timeout, delivery delay, and batch size.
+
+```typescript
+@Standard({
+  queueName: 'emails',
+  visibilityTimeout: 30,
+  batchSize: 10,
+})
+sendEmail(@Event() event: SQSEvent) {
+  // Process messages
+}
+```
+
+### FIFO Queues
+
+Use the `@Fifo` decorator for FIFO (First-In-First-Out) queues. This ensures that the message order is preserved. You can enable content-based deduplication.
+
+```typescript
+@Fifo({
+  queueName: 'orders.fifo',
+  contentBasedDeduplication: true,
+})
+processOrder(@Event() event: SQSEvent) {
+  // Process ordered messages
+}
+```
+
+### Message Handling & Parameter Mapping
+
+`@lafkn/queue` allows you to extract specific data from the SQS message directly into your method parameters using `@Param` and `@Payload`.
+
+#### Accessing Message Body Fields
+
+You can parse the message body (if it's JSON) and inject specific fields.
+
+```typescript
+@Standard({ queueName: 'registrations' })
+registerUser(
+  @Param({ source: 'body', parse: true, name: 'userId' }) userId: string,
+  @Param({ source: 'body', parse: true, name: 'email' }) email: string
+) {
+  console.log(`Registering user ${userId} with email ${email}`);
+}
+```
+
+#### Accessing Message Attributes
+
+You can also access SQS Message Attributes.
+
+```typescript
+@Standard({ queueName: 'logging' })
+logMessage(
+  @Param({ source: 'attribute', name: 'TraceId' }) traceId: string,
+  @Event() event: any
+) {
+  // ...
+}
+```
+
+#### Using Payload DTOs
+
+You can use the `@Payload` decorator to map the entire message body to a typed object.
+
+```typescript
+class UserDto {
+  userId: string;
+  email: string;
+}
+
+@Standard({ queueName: 'users' })
+updateUser(@Payload() user: UserDto) {
+  // user is fully typed and parsed from the message body
+}
+```

package/lib/index.d.ts

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

package/lib/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("./main"), exports);

package/lib/main/event/event.d.ts

@@ -0,0 +1,7 @@
+import type { ParamProps } from './event.types';
+export declare const queueFieldKey: string;
+export declare const queuePayloadKey: string;
+export declare const Payload: (props?: import("@lafkn/common").PayloadProps | undefined) => (target: Function) => void;
+export declare const Param: (props?: ParamProps | undefined) => (target: any, destinationName: string) => void;
+export declare const Field: (props?: import("@lafkn/common").FieldProps | undefined) => (target: any, destinationName: string) => void;
+export declare const Event: (eventField: Function) => (target: any, methodName: string, _number: number) => void;

package/lib/main/event/event.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Event = exports.Field = exports.Param = exports.Payload = exports.queuePayloadKey = exports.queueFieldKey = void 0;
+const common_1 = require("@lafkn/common");
+const queue_1 = require("../queue");
+exports.queueFieldKey = (0, common_1.createFieldName)(queue_1.RESOURCE_TYPE, common_1.FieldProperties.field);
+exports.queuePayloadKey = (0, common_1.createFieldName)(queue_1.RESOURCE_TYPE, common_1.FieldProperties.payload);
+exports.Payload = (0, common_1.createPayloadDecorator)({
+    prefix: queue_1.RESOURCE_TYPE,
+    createUniqueId: false,
+    enableInLambdaInvocation: true,
+});
+exports.Param = (0, common_1.createFieldDecorator)({
+    prefix: queue_1.RESOURCE_TYPE,
+    enableInLambdaInvocation: true,
+    getMetadata: (props) => {
+        const source = props?.source || 'attribute';
+        return {
+            source,
+            parse: props?.source === 'body' && !!props?.parse,
+        };
+    },
+});
+exports.Field = (0, common_1.createFieldDecorator)({
+    prefix: queue_1.RESOURCE_TYPE,
+    enableInLambdaInvocation: true,
+    getMetadata: () => ({}),
+});
+const Event = (eventField) => (0, common_1.createEventDecorator)({
+    prefix: queue_1.RESOURCE_TYPE,
+    enableInLambdaInvocation: true,
+})(eventField);
+exports.Event = Event;

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

@@ -0,0 +1,89 @@
+import type { ArrayField, BooleanField, FieldProps, NumberField, ObjectField, StringField } from '@lafkn/common';
+export interface ParamAttributeProps extends Omit<FieldProps, 'type'> {
+    /**
+     * Attribute source.
+     *
+     * Specifies the source from which to obtain the attribute value.
+     * This can be used to map values from the event
+     * when processing messages.
+     */
+    source?: 'attribute';
+    /**
+     * Attribute type.
+     *
+     * Specifies the data type of the attribute. This can be used to
+     * enforce the type of the value extracted from the source before
+     * passing it to the consumer or processing logic.
+     */
+    type?: NumberConstructor | StringConstructor;
+}
+export interface ParamBodyUnparsedProps extends Omit<FieldProps, 'type'> {
+    /**
+     * Attribute source.
+     *
+     * Specifies the source from which to obtain the attribute value.
+     * This can be used to map values from the event
+     * when processing messages.
+     */
+    source: 'body';
+    /**
+     * Parse message body.
+     *
+     * Specifies whether the message body should be parsed and converted
+     * into a JavaScript object before being passed to the consumer.
+     */
+    parse?: false;
+    /**
+     * Attribute type.
+     *
+     * Specifies the data type of the attribute. This can be used to
+     * enforce the type of the value extracted from the source before
+     * passing it to the consumer or processing logic.
+     */
+    type?: StringConstructor;
+}
+export interface ParamBodyParsedProps extends Omit<FieldProps, 'type'> {
+    /**
+     * Attribute source.
+     *
+     * Specifies the source from which to obtain the attribute value.
+     * This can be used to map values from the event
+     * when processing messages.
+     */
+    source: 'body';
+    /**
+     * Parse message body.
+     *
+     * Specifies whether the message body should be parsed and converted
+     * into a JavaScript object before being passed to the consumer.
+     */
+    parse: true;
+    /**
+     * Attribute type.
+     *
+     * Specifies the data type of the attribute. This can be used to
+     * enforce the type of the value extracted from the source before
+     * passing it to the consumer or processing logic.
+     */
+    type?: StringConstructor | Function | [Function];
+}
+export type ParamProps = ParamAttributeProps | ParamBodyUnparsedProps | ParamBodyParsedProps;
+export type Source = Exclude<ParamProps['source'], undefined>;
+interface QueueParamBase {
+    source: Source;
+    parse: boolean;
+}
+export interface QueueStringParam extends StringField, QueueParamBase {
+}
+export interface QueueNumberParam extends NumberField, QueueParamBase {
+}
+export interface QueueBooleanParam extends BooleanField, QueueParamBase {
+}
+export interface QueueObjectParam extends Omit<ObjectField, 'properties'>, QueueParamBase {
+    properties: QueueParamMetadata[];
+}
+export interface QueueArrayParam extends Omit<ArrayField, 'items'>, QueueParamBase {
+    items: QueueParamMetadata;
+}
+export type QueueParamMetadata = QueueStringParam | QueueNumberParam | QueueBooleanParam | QueueObjectParam | QueueArrayParam;
+export {};

package/lib/main/event/event.types.js

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

package/lib/main/event/index.d.ts

@@ -0,0 +1,2 @@
+export * from './event';
+export * from './event.types';

package/lib/main/event/index.js

@@ -0,0 +1,18 @@
+"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("./event"), exports);
+__exportStar(require("./event.types"), exports);

package/lib/main/index.d.ts

@@ -0,0 +1,2 @@
+export * from './event';
+export * from './queue';

package/lib/main/index.js

@@ -0,0 +1,18 @@
+"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("./event"), exports);
+__exportStar(require("./queue"), exports);

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

@@ -0,0 +1,2 @@
+export * from './queue';
+export * from './queue.types';

package/lib/main/queue/index.js

@@ -0,0 +1,18 @@
+"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("./queue"), exports);
+__exportStar(require("./queue.types"), exports);

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

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+import type { FifoProps, StandardProps } from './queue.types';
+export declare const RESOURCE_TYPE: "QUEUE";
+export declare const Queue: (props?: import("@lafkn/common").ResourceProps | undefined) => (constructor: Function) => void;
+export declare const Standard: (props?: StandardProps | undefined) => (target: any, methodName: string, descriptor: PropertyDescriptor) => any;
+export declare const Fifo: (props?: FifoProps | undefined) => (target: any, methodName: string, descriptor: PropertyDescriptor) => any;

package/lib/main/queue/queue.js

@@ -0,0 +1,70 @@
+"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("@lafkn/common");
+exports.RESOURCE_TYPE = 'QUEUE';
+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;
+    },
+};
+exports.Standard = (0, common_1.createLambdaDecorator)({
+    getLambdaMetadata: (props, methodName) => ({
+        ...props,
+        queueName: props.queueName || methodName,
+        name: methodName,
+        isFifo: false,
+    }),
+    argumentParser,
+});
+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,75 @@
+import type { LambdaMetadata, LambdaProps, QueueNames } from '@lafkn/common';
+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;
+}
+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,20 @@
+import { SqsQueue } from '@cdktf/provider-aws/lib/sqs-queue';
+import { type AppModule } from '@lafkn/resolver';
+import type { QueueProps } from './queue.types';
+declare const Queue_base: {
+    new (...args: any[]): {
+        isGlobal(module: import("@lafkn/common").ModuleGlobalReferenceNames | (string & {}), id: string): void;
+        isDependent(resolveDependency: () => void): void;
+        readonly node: import("constructs").Node;
+        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("@cdktf/provider-aws/lib/lambda-event-source-mapping");
+const sqs_queue_1 = require("@cdktf/provider-aws/lib/sqs-queue");
+const common_1 = require("@lafkn/common");
+const resolver_1 = require("@lafkn/resolver");
+const attributeAllowedTypes = new Set(['String', 'Number']);
+const bodyParsedTypes = new Set(['String', 'Object', 'Array']);
+const bodyUnparsedTypes = new Set(['String']);
+class Queue extends resolver_1.lafknResource.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, handler.queueName);
+        this.validateEventParams();
+        this.addEventSource(id);
+    }
+    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',
+            principal: 'sqs.amazonaws.com',
+        });
+        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 '@lafkn/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 '@lafkn/common';
+import { type AppModule, type ResolverType } from '@lafkn/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("@lafkn/common");
+const resolver_1 = require("@lafkn/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;

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@lafkn/queue",
+  "version": "0.1.0",
+  "private": false,
+  "license": "MIT",
+  "exports": {
+    "./main": {
+      "import": "./lib/main/index.js",
+      "types": "./lib/main/index.d.ts",
+      "require": "./lib/main/index.js"
+    },
+    "./service": {
+      "import": "./lib/service/index.js",
+      "types": "./lib/service/index.d.ts",
+      "require": "./lib/service/index.js"
+    },
+    "./resolver": {
+      "import": "./lib/resolver/index.js",
+      "types": "./lib/resolver/index.d.ts",
+      "require": "./lib/resolver/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "main": [
+        "./lib/main/index.d.ts"
+      ],
+      "resolver": [
+        "./lib/resolver/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "lib"
+  ],
+  "dependencies": {
+    "@aws-sdk/client-sqs": "3.956.0",
+    "@cdktf/provider-aws": "21.22.0",
+    "aws-lambda": "1.0.7",
+    "cdktf": "0.21.0",
+    "constructs": "10.4.4",
+    "reflect-metadata": "0.2.2",
+    "@lafkn/common": "0.1.0",
+    "@lafkn/resolver": "0.1.0"
+  },
+  "devDependencies": {
+    "@jest/types": "^30.2.0",
+    "@types/aws-lambda": "8.10.159",
+    "@types/jest": "30.0.0",
+    "jest": "30.2.0",
+    "ts-jest": "29.4.6",
+    "ts-node": "10.9.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "pnpm clean && tsc -p ./tsconfig.build.json",
+    "clean": "rm -rf ./lib",
+    "dev": "tsc -w",
+    "test": "jest",
+    "test:coverage": "jest --coverage"
+  }
+}