unnbound-events 1.0.0 → 1.0.2

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { createEventsClient } from './lib/client';
+export type { EventsClient, EventRequest, EventResponse, RouteHandler, RouteMatcher, RegisteredRoute, SqsBatchEvent, StartOptions, } from './lib/types';
+export { createExpressMiddleware } from './lib/adapters/express';
+export { createSqsConsumer } from './lib/adapters/sqs';

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSqsConsumer = exports.createExpressMiddleware = exports.createEventsClient = void 0;
+var client_1 = require("./lib/client");
+Object.defineProperty(exports, "createEventsClient", { enumerable: true, get: function () { return client_1.createEventsClient; } });
+var express_1 = require("./lib/adapters/express");
+Object.defineProperty(exports, "createExpressMiddleware", { enumerable: true, get: function () { return express_1.createExpressMiddleware; } });
+var sqs_1 = require("./lib/adapters/sqs");
+Object.defineProperty(exports, "createSqsConsumer", { enumerable: true, get: function () { return sqs_1.createSqsConsumer; } });

package/dist/lib/adapters/express.d.ts

@@ -0,0 +1,16 @@
+type Request = {
+    method: string;
+    path: string;
+    headers: Record<string, string | string[] | undefined>;
+    query: Record<string, unknown>;
+    body: unknown;
+};
+type Response = {
+    status: (code: number) => Response;
+    setHeader: (name: string, value: string) => void;
+    send: (body: unknown) => void;
+    end: () => void;
+};
+import type { EventsClient } from '../types';
+export declare function createExpressMiddleware(client: EventsClient): (req: Request, res: Response) => Promise<void>;
+export {};

package/dist/lib/adapters/express.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExpressMiddleware = createExpressMiddleware;
+function toEventRequest(req) {
+    const method = req.method.toUpperCase();
+    const headers = {};
+    for (const [key, value] of Object.entries(req.headers)) {
+        if (typeof value === 'string')
+            headers[key] = value;
+        else if (Array.isArray(value))
+            headers[key] = value.join(',');
+    }
+    return {
+        method,
+        path: req.path,
+        headers,
+        query: req.query,
+        body: req.body,
+        metadata: { source: 'http' },
+    };
+}
+function applyResponse(res, response) {
+    res.status(response.status);
+    if (response.headers) {
+        for (const [k, v] of Object.entries(response.headers))
+            res.setHeader(k, v);
+    }
+    if (response.body !== undefined)
+        return res.send(response.body);
+    return res.end();
+}
+function createExpressMiddleware(client) {
+    return async function eventsMiddleware(req, res) {
+        const eventReq = toEventRequest(req);
+        const eventRes = await client.handle(eventReq);
+        applyResponse(res, eventRes);
+    };
+}

package/dist/lib/adapters/sqs.d.ts

@@ -0,0 +1,36 @@
+import type { EventsClient, HttpMethod } from '../types';
+export interface QueueEnvelope {
+    id: string;
+    timestamp: number;
+    version: string;
+    workflow: string;
+    priority: number;
+    payload: {
+        type: string;
+        size: number;
+        compressed: boolean;
+    };
+    request: {
+        method: HttpMethod;
+        path: string;
+        headers: Record<string, string>;
+        query: Record<string, unknown>;
+        body: unknown;
+    };
+    metadata?: Record<string, unknown>;
+    addons?: Record<string, unknown>;
+}
+export type SqsRecord = {
+    messageId: string;
+    body: string;
+};
+export interface SqsBatchEvent {
+    Records: SqsRecord[];
+}
+export declare function createSqsConsumer(client: EventsClient): (event: SqsBatchEvent) => Promise<{
+    successes: number;
+    failures: Array<{
+        messageId: string;
+        reason: string;
+    }>;
+}>;

package/dist/lib/adapters/sqs.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSqsConsumer = createSqsConsumer;
+function createSqsConsumer(client) {
+    return async function consume(event) {
+        let successes = 0;
+        const failures = [];
+        await Promise.all(event.Records.map(async (record) => {
+            try {
+                const envelope = JSON.parse(record.body);
+                const req = {
+                    method: envelope.request.method,
+                    path: envelope.request.path,
+                    headers: envelope.request.headers,
+                    query: envelope.request.query,
+                    body: envelope.request.body,
+                    metadata: {
+                        source: 'sqs',
+                        id: envelope.id,
+                        workflow: envelope.workflow,
+                        timestamp: envelope.timestamp,
+                        version: envelope.version,
+                        ...envelope.metadata,
+                    },
+                };
+                const res = await client.handle(req);
+                if (res.status >= 200 && res.status < 300)
+                    successes += 1;
+                else
+                    failures.push({
+                        messageId: record.messageId,
+                        reason: `Handler returned status ${res.status}`,
+                    });
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                failures.push({ messageId: record.messageId, reason: err.message ?? 'Unknown error' });
+            }
+        }));
+        return { successes, failures };
+    };
+}

package/dist/lib/client.d.ts

@@ -0,0 +1,2 @@
+import type { EventsClient } from './types';
+export declare function createEventsClient(): EventsClient;

package/dist/lib/client.js

@@ -0,0 +1,312 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventsClient = createEventsClient;
+const unnbound_logger_sdk_1 = require("unnbound-logger-sdk");
+const http = (() => {
+    try {
+        return (require && require('http'));
+    }
+    catch {
+        return null;
+    }
+})();
+function matchPath(matcher, path) {
+    if (typeof matcher === 'string') {
+        return matcher === path;
+    }
+    if (matcher instanceof RegExp) {
+        return matcher.test(path);
+    }
+    return matcher(path);
+}
+function createEventsClient() {
+    const routes = [];
+    return {
+        on(method, matcher, handler) {
+            routes.push({ method, matcher, handler });
+        },
+        get(matcher, handler) {
+            routes.push({ method: 'GET', matcher, handler });
+        },
+        post(matcher, handler) {
+            routes.push({ method: 'POST', matcher, handler });
+        },
+        put(matcher, handler) {
+            routes.push({ method: 'PUT', matcher, handler });
+        },
+        patch(matcher, handler) {
+            routes.push({ method: 'PATCH', matcher, handler });
+        },
+        delete(matcher, handler) {
+            routes.push({ method: 'DELETE', matcher, handler });
+        },
+        options(matcher, handler) {
+            routes.push({ method: 'OPTIONS', matcher, handler });
+        },
+        head(matcher, handler) {
+            routes.push({ method: 'HEAD', matcher, handler });
+        },
+        async handle(request) {
+            const route = routes.find((r) => r.method === request.method && matchPath(r.matcher, request.path));
+            if (!route) {
+                unnbound_logger_sdk_1.logger.warn({ path: request.path, method: request.method }, 'No route match');
+                return { status: 404, body: { message: 'Not Found' } };
+            }
+            try {
+                const response = await route.handler(request);
+                return response;
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                unnbound_logger_sdk_1.logger.error({ err, path: request.path }, 'Handler error');
+                return { status: 500, body: { message: 'Internal Server Error' } };
+            }
+        },
+        async http(options) {
+            const port = options?.port ?? 3000;
+            const server = http.createServer((req, res) => {
+                const method = (req.method || 'GET').toUpperCase();
+                const url = new URL(req.url || '/', 'http://localhost');
+                const path = url.pathname;
+                const query = {};
+                url.searchParams.forEach((value, key) => {
+                    query[key] = value;
+                });
+                const headers = {};
+                for (const [k, v] of Object.entries(req.headers)) {
+                    if (typeof v === 'string')
+                        headers[k] = v;
+                    else if (Array.isArray(v))
+                        headers[k] = v.join(',');
+                }
+                let raw = '';
+                req.setEncoding('utf8');
+                req.on('data', (chunk) => {
+                    raw += String(chunk);
+                });
+                req.on('end', async () => {
+                    let body = undefined;
+                    const contentType = headers['content-type'] || headers['Content-Type'];
+                    if (raw) {
+                        if (contentType && contentType.includes('application/json')) {
+                            try {
+                                body = JSON.parse(raw);
+                            }
+                            catch {
+                                body = raw;
+                            }
+                        }
+                        else {
+                            body = raw;
+                        }
+                    }
+                    const eventReq = {
+                        method,
+                        path,
+                        headers,
+                        query,
+                        body,
+                        metadata: { source: 'http' },
+                    };
+                    const eventRes = await this.handle(eventReq);
+                    res.statusCode = eventRes.status;
+                    if (eventRes.headers) {
+                        for (const [k, v] of Object.entries(eventRes.headers))
+                            res.setHeader(k, v);
+                    }
+                    if (eventRes.body !== undefined) {
+                        const bodyStr = typeof eventRes.body === 'string' ? eventRes.body : JSON.stringify(eventRes.body);
+                        res.end(bodyStr);
+                    }
+                    else {
+                        res.end();
+                    }
+                });
+            });
+            await new Promise((resolve) => server.listen(port, resolve));
+            unnbound_logger_sdk_1.logger.info({ port }, 'HTTP server started');
+            return {
+                close() {
+                    return new Promise((resolve, reject) => {
+                        server.close((err) => {
+                            if (err instanceof Error) {
+                                reject(err);
+                                return;
+                            }
+                            if (typeof err === 'string') {
+                                reject(new Error(err));
+                                return;
+                            }
+                            if (err != null) {
+                                reject(new Error('Server close failed'));
+                                return;
+                            }
+                            resolve();
+                        });
+                    });
+                },
+            };
+        },
+        sqs() {
+            return async (event) => {
+                let successes = 0;
+                const failures = [];
+                await Promise.all(event.Records.map(async (record) => {
+                    try {
+                        const envelope = JSON.parse(record.body);
+                        const req = {
+                            method: envelope.request.method,
+                            path: envelope.request.path,
+                            headers: envelope.request.headers,
+                            query: envelope.request.query,
+                            body: envelope.request.body,
+                            metadata: { source: 'sqs', ...envelope.metadata },
+                        };
+                        const res = await this.handle(req);
+                        if (res.status >= 200 && res.status < 300)
+                            successes += 1;
+                        else
+                            failures.push({
+                                messageId: record.messageId,
+                                reason: `Handler returned status ${res.status}`,
+                            });
+                    }
+                    catch (error) {
+                        const err = error instanceof Error ? error : new Error(String(error));
+                        failures.push({
+                            messageId: record.messageId,
+                            reason: err.message ?? 'Unknown error',
+                        });
+                    }
+                }));
+                return { successes, failures };
+            };
+        },
+        sqsListen(options) {
+            const awsSqs = (() => {
+                try {
+                    return require('@aws-sdk/client-sqs');
+                }
+                catch {
+                    return null;
+                }
+            })();
+            if (!awsSqs) {
+                throw new Error('@aws-sdk/client-sqs is required to use sqsListen');
+            }
+            const env = globalThis
+                .process?.env ?? {};
+            const queueUrl = options?.queueUrl || env.SQS_QUEUE_URL || env.QUEUE_URL;
+            if (!queueUrl || queueUrl === undefined) {
+                throw new Error('SQS queue URL not provided. Set SQS_QUEUE_URL env or pass options.queueUrl');
+            }
+            const region = options?.region || env.AWS_REGION || 'us-east-1';
+            const endpoint = env.AWS_SQS_ENDPOINT || env.AWS_ENDPOINT_URL || undefined;
+            const waitTimeSeconds = options?.waitTimeSeconds ?? 10;
+            const maxMessages = options?.maxMessages ?? 10;
+            const visibilityTimeout = options?.visibilityTimeoutSeconds;
+            const sqs = new awsSqs.SQSClient({ region, endpoint });
+            let stopped = false;
+            const consume = this.sqs();
+            async function loop() {
+                while (!stopped) {
+                    try {
+                        const params = {
+                            QueueUrl: queueUrl,
+                            MaxNumberOfMessages: maxMessages,
+                            WaitTimeSeconds: waitTimeSeconds,
+                            ...(visibilityTimeout && { VisibilityTimeout: visibilityTimeout }),
+                        };
+                        const resp = (await sqs.send(new awsSqs.ReceiveMessageCommand(params)));
+                        const messages = (resp.Messages ?? []).map((m) => ({
+                            id: m.MessageId ?? '',
+                            body: String(m.Body ?? ''),
+                            receiptHandle: String(m.ReceiptHandle ?? ''),
+                        }));
+                        if (messages.length === 0)
+                            continue;
+                        const result = await consume({
+                            Records: messages.map((m) => ({ messageId: m.id, body: m.body })),
+                        });
+                        const failed = new Set(result.failures.map((f) => f.messageId));
+                        const toDelete = messages
+                            .filter((m) => !failed.has(m.id))
+                            .map((m) => ({ Id: m.id, ReceiptHandle: m.receiptHandle }));
+                        for (let i = 0; i < toDelete.length; i += 10) {
+                            const chunk = toDelete.slice(i, i + 10);
+                            if (chunk.length > 0) {
+                                await sqs.send(new awsSqs.DeleteMessageBatchCommand({ QueueUrl: queueUrl, Entries: chunk }));
+                            }
+                        }
+                    }
+                    catch (err) {
+                        unnbound_logger_sdk_1.logger.error({ err }, 'SQS listen loop error');
+                    }
+                }
+            }
+            // Start async loop without awaiting
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            loop();
+            return Promise.resolve({
+                stop() {
+                    stopped = true;
+                    return Promise.resolve();
+                },
+            });
+        },
+        async start(options) {
+            // Default to starting both HTTP and SQS if no options provided
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            const httpOptions = options?.http ?? { port: 3000 };
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            const sqsOptions = options?.sqs ?? {};
+            // Start HTTP server
+            let httpServer;
+            try {
+                httpServer = await this.http(httpOptions);
+            }
+            catch (error) {
+                unnbound_logger_sdk_1.logger.warn({ error }, 'Failed to start HTTP server, continuing without it');
+            }
+            // Start SQS listener
+            let sqsListener;
+            try {
+                sqsListener = await this.sqsListen(sqsOptions);
+            }
+            catch (error) {
+                unnbound_logger_sdk_1.logger.warn({ error }, 'Failed to start SQS listener, continuing without it');
+            }
+            // If neither HTTP nor SQS started successfully, throw an error
+            if (!httpServer && !sqsListener) {
+                throw new Error('Failed to start any transport. Please check your configuration and try again.');
+            }
+            // Set up graceful shutdown
+            const g = globalThis;
+            const shutdown = async () => {
+                unnbound_logger_sdk_1.logger.info('Received shutdown signal, closing servers...');
+                const promises = [];
+                if (httpServer)
+                    promises.push(httpServer.close());
+                if (sqsListener)
+                    promises.push(sqsListener.stop());
+                await Promise.all(promises);
+                unnbound_logger_sdk_1.logger.info('All servers closed');
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                g.process?.exit?.(0);
+            };
+            // Handle SIGINT and SIGTERM
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            g.process?.on?.('SIGINT', shutdown);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            g.process?.on?.('SIGTERM', shutdown);
+            // Log startup information
+            const services = [];
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            if (httpServer)
+                services.push(`HTTP on port ${httpOptions?.port ?? 3000}`);
+            if (sqsListener)
+                services.push('SQS listener');
+            unnbound_logger_sdk_1.logger.info({ services: services.join(' and ') }, 'Services started. Press Ctrl+C to stop.');
+        },
+    };
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,73 @@
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
+export interface EventRequest<Body = unknown, Query = Record<string, unknown>> {
+    method: HttpMethod;
+    path: string;
+    headers: Record<string, string>;
+    query: Query;
+    body: Body;
+    metadata?: Record<string, unknown>;
+}
+export interface EventResponse<Body = unknown> {
+    status: number;
+    headers?: Record<string, string>;
+    body?: Body;
+}
+export type RouteHandler<ReqBody = unknown, ResBody = unknown> = (request: EventRequest<ReqBody>) => Promise<EventResponse<ResBody>> | EventResponse<ResBody>;
+export type RouteMatcher = string | RegExp | ((path: string) => boolean);
+export interface RegisteredRoute {
+    method: HttpMethod;
+    matcher: RouteMatcher;
+    handler: RouteHandler<any, any>;
+}
+export type SqsRecord = {
+    messageId: string;
+    body: string;
+};
+export interface SqsBatchEvent {
+    Records: SqsRecord[];
+}
+export interface StartOptions {
+    http?: {
+        port?: number;
+    };
+    sqs?: {
+        queueUrl?: string;
+        region?: string;
+        waitTimeSeconds?: number;
+        maxMessages?: number;
+        visibilityTimeoutSeconds?: number;
+    };
+}
+export interface EventsClient {
+    on: (method: HttpMethod, matcher: RouteMatcher, handler: RouteHandler<any, any>) => void;
+    handle: (request: EventRequest<any>) => Promise<EventResponse<any>>;
+    get: (matcher: RouteMatcher, handler: RouteHandler<any, any>) => void;
+    post: (matcher: RouteMatcher, handler: RouteHandler<any, any>) => void;
+    put: (matcher: RouteMatcher, handler: RouteHandler<any, any>) => void;
+    patch: (matcher: RouteMatcher, handler: RouteHandler<any, any>) => void;
+    delete: (matcher: RouteMatcher, handler: RouteHandler<any, any>) => void;
+    options: (matcher: RouteMatcher, handler: RouteHandler<any, any>) => void;
+    head: (matcher: RouteMatcher, handler: RouteHandler<any, any>) => void;
+    http: (options?: {
+        port?: number;
+    }) => Promise<{
+        close: () => Promise<void>;
+    }>;
+    sqs: () => (event: SqsBatchEvent) => Promise<{
+        successes: number;
+        failures: Array<{
+            messageId: string;
+            reason: string;
+        }>;
+    }>;
+    sqsListen: (options?: {
+        queueUrl?: string;
+        region?: string;
+        waitTimeSeconds?: number;
+        maxMessages?: number;
+        visibilityTimeoutSeconds?: number;
+    }) => Promise<{
+        stop: () => Promise<void>;
+    }>;
+    start: (options?: StartOptions) => Promise<void>;
+}

package/dist/lib/types.js

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

package/dist/logger/src/axios.d.ts

@@ -1,9 +1,11 @@
-import { Axios } from 'axios';
+import { Axios, type AxiosRequestConfig, type AxiosResponse } from 'axios';
 import { HttpOptions } from './types';
+type GetPayload = (config: AxiosRequestConfig, res?: AxiosResponse) => object;
 /**
  * Wraps an axios instance to add tracing and span tracking
  * @param axios - The axios instance to wrap
  * @param options - Configuration options for HTTP tracing
  * @returns The wrapped axios instance with span tracking
  */
-export declare const traceAxios: (client: Axios, { ignoreTraceRoutes, traceHeaderKey, }?: HttpOptions) => Axios;
+export declare const traceAxios: (client: Axios, { ignoreTraceRoutes, traceHeaderKey, getPayload, }?: HttpOptions<GetPayload>) => Axios;
+export {};

package/dist/logger/src/axios.js

@@ -25,15 +25,17 @@ const buildOutgoingHttpPayload = (config, res) => ({
             : undefined,
     },
 });
+const getNoopPayload = () => ({});
 /**
  * Wraps an axios instance to add tracing and span tracking
  * @param axios - The axios instance to wrap
  * @param options - Configuration options for HTTP tracing
  * @returns The wrapped axios instance with span tracking
  */
-const traceAxios = (client, { ignoreTraceRoutes = types_1.defaultIgnoreTraceRoutes, traceHeaderKey = types_1.defaultTraceHeaderKey, } = {
+const traceAxios = (client, { ignoreTraceRoutes = types_1.defaultIgnoreTraceRoutes, traceHeaderKey = types_1.defaultTraceHeaderKey, getPayload = getNoopPayload, } = {
     ignoreTraceRoutes: types_1.defaultIgnoreTraceRoutes,
     traceHeaderKey: types_1.defaultTraceHeaderKey,
+    getPayload: getNoopPayload,
 }) => {
     const createSpanWrappedRequest = (originalMethod, method) => {
         const { headers: defaultHeaders, ...partialDefaultConfig } = client.defaults;
@@ -50,11 +52,14 @@ const traceAxios = (client, { ignoreTraceRoutes = types_1.defaultIgnoreTraceRout
             config = { ...config, headers: { ...config.headers, [traceHeaderKey]: traceId } };
             // Execute the request within a span
             return (0, span_1.startSpan)(`Outgoing HTTP request`, () => originalMethod(config), (options) => {
-                if (!options)
-                    return buildOutgoingHttpPayload(config);
-                if (options.error)
-                    return buildOutgoingHttpPayload(config, (0, axios_1.isAxiosError)(options.error) ? options.error.response : undefined);
-                return buildOutgoingHttpPayload(config, options.result);
+                const response = options
+                    ? options.error
+                        ? (0, axios_1.isAxiosError)(options.error)
+                            ? options.error.response
+                            : undefined
+                        : options.result
+                    : undefined;
+                return { ...buildOutgoingHttpPayload(config, response), ...getPayload(config, response) };
             });
         };
     };

package/dist/logger/src/middleware.d.ts

@@ -1,3 +1,10 @@
-import { RequestHandler } from 'express';
+import { Request, RequestHandler } from 'express';
 import { HttpOptions } from './types';
-export declare const traceMiddleware: ({ ignoreTraceRoutes, traceHeaderKey, }?: HttpOptions) => RequestHandler;
+interface Response {
+    status: number;
+    headers?: Record<string, string | undefined>;
+    body?: unknown;
+}
+type GetPayload = (config: Request, res?: Response) => object;
+export declare const traceMiddleware: ({ ignoreTraceRoutes, traceHeaderKey, getPayload, }?: HttpOptions<GetPayload>) => RequestHandler;
+export {};

package/dist/logger/src/middleware.js

@@ -19,7 +19,7 @@ const getFullUrl = (req) => {
     const host = req.get('host') || req.get('x-forwarded-host') || 'localhost';
     return `${protocol}://${host}${url}`;
 };
-const buildIncomingHttpPayload = (req, res, body) => ({
+const buildIncomingHttpPayload = (req, res) => ({
     type: 'http',
     http: {
         url: getFullUrl(req),
@@ -32,16 +32,18 @@ const buildIncomingHttpPayload = (req, res, body) => ({
         },
         response: res
             ? {
-                headers: res?.headers,
-                status: res.statusCode,
-                body: (0, utils_1.safeJsonParse)(body),
+                headers: res.headers,
+                status: res.status,
+                body: (0, utils_1.safeJsonParse)(res.body),
             }
             : undefined,
     },
 });
-const traceMiddleware = ({ ignoreTraceRoutes = types_1.defaultIgnoreTraceRoutes, traceHeaderKey = types_1.defaultTraceHeaderKey, } = {
+const getNoopPayload = () => ({});
+const traceMiddleware = ({ ignoreTraceRoutes = types_1.defaultIgnoreTraceRoutes, traceHeaderKey = types_1.defaultTraceHeaderKey, getPayload = getNoopPayload, } = {
     ignoreTraceRoutes: types_1.defaultIgnoreTraceRoutes,
     traceHeaderKey: types_1.defaultTraceHeaderKey,
+    getPayload: getNoopPayload,
 }) => async (req, res, next) => {
     if ((0, utils_1.shouldIgnorePath)(req.path, ignoreTraceRoutes))
         return next();
@@ -60,12 +62,14 @@ const traceMiddleware = ({ ignoreTraceRoutes = types_1.defaultIgnoreTraceRoutes,
                 return next();
             });
         }, (o) => {
-            return buildIncomingHttpPayload(req, o
+            const response = o
                 ? {
-                    statusCode: res.statusCode,
+                    status: res.statusCode,
                     headers: res.getHeaders(),
+                    body: res.locals.body,
                 }
-                : undefined, res.locals.body);
+                : undefined;
+            return { ...buildIncomingHttpPayload(req, response), ...getPayload(req, response) };
         });
     }, { traceId });
 };

package/dist/logger/src/types.d.ts

@@ -53,9 +53,10 @@ export interface SftpPayload {
     content?: string;
     exists?: string | false;
 }
-export interface HttpOptions {
+export interface HttpOptions<G extends Function> {
     ignoreTraceRoutes?: string[];
     traceHeaderKey?: string;
+    getPayload?: G;
 }
 export declare const defaultIgnoreTraceRoutes: string[];
 export declare const defaultTraceHeaderKey = "x-unnbound-trace-id";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unnbound-events",
   "description": "Unified events SDK to handle HTTP routes and SQS messages with a single routing API.",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -32,7 +32,7 @@
   "dependencies": {
     "express": "^4.0.0 || ^5.0.0",
     "@aws-sdk/client-sqs": "^3.0.0",
-    "unnbound-logger-sdk": "workspace:*"
+    "unnbound-logger-sdk": "^3.0.9"
   },
   "peerDependencies": {
     "express": "^4.0.0 || ^5.0.0"