unnbound-events 2.0.14 → 2.0.16

package/dist/lib/routing/endpoint.js

@@ -21,6 +21,8 @@ exports.parseEndpointArguments = parseEndpointArguments;
 const patchEndpoint = (handler) => {
     return async (context) => {
         const state = context.get('state');
+        // We have to recalculate the params because the handler path might contain url params
+        state.request.params = { ...state.request.params, ...context.req.param() };
         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 };

package/dist/lib/routing/middleware.js

@@ -2,7 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildMiddlewareArguments = exports.parseMiddlewareArguments = exports.patchMiddleware = void 0;
 const patchMiddleware = (handler) => {
-    return (context, next) => handler(context.get('state'), next);
+    return (context, next) => {
+        const state = context.get('state');
+        // We have to recalculate the params because middleware path might contain url params
+        state.request.params = { ...state.request.params, ...context.req.param() };
+        return handler(state, next);
+    };
 };
 exports.patchMiddleware = patchMiddleware;
 const parseMiddlewareArguments = (...args) => {

package/package.json

@@ -1,9 +1,23 @@
 {
   "name": "unnbound-events",
   "description": "Unified events SDK to handle HTTP routes and queued messages with a single routing API.",
-  "version": "2.0.14",
+  "version": "2.0.16",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:coverage": "jest --coverage",
+    "test:watch": "jest --watch",
+    "typecheck": "tsc -noEmit",
+    "lint": "eslint --cache --cache-location ./node_modules/.cache/eslint .",
+    "lint:fix": "pnpm lint --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "prepublishOnly": "pnpm build",
+    "start:example": "npx --yes tsx --watch examples/node-server.ts",
+    "version:bump": "npm version patch"
+  },
   "author": "Unnbound Team",
   "license": "MIT",
   "repository": {
@@ -20,7 +34,7 @@
     "@hono/node-server": "^1.19.6",
     "axios": "^1.12.2",
     "hono": "^4.10.4",
-    "unnbound-logger-sdk": "3.0.25"
+    "unnbound-logger-sdk": "workspace:*"
   },
   "devDependencies": {
     "@types/jest": "^29.5.12",
@@ -34,18 +48,5 @@
   "engines": {
     "node": ">=22"
   },
-  "sideEffects": false,
-  "scripts": {
-    "build": "tsc",
-    "test": "jest",
-    "test:coverage": "jest --coverage",
-    "test:watch": "jest --watch",
-    "typecheck": "tsc -noEmit",
-    "lint": "eslint --cache --cache-location ./node_modules/.cache/eslint .",
-    "lint:fix": "pnpm lint --fix",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "start:example": "npx --yes tsx --watch examples/node-server.ts",
-    "version:bump": "npm version patch"
-  }
-}
+  "sideEffects": false
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Unnbound Team
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE. 

package/dist/events/src/index.d.ts

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

package/dist/events/src/index.js

@@ -1,24 +0,0 @@
-'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/events/src/lib/adapters/express.d.ts

@@ -1,18 +0,0 @@
-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/events/src/lib/adapters/express.js

@@ -1,34 +0,0 @@
-'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/events/src/lib/adapters/sqs.d.ts

@@ -1,36 +0,0 @@
-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/events/src/lib/adapters/sqs.js

@@ -1,42 +0,0 @@
-'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/events/src/lib/client.d.ts

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

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

@@ -1,255 +0,0 @@
-'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 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 +0,0 @@
-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 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>;
-  }>;
-}

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

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

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

@@ -1,40 +0,0 @@
-import { UnnboundLogger } from 'unnbound-logger-sdk';
-import { EventHandlerResult, EventMetadata, EventSource, IncomingEvent, IncomingRequest } from '../types';
-export type EventHandler = (event: IncomingEvent) => Promise<EventHandlerResult>;
-export interface EventAdapterOptions {
-    logger?: UnnboundLogger;
-    source: EventSource;
-    handler: EventHandler;
-}
-export declare abstract class EventAdapter<E> {
-    protected readonly logger: UnnboundLogger;
-    protected readonly source: EventSource;
-    private readonly handler;
-    protected constructor(options: EventAdapterOptions);
-    protected abstract parseEvent(event: E): IncomingEvent;
-    abstract listen(): () => Promise<void>;
-    protected getMetadataFromRequest(request: IncomingRequest): EventMetadata;
-    protected normalizeHeaders(headers: Record<string, string | string[]>): Record<string, string>;
-    protected handle(event: IncomingEvent): Promise<EventHandlerResult>;
-    protected buildIncomingPayload(req: IncomingRequest, res?: EventHandlerResult): {
-        type: string;
-        source: EventSource;
-        http: {
-            url: string;
-            method: string;
-            query: Record<string, any>;
-            ip: string | undefined;
-            incoming: boolean;
-            request: {
-                headers: Record<string, string>;
-                body: any;
-            };
-            response: {
-                status: import("hono/utils/http-status").StatusCode;
-                headers: Record<string, string> | undefined;
-                body: any;
-            } | undefined;
-        };
-    };
-    protected handleError(error: unknown): EventHandlerResult;
-}