@lafken/queue 0.6.4 → 0.8.0

package/README.md

@@ -1,6 +1,6 @@
 # @lafken/queue
 
-`@lafken/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.
+Define and consume Amazon SQS queues using TypeScript decorators. `@lafken/queue` lets you declare Standard and FIFO queues, map message data to typed handler parameters, and send messages at runtime through a built-in service client.
 
 ## Installation
 
@@ -8,122 +8,240 @@
 npm install @lafken/queue
 ```
 
-## Configuration
+## Getting Started
 
-Add the `QueueResolver` from the `@lafken/queue/resolver` library to your application configuration.
+Define a queue class with `@Queue`, add consumer methods with `@Standard` or `@Fifo`, and register everything through `QueueResolver`:
 
 ```typescript
+import { createApp, createModule } from '@lafken/main';
 import { QueueResolver } from '@lafken/queue/resolver';
+import { Queue, Standard, Payload, Param, Event } from '@lafken/queue/main';
 
-createApp({
-  name: 'awesome-app',
-  resolvers: [
-    new QueueResolver(),
-  ],
-  // ...
-});
+// 1. Define the message payload
+@Payload()
+export class OrderMessage {
+  @Param({ source: 'body', parse: true })
+  orderId: string;
 
+  @Param({ source: 'body', parse: true })
+  total: number;
+}
+
+// 2. Define the queue and its consumer
 @Queue()
-class GreetingQueue {
-  // ...
+export class OrderQueue {
+  @Standard({ batchSize: 5, visibilityTimeout: 60 })
+  processOrder(@Event(OrderMessage) message: OrderMessage) {
+    console.log(`Processing order ${message.orderId}`);
+  }
 }
 
-const greetingModule = createModule({
-  name: 'greeting',
-  resources: [
-    GreetingQueue
-  ]
+// 3. Register in a module
+const orderModule = createModule({
+  name: 'order',
+  resources: [OrderQueue],
+});
+
+// 4. Add the resolver to the app
+createApp({
+  name: 'my-app',
+  resolvers: [new QueueResolver()],
+  modules: [orderModule],
 });
 ```
 
+Each `@Standard` or `@Fifo` method becomes an independent Lambda function with its own SQS queue and event source mapping.
+
 ## Features
 
-### Defining a Queue Resource
+### Queue Class
 
-Use the `@Queue` decorator to define a class that contains queue-processing methods.
+Use the `@Queue` decorator to group related queue consumers in a single class. A queue class can contain multiple `@Standard` and `@Fifo` handlers:
 
 ```typescript
-import { Queue, Standard, Fifo } from '@lafken/queue';
+import { Queue, Standard, Fifo } from '@lafken/queue/main';
 
 @Queue()
-export class NotificationService {
-  // ... queue handlers
+export class NotificationQueue {
+  @Standard({ queueName: 'email-notifications' })
+  sendEmail() { }
+
+  @Fifo({ queueName: 'sms-notifications', contentBasedDeduplication: true })
+  sendSms() { }
 }
 ```
 
 ### 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.
+Use the `@Standard` decorator to create a standard (non-FIFO) SQS queue consumer. Messages are delivered at least once with best-effort ordering:
 
 ```typescript
 @Standard({
-  queueName: 'emails',
-  visibilityTimeout: 30,
+  queueName: 'reports',
   batchSize: 10,
+  visibilityTimeout: 120,
+  maxConcurrency: 5,
 })
-sendEmail(@Event() event: SQSEvent) {
-  // Process messages
+generateReport(@Event(ReportMessage) message: ReportMessage) {
+  // Process up to 10 messages per invocation
 }
 ```
 
+If `queueName` is omitted, the method name is used as the queue name.
+
+#### Standard Queue Options
+
+| Option                | Type     | Description                                                        |
+| --------------------- | -------- | ------------------------------------------------------------------ |
+| `queueName`           | `string` | Queue name (defaults to the method name)                           |
+| `batchSize`           | `1–10`   | Number of messages per Lambda invocation                           |
+| `visibilityTimeout`   | `number` | Seconds a message is hidden from other consumers while processing  |
+| `deliveryDelay`       | `number` | Seconds to delay message delivery after it is sent                 |
+| `retentionPeriod`     | `number` | Seconds messages are retained before automatic deletion            |
+| `maxMessageSizeBytes` | `number` | Maximum message size in bytes                                      |
+| `maxConcurrency`      | `number` | Maximum concurrent Lambda invocations for this queue               |
+| `maxBatchingWindow`   | `number` | Seconds to wait gathering messages into a batch before invoking    |
+| `lambda`              | `object` | Lambda-specific configuration (memory, timeout, etc.)              |
+
 ### 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.
+Use the `@Fifo` decorator for FIFO (First-In-First-Out) queues. FIFO queues guarantee exactly-once processing and strict message ordering. The queue name automatically gets a `.fifo` suffix:
 
 ```typescript
 @Fifo({
-  queueName: 'orders.fifo',
+  queueName: 'payment-processing',
   contentBasedDeduplication: true,
+  batchSize: 1,
 })
-processOrder(@Event() event: SQSEvent) {
-  // Process ordered messages
+processPayment(@Event(PaymentMessage) message: PaymentMessage) {
+  // Messages are processed in exact send order
 }
 ```
 
-### Message Handling & Parameter Mapping
+FIFO queues support all standard queue options plus:
+
+| Option                      | Type      | Description                                                     |
+| --------------------------- | --------- | --------------------------------------------------------------- |
+| `contentBasedDeduplication` | `boolean` | Use message content to generate deduplication IDs automatically |
 
-`@lafken/queue` allows you to extract specific data from the SQS message directly into your method parameters using `@Param` and `@Payload`.
+> [!NOTE]
+> FIFO queues automatically enable `ReportBatchItemFailures`, allowing partial batch failure reporting.
 
-#### Accessing Message Body Fields
+### Message Payload
 
-You can parse the message body (if it's JSON) and inject specific fields.
+Use `@Payload` on a class to define the structure of SQS messages. Decorate each property with `@Param` to specify where the value is extracted from in the SQS record:
 
 ```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}`);
+import { Payload, Param } from '@lafken/queue/main';
+
+@Payload()
+export class TaskMessage {
+  @Param({ source: 'attribute', type: String })
+  correlationId: string;
+
+  @Param({ source: 'body', parse: true })
+  taskName: string;
+
+  @Param({ source: 'body', parse: true })
+  priority: number;
 }
 ```
 
-#### Accessing Message Attributes
+#### @Param Options
 
-You can also access SQS Message Attributes.
+| Option   | Type                      | Default       | Description                                      |
+| -------- | ------------------------- | ------------- | ------------------------------------------------ |
+| `source` | `'attribute' \| 'body'`   | `'attribute'` | Where to extract the value from the SQS record   |
+| `parse`  | `boolean`                 | `false`       | JSON-parse the message body before extraction     |
+| `type`   | `String \| Number \| ...` | inferred      | Data type of the extracted value                  |
+| `name`   | `string`                  | property name | Override the field name used for extraction       |
+
+- **`source: 'attribute'`** — reads from SQS message attributes (supports `String` and `Number` types)
+- **`source: 'body'`** — reads from the message body. Set `parse: true` to JSON-parse the body and extract a specific field
+
+> [!NOTE]
+> Only one `@Param` with `source: 'body'` and `parse: false` (raw body) is allowed per handler.
+
+#### @Field Decorator
+
+Use `@Field` to include a property in the payload schema without specifying an extraction source:
 
 ```typescript
-@Standard({ queueName: 'logging' })
-logMessage(
-  @Param({ source: 'attribute', name: 'TraceId' }) traceId: string,
-  @Event() event: any
-) {
-  // ...
+import { Payload, Field } from '@lafken/queue/main';
+
+@Payload()
+export class SimpleMessage {
+  @Field()
+  action: string;
+
+  @Field()
+  timestamp: number;
 }
 ```
 
-#### Using Payload DTOs
+### Consuming Messages
 
-You can use the `@Payload` decorator to map the entire message body to a typed object.
+Bind a typed payload to a handler method using the `@Event` parameter decorator. Pass the payload class so the framework can automatically extract and map fields from the SQS record at runtime:
 
 ```typescript
-class UserDto {
-  userId: string;
-  email: string;
-}
+import { Queue, Standard, Event } from '@lafken/queue/main';
 
-@Standard({ queueName: 'users' })
-updateUser(@Payload() user: UserDto) {
-  // user is fully typed and parsed from the message body
+@Queue()
+export class AlertQueue {
+  @Standard({ queueName: 'alerts', batchSize: 5 })
+  processAlert(@Event(AlertMessage) alert: AlertMessage) {
+    console.log(`Alert from ${alert.source}: ${alert.message}`);
+  }
 }
 ```
+
+### Sending Messages
+
+Use `QueueService` at runtime to send messages to any SQS queue:
+
+```typescript
+import { QueueService } from '@lafken/queue/service';
+
+// Send a single message
+await QueueService.sendMessage({
+  url: 'https://sqs.us-east-1.amazonaws.com/123456789/orders',
+  body: { orderId: 'ord-123', total: 49.99 },
+  delay: 10,
+});
+
+// Send to a FIFO queue
+await QueueService.sendMessage({
+  url: 'https://sqs.us-east-1.amazonaws.com/123456789/payments.fifo',
+  body: { paymentId: 'pay-456', amount: 100 },
+  groupId: 'customer-789',
+  deduplicationId: 'pay-456',
+});
+```
+
+#### SendMessage Options
+
+| Option              | Type                               | Description                                        |
+| ------------------- | ---------------------------------- | -------------------------------------------------- |
+| `url`               | `string`                           | Full SQS queue URL                                 |
+| `body`              | `any`                              | Message body (automatically JSON-stringified)      |
+| `attributes`        | `Record<string, string \| number>` | SQS message attributes                            |
+| `delay`             | `number`                           | Delay in seconds before the message becomes visible |
+| `groupId`           | `string`                           | Message group ID (FIFO queues only)                |
+| `deduplicationId`   | `string`                           | Deduplication ID (FIFO queues only)                |
+
+### Sending Batch Messages
+
+Send multiple messages in a single API call:
+
+```typescript
+import { QueueService } from '@lafken/queue/service';
+
+await QueueService.sendBatchMessage({
+  url: 'https://sqs.us-east-1.amazonaws.com/123456789/tasks',
+  messages: [
+    { body: { task: 'resize-image', fileId: 'f1' } },
+    { body: { task: 'resize-image', fileId: 'f2' }, delay: 30 },
+    { body: { task: 'generate-thumbnail', fileId: 'f3' } },
+  ],
+});
+```

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

@@ -1,7 +1,99 @@
 import type { ParamProps } from './event.types';
 export declare const queueFieldKey: string;
 export declare const queuePayloadKey: string;
+/**
+ * Class decorator that declares a class as an SQS message payload.
+ *
+ * The decorated class defines the structure of data carried in a queue
+ * message. Use `@Param` or `@Field` on its properties to describe
+ * where each value is extracted from in the SQS record (message
+ * attributes or body).
+ *
+ * Works both at build time and at Lambda invocation time, so the
+ * same class can be used for sending and receiving messages.
+ *
+ * @param props - Optional payload configuration (e.g. a custom `name`).
+ *
+ * @example
+ * ```ts
+ * @Payload()
+ * export class OrderMessage {
+ *   @Param({ source: 'attribute' })
+ *   orderId: string;
+ *
+ *   @Param({ source: 'body', parse: true })
+ *   details: OrderDetails;
+ * }
+ * ```
+ */
 export declare const Payload: (props?: import("@lafken/common").PayloadProps | undefined) => (target: Function) => void;
+/**
+ * Property decorator that maps a class field to a value extracted
+ * from an SQS message.
+ *
+ * By default the value is read from a **message attribute** whose name
+ * matches the property. Set `source: 'body'` to extract it from the
+ * message body instead, and optionally enable `parse: true` to
+ * JSON-parse the body before extraction.
+ *
+ * @param props - Optional extraction configuration (source, type, parse).
+ *
+ * @example
+ * ```ts
+ * @Payload()
+ * export class NotificationMessage {
+ *   @Param({ source: 'attribute', type: String })
+ *   userId: string;
+ *
+ *   @Param({ source: 'body', parse: true })
+ *   content: NotificationContent;
+ * }
+ * ```
+ */
 export declare const Param: (props?: ParamProps | undefined) => (target: any, destinationName: string) => void;
+/**
+ * Property decorator that registers a class field as a generic
+ * queue message field.
+ *
+ * Unlike `@Param`, this decorator does not configure a specific
+ * extraction source or parsing behaviour — it simply marks the
+ * property for inclusion in the message payload schema.
+ *
+ * @param props - Optional field configuration (e.g. a custom `name` or `type`).
+ *
+ * @example
+ * ```ts
+ * @Payload()
+ * export class SimpleMessage {
+ *   @Field()
+ *   action: string;
+ *
+ *   @Field()
+ *   timestamp: number;
+ * }
+ * ```
+ */
 export declare const Field: (props?: import("@lafken/common").FieldProps | undefined) => (target: any, destinationName: string) => void;
+/**
+ * Parameter decorator that binds the incoming SQS event to a typed
+ * payload class on a handler method argument.
+ *
+ * Pass a class decorated with `@Payload` so the framework can
+ * automatically extract and map each field from the raw SQS record
+ * into a strongly-typed object at runtime.
+ *
+ * @param eventField - The payload class describing the expected
+ *                      message structure.
+ *
+ * @example
+ * ```ts
+ * @Queue()
+ * export class OrderQueue {
+ *   @Consumer()
+ *   process(@Event(OrderMessage) msg: OrderMessage) {
+ *     // msg fields are extracted from the SQS record
+ *   }
+ * }
+ * ```
+ */
 export declare const Event: (eventField: Function) => (target: any, methodName: string, _number: number) => void;

package/lib/main/event/event.js

@@ -5,11 +5,59 @@ const common_1 = require("@lafken/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);
+/**
+ * Class decorator that declares a class as an SQS message payload.
+ *
+ * The decorated class defines the structure of data carried in a queue
+ * message. Use `@Param` or `@Field` on its properties to describe
+ * where each value is extracted from in the SQS record (message
+ * attributes or body).
+ *
+ * Works both at build time and at Lambda invocation time, so the
+ * same class can be used for sending and receiving messages.
+ *
+ * @param props - Optional payload configuration (e.g. a custom `name`).
+ *
+ * @example
+ * ```ts
+ * @Payload()
+ * export class OrderMessage {
+ *   @Param({ source: 'attribute' })
+ *   orderId: string;
+ *
+ *   @Param({ source: 'body', parse: true })
+ *   details: OrderDetails;
+ * }
+ * ```
+ */
 exports.Payload = (0, common_1.createPayloadDecorator)({
     prefix: queue_1.RESOURCE_TYPE,
     createUniqueId: false,
     enableInLambdaInvocation: true,
 });
+/**
+ * Property decorator that maps a class field to a value extracted
+ * from an SQS message.
+ *
+ * By default the value is read from a **message attribute** whose name
+ * matches the property. Set `source: 'body'` to extract it from the
+ * message body instead, and optionally enable `parse: true` to
+ * JSON-parse the body before extraction.
+ *
+ * @param props - Optional extraction configuration (source, type, parse).
+ *
+ * @example
+ * ```ts
+ * @Payload()
+ * export class NotificationMessage {
+ *   @Param({ source: 'attribute', type: String })
+ *   userId: string;
+ *
+ *   @Param({ source: 'body', parse: true })
+ *   content: NotificationContent;
+ * }
+ * ```
+ */
 exports.Param = (0, common_1.createFieldDecorator)({
     prefix: queue_1.RESOURCE_TYPE,
     enableInLambdaInvocation: true,
@@ -21,11 +69,55 @@ exports.Param = (0, common_1.createFieldDecorator)({
         };
     },
 });
+/**
+ * Property decorator that registers a class field as a generic
+ * queue message field.
+ *
+ * Unlike `@Param`, this decorator does not configure a specific
+ * extraction source or parsing behaviour — it simply marks the
+ * property for inclusion in the message payload schema.
+ *
+ * @param props - Optional field configuration (e.g. a custom `name` or `type`).
+ *
+ * @example
+ * ```ts
+ * @Payload()
+ * export class SimpleMessage {
+ *   @Field()
+ *   action: string;
+ *
+ *   @Field()
+ *   timestamp: number;
+ * }
+ * ```
+ */
 exports.Field = (0, common_1.createFieldDecorator)({
     prefix: queue_1.RESOURCE_TYPE,
     enableInLambdaInvocation: true,
     getMetadata: () => ({}),
 });
+/**
+ * Parameter decorator that binds the incoming SQS event to a typed
+ * payload class on a handler method argument.
+ *
+ * Pass a class decorated with `@Payload` so the framework can
+ * automatically extract and map each field from the raw SQS record
+ * into a strongly-typed object at runtime.
+ *
+ * @param eventField - The payload class describing the expected
+ *                      message structure.
+ *
+ * @example
+ * ```ts
+ * @Queue()
+ * export class OrderQueue {
+ *   @Consumer()
+ *   process(@Event(OrderMessage) msg: OrderMessage) {
+ *     // msg fields are extracted from the SQS record
+ *   }
+ * }
+ * ```
+ */
 const Event = (eventField) => (0, common_1.createEventDecorator)({
     prefix: queue_1.RESOURCE_TYPE,
     enableInLambdaInvocation: true,

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

@@ -1,6 +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

@@ -4,6 +4,23 @@ 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,
@@ -50,6 +67,27 @@ const argumentParser = {
         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,
@@ -59,6 +97,27 @@ exports.Standard = (0, common_1.createLambdaDecorator)({
     }),
     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,

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

@@ -1,4 +1,4 @@
-import { SqsQueue } from '@cdktf/provider-aws/lib/sqs-queue';
+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[]) => {

package/lib/resolver/queue/queue.js

@@ -1,8 +1,8 @@
 "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 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']);

package/package.json

@@ -1,15 +1,26 @@
 {
   "name": "@lafken/queue",
-  "version": "0.6.4",
-  "description": "Create and manage Amazon SQS queues in TypeScript with Lambda integration",
+  "version": "0.8.0",
+  "private": false,
+  "description": "Define SQS queues and consumers using TypeScript decorators - automatic infrastructure generation with Lafken",
   "keywords": [
     "aws",
     "sqs",
+    "message queue",
     "serverless",
+    "typescript",
+    "decorators",
     "lafken"
   ],
-  "private": false,
+  "homepage": "https://github.com/Hero64/lafken#readme",
+  "bugs": "https://github.com/Hero64/lafken/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Hero64/lafken",
+    "directory": "packages/queue"
+  },
   "license": "MIT",
+  "author": "Aníbal Jorquera",
   "exports": {
     "./main": {
       "import": "./lib/main/index.js",
@@ -41,31 +52,41 @@
     "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",
-    "@lafken/common": "0.6.4",
-    "@lafken/resolver": "0.6.4"
+    "@aws-sdk/client-sqs": "^3.990.0",
+    "aws-lambda": "^1.0.7",
+    "reflect-metadata": "^0.2.2",
+    "@lafken/resolver": "0.8.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"
+    "@cdktn/provider-aws": "^23.0.0",
+    "@swc/core": "^1.15.11",
+    "@swc/helpers": "^0.5.18",
+    "@types/aws-lambda": "^8.10.160",
+    "@vitest/runner": "^4.0.18",
+    "cdktn": "^0.22.0",
+    "cdktn-vitest": "^1.0.0",
+    "constructs": "^10.4.5",
+    "unplugin-swc": "^1.5.9",
+    "vitest": "^4.0.18",
+    "@lafken/common": "0.8.0"
+  },
+  "peerDependencies": {
+    "@cdktn/provider-aws": "^23.0.0",
+    "@lafken/common": "^0.7.0",
+    "cdktn": "^0.22.0",
+    "constructs": "^10.4.5"
+  },
+  "engines": {
+    "node": ">=20.19"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
     "build": "pnpm clean && tsc -p ./tsconfig.build.json",
+    "check-types": "tsc --noEmit -p ./tsconfig.build.json",
     "clean": "rm -rf ./lib",
     "dev": "tsc -w",
-    "test": "jest",
-    "test:coverage": "jest --coverage"
+    "test": "vitest"
   }
 }