@vyriy/handler 0.2.1 → 0.3.2

package/README.md

@@ -22,6 +22,14 @@ With Yarn:
 yarn add @vyriy/handler
 ```
 
+For TypeScript Lambda projects, install AWS Lambda types as a development dependency:
+
+```bash
+yarn add @types/aws-lambda
+```
+
+The `awslambda` response streaming helper is a global provided by the AWS Lambda Node.js runtime. It is not imported from `aws-lambda`; `@types/aws-lambda` only lets TypeScript type-check that global.
+
 ## Usage
 
 Use a prebuilt API Gateway handler chain:
@@ -37,6 +45,59 @@ export const handler = api(async (event) => ({
 }));
 ```
 
+For Lambda response streaming, use the separate stream chain:
+
+```ts
+// handler.ts
+import { streamApi } from '@vyriy/handler';
+
+export const handler = streamApi(async (event, responseStream) => {
+  responseStream.setContentType?.('text/plain');
+  responseStream.write(`Request path: ${event.path}\n`);
+  responseStream.write('Part 1 of the response...');
+  responseStream.end('Part 2 of the response...');
+});
+```
+
+`streamApi(...)` handlers receive `(event, responseStream, context)` and write directly to the response stream.
+
+Use the same handler locally, in Docker, or in a Fargate-style HTTP runtime:
+
+```ts
+// server.ts
+import { streamServer } from '@vyriy/server';
+
+import { handler } from './handler.js';
+
+streamServer(handler);
+```
+
+Use the same handler in AWS Lambda response streaming:
+
+```ts
+// lambda.ts
+import { handler } from './handler.js';
+
+export const main = awslambda.streamifyResponse(handler);
+```
+
+That `handler.ts` shape already matches Lambda response streaming. For a standard non-streaming Lambda, export an `api(...)` handler directly without `responseStream`.
+
+You can also inline the same shape in one file when a separate local entrypoint is not needed:
+
+```ts
+import { streamApi } from '@vyriy/handler';
+
+export const main = awslambda.streamifyResponse(
+  streamApi(async (event, responseStream) => {
+    responseStream.setContentType?.('text/plain');
+    responseStream.write(`Request path: ${event.path}\n`);
+    responseStream.write('Part 1 of the response...');
+    responseStream.end('Part 2 of the response...');
+  }),
+);
+```
+
 Use a prebuilt queue or event handler chain:
 
 ```ts
@@ -74,15 +135,14 @@ export const handler = schedule(async (event) => {
 Compose a custom handler pipeline from individual helpers:
 
 ```ts
-import { compose, withChaos, withContext, withError, withLogger, withSmoke, withTimeout } from '@vyriy/handler';
+import { compose, withChaos, withContext, withError, withLogger, withTimeout } from '@vyriy/handler';
 
 export const handler = compose(
-  withError({ throwError: true }),
+  withError(),
   withLogger(),
   withChaos(),
   withTimeout(),
   withContext(),
-  withSmoke(),
 )(async (event) => {
   return {
     ok: true,
@@ -112,7 +172,7 @@ const withRequestId = factory<{ headerName?: string }>(async (handler, args, opt
 });
 
 export const handler = compose(
-  withError({ throwError: true }),
+  withError(),
   withLogger(),
   withTimeout(),
   withRequestId({
@@ -130,6 +190,8 @@ export const handler = compose(
 
 - `api`
   API Gateway chain with error handling, logging, timeout handling, context setup, smoke checks, healthcheck handling, default headers, and CORS preflight handling.
+- `streamApi`
+  Response streaming API Gateway chain with the same wrapper behavior as `api`. Handlers receive `(event, responseStream, context)` and write directly to the Lambda response stream.
 
 - `schedule`
   EventBridge schedule chain with logging, timeout handling, context setup, smoke checks, and rethrown errors.
@@ -144,22 +206,18 @@ export const handler = compose(
 
 ### `withError(options?)`
 
-Catches handler failures, optionally runs an async error handler, and rethrows only when `throwError` is enabled.
+Catches handler failures, optionally runs a side-effect `errorHandler`, and rethrows the original error.
 
 Options:
 
 ```ts
 {
-  errorHandler?: (error: unknown) => Promise<void>;
-  throwError?: boolean;
+  errorHandler?: (error: unknown, args: HandlerParams<Event>) => Promise<void> | void;
 }
 ```
 
 - `errorHandler`
-  Async callback invoked with the caught error.
-
-- `throwError`
-  Re-throws the original error after `errorHandler` runs. Defaults to `false`.
+  Callback invoked with the caught error and handler arguments before the original error is rethrown.
 
 Example:
 
@@ -170,12 +228,15 @@ export const handler = withError({
   errorHandler: async (error) => {
     console.error('Handler failed:', error);
   },
-  throwError: true,
 })(async () => {
   throw new Error('boom');
 });
 ```
 
+### `withApiError(options?)`
+
+Catches API handler failures and converts them to an API Gateway result. Without a custom `errorHandler`, it returns a JSON `500`.
+
 ### `withLogger(options?)`
 
 Logs the incoming event and context, then logs either the result or the thrown error.
@@ -286,7 +347,7 @@ export const handler = withChaos({
 
 ### `withSmoke()`
 
-Returns the smoke response when the incoming event matches the smoke request payload.
+Returns the smoke response when the incoming event has `isSmoke: true`.
 
 Example:
 
@@ -303,16 +364,18 @@ export const handler = withSmoke()(async () => {
 });
 ```
 
+`withSmoke()` is used by the API, schedule, SNS, and SQS chains.
+
 ## Types
 
 The package also exports shared handler types:
 
 ```ts
-import type { Context, Decorator, Handler, Response } from '@vyriy/handler';
+import type { Context, Decorator, Handler, HandlerParams, Response } from '@vyriy/handler';
 ```
 
 ## Notes
 
 - `api` includes API-specific wrappers such as healthcheck handling, default headers, and CORS preflight handling
-- `schedule`, `sns`, and `sqs` enable `throwError: true` in `withError(...)`
-- `withSmoke()` delegates matching to `@vyriy/smoke`
+- `schedule`, `sns`, and `sqs` use `withError()` so failures are rethrown for event-source retry behavior
+- `withSmoke()` delegates matching to `@vyriy/smoke` and returns its API Gateway-compatible response

package/api.d.ts

@@ -1,2 +1,2 @@
-import type { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
-export declare const api: import("./types.js").Decorator<APIGatewayProxyEvent, APIGatewayProxyResult>;
+export declare const api: import("./types.js").Decorator<import("aws-lambda").APIGatewayProxyEvent, import("aws-lambda").APIGatewayProxyResult>;
+export declare const streamApi: import("./types.js").StreamDecorator<import("aws-lambda").APIGatewayProxyEvent>;

package/api.js

@@ -1,17 +1,24 @@
-import { compose } from './compose.js';
-import { withError } from './wrapper/error.js';
-import { withLogger } from './wrapper/logger.js';
-import { withTimeout } from './wrapper/timeout.js';
-import { withContext } from './wrapper/context.js';
-import { withSmoke } from './wrapper/smoke.js';
-import { withHealthcheck } from './wrapper/healthcheck.js';
-import { withHeaders } from './wrapper/headers.js';
-import { withCors } from './wrapper/cors.js';
-import { withChaos } from './wrapper/chaos.js';
-export const api = compose(withError(), withLogger(), withTimeout(), withContext(), withSmoke(), withHealthcheck(), withHeaders({
+import { compose, streamCompose } from './compose.js';
+import { streamWithApiError, withApiError } from './wrapper/error.js';
+import { streamWithLogger, withLogger } from './wrapper/logger.js';
+import { streamWithTimeout, withTimeout } from './wrapper/timeout.js';
+import { streamWithContext, withContext } from './wrapper/context.js';
+import { streamWithSmoke, withSmoke } from './wrapper/smoke.js';
+import { streamWithHealthcheck, withHealthcheck } from './wrapper/healthcheck.js';
+import { streamWithHeaders, withHeaders } from './wrapper/headers.js';
+import { streamWithCors, withCors } from './wrapper/cors.js';
+import { streamWithChaos, withChaos } from './wrapper/chaos.js';
+export const api = compose(withApiError(), withLogger(), withTimeout(), withContext(), withSmoke(), withHealthcheck(), withHeaders({
     'Access-Control-Allow-Origin': '*',
     'Access-Control-Allow-Methods': 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
     'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-Requested-With, X-Api-Key, Accept, User-Agent, X-CSRF-Token',
     'Content-Type': 'application/json',
     'X-Robots-Tag': 'noindex, nofollow',
 }), withCors(), withChaos());
+export const streamApi = streamCompose(streamWithApiError(), streamWithLogger(), streamWithTimeout(), streamWithContext(), streamWithSmoke(), streamWithHealthcheck(), streamWithHeaders({
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-Requested-With, X-Api-Key, Accept, User-Agent, X-CSRF-Token',
+    'Content-Type': 'application/json',
+    'X-Robots-Tag': 'noindex, nofollow',
+}), streamWithCors(), streamWithChaos());

package/compose.d.ts

@@ -1,2 +1,3 @@
-import type { Compose } from './types.js';
+import type { Compose, StreamCompose } from './types.js';
 export declare const compose: Compose;
+export declare const streamCompose: StreamCompose;

package/compose.js

@@ -1 +1,2 @@
 export const compose = (...fns) => fns.reduceRight((prevDecorator, nextDecorator) => (handler) => nextDecorator(prevDecorator(handler)));
+export const streamCompose = (...fns) => fns.reduceRight((prevDecorator, nextDecorator) => (handler) => nextDecorator(prevDecorator(handler)));

package/factory.d.ts

@@ -1,2 +1,7 @@
-import type { Factory } from './types.js';
+import type { Context } from 'aws-lambda';
+import type { Factory, HandlerParams, ResponseStream, StreamFactory, StreamHandlerParams } from './types.js';
+export declare const getContext: <Event>(args: HandlerParams<Event>) => Context;
+export declare const getResponseStream: <Event>(args: StreamHandlerParams<Event>) => ResponseStream;
+export declare const getStreamContext: <Event>(args: StreamHandlerParams<Event>) => Context;
 export declare const factory: Factory;
+export declare const streamFactory: StreamFactory;

package/factory.js

@@ -1,2 +1,5 @@
-const createFactory = (wrapper) => (options) => (handler) => async (event, context) => wrapper(handler, [event, context], options);
-export const factory = createFactory;
+export const getContext = (args) => args[1];
+export const getResponseStream = (args) => args[1];
+export const getStreamContext = (args) => args[2];
+export const factory = (wrapper) => (options) => (handler) => async (event, context) => wrapper(handler, [event, context], options);
+export const streamFactory = (wrapper) => (options) => (handler) => async (event, responseStream, context) => wrapper(handler, [event, responseStream, context], options);

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@vyriy/handler",
-  "version": "0.2.1",
+  "version": "0.3.2",
   "description": "Composable AWS Lambda handler chains and wrappers for Vyriy projects",
   "type": "module",
   "main": "./index.js",
   "dependencies": {
     "@types/aws-lambda": "^8.10.161",
-    "@vyriy/chaos": "0.2.1",
-    "@vyriy/config": "0.2.1",
-    "@vyriy/logger": "0.2.1",
-    "@vyriy/smoke": "0.2.1",
-    "@vyriy/timeout": "0.2.1"
+    "@vyriy/chaos": "0.3.2",
+    "@vyriy/config": "0.3.2",
+    "@vyriy/logger": "0.3.2",
+    "@vyriy/smoke": "0.3.2",
+    "@vyriy/timeout": "0.3.2"
   },
   "agents": "./AGENTS.md",
   "license": "MIT",
@@ -176,6 +176,16 @@
       "import": "./wrapper/smoke.js",
       "default": "./wrapper/smoke.js"
     },
+    "./wrapper/stream": {
+      "types": "./wrapper/stream.d.ts",
+      "import": "./wrapper/stream.js",
+      "default": "./wrapper/stream.js"
+    },
+    "./wrapper/stream.js": {
+      "types": "./wrapper/stream.d.ts",
+      "import": "./wrapper/stream.js",
+      "default": "./wrapper/stream.js"
+    },
     "./wrapper/timeout": {
       "types": "./wrapper/timeout.d.ts",
       "import": "./wrapper/timeout.js",

package/schedule.js

@@ -4,4 +4,4 @@ import { withLogger } from './wrapper/logger.js';
 import { withTimeout } from './wrapper/timeout.js';
 import { withContext } from './wrapper/context.js';
 import { withSmoke } from './wrapper/smoke.js';
-export const schedule = compose(withError({ throwError: true }), withLogger(), withTimeout(), withContext(), withSmoke());
+export const schedule = compose(withError(), withLogger(), withTimeout(), withContext(), withSmoke());

package/sns.js

@@ -4,4 +4,4 @@ import { withLogger } from './wrapper/logger.js';
 import { withTimeout } from './wrapper/timeout.js';
 import { withContext } from './wrapper/context.js';
 import { withSmoke } from './wrapper/smoke.js';
-export const sns = compose(withError({ throwError: true }), withLogger(), withTimeout(), withContext(), withSmoke());
+export const sns = compose(withError(), withLogger(), withTimeout(), withContext(), withSmoke());

package/sqs.js

@@ -4,4 +4,4 @@ import { withLogger } from './wrapper/logger.js';
 import { withTimeout } from './wrapper/timeout.js';
 import { withContext } from './wrapper/context.js';
 import { withSmoke } from './wrapper/smoke.js';
-export const sqs = compose(withError({ throwError: true }), withLogger(), withTimeout(), withContext(), withSmoke());
+export const sqs = compose(withError(), withLogger(), withTimeout(), withContext(), withSmoke());

package/types.d.ts

@@ -1,12 +1,34 @@
-import type { Context } from 'aws-lambda';
+import type { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
 export type { Context } from 'aws-lambda';
+export type ResponseStream = {
+    end: {
+        (): unknown;
+        (chunk: string | Buffer | Uint8Array): unknown;
+    };
+    setContentType?: (contentType: string) => unknown;
+    writableEnded?: boolean;
+    write(chunk: string | Buffer | Uint8Array): unknown;
+};
+export type ApiResult = APIGatewayProxyResult;
+export type ApiEvent = APIGatewayProxyEvent;
+export type HandlerParams<Event> = [event: Event, context: Context];
+export type StreamHandlerParams<Event> = [event: Event, responseStream: ResponseStream, context: Context];
 export type Response<Result> = Promise<Result>;
 export type Handler<Event, Result> = (event: Event, context: Context) => Response<Result>;
+export type StreamHandler<Event> = (event: Event, responseStream: ResponseStream, context: Context) => Response<void>;
 export type Decorator<Event, Result> = (handler: Handler<Event, Result>) => Handler<Event, Result>;
+export type StreamDecorator<Event> = (handler: StreamHandler<Event>) => StreamHandler<Event>;
 export type Compose = <Event, Result>(...decorators: Array<Decorator<Event, Result>>) => Decorator<Event, Result>;
-export type Wrapper<Options> = <Event, Result>(handler: Handler<Event, Result>, args: [event: Event, context: Context], options?: Options) => Response<Result>;
-export type TypedWrapper<Event, Result, Options> = (handler: Handler<Event, Result>, args: [event: Event, context: Context], options?: Options) => Response<Result>;
+export type StreamCompose = <Event>(...decorators: Array<StreamDecorator<Event>>) => StreamDecorator<Event>;
+export type Wrapper<Options> = <Event, Result>(handler: Handler<Event, Result>, args: HandlerParams<Event>, options?: Options) => Response<Result>;
+export type StreamWrapper<Options> = <Event>(handler: StreamHandler<Event>, args: StreamHandlerParams<Event>, options?: Options) => Response<void>;
+export type TypedWrapper<Event, Result, Options> = (handler: Handler<Event, Result>, args: HandlerParams<Event>, options?: Options) => Response<Result>;
+export type StreamTypedWrapper<Event, Options> = (handler: StreamHandler<Event>, args: StreamHandlerParams<Event>, options?: Options) => Response<void>;
 export type Factory = {
     <Options = undefined>(wrapper: Wrapper<Options>): <Event, Result>(options?: Options) => Decorator<Event, Result>;
     <Options, Event, Result>(wrapper: TypedWrapper<Event, Result, Options>): (options?: Options) => Decorator<Event, Result>;
 };
+export type StreamFactory = {
+    <Options = undefined>(wrapper: StreamWrapper<Options>): <Event>(options?: Options) => StreamDecorator<Event>;
+    <Options, Event>(wrapper: StreamTypedWrapper<Event, Options>): (options?: Options) => StreamDecorator<Event>;
+};

package/wrapper/chaos.d.ts

@@ -1,2 +1,3 @@
 import { type ChaosOptions } from '@vyriy/chaos';
 export declare const withChaos: <Event, Result>(options?: ChaosOptions | undefined) => import("../types.js").Decorator<Event, Result>;
+export declare const streamWithChaos: <Event>(options?: ChaosOptions | undefined) => import("../types.js").StreamDecorator<Event>;

package/wrapper/chaos.js

@@ -1,6 +1,6 @@
 import { chaos } from '@vyriy/chaos';
 import { getConfig } from '@vyriy/config';
-import { factory } from '../factory.js';
+import { factory, streamFactory } from '../factory.js';
 const getChaosEnabled = () => getConfig('CHAOS_ENABLED', false, 'boolean');
 const getChaosErrorEnabled = () => getConfig('CHAOS_ERROR_ENABLED', true, 'boolean');
 const getChaosTimeoutEnabled = () => getConfig('CHAOS_TIMEOUT_ENABLED', true, 'boolean');
@@ -33,3 +33,14 @@ export const withChaos = factory(async (handler, args, options = {}) => {
     });
     return handler(...args);
 });
+export const streamWithChaos = streamFactory(async (handler, args, options = {}) => {
+    const enabled = options.enabled ?? getChaosEnabled();
+    const strategy = getStrategy(options);
+    await chaos({
+        ...options,
+        enabled: enabled && (strategy !== 'random' || getChaosErrorEnabled() || getChaosTimeoutEnabled()),
+        strategy,
+        timeoutMs: options.timeoutMs ?? getChaosTimeoutMs(),
+    });
+    return handler(...args);
+});

package/wrapper/context.d.ts

@@ -1 +1,2 @@
 export declare const withContext: <Event, Result>(options?: undefined) => import("../types.js").Decorator<Event, Result>;
+export declare const streamWithContext: <Event>(options?: undefined) => import("../types.js").StreamDecorator<Event>;

package/wrapper/context.js

@@ -1,6 +1,11 @@
-import { factory } from '../factory.js';
+import { factory, getContext, getStreamContext, streamFactory } from '../factory.js';
 export const withContext = factory(async (handler, args) => {
-    const [, ctx] = args;
+    const ctx = getContext(args);
+    ctx.callbackWaitsForEmptyEventLoop = false;
+    return handler(...args);
+});
+export const streamWithContext = streamFactory(async (handler, args) => {
+    const ctx = getStreamContext(args);
     ctx.callbackWaitsForEmptyEventLoop = false;
     return handler(...args);
 });

package/wrapper/cors.d.ts

@@ -1,2 +1,2 @@
-import type { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
-export declare const withCors: (options?: undefined) => import("../types.js").Decorator<APIGatewayProxyEvent, APIGatewayProxyResult>;
+export declare const withCors: (options?: unknown) => import("../types.js").Decorator<import("aws-lambda").APIGatewayProxyEvent, import("aws-lambda").APIGatewayProxyResult>;
+export declare const streamWithCors: (options?: unknown) => import("../types.js").StreamDecorator<import("aws-lambda").APIGatewayProxyEvent>;

package/wrapper/cors.js

@@ -1,4 +1,5 @@
-import { factory } from '../factory.js';
+import { factory, streamFactory } from '../factory.js';
+import { responseStream } from './stream.js';
 export const withCors = factory(async (handler, args) => {
     const [request] = args;
     if (request.httpMethod === 'OPTIONS') {
@@ -9,3 +10,11 @@ export const withCors = factory(async (handler, args) => {
     }
     return handler(...args);
 });
+export const streamWithCors = streamFactory(async (handler, args) => {
+    const [request, stream] = args;
+    if (request.httpMethod === 'OPTIONS') {
+        responseStream(stream, { statusCode: 204 }).end();
+        return;
+    }
+    await handler(...args);
+});

package/wrapper/error.d.ts

@@ -1,5 +1,12 @@
-export type ErrorOptions = {
-    errorHandler?: (err: unknown) => Promise<void>;
-    throwError?: boolean;
+import type { ApiEvent, ApiResult, Decorator, HandlerParams, StreamDecorator, StreamHandlerParams } from '../types.js';
+export type ErrorHandler<Params extends unknown[]> = (err: unknown, args: Params) => Promise<void> | void;
+export type ApiErrorHandler<Params extends unknown[], Result> = (err: unknown, args: Params) => Promise<Result> | Result;
+export type ErrorOptions<Params extends unknown[]> = {
+    errorHandler?: ErrorHandler<Params>;
 };
-export declare const withError: <Event, Result>(options?: ErrorOptions | undefined) => import("../types.js").Decorator<Event, Result>;
+export type ApiErrorOptions<Params extends unknown[], Result> = {
+    errorHandler?: ApiErrorHandler<Params, Result>;
+};
+export declare const withError: <Event, Result>(options?: ErrorOptions<HandlerParams<Event>>) => Decorator<Event, Result>;
+export declare const withApiError: (options?: ApiErrorOptions<HandlerParams<ApiEvent>, ApiResult>) => Decorator<ApiEvent, ApiResult>;
+export declare const streamWithApiError: (options?: ApiErrorOptions<StreamHandlerParams<ApiEvent>, ApiResult | void>) => StreamDecorator<ApiEvent>;

package/wrapper/error.js

@@ -1,17 +1,42 @@
-import { factory } from '../factory.js';
-export const withError = factory(async (handler, args, options = {}) => {
-    const { errorHandler, throwError = false } = options;
-    let result;
+import { STATUS_CODES } from 'node:http';
+import { responseStream } from './stream.js';
+const defaultErrorResult = () => ({
+    statusCode: 500,
+    headers: {
+        'content-type': 'application/json',
+    },
+    body: JSON.stringify({
+        message: STATUS_CODES[500],
+    }),
+});
+export const withError = (options = {}) => (handler) => async (event, context) => {
     try {
-        result = await handler(...args);
+        return await handler(event, context);
     }
     catch (err) {
-        if (errorHandler) {
-            await errorHandler(err);
-        }
-        if (throwError) {
-            throw err;
+        await options.errorHandler?.(err, [event, context]);
+        throw err;
+    }
+};
+export const withApiError = (options = {}) => (handler) => async (event, context) => {
+    try {
+        return await handler(event, context);
+    }
+    catch (err) {
+        return options.errorHandler?.(err, [event, context]) ?? defaultErrorResult();
+    }
+};
+export const streamWithApiError = (options = {}) => (handler) => async (event, stream, context) => {
+    try {
+        await handler(event, stream, context);
+    }
+    catch (err) {
+        const result = (await options.errorHandler?.(err, [event, stream, context])) ?? defaultErrorResult();
+        if (result) {
+            responseStream(stream, {
+                headers: result.headers,
+                statusCode: result.statusCode,
+            }).end(result.body);
         }
     }
-    return result;
-});
+};

package/wrapper/headers.d.ts

@@ -1,2 +1,2 @@
-import type { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
-export declare const withHeaders: (options?: Record<string, string> | undefined) => import("../types.js").Decorator<APIGatewayProxyEvent, APIGatewayProxyResult>;
+export declare const withHeaders: (options?: Record<string, string> | undefined) => import("../types.js").Decorator<import("aws-lambda").APIGatewayProxyEvent, import("aws-lambda").APIGatewayProxyResult>;
+export declare const streamWithHeaders: (options?: Record<string, string> | undefined) => import("../types.js").StreamDecorator<import("aws-lambda").APIGatewayProxyEvent>;

package/wrapper/headers.js

@@ -1,9 +1,17 @@
-import { factory } from '../factory.js';
-export const withHeaders = factory(async (handler, args, options = {}) => {
-    const result = await handler(...args);
+import { factory, streamFactory } from '../factory.js';
+import { responseStream } from './stream.js';
+const mergeHeaders = (result, options) => {
     result.headers = {
         ...options,
         ...result.headers,
     };
     return result;
+};
+export const withHeaders = factory(async (handler, args, options = {}) => {
+    const result = await handler(...args);
+    return mergeHeaders(result, options);
+});
+export const streamWithHeaders = streamFactory(async (handler, args, options = {}) => {
+    const [event, stream, context] = args;
+    await handler(event, responseStream(stream, { headers: options }), context);
 });

package/wrapper/healthcheck.d.ts

@@ -1,5 +1,9 @@
-import type { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
-export declare const withHealthcheck: (options?: {
+export type HealthcheckOptions = {
     path?: string;
     action?: () => Promise<void>;
-} | undefined) => import("../types.js").Decorator<APIGatewayProxyEvent, APIGatewayProxyResult>;
+};
+export declare const withHealthcheck: (options?: HealthcheckOptions | undefined) => import("../types.js").Decorator<import("aws-lambda").APIGatewayProxyEvent, import("aws-lambda").APIGatewayProxyResult | {
+    statusCode: number;
+    body: string;
+}>;
+export declare const streamWithHealthcheck: (options?: HealthcheckOptions | undefined) => import("../types.js").StreamDecorator<import("aws-lambda").APIGatewayProxyEvent>;

package/wrapper/healthcheck.js

@@ -1,18 +1,32 @@
 import { STATUS_CODES } from 'node:http';
-import { factory } from '../factory.js';
+import { factory, streamFactory } from '../factory.js';
+import { responseStream } from './stream.js';
+const getHealthcheckResult = async (event, options = {}) => {
+    const { path = '/healthcheck', action } = options;
+    if (event.path !== path) {
+        return undefined;
+    }
+    if (action) {
+        await action();
+    }
+    return {
+        statusCode: 200,
+        body: JSON.stringify({
+            message: STATUS_CODES[200],
+        }),
+    };
+};
 export const withHealthcheck = factory(async (handler, args, options = {}) => {
     const [event] = args;
-    const { path = '/healthcheck', action } = options;
-    if (event.path === path) {
-        if (action) {
-            await action();
-        }
-        return {
-            statusCode: 200,
-            body: JSON.stringify({
-                message: STATUS_CODES[200],
-            }),
-        };
+    const result = await getHealthcheckResult(event, options);
+    return result ?? handler(...args);
+});
+export const streamWithHealthcheck = streamFactory(async (handler, args, options = {}) => {
+    const [event, stream] = args;
+    const result = await getHealthcheckResult(event, options);
+    if (result) {
+        responseStream(stream, { statusCode: result.statusCode }).end(result.body);
+        return;
     }
-    return handler(...args);
+    await handler(...args);
 });

package/wrapper/logger.d.ts

@@ -2,3 +2,4 @@ export type LoggerOptions = {
     logger?: typeof console;
 };
 export declare const withLogger: <Event, Result>(options?: LoggerOptions | undefined) => import("../types.js").Decorator<Event, Result>;
+export declare const streamWithLogger: <Event>(options?: LoggerOptions | undefined) => import("../types.js").StreamDecorator<Event>;

package/wrapper/logger.js

@@ -1,8 +1,9 @@
 import { createLogger } from '@vyriy/logger';
-import { factory } from '../factory.js';
+import { factory, getContext, getStreamContext, streamFactory } from '../factory.js';
 export const withLogger = factory(async (handler, args, options = {}) => {
     const { logger = createLogger() } = options;
-    const [event, context] = args;
+    const [event] = args;
+    const context = getContext(args);
     logger.info('Event:', event);
     logger.info('Context:', context);
     try {
@@ -18,3 +19,21 @@ export const withLogger = factory(async (handler, args, options = {}) => {
         throw error;
     }
 });
+export const streamWithLogger = streamFactory(async (handler, args, options = {}) => {
+    const { logger = createLogger() } = options;
+    const [event] = args;
+    const context = getStreamContext(args);
+    logger.info('Event:', event);
+    logger.info('Context:', context);
+    try {
+        await handler(...args);
+        logger.info('Result:', undefined);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            logger.error('Error:', error.message);
+        }
+        logger.error(error);
+        throw error;
+    }
+});

package/wrapper/smoke.d.ts

@@ -1,2 +1,3 @@
-import type { Decorator } from '../types.js';
-export declare const withSmoke: <Event, Result>() => Decorator<Event, Result>;
+import type { ApiResult, Decorator, StreamDecorator } from '../types.js';
+export declare const withSmoke: <Event, Result extends ApiResult | void = ApiResult>() => Decorator<Event, Result>;
+export declare const streamWithSmoke: <Event>() => StreamDecorator<Event>;

package/wrapper/smoke.js

@@ -1,4 +1,17 @@
 import { smoke } from '@vyriy/smoke';
-import { factory } from '../factory.js';
-const smokeWrapper = async (handler, args) => smoke(args[0]) || handler(...args);
-export const withSmoke = factory(smokeWrapper);
+import { responseStream } from './stream.js';
+export const withSmoke = () => (handler) => async (event, context) => {
+    const result = smoke(event);
+    return (result || (await handler(event, context)));
+};
+export const streamWithSmoke = () => (handler) => async (event, stream, context) => {
+    const result = smoke(event);
+    if (result) {
+        responseStream(stream, {
+            headers: result.headers,
+            statusCode: result.statusCode,
+        }).end(result.body);
+        return;
+    }
+    await handler(event, stream, context);
+};

package/wrapper/stream.d.ts

@@ -0,0 +1,6 @@
+import type { ApiResult, ResponseStream } from '../types.js';
+export type StreamMetadata = {
+    headers?: ApiResult['headers'];
+    statusCode?: ApiResult['statusCode'];
+};
+export declare const responseStream: (stream: ResponseStream, metadata?: StreamMetadata) => ResponseStream;

package/wrapper/stream.js

@@ -0,0 +1,15 @@
+const getContentType = (headers) => headers?.['content-type'] ?? headers?.['Content-Type'];
+export const responseStream = (stream, metadata = {}) => {
+    const runtimeStream = globalThis.awslambda?.HttpResponseStream?.from?.(stream, {
+        headers: metadata.headers,
+        statusCode: metadata.statusCode ?? 200,
+    });
+    if (runtimeStream) {
+        return runtimeStream;
+    }
+    const contentType = getContentType(metadata.headers);
+    if (contentType) {
+        stream.setContentType?.(String(contentType));
+    }
+    return stream;
+};

package/wrapper/timeout.d.ts

@@ -1 +1,2 @@
 export declare const withTimeout: <Event, Result>(options?: undefined) => import("../types.js").Decorator<Event, Result>;
+export declare const streamWithTimeout: <Event>(options?: undefined) => import("../types.js").StreamDecorator<Event>;

package/wrapper/timeout.js

@@ -1,6 +1,10 @@
 import { timeout as error } from '@vyriy/timeout';
-import { factory } from '../factory.js';
+import { factory, getContext, getStreamContext, streamFactory } from '../factory.js';
 export const withTimeout = factory(async (handler, args) => Promise.race([
-    error(args[1].getRemainingTimeInMillis() - 1000),
+    error(getContext(args).getRemainingTimeInMillis() - 1000),
+    handler(...args),
+]));
+export const streamWithTimeout = streamFactory(async (handler, args) => Promise.race([
+    error(getStreamContext(args).getRemainingTimeInMillis() - 1000),
     handler(...args),
 ]));