unnbound-events 2.0.9 → 2.0.11

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export type { IncomingEvent, IncomingRequest, EventMetadata, EventSource } from './lib/types';
+export type { IncomingEvent, IncomingRequest, EventMetadata, EventSource } from './lib/event';
 export type { EventServerOptions, EventServer } from './lib/server';
 export { createServer } from './lib/server';
 export { createEnqueuer } from './lib/enqueue';

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

@@ -15,6 +15,6 @@ export declare class ExtendedSQSClient extends SQSClient {
     constructor(config: ExtendedSQSClientConfig);
     private isS3PointerMessage;
     private retrieveMessage;
-    receive(command: ReceiveMessageCommand): Promise<ReceiveMessageCommandOutput>;
+    receive(command: ReceiveMessageCommand, options?: Parameters<SQSClient['send']>[1]): Promise<ReceiveMessageCommandOutput>;
 }
 export {};

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

@@ -24,15 +24,17 @@ class ExtendedSQSClient extends client_sqs_1.SQSClient {
         if (!this.isS3PointerMessage(parsed))
             return message;
         const { bucket, key } = parsed[1];
-        unnbound_logger_sdk_1.logger.debug({ bucket, key, ...(0, internal_1.internal)() }, 'Retrieving message from storage.');
-        const payload = await this.s3.send(new client_s3_1.GetObjectCommand({ Bucket: bucket, Key: key }));
-        const body = await payload.Body?.transformToString();
-        if (!body)
-            throw new Error('Failed to retrieve queue message from storage.');
+        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();
+            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 };
     }
-    async receive(command) {
-        const result = await this.send(command);
+    async receive(command, options) {
+        const result = await this.send(command, options);
         return {
             ...result,
             Messages: await Promise.all(result.Messages?.map(this.retrieveMessage.bind(this)) ?? []),

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

@@ -1,14 +1,14 @@
-import { UnnboundLogger } from 'unnbound-logger-sdk';
+import { ILogger } from 'unnbound-logger-sdk';
 import { Hono } from 'hono';
 export interface HttpAdapterOptions {
     app: Hono<any, any, any>;
-    logger?: UnnboundLogger;
+    logger: ILogger;
     ignoreTraceRoutes?: string[];
 }
 export declare class HttpAdapter {
     private readonly logger;
     private readonly app;
     constructor({ app, ...options }: HttpAdapterOptions);
-    listen(): () => Promise<void>;
+    listen(): Promise<() => Promise<void>>;
     private close;
 }

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

@@ -11,25 +11,34 @@ class HttpAdapter {
         this.logger = options.logger ?? unnbound_logger_sdk_1.logger;
         this.app = app;
     }
-    listen() {
+    async listen() {
         try {
             const port = parseInt(process.env.PORT ?? '3000');
-            const server = (0, node_server_1.serve)({ fetch: this.app.fetch, port });
-            this.logger?.info((0, internal_1.internal)(), 'HTTP server started.');
+            const server = await new Promise((resolve, reject) => {
+                try {
+                    const server = (0, node_server_1.serve)({ fetch: this.app.fetch, port }, () => resolve(server));
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+            this.logger.debug({ port, ...(0, internal_1.internal)() }, 'HTTP server started.');
             return () => this.close(server);
         }
         catch (error) {
-            this.logger?.info({ err: error, ...(0, internal_1.internal)() }, 'HTTP server failed to start.');
+            this.logger.error({ err: error, ...(0, internal_1.internal)() }, 'HTTP server failed to start.');
             throw error;
         }
     }
     close(server) {
         return new Promise((resolve, reject) => {
-            this.logger?.info((0, internal_1.internal)(), 'Http sever stopping...');
+            this.logger.debug((0, internal_1.internal)(), 'Http server stopping...');
             server.close((error) => {
-                if (error)
+                if (error) {
+                    this.logger.error({ err: error }, 'Http server failed to stop.');
                     return reject(error);
-                this.logger?.info((0, internal_1.internal)(), 'Http sever stopped.');
+                }
+                this.logger.debug((0, internal_1.internal)(), 'Http server stopped.');
                 return resolve();
             });
         });

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

@@ -1,6 +1,5 @@
-import { UnnboundLogger } from 'unnbound-logger-sdk';
-import { Message } from '@aws-sdk/client-sqs';
-import { EventHandlerResult, IncomingEvent, IncomingRequest } from '../types';
+import { ILogger } from 'unnbound-logger-sdk';
+import { Hono } from 'hono';
 export interface SqsRequest {
     method: string;
     url: string;
@@ -15,23 +14,26 @@ export interface SqsMessage {
     request: SqsRequest;
     metadata: SqsMetadata;
 }
-export type QueueEventHandler = (request: IncomingEvent<IncomingRequest>) => Promise<EventHandlerResult>;
+export interface QueueOptions {
+    readonly maxMessages?: number;
+    readonly visibilityTimeout?: number;
+}
 export interface QueueAdapterOptions {
-    logger?: UnnboundLogger;
-    maxMessages?: number;
-    visibilityTimeout?: number | undefined;
-    handler: QueueEventHandler;
+    logger: ILogger;
+    app: Hono<any, any, any>;
+    options?: QueueOptions;
 }
 export declare class QueueAdapter {
     private readonly logger;
+    private readonly app;
     private readonly sqs;
     private readonly options;
-    private readonly queue?;
-    private readonly handler;
-    constructor({ maxMessages, visibilityTimeout, handler, ...options }: QueueAdapterOptions);
-    parseEvent(message: Message): IncomingEvent<IncomingRequest>;
-    listen(): () => Promise<void>;
-    private getReceiveOptions;
+    constructor({ logger, app, options }: QueueAdapterOptions);
+    private getQueue;
+    listen(): Promise<() => Promise<void>>;
+    private processMessage;
+    private getReceiveCommand;
     private delete;
     private isSqsMessage;
+    private parseEvent;
 }

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

@@ -9,113 +9,117 @@ const utils_1 = require("../utils");
 const extended_sqs_client_1 = require("./extended-sqs-client");
 class QueueAdapter {
     logger;
+    app;
     sqs;
     options;
-    queue;
-    handler;
-    constructor({ maxMessages, visibilityTimeout, handler, ...options }) {
-        this.logger = options.logger ?? unnbound_logger_sdk_1.logger;
-        this.options = { maxMessages, visibilityTimeout };
-        this.handler = handler;
+    constructor({ logger, app, options }) {
+        this.logger = logger;
+        this.app = app;
+        this.options = {
+            ...options,
+            maxMessages: options?.maxMessages ?? 10,
+            visibilityTimeout: options?.visibilityTimeout ?? 20,
+        };
         const region = process.env.UNNBOUND_AWS_REGION ?? process.env.AWS_REGION ?? 'us-west-1';
-        const s3 = new client_s3_1.S3Client({ region, endpoint: process.env.UNNBOUND_S3_ENDPOINT });
-        this.sqs = new extended_sqs_client_1.ExtendedSQSClient({
-            region,
-            endpoint: process.env.UNNBOUND_SQS_ENDPOINT,
-            s3,
-        });
-        this.queue = process.env.UNNBOUND_SQS_URL;
+        const endpoint = process.env.UNNBOUND_S3_ENDPOINT;
+        const s3 = new client_s3_1.S3Client({ region, endpoint, maxAttempts: 3 });
+        this.sqs = new extended_sqs_client_1.ExtendedSQSClient({ region, endpoint, s3, maxAttempts: 3 });
     }
-    parseEvent(message) {
-        try {
-            if (!message.Body)
-                throw new Error('Queue message body is missing.');
-            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').toString('utf-8')
-                    : undefined,
-            };
-            return {
-                request,
-                timestamp: parsed.timestamp,
-                metadata: {
-                    ...parsed.metadata,
-                    ...(0, utils_1.getMetadataFromRequest)(request, 'queue'),
-                },
-            };
-        }
-        catch (error) {
-            throw new Error('Failed to parse queue message.', { cause: error });
-        }
+    getQueue() {
+        const queue = process.env.UNNBOUND_SQS_URL;
+        if (queue)
+            return queue;
+        throw new Error('UNNBOUND_SQS_URL is not configured.');
     }
-    listen() {
-        if (!this.queue) {
-            this.logger?.warn({}, 'Queue adapter configuration is not provided. Reach out to support.');
-            return () => Promise.resolve();
-        }
-        let stopped = false;
-        const loop = async () => {
-            this.logger?.debug({ queue: this.queue, ...(0, internal_1.internal)() }, 'Queue listener starting...');
-            const command = new client_sqs_1.ReceiveMessageCommand({
-                QueueUrl: this.queue,
-                ...this.getReceiveOptions(false),
-            });
-            await this.sqs.receive(command);
-            while (!stopped) {
+    async listen() {
+        this.logger.debug((0, internal_1.internal)(), 'Queue listener starting...');
+        await this.sqs.receive(this.getReceiveCommand(true));
+        this.logger.debug((0, internal_1.internal)(), 'Queue listener started.');
+        const controller = new AbortController();
+        const loop = new Promise((resolve, reject) => {
+            const loop = async () => {
+                if (controller.signal.aborted)
+                    return resolve(void 0);
                 try {
-                    const command = new client_sqs_1.ReceiveMessageCommand({
-                        QueueUrl: this.queue,
-                        ...this.getReceiveOptions(false),
+                    const { Messages: messages } = await this.sqs.receive(this.getReceiveCommand(false), {
+                        abortSignal: controller.signal,
                     });
-                    const { Messages: messages } = await this.sqs.receive(command);
                     if (!messages?.length)
-                        continue;
-                    const results = await Promise.all(messages.map(async (message) => await this.handler(this.parseEvent(message))
-                        .then((result) => {
-                        if (!result?.status || result.status < 400)
-                            return undefined;
-                        return message;
-                    })
-                        .catch(() => undefined)));
-                    await this.delete(results.filter((result) => !!result));
+                        return;
+                    const { failed } = await (0, unnbound_logger_sdk_1.startSpan)('Process messages', async () => {
+                        const results = await Promise.all(messages.map(this.processMessage.bind(this)));
+                        const failed = results.filter((result) => !!result);
+                        return { failed, succeeded: results.length - failed.length, total: results.length };
+                    }, (o) => ({ ...(0, internal_1.internal)(), ...o?.result, failed: o?.result?.failed?.length }));
+                    await this.delete(failed);
                 }
                 catch (err) {
-                    this.logger?.error({ err }, 'Queue loop error.');
+                    if (err instanceof Error && err.name === 'AbortError')
+                        return;
+                    this.logger.error({ err }, 'Queue loop error.');
                 }
-            }
-        };
-        const promise = loop();
+                finally {
+                    process.nextTick(loop);
+                }
+            };
+            loop().catch(reject);
+        });
         return async () => {
-            stopped = true;
-            this.logger?.info((0, internal_1.internal)(), 'Queue listener stopping...');
-            await promise.catch(() => void 0);
-            this.logger?.info((0, internal_1.internal)(), 'Queue listener stopped.');
+            controller.abort();
+            this.logger.debug((0, internal_1.internal)(), 'Queue listener stopping...');
+            try {
+                await loop;
+                this.logger.debug((0, internal_1.internal)(), 'Queue listener stopped.');
+            }
+            catch (error) {
+                this.logger.error({ err: error }, 'Queue listener failed to stop.');
+                throw error;
+            }
         };
     }
-    getReceiveOptions(peek) {
-        if (peek)
-            return { MaxNumberOfMessages: 1, WaitTimeSeconds: 0, VisibilityTimeout: 0 };
-        return {
-            MaxNumberOfMessages: this.options.maxMessages ?? 10,
-            WaitTimeSeconds: 20,
-            VisibilityTimeout: this.options.visibilityTimeout,
-        };
+    async processMessage(message) {
+        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,
+                headers: {
+                    ...event.request.headers,
+                    ...(0, utils_1.serializeMetadata)({ source: 'queue', timestamp: event.timestamp }),
+                },
+            });
+            if (response.status >= 400)
+                return;
+            return message;
+        }
+        catch (error) {
+            this.logger.error({ err: error }, 'Failed to handle queue event.');
+        }
+    }
+    getReceiveCommand(peek) {
+        const maxMessages = this.options.maxMessages ?? 10;
+        if (maxMessages < 1)
+            throw new Error('Max messages must be greater than 0.');
+        if (maxMessages > 10)
+            throw new Error('Max messages must be less than or equal to 10.');
+        return new client_sqs_1.ReceiveMessageCommand({
+            QueueUrl: this.getQueue(),
+            ...(peek
+                ? { MaxNumberOfMessages: 1, WaitTimeSeconds: 0, VisibilityTimeout: 0 }
+                : {
+                    MaxNumberOfMessages: maxMessages,
+                    WaitTimeSeconds: 20,
+                    VisibilityTimeout: this.options.visibilityTimeout ?? 0,
+                }),
+        });
     }
     async delete(messages) {
         if (!messages.length)
             return;
         await this.sqs.send(new client_sqs_1.DeleteMessageBatchCommand({
-            QueueUrl: this.queue,
+            QueueUrl: this.getQueue(),
             Entries: messages.map((m) => ({ Id: m.MessageId, ReceiptHandle: m.ReceiptHandle })),
         }));
     }
@@ -126,5 +130,32 @@ class QueueAdapter {
             '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/enqueue.d.ts

@@ -1,2 +1,6 @@
-import { EventMetadata, IncomingRequest } from './types';
-export declare const createEnqueuer: () => (event: IncomingRequest, metadata?: EventMetadata) => Promise<undefined>;
+import { EventMetadata, IncomingRequest } from './event';
+export interface EnqueuedRequest extends Omit<IncomingRequest, 'url' | 'headers' | 'query'> {
+    query?: IncomingRequest['query'];
+    headers?: IncomingRequest['headers'];
+}
+export declare const createEnqueuer: () => (event: EnqueuedRequest, metadata?: Partial<EventMetadata>) => Promise<undefined>;

package/dist/lib/enqueue.js

@@ -9,7 +9,14 @@ const types_1 = require("unnbound-logger-sdk/dist/types");
 const unnbound_logger_sdk_1 = require("unnbound-logger-sdk");
 const internal_1 = require("unnbound-logger-sdk/dist/internal");
 const storage_1 = require("unnbound-logger-sdk/dist/storage");
-const getWorkspaceId = (url) => url.replace(/^https?:\/\//, '').replace(/\.unnbound\.ai$/, '');
+const getWorkspaceId = (url) => {
+    url = url.replace(/^https?:\/\//, '');
+    if (!url.includes('unnbound.ai'))
+        return url.replace(/^.+?\/(.+)$/, '$1').replace(/^a?sync\//, '');
+    if (url.startsWith('workflow.'))
+        return url.replace(/^.+?\/(.+)$/, '$1').replace(/^a?sync\//, '');
+    return url.replace(/\.unnbound\.ai$/, '').replace(/^a?sync\//, '');
+};
 const getEnvironment = (url) => (url.includes('stg.unnbound.ai') ? 'stg' : 'prod');
 const getWorkflowDomain = (url) => {
     return getEnvironment(url) === 'stg' ? 'workflow.stg.unnbound.ai' : 'workflow.unnbound.ai';
@@ -20,6 +27,7 @@ const createEnqueuer = () => {
         throw new Error('UNNBOUND_WORKFLOW_URL is not configured. Reach out to support.');
     const client = (0, unnbound_logger_sdk_1.traceAxios)(axios_1.default.create({ baseURL: `https://${getWorkflowDomain(url)}/async/${getWorkspaceId(url)}` }), { getPayload: internal_1.internal });
     return async (event, metadata) => {
+        unnbound_logger_sdk_1.logger.info({ event, metadata }, 'Enqueuing event...');
         if (!event.path.startsWith('/'))
             throw new Error('Path must be relative.');
         const { traceId, messageId } = storage_1.storage.getStore() ?? {};

package/dist/lib/error.d.ts

@@ -1,5 +1,5 @@
 import { StatusCode } from 'hono/utils/http-status';
-import { StrictEventHandlerResult } from './types';
+import { StrictEventHandlerResult } from './event';
 interface HandlerErrorOptions extends ErrorOptions {
     status?: StatusCode;
     message?: string;

package/dist/lib/error.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HandlerError = void 0;
-const unnbound_logger_sdk_1 = require("unnbound-logger-sdk");
 class HandlerError extends Error {
     status;
     message;
@@ -17,11 +16,13 @@ class HandlerError extends Error {
         return new HandlerError({ message: 'Internal server error', status: 500, cause: error });
     }
     toError() {
-        return this.cause && this.cause instanceof Error ? this.cause : this;
+        if (this.cause instanceof HandlerError)
+            return this.cause.toError();
+        if (this.cause instanceof Error)
+            return this.cause;
+        return this;
     }
     toJson() {
-        const err = this.toError();
-        unnbound_logger_sdk_1.logger.error({ err }, err.message);
         return { status: this.status, body: { message: this.message } };
     }
 }

package/dist/lib/event.d.ts

@@ -0,0 +1,30 @@
+import type { HttpMethod } from 'unnbound-logger-sdk';
+import { StatusCode } from 'hono/utils/http-status';
+export interface IncomingRequest<B = any> {
+    url: string;
+    method: HttpMethod;
+    path: string;
+    headers: Record<string, string>;
+    query: Record<string, any>;
+    body?: B;
+}
+export interface MatchedIncomingRequest<B = any> extends IncomingRequest<B> {
+    params?: Record<string, string> | undefined;
+}
+export type EventSource = 'http' | 'queue';
+export interface EventMetadata {
+    traceId: string;
+    messageId: string;
+    source: EventSource;
+}
+export interface IncomingEvent<R extends IncomingRequest = IncomingRequest> {
+    timestamp: number;
+    request: R;
+    metadata: EventMetadata;
+}
+export interface StrictEventHandlerResult {
+    status: StatusCode;
+    headers?: Record<string, string>;
+    body?: object | undefined | null;
+}
+export type EventHandlerResult = Partial<StrictEventHandlerResult> | undefined | null | void;

package/dist/lib/event.js

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

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

@@ -1,17 +1,19 @@
 import { Context } from 'hono';
-import { EventHandlerResult } from '../types';
+import { EventHandlerResult, StrictEventHandlerResult } from '../event';
 import { MiddlewareHandler } from './middleware';
-import { EventContext, MaybePromise } from './types';
+import { EventEnvironment, EventVariables, MaybePromise } from './types';
 export type Handler<I, R = EventHandlerResult> = (input: I) => MaybePromise<R>;
 export interface Endpoint<I> {
     (path: string, handler: Handler<I>): MaybePromise<void>;
     (path: string, middleware: MiddlewareHandler<I>, handler: Handler<I>): MaybePromise<void>;
 }
 export type EndpointArgs<I> = [path: string, handler: Handler<I>] | [path: string, middleware: MiddlewareHandler<I>, handler: Handler<I>];
-export declare const buildEndpointArguments: (...args: EndpointArgs<EventContext>) => (string | MiddlewareHandler<Context<any, any, {}>> | Handler<Context<any, any, {}>, Response>)[];
-export declare const parseEndpointArguments: (...args: EndpointArgs<EventContext>) => {
+export declare const buildEndpointArguments: (...args: EndpointArgs<EventVariables<{}>>) => (string | MiddlewareHandler<Context<EventEnvironment<{}>, any, {}>> | Handler<Context<EventEnvironment<{}>, any, {}>, Response>)[];
+export declare const parseEndpointArguments: (...args: EndpointArgs<EventVariables<{}>>) => {
     path: string;
-    middlewares: MiddlewareHandler<EventContext>[];
-    handler: Handler<EventContext, EventHandlerResult>;
+    middlewares: MiddlewareHandler<EventVariables<{}>>[];
+    handler: Handler<EventVariables<{}>, EventHandlerResult>;
 };
-export declare const patchEndpoint: (handler: Handler<EventContext>) => Handler<Context, Response>;
+export declare const patchEndpoint: <V extends object>(handler: Handler<EventVariables<V>>) => Handler<Context<EventEnvironment<V>>, Response>;
+export declare const respondWith: (context: Context, result: StrictEventHandlerResult) => (Response & import("hono").TypedResponse<null, 100 | 101 | 102 | 103 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226 | 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 | -1, "body">) | (Response & import("hono").TypedResponse<never, 100 | 102 | 103 | 200 | 201 | 202 | 203 | 206 | 207 | 208 | 226 | 300 | 301 | 302 | 303 | 305 | 306 | 307 | 308 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 | -1, "json">);
+export declare const attachTraceHeaders: (headers?: Record<string, string>) => Record<string, string> | undefined;

package/dist/lib/routing/endpoint.js

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.patchEndpoint = exports.parseEndpointArguments = exports.buildEndpointArguments = void 0;
+exports.attachTraceHeaders = exports.respondWith = exports.patchEndpoint = exports.parseEndpointArguments = exports.buildEndpointArguments = void 0;
+const types_1 = require("unnbound-logger-sdk/dist/types");
+const storage_1 = require("unnbound-logger-sdk/dist/storage");
 const unnbound_logger_sdk_1 = require("unnbound-logger-sdk");
 const utils_1 = require("../utils");
-const error_1 = require("../error");
 const middleware_1 = require("./middleware");
 const buildEndpointArguments = (...args) => {
     const { path, middlewares, handler } = (0, exports.parseEndpointArguments)(...args);
-    return [path, ...middlewares.map(middleware_1.patchMiddleware), (0, exports.patchEndpoint)(handler)];
+    const patchedHandler = (0, exports.patchEndpoint)(handler);
+    return [path, ...middlewares.map(middleware_1.patchMiddleware), patchedHandler];
 };
 exports.buildEndpointArguments = buildEndpointArguments;
 const parseEndpointArguments = (...args) => {
@@ -18,26 +20,30 @@ const parseEndpointArguments = (...args) => {
 exports.parseEndpointArguments = parseEndpointArguments;
 const patchEndpoint = (handler) => {
     return async (context) => {
-        const event = await (0, utils_1.getIncomingEvent)(context.req);
-        context.set('event', event);
-        const result = await (0, unnbound_logger_sdk_1.withTrace)(() => (0, unnbound_logger_sdk_1.startSpan)('Event request', async () => {
-            try {
-                const result = await handler(context.get('event'));
-                if (result instanceof Error)
-                    return error_1.HandlerError.fromError(result).toJson();
-                return {
-                    status: result?.status ?? 204,
-                    headers: result?.headers,
-                    body: result?.body,
-                };
-            }
-            catch (error) {
-                return error_1.HandlerError.fromError(error).toJson();
-            }
-        }, (o) => (0, utils_1.buildIncomingPayload)(event, o)), event.metadata);
-        if (!result?.body)
-            return context.body(null, result?.status ?? 204, result?.headers);
-        return context.json(result.body, (result.status ?? 200), result.headers);
+        const state = context.get('state');
+        const result = await (0, unnbound_logger_sdk_1.startSpan)('Event request', async () => {
+            const result = await handler(state);
+            return { status: result?.status ?? 204, headers: result?.headers, body: result?.body };
+        }, (o) => (0, utils_1.buildIncomingPayload)(state, o));
+        return (0, exports.respondWith)(context, result);
     };
 };
 exports.patchEndpoint = patchEndpoint;
+const respondWith = (context, result) => {
+    const headers = (0, exports.attachTraceHeaders)(result.headers);
+    if (!result.body)
+        return context.body(null, result.status, headers);
+    return context.json(result.body, result.status, headers);
+};
+exports.respondWith = respondWith;
+const attachTraceHeaders = (headers) => {
+    const { traceId, messageId } = storage_1.storage.getStore() ?? {};
+    if (!traceId || !messageId)
+        return headers;
+    return {
+        ...headers,
+        [types_1.defaultTraceHeaderKey]: headers?.[types_1.defaultTraceHeaderKey] ?? traceId,
+        [types_1.defaultMessageHeaderKey]: headers?.[types_1.defaultMessageHeaderKey] ?? messageId,
+    };
+};
+exports.attachTraceHeaders = attachTraceHeaders;

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

@@ -1,17 +1,17 @@
 import { Context, Next } from 'hono';
-import { EventContext, MaybePromise } from './types';
+import { EventEnvironment, EventVariables, MaybePromise } from './types';
 export type MiddlewareHandler<I> = (input: I, next: Next) => MaybePromise<void>;
 export interface Middleware<I> {
     (...middlewares: MiddlewareHandler<I>[]): MaybePromise<void>;
     (path: string, ...middlewares: MiddlewareHandler<I>[]): MaybePromise<void>;
 }
 export type MiddlewareArgs<I> = [...middlewares: MiddlewareHandler<I>[]] | [path: string, ...middlewares: MiddlewareHandler<I>[]];
-export declare const patchMiddleware: (handler: MiddlewareHandler<EventContext>) => MiddlewareHandler<Context>;
-export declare const parseMiddlewareArguments: (...args: MiddlewareArgs<EventContext>) => {
+export declare const patchMiddleware: (handler: MiddlewareHandler<EventVariables<{}>>) => MiddlewareHandler<Context<EventEnvironment<{}>>>;
+export declare const parseMiddlewareArguments: (...args: MiddlewareArgs<EventVariables<{}>>) => {
     path: string;
-    middlewares: MiddlewareHandler<EventContext>[];
+    middlewares: MiddlewareHandler<EventVariables<{}>>[];
 } | {
     path: undefined;
-    middlewares: MiddlewareHandler<EventContext>[];
+    middlewares: MiddlewareHandler<EventVariables<{}>>[];
 };
-export declare const buildMiddlewareArguments: (...args: MiddlewareArgs<EventContext>) => MiddlewareHandler<EventContext>[] | readonly [string, ...MiddlewareHandler<Context<any, any, {}>>[]];
+export declare const buildMiddlewareArguments: (...args: MiddlewareArgs<EventVariables<{}>>) => MiddlewareHandler<EventVariables<{}>>[] | readonly [string, ...MiddlewareHandler<Context<EventEnvironment<{}>, any, {}>>[]];

package/dist/lib/routing/middleware.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildMiddlewareArguments = exports.parseMiddlewareArguments = exports.patchMiddleware = void 0;
 const patchMiddleware = (handler) => {
-    return (context, next) => handler(context.get('event'), next);
+    return (context, next) => handler(context.get('state'), next);
 };
 exports.patchMiddleware = patchMiddleware;
 const parseMiddlewareArguments = (...args) => {

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

@@ -1,8 +1,16 @@
 import { Env } from 'hono';
-import { IncomingEvent, MatchedIncomingRequest } from '../types';
+import { IncomingEvent, MatchedIncomingRequest } from '../event';
 export type MaybePromise<V> = Promise<V> | V;
-export interface EventEnvironment extends Env {
-    Variables: EventContext;
+interface EventInternalVariables<V extends object> {
+    set: <K extends keyof V>(key: K, value: V[K]) => void;
+    get: <K extends keyof V>(key: K) => V[K] | undefined;
 }
-export interface EventContext extends IncomingEvent<MatchedIncomingRequest> {
+export interface EventVariables<V extends object> extends IncomingEvent<MatchedIncomingRequest>, EventInternalVariables<V> {
 }
+export interface EventContext<V extends object> {
+    state: EventVariables<V>;
+}
+export interface EventEnvironment<V extends object> extends Env {
+    Variables: EventContext<V>;
+}
+export {};

package/dist/lib/server.d.ts

@@ -1,7 +1,7 @@
-import { UnnboundLogger } from 'unnbound-logger-sdk';
+import { ILogger } from 'unnbound-logger-sdk';
 import { Endpoint } from './routing/endpoint';
 import { Middleware } from './routing/middleware';
-import { EventContext } from './routing/types';
+import { EventVariables } from './routing/types';
 interface HttpOptions {
 }
 interface QueueOptions {
@@ -9,20 +9,19 @@ interface QueueOptions {
     visibilityTimeout?: number;
 }
 export interface EventServerOptions {
-    logger?: UnnboundLogger;
+    logger?: ILogger;
     queue?: QueueOptions;
     http?: HttpOptions;
 }
-export interface EventServer {
-    get: Endpoint<EventContext>;
-    post: Endpoint<EventContext>;
-    put: Endpoint<EventContext>;
-    patch: Endpoint<EventContext>;
-    delete: Endpoint<EventContext>;
-    use: Middleware<EventContext>;
-    start(): () => Promise<void>;
+export interface EventServer<V extends object = {}> {
+    get: Endpoint<EventVariables<V>>;
+    post: Endpoint<EventVariables<V>>;
+    put: Endpoint<EventVariables<V>>;
+    patch: Endpoint<EventVariables<V>>;
+    delete: Endpoint<EventVariables<V>>;
+    use: Middleware<EventVariables<V>>;
+    start(): Promise<() => Promise<void>>;
     stop(): Promise<void>;
-    shutdown(): Promise<void>;
 }
-export declare const createServer: (options?: EventServerOptions) => EventServer;
+export declare const createServer: <V extends object = {}>(options?: EventServerOptions) => EventServer<V>;
 export {};

package/dist/lib/server.js

@@ -10,26 +10,33 @@ const endpoint_1 = require("./routing/endpoint");
 const middleware_1 = require("./routing/middleware");
 const utils_1 = require("./utils");
 class HttpQueueServer {
-    options;
+    logger;
     app = new hono_1.Hono();
+    http;
+    queue;
     dispose;
     constructor(options = {}) {
-        this.options = options;
-        options.logger = options.logger ?? unnbound_logger_sdk_1.logger;
+        this.logger = options.logger ?? unnbound_logger_sdk_1.logger;
         this.app.get('/healthcheck', (c) => c.json({ status: 'ok' }));
+        this.app.use(async (context, next) => {
+            const event = await (0, utils_1.getIncomingEvent)(context.req);
+            const state = { get: context.get, set: context.set, ...event };
+            context.set('state', state);
+            return await (0, unnbound_logger_sdk_1.withTrace)(next, event.metadata);
+        });
         this.app.notFound((0, endpoint_1.patchEndpoint)(() => {
-            throw new error_1.HandlerError({ status: 404, message: 'Not found.' });
+            throw new error_1.HandlerError({ status: 404, message: 'Endpoint not found.' });
         }));
-        this.app.onError((err, c) => c.json(new error_1.HandlerError({ status: 500, message: 'Internal server error.', cause: err }).toJson()));
-        process.on('SIGINT', async () => {
-            this.options.logger?.debug({}, 'Received SIGINT. Initiating graceful shutdown...');
-            await this.shutdown();
-            process.exit(0);
+        this.app.onError((err, c) => {
+            const error = error_1.HandlerError.fromError(err);
+            unnbound_logger_sdk_1.logger.error({ err: error.toError() }, error.message);
+            return (0, endpoint_1.respondWith)(c, error.toJson());
         });
-        process.on('SIGTERM', async () => {
-            this.options.logger?.debug({}, 'Received SIGTERM. Initiating graceful shutdown...');
-            await this.shutdown();
-            process.exit(0);
+        this.http = new http_adapter_1.HttpAdapter({ app: this.app, logger: this.logger, ...options.http });
+        this.queue = new queue_adapter_1.QueueAdapter({
+            app: this.app,
+            logger: this.logger,
+            options: options.queue,
         });
     }
     get = (...args) => {
@@ -56,44 +63,36 @@ class HttpQueueServer {
         // @ts-expect-error
         return this.app.use(...(0, middleware_1.buildMiddlewareArguments)(...args));
     };
-    start() {
-        const adapters = [
-            new http_adapter_1.HttpAdapter({
-                app: this.app,
-                logger: this.options.logger,
-                ...this.options.http,
-            }),
-            new queue_adapter_1.QueueAdapter({
-                handler: async (event) => {
-                    // This will forward the request to the HTTP server
-                    // that will handle it according to the routes the user set up.
-                    await this.app.request(event.request.url, {
-                        method: event.request.method,
-                        body: event.request.body,
-                        headers: {
-                            ...event.request.headers,
-                            ...(0, utils_1.serializeMetadata)({ source: 'queue', timestamp: event.timestamp }),
-                        },
-                    });
-                },
-                logger: this.options.logger,
-                ...this.options.queue,
-            }),
-        ];
-        const disposables = adapters.map((adapter) => adapter.listen());
-        this.dispose = () => Promise.all(disposables).then(() => void 0);
-        this.options.logger?.info({}, 'Server started.');
-        return this.dispose.bind(this);
+    async start() {
+        const createOnSignal = (signal) => async () => {
+            this.logger.debug({}, `Received ${signal}. Initiating graceful shutdown...`);
+            await this.stop();
+            process.exit(0);
+        };
+        process.on('SIGINT', createOnSignal('SIGINT'));
+        process.on('SIGTERM', createOnSignal('SIGTERM'));
+        this.logger.debug({}, 'Starting server...');
+        try {
+            const disposables = await Promise.all([this.http.listen(), this.queue.listen()]);
+            this.dispose = async () => {
+                await Promise.all(disposables.map((dispose) => dispose()))
+                    .then(() => void 0)
+                    .catch(console.error);
+            };
+            this.logger.info('Server started.');
+            return this.dispose;
+        }
+        catch (error) {
+            this.logger.error({ err: error }, 'Server failed to start.');
+            throw error;
+        }
     }
     async stop() {
-        this.options.logger?.debug({}, 'Event client stopping...');
-        await this.dispose?.();
-        this.options.logger?.debug({}, 'Event client stopped.');
-    }
-    async shutdown() {
-        this.options.logger?.debug({}, 'Event client shutting down...');
-        await this.stop();
-        this.options.logger?.debug({}, 'Event client shut down.');
+        if (!this.dispose)
+            return;
+        this.logger.debug({ dispose: !!this.dispose }, 'Server stopping...');
+        await this.dispose();
+        this.logger.debug({}, 'Server stopped.');
     }
 }
 const createServer = (options = {}) => new HttpQueueServer(options);

package/dist/lib/utils.d.ts

@@ -1,6 +1,6 @@
 import { Maybe } from 'unnbound-logger-sdk/dist/types';
 import { HonoRequest } from 'hono';
-import { EventHandlerResult, EventMetadata, EventSource, IncomingEvent, IncomingRequest, MatchedIncomingRequest, StrictEventHandlerResult } from './types';
+import { EventHandlerResult, EventMetadata, EventSource, IncomingEvent, IncomingRequest, MatchedIncomingRequest, StrictEventHandlerResult } from './event';
 export declare const normalizeHeaders: (headers: Record<string, string | string[]>) => Record<string, string>;
 export declare const getIncomingEvent: (event: HonoRequest) => Promise<IncomingEvent<MatchedIncomingRequest>>;
 export declare const getMetadataFromRequest: (request: IncomingRequest, source: EventSource) => EventMetadata;
@@ -15,8 +15,9 @@ export declare const serializeMetadata: (metadata: ForwardedMetadata) => {
 export declare const buildIncomingPayload: (event: IncomingEvent<MatchedIncomingRequest>, result?: Maybe<EventHandlerResult>) => {
     type: string;
     source: EventSource;
-    delay: number;
+    delay: number | undefined;
     http: {
+        response?: StrictEventHandlerResult | undefined;
         url: string;
         method: string;
         query: Record<string, any>;
@@ -27,7 +28,6 @@ export declare const buildIncomingPayload: (event: IncomingEvent<MatchedIncoming
             headers: Record<string, string>;
             body: any;
         };
-        response: StrictEventHandlerResult;
     };
 };
 export {};

package/dist/lib/utils.js

@@ -34,19 +34,29 @@ const parseParams = (request) => {
 };
 const getIncomingRequest = async (request) => {
     const url = new URL(request.url, `https://unnbound.ai`);
+    const headers = (0, exports.normalizeHeaders)(request.header());
     return {
         url: url.toString(),
         method: request.method.toLowerCase(),
         path: request.path,
-        headers: (0, exports.normalizeHeaders)(request.header()),
+        headers,
         query: request.query(),
-        body: await parseBody(request),
+        body: await parseBody(request, headers),
         params: parseParams(request),
     };
 };
-const parseBody = async (request) => {
+const parseBody = async (request, headers) => {
     try {
-        return await request.json();
+        if (headers['content-type']?.includes('application/json'))
+            return await request.json();
+        if (headers['content-type']?.includes('application/x-www-form-urlencoded'))
+            return await request.parseBody();
+        if (headers['content-type']?.includes('multipart/form-data'))
+            return await request.parseBody();
+        if (headers['content-type']?.includes('text/plain'))
+            return await request.text();
+        // TODO: handle binary body
+        return undefined;
     }
     catch {
         return undefined;
@@ -69,21 +79,19 @@ const deserializeMetadata = (request) => ({
     source: request.headers[sourceKey],
     timestamp: request.headers[timestampKey] ? parseInt(request.headers[timestampKey]) : undefined,
 });
-const buildResponsePayload = (result) => {
-    return {
-        status: result?.status ?? 204,
-        headers: {
-            'content-type': 'application/json; charset=utf-8',
-            ...(result?.headers ? (0, exports.normalizeHeaders)(result.headers) : undefined),
-        },
-        body: result?.body ? (0, utils_1.safeJsonParse)(result.body) : undefined,
-    };
-};
+const buildResponsePayload = (result) => ({
+    status: result?.status ?? 204,
+    headers: {
+        'content-type': 'application/json; charset=utf-8',
+        ...(result?.headers ? (0, exports.normalizeHeaders)(result.headers) : undefined),
+    },
+    body: result?.body ? (0, utils_1.safeJsonParse)(result.body) : undefined,
+});
 const buildIncomingPayload = (event, result) => {
     return {
         type: 'http',
         source: event.metadata.source,
-        delay: Date.now() - event.timestamp,
+        delay: event.metadata.source === 'queue' ? Date.now() - event.timestamp : undefined,
         http: {
             url: event.request.url,
             method: event.request.method.toLowerCase(),
@@ -97,9 +105,11 @@ const buildIncomingPayload = (event, result) => {
                 headers: event.request.headers,
                 body: (0, utils_1.safeJsonParse)(event.request.body),
             },
-            response: result?.error
-                ? buildResponsePayload(error_1.HandlerError.fromError(result.error).toJson())
-                : buildResponsePayload(result?.result),
+            ...(result && {
+                response: result.error
+                    ? buildResponsePayload(error_1.HandlerError.fromError(result.error).toJson())
+                    : buildResponsePayload(result.result),
+            }),
         },
     };
 };

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.9",
+  "version": "2.0.11",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "Unnbound Team",
@@ -20,7 +20,7 @@
     "@hono/node-server": "^1.19.6",
     "axios": "^1.12.2",
     "hono": "^4.10.4",
-    "unnbound-logger-sdk": "3.0.24"
+    "unnbound-logger-sdk": "3.0.25"
   },
   "devDependencies": {
     "@types/jest": "^29.5.12",