@kleanjs/aws-lambda 0.1.0

package/README.md

@@ -0,0 +1,103 @@
+# @kleanjs/aws-lambda
+
+High-performance adapters for AWS Lambda. This package provides specialized wrappers for API Gateway and SQS, integrating seamlessly with the `@kleanjs/core` middleware engine.
+
+## Key Features
+
+* **Service-Specific Wrappers**: Specialized middlewares for API Gateway (REST/HTTP) and SQS (Parallel or Serial).
+* **Automatic Response Formatting**: Built-in handlers to transform business objects into AWS-compliant responses.
+* **Partial Batch Support**: Native handling of SQS `batchItemFailures` to optimize queue processing and costs.
+* **Type Injection**: Pre-configured infrastructure types (Events, Context, Results) for a zero-boilerplate experience.
+
+## Installation
+
+```bash
+npm install @kleanjs/aws-lambda @kleanjs/core ajv ajv-formats
+```
+
+---
+
+## API Gateway Reference
+
+The `apiGatewayMiddleware` is pre-configured to handle HTTP requests. It automatically injects `APIGatewayProxyEvent` and `APIGatewayProxyResult` types.
+
+### Configuration Extensions
+While it inherits from `HandlerConfig`, it provides sensible defaults:
+- **Default Result**: `APIGatewayProxyResult`.
+- **Default Response**: `responseJSON()` (Content-Type: application/json).
+- **Default Error Handler**: Automatically maps `EventError` properties to the response body and status code.
+
+### Example
+```typescript
+import { apiGatewayMiddleware, responseJSON, Use } from "@kleanjs/aws-lambda";
+
+export const handler = apiGatewayMiddleware(
+  async (event) => {
+    return { id: event.body.id, status: "active" };
+  },
+  {
+    validators: {
+      body: Use<{ id: string }>()
+    },
+    customResponse: responseJSON({ statusCode: 201 })
+  }
+);
+```
+
+---
+
+## SQS Reference
+
+SQS processing is divided into two execution modes. Both modes isolate the logic to a single `SQSRecord`, abstracting the `Records` array iteration.
+
+### 1. Parallel Processing (`sqsMiddlewareParallel`)
+Processes all records in the batch simultaneously using `Promise.allSettled`. This is ideal for high-throughput tasks.
+
+### 2. Serial Processing (`sqsMiddlewareSeries`)
+Processes records one by one. Use this when the processing order is critical or to prevent race conditions.
+
+### Batch Error Handling
+If a record throws an `EventError` or fails validation, the middleware catches it and adds its `messageId` to the `batchItemFailures` array. AWS will then retry only the failed messages.
+
+### Example
+```typescript
+import { sqsMiddlewareParallel, Use } from "@kleanjs/aws-lambda";
+
+export const handler = sqsMiddlewareParallel(
+  async (record) => {
+    // 'record' is a single SQSRecord with typed body
+    await processOrder(record.body.orderId);
+  },
+  {
+    validators: {
+      body: Use<{ orderId: string }>()
+    }
+  }
+);
+```
+
+---
+
+## Technical Interfaces
+
+### `SQSOptions`
+```typescript
+export type SQSOptions<TValidators extends TSchemaMap, TContext = Context> = 
+  Omit<HandlerConfig<any, any, TContext, TValidators>, "customResponse" | "event" | "result" | "context">;
+```
+
+---
+
+## Error Mapping Logic
+
+The adapters catch any `EventError` (including `AJVSimpleError` or `AJVFullError`) and transform them as follows:
+
+### API Gateway Mapping
+- **Status Code**: Taken from `error.statusCode`.
+- **Body**: Standardized JSON with `type`, `message`, and `details`.
+
+### SQS Mapping
+Any error thrown within the record handler marks that specific message as failed. The adapter returns the `batchItemFailures` object required by AWS.
+
+## License
+GPLv3

package/dist/apigateway/index.cjs

@@ -0,0 +1 @@
+"use strict";var T=Object.defineProperty;var n=(e,t)=>T(e,"name",{value:t,configurable:!0});var a=require("@kleanjs/core");const d={"Content-Type":"application/json"},i={"Content-Type":"text/html"},l={"Content-Type":"application/octet-stream"},y={"Content-Type":"text/plain"},f="application/json",_="application/x-www-form-urlencoded",u=n(e=>{if(!e.body)return{};const t=e.headers["content-type"]||e.headers["Content-Type"]||"",r=e.isBase64Encoded?Buffer.from(e.body,"base64").toString("utf8"):e.body;if(t.includes(_))return Object.fromEntries(new URLSearchParams(r));if(t.includes(f))try{return JSON.parse(r)}catch{return r}return r},"getBody"),E=n((e={})=>{const{statusCode:t=200,headers:r,...s}=e,o={...d,...r};return c=>({statusCode:t,headers:o,body:JSON.stringify(c??null),...s})},"responseJSON"),m=n((e={})=>{const{statusCode:t=200,headers:r,...s}=e,o={...i,...r};return c=>({statusCode:t,headers:o,body:c,...s})},"responseHTML"),b=n((e={})=>{const{statusCode:t=200,contentType:r="application/octet-stream",headers:s,...o}=e,c={"Content-Type":r,...s};return p=>({statusCode:t,headers:c,body:p,isBase64Encoded:!0,...o})},"responseMediaFile"),O=n((e={})=>{const{statusCode:t=302,headers:r,...s}=e;return o=>({statusCode:t,headers:{Location:o,...r},body:"",...s})},"responseRedirect"),P=n((e,t={})=>{const r={body:u,...t.transformers};return a.middleware(e,{event:a.Use(),result:a.Use(),context:a.Use(),...t,transformers:r,customResponse:t.customResponse??E()})},"middleware");Object.defineProperty(exports,"AJVError",{enumerable:!0,get:n(function(){return a.AJVError},"get")}),Object.defineProperty(exports,"EventError",{enumerable:!0,get:n(function(){return a.EventError},"get")}),Object.defineProperty(exports,"Use",{enumerable:!0,get:n(function(){return a.Use},"get")}),exports.HEADER_TYPE_HTML=i,exports.HEADER_TYPE_JSON=d,exports.HEADER_TYPE_OCTET=l,exports.HEADER_TYPE_PLAIN=y,exports.getBody=u,exports.middleware=P,exports.responseHTML=m,exports.responseJSON=E,exports.responseMediaFile=b,exports.responseRedirect=O;

package/dist/apigateway/index.d.ts

@@ -0,0 +1,174 @@
+import { C as Context } from '../handler.d-CkaE-Brj.js';
+import { TSchemaMap, TCombinedEvent, HandlerConfig } from '@kleanjs/core';
+export { AJVError, EventError, Use } from '@kleanjs/core';
+import 'node:stream';
+
+// Default authorizer type, prefer using a specific type with the "...WithAuthorizer..." variant types.
+// Note that this doesn't have to be a context from a custom lambda outhorizer, AWS also has a cognito
+// authorizer type and could add more, so the property won't always be a string.
+type APIGatewayEventDefaultAuthorizerContext =
+    | undefined
+    | null
+    | {
+        [name: string]: any;
+    };
+
+// The requestContext property of both request authorizer and proxy integration events.
+interface APIGatewayEventRequestContextWithAuthorizer<TAuthorizerContext> {
+    accountId: string;
+    apiId: string;
+    // This one is a bit confusing: it is not actually present in authorizer calls
+    // and proxy calls without an authorizer. We model this by allowing undefined in the type,
+    // since it ends up the same and avoids breaking users that are testing the property.
+    // This lets us allow parameterizing the authorizer for proxy events that know what authorizer
+    // context values they have.
+    authorizer: TAuthorizerContext;
+    connectedAt?: number | undefined;
+    connectionId?: string | undefined;
+    domainName?: string | undefined;
+    domainPrefix?: string | undefined;
+    eventType?: string | undefined;
+    extendedRequestId?: string | undefined;
+    protocol: string;
+    httpMethod: string;
+    identity: APIGatewayEventIdentity;
+    messageDirection?: string | undefined;
+    messageId?: string | null | undefined;
+    path: string;
+    stage: string;
+    requestId: string;
+    requestTime?: string | undefined;
+    requestTimeEpoch: number;
+    resourceId: string;
+    resourcePath: string;
+    routeKey?: string | undefined;
+}
+
+interface APIGatewayEventClientCertificate {
+    clientCertPem: string;
+    serialNumber: string;
+    subjectDN: string;
+    issuerDN: string;
+    validity: {
+        notAfter: string;
+        notBefore: string;
+    };
+}
+
+interface APIGatewayEventIdentity {
+    accessKey: string | null;
+    accountId: string | null;
+    apiKey: string | null;
+    apiKeyId: string | null;
+    caller: string | null;
+    clientCert: APIGatewayEventClientCertificate | null;
+    cognitoAuthenticationProvider: string | null;
+    cognitoAuthenticationType: string | null;
+    cognitoIdentityId: string | null;
+    cognitoIdentityPoolId: string | null;
+    principalOrgId: string | null;
+    sourceIp: string;
+    user: string | null;
+    userAgent: string | null;
+    userArn: string | null;
+    vpcId?: string | undefined;
+    vpceId?: string | undefined;
+}
+
+/**
+ * Works with Lambda Proxy Integration for Rest API or HTTP API integration Payload Format version 1.0
+ * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+ */
+type APIGatewayProxyEvent = APIGatewayProxyEventBase<APIGatewayEventDefaultAuthorizerContext>;
+
+interface APIGatewayProxyEventHeaders {
+    [name: string]: string | undefined;
+}
+
+interface APIGatewayProxyEventMultiValueHeaders {
+    [name: string]: string[] | undefined;
+}
+
+interface APIGatewayProxyEventPathParameters {
+    [name: string]: string | undefined;
+}
+
+interface APIGatewayProxyEventQueryStringParameters {
+    [name: string]: string | undefined;
+}
+
+interface APIGatewayProxyEventMultiValueQueryStringParameters {
+    [name: string]: string[] | undefined;
+}
+
+interface APIGatewayProxyEventStageVariables {
+    [name: string]: string | undefined;
+}
+
+interface APIGatewayProxyEventBase<TAuthorizerContext> {
+    body: string | null;
+    headers: APIGatewayProxyEventHeaders;
+    multiValueHeaders: APIGatewayProxyEventMultiValueHeaders;
+    httpMethod: string;
+    isBase64Encoded: boolean;
+    path: string;
+    pathParameters: APIGatewayProxyEventPathParameters | null;
+    queryStringParameters: APIGatewayProxyEventQueryStringParameters | null;
+    multiValueQueryStringParameters: APIGatewayProxyEventMultiValueQueryStringParameters | null;
+    stageVariables: APIGatewayProxyEventStageVariables | null;
+    requestContext: APIGatewayEventRequestContextWithAuthorizer<TAuthorizerContext>;
+    resource: string;
+}
+
+/**
+ * Works with Lambda Proxy Integration for Rest API or HTTP API integration Payload Format version 1.0
+ * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+ */
+interface APIGatewayProxyResult {
+    statusCode: number;
+    headers?:
+        | {
+            [header: string]: boolean | number | string;
+        }
+        | undefined;
+    multiValueHeaders?:
+        | {
+            [header: string]: Array<boolean | number | string>;
+        }
+        | undefined;
+    body: string;
+    isBase64Encoded?: boolean | undefined;
+}
+
+declare const HEADER_TYPE_JSON: {
+    "Content-Type": string;
+};
+declare const HEADER_TYPE_HTML: {
+    "Content-Type": string;
+};
+declare const HEADER_TYPE_OCTET: {
+    "Content-Type": string;
+};
+declare const HEADER_TYPE_PLAIN: {
+    "Content-Type": string;
+};
+interface ResponseOptions {
+    statusCode?: number;
+    headers?: Record<string, string | boolean | number>;
+    multiValueHeaders?: Record<string, (string | boolean | number)[]>;
+    isBase64Encoded?: boolean;
+    cookies?: string[];
+}
+declare const getBody: <T = unknown>(event: APIGatewayProxyEvent) => T;
+declare const responseJSON: (options?: ResponseOptions) => (data: any) => APIGatewayProxyResult;
+declare const responseHTML: (options?: ResponseOptions) => (html: string) => APIGatewayProxyResult;
+declare const responseMediaFile: (options?: ResponseOptions & {
+    contentType?: string;
+}) => (base64: string) => APIGatewayProxyResult;
+declare const responseRedirect: (options?: ResponseOptions) => (url: string) => APIGatewayProxyResult;
+
+declare const middleware: <TEvent = APIGatewayProxyEvent, TResult = APIGatewayProxyResult, TContext = Context, TValidators extends TSchemaMap = TSchemaMap>(handler: (event: TCombinedEvent<TEvent, TValidators>, context?: TContext) => any, options?: HandlerConfig<TEvent, TResult, TContext, TValidators>) => (rawEvent: TEvent, context?: TContext | undefined) => Promise<TResult>;
+
+export { HEADER_TYPE_HTML, HEADER_TYPE_JSON, HEADER_TYPE_OCTET, HEADER_TYPE_PLAIN, getBody, middleware, responseHTML, responseJSON, responseMediaFile, responseRedirect };
+export type { ResponseOptions };
+//# sourceMappingURL=index.d.ts.map

package/dist/apigateway/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../../../node_modules/@types/aws-lambda/common/api-gateway.d.ts","../../../../node_modules/@types/aws-lambda/trigger/api-gateway-proxy.d.ts","../../src/apigateway/utils.ts","../../src/apigateway/index.ts"],"mappings":";;;;;AAUA;AACA;AACA;AACO,KAAK,uCAAuC;AACnD;AACA;AACA;AACA;AACA;;AAMA;AACO,UAAU,2CAA2C;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc,uBAAuB;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEO,UAAU,gCAAgC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEO,UAAU,uBAAuB;AACxC;AACA;AACA;AACA;AACA;AACA,gBAAgB,gCAAgC;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACO,KAAK,oBAAoB,GAAG,wBAAwB,CAAC,uCAAuC;;AAuC5F,UAAU,2BAA2B;AAC5C;AACA;;AAEO,UAAU,qCAAqC;AACtD;AACA;;AAEO,UAAU,kCAAkC;AACnD;AACA;;AAEO,UAAU,yCAAyC;AAC1D;AACA;;AAEO,UAAU,mDAAmD;AACpE;AACA;;AAEO,UAAU,kCAAkC;AACnD;AACA;;AAEO,UAAU,wBAAwB;AACzC;AACA,aAAa,2BAA2B;AACxC,uBAAuB,qCAAqC;AAC5D;AACA;AACA;AACA,oBAAoB,kCAAkC;AACtD,2BAA2B,yCAAyC;AACpE,qCAAqC,mDAAmD;AACxF,oBAAoB,kCAAkC;AACtD,oBAAoB,2CAA2C;AAC/D;AACA;;AAEA;AACA;AACA;AACA;AACO,UAAU,qBAAqB;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,KAAK;AACnC;AACA;AACA;AACA;AACA;;ACrKA,cAAa,gBAAgB;;;AAC7B,cAAa,gBAAgB;;;AAC7B,cAAa,iBAAiB;;;AAC9B,cAAa,iBAAiB;;;AAKxB,UAAW,eAAe;;cAEpB,MAAM;wBACI,MAAM;;;;AAK5B,cAAa,OAAO,uBAAwB,oBAAoB;AAuBhE,cAAa,YAAY,aAAa,eAAoB,oBAIpC,qBAMrB;AAED,cAAa,YAAY,aAAa,eAAoB,uBAIjC,qBAMxB;AAED,cAAa,iBAAiB,aAAa,eAAe;;0BAI/B,qBAO1B;AAED,cAAa,gBAAgB,aAAa,eAAoB,sBAGtC,qBAMvB;;AClFD,cAAa,UAAU,YACZ,oBAAoB,YACnB,qBAAqB,aACpB,OAAO,sBACE,UAAU,GAAG,UAAU,mBAE1B,cAAc,6DACtB,aAAa,mGAA6C","names":[]}

package/dist/apigateway/index.mjs

@@ -0,0 +1 @@
+var T=Object.defineProperty;var n=(e,t)=>T(e,"name",{value:t,configurable:!0});import{middleware as l,Use as c}from"@kleanjs/core";import{AJVError as w,EventError as S,Use as x}from"@kleanjs/core";const d={"Content-Type":"application/json"},i={"Content-Type":"text/html"},y={"Content-Type":"application/octet-stream"},m={"Content-Type":"text/plain"},f="application/json",h="application/x-www-form-urlencoded",p=n(e=>{if(!e.body)return{};const t=e.headers["content-type"]||e.headers["Content-Type"]||"",s=e.isBase64Encoded?Buffer.from(e.body,"base64").toString("utf8"):e.body;if(t.includes(h))return Object.fromEntries(new URLSearchParams(s));if(t.includes(f))try{return JSON.parse(s)}catch{return s}return s},"getBody"),u=n((e={})=>{const{statusCode:t=200,headers:s,...r}=e,o={...d,...s};return a=>({statusCode:t,headers:o,body:JSON.stringify(a??null),...r})},"responseJSON"),C=n((e={})=>{const{statusCode:t=200,headers:s,...r}=e,o={...i,...s};return a=>({statusCode:t,headers:o,body:a,...r})},"responseHTML"),_=n((e={})=>{const{statusCode:t=200,contentType:s="application/octet-stream",headers:r,...o}=e,a={"Content-Type":s,...r};return E=>({statusCode:t,headers:a,body:E,isBase64Encoded:!0,...o})},"responseMediaFile"),b=n((e={})=>{const{statusCode:t=302,headers:s,...r}=e;return o=>({statusCode:t,headers:{Location:o,...s},body:"",...r})},"responseRedirect"),N=n((e,t={})=>{const s={body:p,...t.transformers};return l(e,{event:c(),result:c(),context:c(),...t,transformers:s,customResponse:t.customResponse??u()})},"middleware");export{w as AJVError,S as EventError,i as HEADER_TYPE_HTML,d as HEADER_TYPE_JSON,y as HEADER_TYPE_OCTET,m as HEADER_TYPE_PLAIN,x as Use,p as getBody,N as middleware,C as responseHTML,u as responseJSON,_ as responseMediaFile,b as responseRedirect};

package/dist/handler.d-CkaE-Brj.d.ts

@@ -0,0 +1,160 @@
+import { Writable } from 'node:stream';
+
+/**
+ * {@link Handler} context parameter.
+ * See {@link https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html AWS documentation}.
+ */
+interface Context {
+    callbackWaitsForEmptyEventLoop: boolean;
+    functionName: string;
+    functionVersion: string;
+    invokedFunctionArn: string;
+    memoryLimitInMB: string;
+    awsRequestId: string;
+    logGroupName: string;
+    logStreamName: string;
+    identity?: CognitoIdentity | undefined;
+    clientContext?: ClientContext | undefined;
+    tenantId?: string | undefined;
+
+    getRemainingTimeInMillis(): number;
+
+    // Functions for compatibility with earlier Node.js Runtime v0.10.42
+    // No longer documented, so they are deprecated, but they still work
+    // as of the 12.x runtime, so they are not removed from the types.
+
+    /** @deprecated Use handler callback or promise result */
+    done(error?: Error, result?: any): void;
+    /** @deprecated Use handler callback with first argument or reject a promise result */
+    fail(error: Error | string): void;
+    /** @deprecated Use handler callback with second argument or resolve a promise result */
+    succeed(messageOrObject: any): void;
+    // Unclear what behavior this is supposed to have, I couldn't find any still extant reference,
+    // and it behaves like the above, ignoring the object parameter.
+    /** @deprecated Use handler callback or promise result */
+    succeed(message: string, object: any): void;
+}
+
+interface CognitoIdentity {
+    cognitoIdentityId: string;
+    cognitoIdentityPoolId: string;
+}
+
+interface ClientContext {
+    client: ClientContextClient;
+    custom?: any;
+    env: ClientContextEnv;
+}
+
+interface ClientContextClient {
+    installationId: string;
+    appTitle: string;
+    appVersionName: string;
+    appVersionCode: string;
+    appPackageName: string;
+}
+
+interface ClientContextEnv {
+    platformVersion: string;
+    platform: string;
+    make: string;
+    model: string;
+    locale: string;
+}
+
+/**
+ * Interface for using response streaming from AWS Lambda.
+ * To indicate to the runtime that Lambda should stream your function’s responses, you must wrap your function handler with the `awslambda.streamifyResponse()` decorator.
+ *
+ * The `streamifyResponse` decorator accepts the following additional parameter, `responseStream`, besides the default node handler parameters, `event`, and `context`.
+ * The new `responseStream` object provides a stream object that your function can write data to. Data written to this stream is sent immediately to the client. You can optionally set the Content-Type header of the response to pass additional metadata to your client about the contents of the stream.
+ *
+ * {@link https://aws.amazon.com/blogs/compute/introducing-aws-lambda-response-streaming/ AWS blog post}
+ * {@link https://docs.aws.amazon.com/lambda/latest/dg/config-rs-write-functions.html AWS documentation}
+ *
+ * @example <caption>Writing to the response stream</caption>
+ * import 'aws-lambda';
+ *
+ * export const handler = awslambda.streamifyResponse(
+ *   async (event, responseStream, context) => {
+ *       responseStream.setContentType("text/plain");
+ *       responseStream.write("Hello, world!");
+ *       responseStream.end();
+ *   }
+ * );
+ *
+ * @example <caption>Using pipeline</caption>
+ * import 'aws-lambda';
+ * import { Readable } from 'stream';
+ * import { pipeline } from 'stream/promises';
+ * import zlib from 'zlib';
+ *
+ * export const handler = awslambda.streamifyResponse(
+ *   async (event, responseStream, context) => {
+ *     // As an example, convert event to a readable stream.
+ *     const requestStream = Readable.from(Buffer.from(JSON.stringify(event)));
+ *
+ *     await pipeline(requestStream, zlib.createGzip(), responseStream);
+ *   }
+ * );
+ */
+type StreamifyHandler<TEvent = any, TResult = any> = (
+    event: TEvent,
+    responseStream: awslambda.HttpResponseStream,
+    context: Context,
+) => TResult | Promise<TResult>;
+
+declare global {
+    namespace awslambda {
+        class HttpResponseStream extends Writable {
+            static from(
+                writable: Writable,
+                metadata: Record<string, unknown>,
+            ): HttpResponseStream;
+            setContentType: (contentType: string) => void;
+        }
+
+        /**
+         * Decorator for using response streaming from AWS Lambda.
+         * To indicate to the runtime that Lambda should stream your function’s responses, you must wrap your function handler with the `awslambda.streamifyResponse()` decorator.
+         *
+         * The `streamifyResponse` decorator accepts the following additional parameter, `responseStream`, besides the default node handler parameters, `event`, and `context`.
+         * The new `responseStream` object provides a stream object that your function can write data to. Data written to this stream is sent immediately to the client. You can optionally set the Content-Type header of the response to pass additional metadata to your client about the contents of the stream.
+         *
+         * {@link https://aws.amazon.com/blogs/compute/introducing-aws-lambda-response-streaming/ AWS blog post}
+         * {@link https://docs.aws.amazon.com/lambda/latest/dg/config-rs-write-functions.html AWS documentation}
+         *
+         * @example <caption>Writing to the response stream</caption>
+         * import 'aws-lambda';
+         *
+         * export const handler = awslambda.streamifyResponse(
+         *   async (event, responseStream, context) => {
+         *       responseStream.setContentType("text/plain");
+         *       responseStream.write("Hello, world!");
+         *       responseStream.end();
+         *   }
+         * );
+         *
+         * @example <caption>Using pipeline</caption>
+         * import 'aws-lambda';
+         * import { Readable } from 'stream';
+         * import { pipeline } from 'stream/promises';
+         * import zlib from 'zlib';
+         *
+         * export const handler = awslambda.streamifyResponse(
+         *   async (event, responseStream, context) => {
+         *     // As an example, convert event to a readable stream.
+         *     const requestStream = Readable.from(Buffer.from(JSON.stringify(event)));
+         *
+         *     await pipeline(requestStream, zlib.createGzip(), responseStream);
+         *   }
+         * );
+         */
+        function streamifyResponse<TEvent = any, TResult = void>(
+            handler: StreamifyHandler<TEvent, TResult>,
+        ): StreamifyHandler<TEvent, TResult>;
+    }
+}
+
+export type { Context as C };
+//# sourceMappingURL=handler.d-CkaE-Brj.d.ts.map

package/dist/handler.d-CkaE-Brj.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d-CkaE-Brj.d.ts","sources":["../../../node_modules/@types/aws-lambda/handler.d.ts"],"mappings":";;AA2FA;AACA;AACA;AACA;AACO,UAAU,OAAO;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,eAAe;AAC9B,oBAAoB,aAAa;AACjC;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA,iBAAiB,KAAK;AACtB;AACA,gBAAgB,KAAK;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEO,UAAU,eAAe;AAChC;AACA;AACA;;AAEO,UAAU,aAAa;AAC9B,YAAY,mBAAmB;AAC/B;AACA,SAAS,gBAAgB;AACzB;;AAEO,UAAU,mBAAmB;AACpC;AACA;AACA;AACA;AACA;AACA;;AAEO,UAAU,gBAAgB;AACjC;AACA;AACA;AACA;AACA;AACA;;AAwBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,KAAK,gBAAgB;AAC5B;AACA,oBAAoB,SAAS,CAAC,kBAAkB;AAChD,aAAa,OAAO;AACpB,eAAe,OAAO;;AAEtB;AACA;AACA,yCAAyC,QAAQ;AACjD;AACA,0BAA0B,QAAQ;AAClC,0BAA0B,MAAM;AAChC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,gBAAgB;AACrC,WAAW,gBAAgB;AAC3B;AACA;;;;","names":[]}

package/dist/sqs/index.cjs

@@ -0,0 +1 @@
+"use strict";var m=Object.defineProperty;var t=(r,e)=>m(r,"name",{value:e,configurable:!0});var s=require("@kleanjs/core");const f=t(r=>{const e=r.body;if(!e)return{};try{return JSON.parse(e)}catch{return e}},"getBody"),l=t((r,e)=>s.middleware(r,{event:s.Use(),context:s.Use(),...e,transformers:{body:f,...e.transformers},errorHandler:t(n=>{throw n},"errorHandler")}),"createProcessor"),y=t((r,e={})=>{const n=l(r,e);return async(a,c)=>({batchItemFailures:(await Promise.allSettled(a.Records.map(o=>n(o,c)))).map((o,d)=>o.status==="rejected"?{itemIdentifier:a.Records[d].messageId}:null).filter(o=>o!==null)})},"middlewareParallel"),b=t((r,e={})=>{const n=l(r,e);return async(a,c)=>{const i=[];for(const u of a.Records)try{await n(u,c)}catch{i.push({itemIdentifier:u.messageId})}return{batchItemFailures:i}}},"middlewareSeries");Object.defineProperty(exports,"AJVError",{enumerable:!0,get:t(function(){return s.AJVError},"get")}),Object.defineProperty(exports,"EventError",{enumerable:!0,get:t(function(){return s.EventError},"get")}),Object.defineProperty(exports,"Use",{enumerable:!0,get:t(function(){return s.Use},"get")}),exports.middlewareParallel=y,exports.middlewareSeries=b;

package/dist/sqs/index.d.ts

@@ -0,0 +1,64 @@
+import { C as Context } from '../handler.d-CkaE-Brj.js';
+import { TSchemaMap, TCombinedEvent, HandlerConfig } from '@kleanjs/core';
+export { AJVError, EventError, Use } from '@kleanjs/core';
+import 'node:stream';
+
+// SQS
+// https://docs.aws.amazon.com/lambda/latest/dg/invoking-lambda-function.html#supported-event-source-sqs
+interface SQSRecord {
+    messageId: string;
+    receiptHandle: string;
+    body: string;
+    attributes: SQSRecordAttributes;
+    messageAttributes: SQSMessageAttributes;
+    md5OfBody: string;
+    md5OfMessageAttributes?: string;
+    eventSource: string;
+    eventSourceARN: string;
+    awsRegion: string;
+}
+
+interface SQSEvent {
+    Records: SQSRecord[];
+}
+
+interface SQSRecordAttributes {
+    AWSTraceHeader?: string | undefined;
+    ApproximateReceiveCount: string;
+    SentTimestamp: string;
+    SenderId: string;
+    ApproximateFirstReceiveTimestamp: string;
+    SequenceNumber?: string | undefined;
+    MessageGroupId?: string | undefined;
+    MessageDeduplicationId?: string | undefined;
+    DeadLetterQueueSourceArn?: string | undefined; // Undocumented, but used by AWS to support their re-drive functionality in the console
+}
+
+type SQSMessageAttributeDataType = "String" | "Number" | "Binary" | string;
+
+interface SQSMessageAttribute {
+    stringValue?: string | undefined;
+    binaryValue?: string | undefined;
+    stringListValues?: string[] | undefined; // Not implemented. Reserved for future use.
+    binaryListValues?: string[] | undefined; // Not implemented. Reserved for future use.
+    dataType: SQSMessageAttributeDataType;
+}
+
+interface SQSMessageAttributes {
+    [name: string]: SQSMessageAttribute;
+}
+
+// https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html#services-sqs-batchfailurereporting
+interface SQSBatchResponse {
+    batchItemFailures: SQSBatchItemFailure[];
+}
+
+interface SQSBatchItemFailure {
+    itemIdentifier: string;
+}
+
+declare const middlewareParallel: <TEvent = SQSRecord, TContext = Context, TValidators extends TSchemaMap = TSchemaMap>(handler: (record: TCombinedEvent<TEvent, TValidators>, context?: TContext) => any, options?: HandlerConfig<TEvent, any, TContext, TValidators>) => (event: SQSEvent, context?: TContext) => Promise<SQSBatchResponse>;
+declare const middlewareSeries: <TEvent = SQSRecord, TContext = Context, TValidators extends TSchemaMap = TSchemaMap>(handler: (record: TCombinedEvent<TEvent, TValidators>, context?: TContext) => any, options?: HandlerConfig<TEvent, any, TContext, TValidators>) => (event: SQSEvent, context?: TContext) => Promise<SQSBatchResponse>;
+
+export { middlewareParallel, middlewareSeries };
+//# sourceMappingURL=index.d.ts.map

package/dist/sqs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../../../node_modules/@types/aws-lambda/trigger/sqs.d.ts","../../src/sqs/index.ts"],"mappings":";;;;;AAKA;AACA;AACO,UAAU,SAAS;AAC1B;AACA;AACA;AACA,gBAAgB,mBAAmB;AACnC,uBAAuB,oBAAoB;AAC3C;AACA;AACA;AACA;AACA;AACA;;AAEO,UAAU,QAAQ;AACzB,aAAa,SAAS;AACtB;;AAEO,UAAU,mBAAmB;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEO,KAAK,2BAA2B;;AAEhC,UAAU,mBAAmB;AACpC;AACA;AACA;AACA;AACA,cAAc,2BAA2B;AACzC;;AAEO,UAAU,oBAAoB;AACrC,oBAAoB,mBAAmB;AACvC;;AAEA;AACO,UAAU,gBAAgB;AACjC,uBAAuB,mBAAmB;AAC1C;;AAEO,UAAU,mBAAmB;AACpC;AACA;;ACzCA,cAAa,kBAAkB,YACpB,SAAS,aACP,OAAO,sBACE,UAAU,GAAG,UAAU,oBAEzB,cAAc,6DACvB,aAAa,iDAID,QAAQ,yBAAuB,OAAO,CAAC,gBAAgB;AAa9E,cAAa,gBAAgB,YAClB,SAAS,aACP,OAAO,sBACE,UAAU,GAAG,UAAU,oBAEzB,cAAc,6DACvB,aAAa,iDAID,QAAQ,yBAAuB,OAAO,CAAC,gBAAgB","names":[]}

package/dist/sqs/index.mjs

@@ -0,0 +1 @@
+var u=Object.defineProperty;var t=(e,r)=>u(e,"name",{value:r,configurable:!0});import{middleware as f,Use as i}from"@kleanjs/core";import{AJVError as b,EventError as g,Use as x}from"@kleanjs/core";const p=t(e=>{const r=e.body;if(!r)return{};try{return JSON.parse(r)}catch{return r}},"getBody"),l=t((e,r)=>f(e,{event:i(),context:i(),...r,transformers:{body:p,...r.transformers},errorHandler:t(s=>{throw s},"errorHandler")}),"createProcessor"),y=t((e,r={})=>{const s=l(e,r);return async(a,c)=>({batchItemFailures:(await Promise.allSettled(a.Records.map(o=>s(o,c)))).map((o,m)=>o.status==="rejected"?{itemIdentifier:a.Records[m].messageId}:null).filter(o=>o!==null)})},"middlewareParallel"),h=t((e,r={})=>{const s=l(e,r);return async(a,c)=>{const n=[];for(const d of a.Records)try{await s(d,c)}catch{n.push({itemIdentifier:d.messageId})}return{batchItemFailures:n}}},"middlewareSeries");export{b as AJVError,g as EventError,x as Use,y as middlewareParallel,h as middlewareSeries};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@kleanjs/aws-lambda",
+  "version": "0.1.0",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "./apigateway": {
+      "types": "./dist/apigateway/index.d.ts",
+      "import": "./dist/apigateway/index.mjs",
+      "require": "./dist/apigateway/index.cjs"
+    },
+    "./sqs": {
+      "types": "./dist/sqs/index.d.ts",
+      "import": "./dist/sqs/index.mjs",
+      "require": "./dist/sqs/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "pkgroll --minify"
+  },
+  "dependencies": {
+    "@kleanjs/core": "0.4.0"
+  },
+  "devDependencies": {
+    "@types/aws-lambda": "^8.10.159",
+    "pkgroll": "^2.21.4",
+    "typescript": "^5.9.3"
+  }
+}