unnbound-events 1.0.19 → 1.0.21

package/LICENSE

@@ -0,0 +1,21 @@
+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/README.md

@@ -132,6 +132,56 @@ API:
 - `use(matcher, middleware)` where matcher is `string | RegExp | (path) => boolean`
 - `middleware(req, next) -> Promise<EventResponse>`
 
+## Enqueue Events
+
+The `enqueue` function allows you to send events to the queue by using the async endpoint.
+
+### Basic Usage
+
+```ts
+import { createEventsClient } from 'unnbound-events-sdk';
+
+const client = createEventsClient();
+
+client.post('/process-job', async (req) => {
+  console.log('Handle job:', req.body);
+
+  // Split job into multiple tasks
+  const tasks = [...];
+
+  tasks.map(async (task) => {
+    await client.enqueue({
+      method: 'POST',
+      path: '/process-task',
+      body: { jobId: '123', data: 'important data' }
+    });
+  });
+
+  return { status: 200, body: { processed: true } };
+});
+
+client.post('/process-task', async (req) => {
+  console.log('Handle task:', req.body);
+
+  return { status: 200, body: { processed: true } };
+});
+
+await client.start();
+```
+
+### Scheduled Jobs
+
+```ts
+// Trigger scheduled processing
+setInterval(async () => {
+  await client.enqueue({
+    method: 'POST',
+    path: '/cleanup',
+    body: { timestamp: Date.now() },
+  });
+}, 60000); // Every minute
+```
+
 ## Message envelope
 
 The SQS record `body` should be a JSON string matching this shape:
@@ -288,14 +338,3 @@ For S3 payload support, configure:
 export UNNBOUND_S3_PAYLOAD_BUCKET="my-payload-bucket"
 export AWS_REGION="us-west-2"
 ```
-
-### AWS Credentials
-
-When running in ECS with a Task Role, no additional credentials are needed. The AWS SDK will automatically use the ECS Task Role credentials.
-
-For local development or other environments, set:
-
-```bash
-export AWS_ACCESS_KEY_ID="your-access-key"
-export AWS_SECRET_ACCESS_KEY="your-secret-key"
-```

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

@@ -1,4 +1,12 @@
 export { createEventsClient } from './lib/client';
-export type { EventsClient, EventRequest, EventResponse, RouteHandler, RouteMatcher, RegisteredRoute, SqsBatchEvent, StartOptions, } from './lib/types';
+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,9 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+'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; } });
+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,16 +1,18 @@
 type Request = {
-    method: string;
-    path: string;
-    headers: Record<string, string | string[] | undefined>;
-    query: Record<string, unknown>;
-    body: unknown;
+  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;
+  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 declare function createExpressMiddleware(
+  client: EventsClient
+): (req: Request, res: Response) => Promise<void>;
 export {};

package/dist/events/src/lib/adapters/express.js

@@ -1,38 +1,34 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+'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' },
-    };
+  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();
+  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);
-    };
+  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 +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>;
+  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;
+  messageId: string;
+  body: string;
 };
 export interface SqsBatchEvent {
-    Records: SqsRecord[];
+  Records: SqsRecord[];
 }
 export declare function createSqsConsumer(client: EventsClient): (event: SqsBatchEvent) => Promise<{
-    successes: number;
-    failures: Array<{
-        messageId: string;
-        reason: string;
-    }>;
+  successes: number;
+  failures: Array<{
+    messageId: string;
+    reason: string;
+  }>;
 }>;

package/dist/events/src/lib/adapters/sqs.js

@@ -1,42 +1,42 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+'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 };
-    };
+  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 };
+  };
 }