unnbound-events 1.0.20 → 1.0.21

package/dist/events/src/lib/client.js

@@ -1,260 +1,255 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.createEventsClient = createEventsClient;
-const unnbound_logger_sdk_1 = require("unnbound-logger-sdk");
+const unnbound_logger_sdk_1 = require('unnbound-logger-sdk');
 const http = (() => {
-    try {
-        return (require && require('http'));
-    }
-    catch {
-        return null;
-    }
+  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);
+  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' } };
+  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;
             }
-        },
-        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();
-                    }
-                });
+          }
+          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();
             });
-            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 AWS = (() => {
-                try {
-                    return require('aws-sdk');
-                }
-                catch {
-                    return null;
-                }
-            })();
-            if (!AWS) {
-                throw new Error('aws-sdk 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 AWSLib = AWS;
-            const sqs = new AWSLib.SQS({ region, endpoint });
-            let stopped = false;
-            const consume = this.sqs();
-            async function loop() {
-                while (!stopped) {
-                    try {
-                        const params = {
-                            QueueUrl: queueUrl,
-                            MaxNumberOfMessages: maxMessages,
-                            WaitTimeSeconds: waitTimeSeconds,
-                        };
-                        if (visibilityTimeout)
-                            params.VisibilityTimeout = visibilityTimeout;
-                        const resp = await sqs.receiveMessage(params).promise();
-                        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.deleteMessageBatch({ QueueUrl: queueUrl, Entries: chunk }).promise();
-                            }
-                        }
-                    }
-                    catch (err) {
-                        unnbound_logger_sdk_1.logger.error({ err }, 'SQS listen loop error');
-                    }
-                }
+      };
+    },
+    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',
+              });
             }
-            // Start async loop without awaiting
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            loop();
-            return Promise.resolve({
-                stop() {
-                    stopped = true;
-                    return Promise.resolve();
-                },
+          })
+        );
+        return { successes, failures };
+      };
+    },
+    sqsListen(options) {
+      const AWS = (() => {
+        try {
+          return require('aws-sdk');
+        } catch {
+          return null;
+        }
+      })();
+      if (!AWS) {
+        throw new Error('aws-sdk 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 AWSLib = AWS;
+      const sqs = new AWSLib.SQS({ region, endpoint });
+      let stopped = false;
+      const consume = this.sqs();
+      async function loop() {
+        while (!stopped) {
+          try {
+            const params = {
+              QueueUrl: queueUrl,
+              MaxNumberOfMessages: maxMessages,
+              WaitTimeSeconds: waitTimeSeconds,
+            };
+            if (visibilityTimeout) params.VisibilityTimeout = visibilityTimeout;
+            const resp = await sqs.receiveMessage(params).promise();
+            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.deleteMessageBatch({ QueueUrl: queueUrl, Entries: chunk }).promise();
+              }
+            }
+          } 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();
         },
-    };
+      });
+    },
+  };
 }

package/dist/events/src/lib/types.d.ts

@@ -1,60 +1,60 @@
 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>;
+  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;
+  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 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>;
+  method: HttpMethod;
+  matcher: RouteMatcher;
+  handler: RouteHandler<any, any>;
 }
 export type SqsRecord = {
-    messageId: string;
-    body: string;
+  messageId: string;
+  body: string;
 };
 export interface SqsBatchEvent {
-    Records: SqsRecord[];
+  Records: SqsRecord[];
 }
 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>;
+  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>;
+  }>;
 }

package/dist/events/src/lib/types.js

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