unnbound-events 2.0.15 → 2.0.17

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.15",
+  "version": "2.0.17",
   "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.26"
+    "unnbound-logger-sdk": "3.0.34"
   },
   "devDependencies": {
     "@types/jest": "^29.5.12",

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;
-}

package/dist/lib/adapters/adapter.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventAdapter = void 0;
-const unnbound_logger_sdk_1 = require("unnbound-logger-sdk");
-const trace_1 = require("unnbound-logger-sdk/dist/trace");
-const types_1 = require("unnbound-logger-sdk/dist/types");
-const utils_1 = require("unnbound-logger-sdk/dist/utils");
-const error_1 = require("../error");
-class EventAdapter {
-    logger;
-    source;
-    handler;
-    constructor(options) {
-        this.logger = options.logger ?? unnbound_logger_sdk_1.logger;
-        this.source = options.source;
-        this.handler = options.handler;
-    }
-    getMetadataFromRequest(request) {
-        return {
-            traceId: request.headers[types_1.defaultTraceHeaderKey] ?? unnbound_logger_sdk_1.getTraceId,
-            messageId: request.headers[types_1.defaultMessageHeaderKey] ?? (0, trace_1.getMessageId)(),
-            source: this.source,
-        };
-    }
-    normalizeHeaders(headers) {
-        return Object.fromEntries(Object.entries(headers).map(([key, value]) => [
-            key,
-            Array.isArray(value) ? value.join(',') : (value?.toString() ?? ''),
-        ]));
-    }
-    async handle(event) {
-        return await (0, trace_1.withTrace)(() => this.handler(event), event.metadata);
-    }
-    buildIncomingPayload(req, res) {
-        return {
-            type: 'http',
-            source: this.source,
-            http: {
-                url: req.url,
-                method: req.method.toLowerCase(),
-                query: req.query,
-                ip: (0, utils_1.normalizeIp)(req.headers['cf-connecting-ip'] ??
-                    req.headers['x-forwarded-for'] ??
-                    req.headers['x-real-ip']),
-                incoming: true,
-                request: {
-                    headers: req.headers,
-                    body: (0, utils_1.safeJsonParse)(req.body),
-                },
-                response: res
-                    ? {
-                        status: res.status ?? 204,
-                        headers: res.headers ? this.normalizeHeaders(res.headers) : undefined,
-                        body: res.body ? (0, utils_1.safeJsonParse)(res.body) : undefined,
-                    }
-                    : undefined,
-            },
-        };
-    }
-    handleError(error) {
-        if (error instanceof error_1.HandlerError) {
-            return {
-                status: error.status,
-                body: error.toJson(),
-            };
-        }
-        return this.handleError(new error_1.HandlerError({ message: 'Internal server error', status: 500, cause: error }));
-    }
-}
-exports.EventAdapter = EventAdapter;

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

@@ -1,17 +0,0 @@
-import type { EventsClient } from '../types';
-type Request = {
-    url: string;
-    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;
-};
-export declare function createExpressMiddleware(client: EventsClient): (req: Request, res: Response) => Promise<void>;
-export {};

package/dist/lib/adapters/express.js

@@ -1,39 +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 {
-        url: req.url,
-        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);
-    };
-}