unnbound-events 2.0.12 → 2.0.14

package/dist/lib/adapters/extended-sqs-client.d.ts

@@ -1,11 +1,16 @@
 import { S3Client } from '@aws-sdk/client-s3';
-import { ReceiveMessageCommand, ReceiveMessageCommandOutput, SQSClient } from '@aws-sdk/client-sqs';
+import { Message, ReceiveMessageCommand, SQSClient } from '@aws-sdk/client-sqs';
+import { IncomingEvent, IncomingRequest } from '../event';
 export interface S3Pointer {
     bucket: string;
     key: string;
 }
 export type S3PointerMessage = ['software.amazon.payloadoffloading.PayloadS3Pointer', S3Pointer];
 type SQSClientConfig = ConstructorParameters<typeof SQSClient>[0];
+export interface ExtendedSqsMessage {
+    message: Message;
+    event: IncomingEvent<IncomingRequest>;
+}
 export type ExtendedSQSClientConfig = SQSClientConfig & {
     s3: S3Client;
 };
@@ -13,8 +18,10 @@ export declare class ExtendedSQSClient extends SQSClient {
     private readonly s3;
     private readonly S3_POINTER_CLASS;
     constructor(config: ExtendedSQSClientConfig);
-    private isS3PointerMessage;
+    receive(command: ReceiveMessageCommand, options?: Parameters<SQSClient['send']>[1]): Promise<ExtendedSqsMessage[]>;
     private retrieveMessage;
-    receive(command: ReceiveMessageCommand, options?: Parameters<SQSClient['send']>[1]): Promise<ReceiveMessageCommandOutput>;
+    private isSqsMessage;
+    private isS3PointerMessage;
+    private parseEvent;
 }
 export {};

package/dist/lib/adapters/extended-sqs-client.js

@@ -5,6 +5,7 @@ const client_s3_1 = require("@aws-sdk/client-s3");
 const client_sqs_1 = require("@aws-sdk/client-sqs");
 const unnbound_logger_sdk_1 = require("unnbound-logger-sdk");
 const internal_1 = require("unnbound-logger-sdk/dist/internal");
+const utils_1 = require("../utils");
 class ExtendedSQSClient extends client_sqs_1.SQSClient {
     s3;
     S3_POINTER_CLASS = 'software.amazon.payloadoffloading.PayloadS3Pointer';
@@ -12,32 +13,60 @@ class ExtendedSQSClient extends client_sqs_1.SQSClient {
         super(config);
         this.s3 = config.s3;
     }
-    isS3PointerMessage(body) {
-        return Array.isArray(body) && body.length === 2 && body[0] === this.S3_POINTER_CLASS;
+    async receive(command, options) {
+        const result = await this.send(command, options);
+        return await Promise.all(result.Messages?.map(async (message) => ({
+            message,
+            event: await this.retrieveMessage(message),
+        })) ?? []);
     }
     async retrieveMessage(message) {
         if (!message.Body)
-            return message;
-        if (!message.Body.startsWith(`["${this.S3_POINTER_CLASS}",`))
-            return message;
+            throw new Error('Queue message body is missing.');
         const parsed = JSON.parse(message.Body);
-        if (!this.isS3PointerMessage(parsed))
-            return message;
-        const { bucket, key } = parsed[1];
+        if (!this.isSqsMessage(parsed))
+            throw new Error('Invalid queue message format.');
+        const payload = parsed.request.body;
+        if (!this.isS3PointerMessage(payload))
+            return this.parseEvent(parsed);
+        const { bucket, key } = payload[1];
         const body = await (0, unnbound_logger_sdk_1.startSpan)('Retrieve message from storage', async () => {
             const payload = await this.s3.send(new client_s3_1.GetObjectCommand({ Bucket: bucket, Key: key }));
-            const body = await payload.Body?.transformToString();
+            const body = await payload.Body?.transformToByteArray();
             if (!body)
                 throw new Error('Failed to retrieve queue message from storage.');
-            return body;
-        }, (o) => ({ bucket, key, ...(0, internal_1.internal)(), size: o?.result?.length }));
-        return { ...message, Body: body };
+            return body.buffer;
+        }, (o) => ({ bucket, key, ...(0, internal_1.internal)(), size: o?.result?.byteLength }));
+        return this.parseEvent({ ...parsed, request: { ...parsed.request, body } });
     }
-    async receive(command, options) {
-        const result = await this.send(command, options);
+    isSqsMessage(message) {
+        return (!!message &&
+            typeof message === 'object' &&
+            'id' in message &&
+            'timestamp' in message &&
+            'request' in message);
+    }
+    isS3PointerMessage(body) {
+        return Array.isArray(body) && body.length === 2 && body[0] === this.S3_POINTER_CLASS;
+    }
+    parseEvent(message) {
+        const method = message.request.method.toLowerCase();
+        const url = new URL(message.request.url, `https://unnbound.ai`);
+        const request = {
+            url: url.toString(),
+            method,
+            path: url.pathname,
+            headers: (0, utils_1.normalizeHeaders)(message.request.headers),
+            query: Object.fromEntries(url.searchParams.entries()),
+            body: message.request.body,
+        };
         return {
-            ...result,
-            Messages: await Promise.all(result.Messages?.map(this.retrieveMessage.bind(this)) ?? []),
+            request,
+            timestamp: message.timestamp,
+            metadata: {
+                ...message.metadata,
+                ...(0, utils_1.getMetadataFromRequest)(request, 'queue'),
+            },
         };
     }
 }

package/dist/lib/adapters/queue-adapter.d.ts

@@ -34,6 +34,4 @@ export declare class QueueAdapter {
     private processMessage;
     private getReceiveCommand;
     private delete;
-    private isSqsMessage;
-    private parseEvent;
 }

package/dist/lib/adapters/queue-adapter.js

@@ -41,10 +41,10 @@ class QueueAdapter {
                 if (controller.signal.aborted)
                     return resolve(void 0);
                 try {
-                    const { Messages: messages } = await this.sqs.receive(this.getReceiveCommand(false), {
+                    const messages = await this.sqs.receive(this.getReceiveCommand(false), {
                         abortSignal: controller.signal,
                     });
-                    if (!messages?.length)
+                    if (!messages.length)
                         return;
                     const { failed } = await (0, unnbound_logger_sdk_1.startSpan)('Process messages', async () => {
                         const results = await Promise.all(messages.map(this.processMessage.bind(this)));
@@ -77,14 +77,17 @@ class QueueAdapter {
             }
         };
     }
-    async processMessage(message) {
+    async processMessage({ message, event, }) {
         try {
-            const event = this.parseEvent(message);
             // It forward the request to the HTTP server that will
             // handle it according to the routes the user set up.
             const response = await this.app.request(event.request.url, {
                 method: event.request.method,
-                body: event.request.body,
+                body: event.request.body instanceof ArrayBuffer || event.request.body instanceof FormData
+                    ? event.request.body
+                    : typeof event.request.body === 'object'
+                        ? JSON.stringify(event.request.body)
+                        : event.request.body,
                 headers: {
                     ...event.request.headers,
                     ...(0, utils_1.serializeMetadata)({ source: 'queue', timestamp: event.timestamp }),
@@ -118,44 +121,15 @@ class QueueAdapter {
     async delete(messages) {
         if (!messages.length)
             return;
-        await this.sqs.send(new client_sqs_1.DeleteMessageBatchCommand({
-            QueueUrl: this.getQueue(),
-            Entries: messages.map((m) => ({ Id: m.MessageId, ReceiptHandle: m.ReceiptHandle })),
+        const queue = this.getQueue();
+        // Batch the messages into 10 messages per batch
+        const batches = (0, utils_1.batchArray)(messages, 10);
+        await Promise.all(batches.map(async (messages) => {
+            await this.sqs.send(new client_sqs_1.DeleteMessageBatchCommand({
+                QueueUrl: queue,
+                Entries: messages.map((m) => ({ Id: m.MessageId, ReceiptHandle: m.ReceiptHandle })),
+            }));
         }));
     }
-    isSqsMessage(message) {
-        return (!!message &&
-            typeof message === 'object' &&
-            'id' in message &&
-            'timestamp' in message &&
-            'request' in message);
-    }
-    parseEvent(message) {
-        if (!message.Body)
-            throw new Error('Queue message body is missing.');
-        if (typeof message.Body !== 'string')
-            throw new Error('Queue message body is malformed.');
-        const parsed = JSON.parse(message.Body);
-        if (!this.isSqsMessage(parsed))
-            throw new Error('Invalid queue message format.');
-        const method = parsed.request.method.toLowerCase();
-        const url = new URL(parsed.request.url, `https://unnbound.ai`);
-        const request = {
-            url: url.toString(),
-            method,
-            path: url.pathname,
-            headers: (0, utils_1.normalizeHeaders)(parsed.request.headers),
-            query: Object.fromEntries(url.searchParams.entries()),
-            body: parsed.request.body ? Buffer.from(parsed.request.body, 'base64') : undefined,
-        };
-        return {
-            request,
-            timestamp: parsed.timestamp,
-            metadata: {
-                ...parsed.metadata,
-                ...(0, utils_1.getMetadataFromRequest)(request, 'queue'),
-            },
-        };
-    }
 }
 exports.QueueAdapter = QueueAdapter;

package/dist/lib/routing/middleware.d.ts

@@ -14,4 +14,4 @@ export declare const parseMiddlewareArguments: (...args: MiddlewareArgs<EventVar
     path: undefined;
     middlewares: MiddlewareHandler<EventVariables<{}>>[];
 };
-export declare const buildMiddlewareArguments: (...args: MiddlewareArgs<EventVariables<{}>>) => MiddlewareHandler<EventVariables<{}>>[] | readonly [string, ...MiddlewareHandler<Context<EventEnvironment<{}>, any, {}>>[]];
+export declare const buildMiddlewareArguments: (...args: MiddlewareArgs<EventVariables<{}>>) => MiddlewareHandler<Context<EventEnvironment<{}>, any, {}>>[] | readonly [string, ...MiddlewareHandler<Context<EventEnvironment<{}>, any, {}>>[]];

package/dist/lib/routing/middleware.js

@@ -14,7 +14,7 @@ exports.parseMiddlewareArguments = parseMiddlewareArguments;
 const buildMiddlewareArguments = (...args) => {
     const { path, middlewares } = (0, exports.parseMiddlewareArguments)(...args);
     if (!path)
-        return middlewares;
+        return middlewares.map(exports.patchMiddleware);
     return [path, ...middlewares.map(exports.patchMiddleware)];
 };
 exports.buildMiddlewareArguments = buildMiddlewareArguments;

package/dist/lib/utils.d.ts

@@ -30,4 +30,5 @@ export declare const buildIncomingPayload: (event: IncomingEvent<MatchedIncoming
         };
     };
 };
+export declare const batchArray: <T>(array: T[], size: number) => T[][];
 export {};

package/dist/lib/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildIncomingPayload = exports.serializeMetadata = exports.getMetadataFromRequest = exports.getIncomingEvent = exports.normalizeHeaders = void 0;
+exports.batchArray = exports.buildIncomingPayload = exports.serializeMetadata = exports.getMetadataFromRequest = exports.getIncomingEvent = exports.normalizeHeaders = void 0;
 const unnbound_logger_sdk_1 = require("unnbound-logger-sdk");
 const types_1 = require("unnbound-logger-sdk/dist/types");
 const trace_1 = require("unnbound-logger-sdk/dist/trace");
@@ -55,8 +55,7 @@ const parseBody = async (request, headers) => {
             return await request.parseBody();
         if (headers['content-type']?.includes('text/plain'))
             return await request.text();
-        // TODO: handle binary body
-        return undefined;
+        return request.arrayBuffer();
     }
     catch {
         return undefined;
@@ -114,3 +113,7 @@ const buildIncomingPayload = (event, result) => {
     };
 };
 exports.buildIncomingPayload = buildIncomingPayload;
+const batchArray = (array, size) => {
+    return [...Array(Math.ceil(array.length / size))].map((_, i) => array.slice(i * size, i * size + size));
+};
+exports.batchArray = batchArray;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unnbound-events",
   "description": "Unified events SDK to handle HTTP routes and queued messages with a single routing API.",
-  "version": "2.0.12",
+  "version": "2.0.14",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "Unnbound Team",