@vyriy/handler 0.7.7 → 0.8.0

package/api/api.d.ts

@@ -0,0 +1,10 @@
+import type { Api } from './types.js';
+export declare const API_HEADERS: {
+    'access-control-allow-origin': string;
+    'access-control-allow-methods': string;
+    'access-control-allow-headers': string;
+    'content-type': string;
+    'x-robots-tag': string;
+};
+export declare const createApi: Api;
+export declare const api: import("./types.js").Decorator<import("aws-lambda").APIGatewayProxyEvent, import("aws-lambda").APIGatewayProxyResult>;

package/api/api.js

@@ -0,0 +1,19 @@
+import { compose } from '../compose/index.js';
+import { withChaos } from './wrappers/chaos.js';
+import { withCors } from './wrappers/cors.js';
+import { withApiError } from './wrappers/error.js';
+import { withHealthcheck } from './wrappers/healthcheck.js';
+import { withHeaders } from './wrappers/headers.js';
+import { withContext } from '../wrappers/context.js';
+import { withLogger } from '../wrappers/logger.js';
+import { withSmoke } from '../wrappers/smoke.js';
+import { withTimeout } from '../wrappers/timeout.js';
+export const API_HEADERS = {
+    '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',
+};
+export const createApi = (options = {}) => compose(withApiError(options.error), withLogger(options.logger), withTimeout(), withContext(), withSmoke(), withHealthcheck(options.healthcheck), withHeaders(options.headers ?? API_HEADERS), withCors(), withChaos(options.chaos));
+export const api = createApi();

package/api/http/compose/compose.d.ts

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

package/api/http/compose/compose.js

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

package/api/http/compose/index.d.ts

@@ -0,0 +1 @@
+export { compose } from './compose.js';

package/api/http/compose/index.js

@@ -0,0 +1 @@
+export { compose } from './compose.js';

package/api/http/factory/factory.d.ts

@@ -0,0 +1,2 @@
+import type { Factory } from '../types.js';
+export declare const factory: Factory;

package/api/http/factory/factory.js

@@ -0,0 +1 @@
+export const factory = (wrapper) => (options) => (handler) => async (request, response) => wrapper(handler, [request, response], options);

package/api/http/factory/index.d.ts

@@ -0,0 +1 @@
+export { factory } from './factory.js';

package/api/http/factory/index.js

@@ -0,0 +1 @@
+export { factory } from './factory.js';

package/api/http/http.d.ts

@@ -0,0 +1,3 @@
+import type { Api } from './types.js';
+export declare const createApi: Api;
+export declare const api: import("./types.js").Decorator;

package/api/http/http.js

@@ -0,0 +1,14 @@
+import { compose } from './compose/index.js';
+import { withCors } from './wrappers/cors.js';
+import { withError } from './wrappers/error.js';
+import { withHeaders } from './wrappers/headers.js';
+import { withHealthcheck } from './wrappers/healthcheck.js';
+import { withLogger } from './wrappers/logger.js';
+const API_HEADERS = {
+    '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',
+    'x-robots-tag': 'noindex, nofollow',
+};
+export const createApi = (options = {}) => compose(withError(options.error), withLogger(options.logger), withHealthcheck(options.healthcheck), withHeaders(options.headers ?? API_HEADERS), withCors());
+export const api = createApi();

package/api/http/index.d.ts

@@ -0,0 +1,3 @@
+export { api, createApi, createApi as create } from './http.js';
+export * from './wrappers/index.js';
+export type * from './types.js';

package/api/http/index.js

@@ -0,0 +1,2 @@
+export { api, createApi, createApi as create } from './http.js';
+export * from './wrappers/index.js';

package/api/http/types.d.ts

@@ -0,0 +1,18 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { HealthcheckOptions } from './wrappers/healthcheck.js';
+import type { Response } from '../../types.js';
+import type { ErrorOptions } from '../../wrappers/error.js';
+import type { LoggerOptions } from '../../wrappers/logger.js';
+export type Handler = (request: IncomingMessage, response: ServerResponse) => Promise<void> | void;
+export type HandlerParams = [request: IncomingMessage, response: ServerResponse];
+export type Decorator = (handler: Handler) => Handler;
+export type Compose = (...decorators: Array<Decorator>) => Decorator;
+export type Wrapper<Options> = (handler: Handler, args: HandlerParams, options?: Options) => Response<void>;
+export type Factory = <Options = undefined>(wrapper: Wrapper<Options>) => (options?: Options) => Decorator;
+export type ApiOptions = {
+    error?: ErrorOptions<HandlerParams>;
+    healthcheck?: HealthcheckOptions;
+    headers?: Record<string, string>;
+    logger?: LoggerOptions;
+};
+export type Api = (options?: ApiOptions) => Decorator;

package/api/http/wrappers/cors.d.ts

@@ -0,0 +1 @@
+export declare const withCors: (options?: undefined) => import("../types.js").Decorator;

package/api/http/wrappers/cors.js

@@ -0,0 +1,9 @@
+import { factory } from '../factory/index.js';
+export const withCors = factory(async (handler, args) => {
+    const [request, response] = args;
+    if (request.method === 'OPTIONS') {
+        response.writeHead(204).end();
+        return;
+    }
+    await handler(...args);
+});

package/api/http/wrappers/error.d.ts

@@ -0,0 +1,3 @@
+import type { Decorator, HandlerParams } from '../types.js';
+import type { ErrorOptions } from '../../../wrappers/error.js';
+export declare const withError: (options?: ErrorOptions<HandlerParams>) => Decorator;

package/api/http/wrappers/error.js

@@ -0,0 +1,21 @@
+import { STATUS_CODES } from 'node:http';
+export const withError = (options = {}) => (handler) => async (request, response) => {
+    try {
+        await handler(request, response);
+    }
+    catch (err) {
+        await options.errorHandler?.(err, [request, response]);
+        if (response.writableEnded) {
+            return;
+        }
+        if (response.headersSent) {
+            response.end();
+            return;
+        }
+        response
+            .writeHead(500, {
+            'content-type': 'application/json',
+        })
+            .end(JSON.stringify({ message: STATUS_CODES[500] }));
+    }
+};

package/api/http/wrappers/headers.d.ts

@@ -0,0 +1 @@
+export declare const withHeaders: (options?: Record<string, string> | undefined) => import("../types.js").Decorator;

package/api/http/wrappers/headers.js

@@ -0,0 +1,8 @@
+import { factory } from '../factory/index.js';
+export const withHeaders = factory(async (handler, args, options = {}) => {
+    const [request, response] = args;
+    for (const [name, value] of Object.entries(options)) {
+        response.setHeader(name.toLowerCase(), value);
+    }
+    await handler(request, response);
+});

package/api/http/wrappers/healthcheck.d.ts

@@ -0,0 +1,5 @@
+import type { HealthcheckOptions as BaseHealthcheckOptions } from '../../wrappers/healthcheck.js';
+export type HealthcheckOptions = BaseHealthcheckOptions & {
+    body?: unknown;
+};
+export declare const withHealthcheck: (options?: HealthcheckOptions | undefined) => import("../types.js").Decorator;

package/api/http/wrappers/healthcheck.js

@@ -0,0 +1,19 @@
+import { STATUS_CODES } from 'node:http';
+import { factory } from '../factory/index.js';
+export const withHealthcheck = factory(async (handler, args, options = {}) => {
+    const { path = '/healthcheck', action, body } = options;
+    const [request, response] = args;
+    const pathname = (request.url ?? '').split('?')[0];
+    if (pathname !== path) {
+        await handler(...args);
+        return;
+    }
+    if (action) {
+        await action();
+    }
+    response
+        .writeHead(200, {
+        'content-type': 'application/json',
+    })
+        .end(JSON.stringify(body ?? { message: STATUS_CODES[200] }));
+});

package/api/http/wrappers/index.d.ts

@@ -0,0 +1,5 @@
+export * from './cors.js';
+export * from './error.js';
+export * from './headers.js';
+export * from './healthcheck.js';
+export * from './logger.js';

package/api/http/wrappers/index.js

@@ -0,0 +1,5 @@
+export * from './cors.js';
+export * from './error.js';
+export * from './headers.js';
+export * from './healthcheck.js';
+export * from './logger.js';

package/api/http/wrappers/logger.d.ts

@@ -0,0 +1,2 @@
+import type { LoggerOptions } from '../../../wrappers/logger.js';
+export declare const withLogger: (options?: LoggerOptions | undefined) => import("../types.js").Decorator;

package/api/http/wrappers/logger.js

@@ -0,0 +1,28 @@
+import { createLogger } from '@vyriy/logger';
+import { factory } from '../factory/index.js';
+export const withLogger = factory(async (handler, args, options = {}) => {
+    const { logger = createLogger() } = options;
+    const [request, response] = args;
+    logger.info('Request:', request.method, request.url);
+    const cleanup = () => {
+        response.off('close', logResult);
+        response.off('finish', logResult);
+    };
+    const logResult = () => {
+        cleanup();
+        logger.info('Result:', response.statusCode);
+    };
+    response.once('close', logResult);
+    response.once('finish', logResult);
+    try {
+        await handler(...args);
+    }
+    catch (error) {
+        cleanup();
+        if (error instanceof Error) {
+            logger.error('Error:', error.message);
+        }
+        logger.error(error);
+        throw error;
+    }
+});

package/api/index.d.ts

@@ -0,0 +1,3 @@
+export { api, createApi, createApi as create } from './api.js';
+export * from './wrappers/index.js';
+export type * from './types.js';

package/api/index.js

@@ -0,0 +1,2 @@
+export { api, createApi, createApi as create } from './api.js';
+export * from './wrappers/index.js';

package/api/stream/compose/compose.d.ts

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

package/api/stream/compose/compose.js

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

package/api/stream/compose/index.d.ts

@@ -0,0 +1 @@
+export { compose } from './compose.js';

package/api/stream/compose/index.js

@@ -0,0 +1 @@
+export { compose } from './compose.js';

package/api/stream/factory/factory.d.ts

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

package/api/stream/factory/factory.js

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

package/api/stream/factory/index.d.ts

@@ -0,0 +1 @@
+export { factory, getContext, getResponseStream } from './factory.js';

package/api/stream/factory/index.js

@@ -0,0 +1 @@
+export { factory, getContext, getResponseStream } from './factory.js';

package/api/stream/index.d.ts

@@ -0,0 +1,3 @@
+export { api, createApi, createApi as create } from './stream.js';
+export * from './wrappers/index.js';
+export type * from './types.js';

package/api/stream/index.js

@@ -0,0 +1,2 @@
+export { api, createApi, createApi as create } from './stream.js';
+export * from './wrappers/index.js';

package/api/stream/stream.d.ts

@@ -0,0 +1,3 @@
+import type { Api } from './types.js';
+export declare const createApi: Api;
+export declare const api: import("./types.js").Decorator<import("aws-lambda").APIGatewayProxyEvent>;

package/api/stream/stream.js

@@ -0,0 +1,13 @@
+import { compose } from './compose/index.js';
+import { API_HEADERS } from '../api.js';
+import { withChaos } from './wrappers/chaos.js';
+import { withContext } from './wrappers/context.js';
+import { withCors } from './wrappers/cors.js';
+import { withApiError } from './wrappers/error.js';
+import { withHeaders } from './wrappers/headers.js';
+import { withHealthcheck } from './wrappers/healthcheck.js';
+import { withLogger } from './wrappers/logger.js';
+import { withSmoke } from './wrappers/smoke.js';
+import { withTimeout } from './wrappers/timeout.js';
+export const createApi = (options = {}) => compose(withApiError(options.error), withLogger(options.logger), withTimeout(), withContext(), withSmoke(), withHealthcheck(options.healthcheck), withHeaders(options.headers ?? API_HEADERS), withCors(), withChaos(options.chaos));
+export const api = createApi();

package/api/stream/types.d.ts

@@ -0,0 +1,36 @@
+import type { Context } from 'aws-lambda';
+import type { ChaosOptions } from '@vyriy/chaos';
+import type { ApiEvent, ApiResult } from '../types.js';
+import type { ApiErrorOptions } from '../wrappers/error.js';
+import type { HealthcheckOptions } from '../wrappers/healthcheck.js';
+import type { Response } from '../../types.js';
+import type { LoggerOptions } from '../../wrappers/logger.js';
+export type { Context } from 'aws-lambda';
+export type { ApiEvent, ApiResult } from '../types.js';
+export type ResponseStream = {
+    end: {
+        (): unknown;
+        (chunk: string | Buffer | Uint8Array): unknown;
+    };
+    setContentType?: (contentType: string) => unknown;
+    writableEnded?: boolean;
+    write(chunk: string | Buffer | Uint8Array): unknown;
+};
+export type HandlerParams<Event> = [event: Event, responseStream: ResponseStream, context: Context];
+export type Handler<Event> = (event: Event, responseStream: ResponseStream, context: Context) => Response<void>;
+export type Decorator<Event> = (handler: Handler<Event>) => Handler<Event>;
+export type Compose = <Event>(...decorators: Array<Decorator<Event>>) => Decorator<Event>;
+export type Wrapper<Options> = <Event>(handler: Handler<Event>, args: HandlerParams<Event>, options?: Options) => Response<void>;
+export type TypedWrapper<Event, Options> = (handler: Handler<Event>, args: HandlerParams<Event>, options?: Options) => Response<void>;
+export type Factory = {
+    <Options = undefined>(wrapper: Wrapper<Options>): <Event>(options?: Options) => Decorator<Event>;
+    <Options, Event>(wrapper: TypedWrapper<Event, Options>): (options?: Options) => Decorator<Event>;
+};
+export type ApiOptions = {
+    chaos?: ChaosOptions;
+    error?: ApiErrorOptions<HandlerParams<ApiEvent>, ApiResult | void>;
+    healthcheck?: HealthcheckOptions;
+    headers?: Record<string, string>;
+    logger?: LoggerOptions;
+};
+export type Api = (options?: ApiOptions) => Decorator<ApiEvent>;

package/api/stream/wrappers/chaos.d.ts

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

package/{wrapper → api/stream/wrappers}/chaos.js

@@ -1,6 +1,6 @@
 import { chaos } from '@vyriy/chaos';
 import { getConfig } from '@vyriy/config';
-import { factory, streamFactory } from '../factory.js';
+import { factory } from '../factory/index.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,14 +33,3 @@ 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/api/stream/wrappers/context.d.ts

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

package/api/stream/wrappers/context.js

@@ -0,0 +1,6 @@
+import { factory, getContext } from '../factory/index.js';
+export const withContext = factory(async (handler, args) => {
+    const ctx = getContext(args);
+    ctx.callbackWaitsForEmptyEventLoop = false;
+    return handler(...args);
+});

package/api/stream/wrappers/cors.d.ts

@@ -0,0 +1 @@
+export declare const withCors: (options?: unknown) => import("../types.js").Decorator<import("aws-lambda").APIGatewayProxyEvent>;

package/api/stream/wrappers/cors.js

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

package/api/stream/wrappers/error.d.ts

@@ -0,0 +1,3 @@
+import type { ApiEvent, ApiResult, Decorator, HandlerParams } from '../types.js';
+import type { ApiErrorOptions } from '../../wrappers/error.js';
+export declare const withApiError: (options?: ApiErrorOptions<HandlerParams<ApiEvent>, ApiResult | void>) => Decorator<ApiEvent>;

package/{wrapper → api/stream/wrappers}/error.js

@@ -9,24 +9,7 @@ const defaultErrorResult = () => ({
         message: STATUS_CODES[500],
     }),
 });
-export const withError = (options = {}) => (handler) => async (event, context) => {
-    try {
-        return await handler(event, context);
-    }
-    catch (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) => {
+export const withApiError = (options = {}) => (handler) => async (event, stream, context) => {
     try {
         await handler(event, stream, context);
     }

package/api/stream/wrappers/headers.d.ts

@@ -0,0 +1 @@
+export declare const withHeaders: (options?: Record<string, string> | undefined) => import("../types.js").Decorator<import("aws-lambda").APIGatewayProxyEvent>;

package/api/stream/wrappers/headers.js

@@ -0,0 +1,7 @@
+import { factory } from '../factory/index.js';
+import { responseStream } from './stream.js';
+const normalizeHeaders = (headers) => Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]));
+export const withHeaders = factory(async (handler, args, options = {}) => {
+    const [event, stream, context] = args;
+    await handler(event, responseStream(stream, { headers: normalizeHeaders(options) }), context);
+});

package/api/stream/wrappers/healthcheck.d.ts

@@ -0,0 +1,2 @@
+import type { HealthcheckOptions } from '../../wrappers/healthcheck.js';
+export declare const withHealthcheck: (options?: HealthcheckOptions | undefined) => import("../types.js").Decorator<import("aws-lambda").APIGatewayProxyEvent>;

package/{wrapper → api/stream/wrappers}/healthcheck.js

@@ -1,5 +1,5 @@
 import { STATUS_CODES } from 'node:http';
-import { factory, streamFactory } from '../factory.js';
+import { factory } from '../factory/index.js';
 import { responseStream } from './stream.js';
 const getHealthcheckResult = async (event, options = {}) => {
     const { path = '/healthcheck', action } = options;
@@ -17,11 +17,6 @@ const getHealthcheckResult = async (event, options = {}) => {
     };
 };
 export const withHealthcheck = factory(async (handler, args, options = {}) => {
-    const [event] = args;
-    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) {

package/api/stream/wrappers/index.d.ts

@@ -0,0 +1,10 @@
+export * from './chaos.js';
+export * from './context.js';
+export * from './cors.js';
+export * from './error.js';
+export * from './headers.js';
+export * from './healthcheck.js';
+export * from './logger.js';
+export * from './smoke.js';
+export * from './stream.js';
+export * from './timeout.js';

package/api/stream/wrappers/index.js

@@ -0,0 +1,10 @@
+export * from './chaos.js';
+export * from './context.js';
+export * from './cors.js';
+export * from './error.js';
+export * from './headers.js';
+export * from './healthcheck.js';
+export * from './logger.js';
+export * from './smoke.js';
+export * from './stream.js';
+export * from './timeout.js';

package/api/stream/wrappers/logger.d.ts

@@ -0,0 +1,2 @@
+import type { LoggerOptions } from '../../../wrappers/logger.js';
+export declare const withLogger: <Event>(options?: LoggerOptions | undefined) => import("../types.js").Decorator<Event>;

package/api/stream/wrappers/logger.js

@@ -0,0 +1,20 @@
+import { createLogger } from '@vyriy/logger';
+import { factory, getContext } from '../factory/index.js';
+export const withLogger = factory(async (handler, args, options = {}) => {
+    const { logger = createLogger() } = options;
+    const [event] = args;
+    const context = getContext(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/api/stream/wrappers/smoke.d.ts

@@ -0,0 +1,2 @@
+import type { Decorator } from '../types.js';
+export declare const withSmoke: <Event>() => Decorator<Event>;

package/{wrapper → api/stream/wrappers}/smoke.js

@@ -1,10 +1,6 @@
 import { smoke } from '@vyriy/smoke';
 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) => {
+export const withSmoke = () => (handler) => async (event, stream, context) => {
     const result = smoke(event);
     if (result) {
         responseStream(stream, {

package/api/stream/wrappers/timeout.d.ts

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

package/api/stream/wrappers/timeout.js

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

package/api/types.d.ts

@@ -0,0 +1,17 @@
+import type { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
+import type { ChaosOptions } from '@vyriy/chaos';
+import type { Decorator, HandlerParams } from '../types.js';
+import type { ApiErrorOptions } from './wrappers/error.js';
+import type { HealthcheckOptions } from './wrappers/healthcheck.js';
+import type { LoggerOptions } from '../wrappers/logger.js';
+export type { Decorator, Handler, HandlerParams } from '../types.js';
+export type ApiResult = APIGatewayProxyResult;
+export type ApiEvent = APIGatewayProxyEvent;
+export type ApiOptions = {
+    chaos?: ChaosOptions;
+    error?: ApiErrorOptions<HandlerParams<ApiEvent>, ApiResult>;
+    healthcheck?: HealthcheckOptions;
+    headers?: Record<string, string>;
+    logger?: LoggerOptions;
+};
+export type Api = (options?: ApiOptions) => Decorator<ApiEvent, ApiResult>;

package/api/wrappers/chaos.d.ts

@@ -0,0 +1 @@
+export { withChaos } from '../../wrappers/chaos.js';

package/api/wrappers/chaos.js

@@ -0,0 +1 @@
+export { withChaos } from '../../wrappers/chaos.js';

package/{wrapper → api/wrappers}/cors.d.ts

@@ -1,2 +1 @@
 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/api/wrappers/cors.js

@@ -0,0 +1,11 @@
+import { factory } from '../../factory/index.js';
+export const withCors = factory(async (handler, args) => {
+    const [request] = args;
+    if (request.httpMethod === 'OPTIONS') {
+        return {
+            body: '',
+            statusCode: 204,
+        };
+    }
+    return handler(...args);
+});

package/api/wrappers/error.d.ts

@@ -0,0 +1,4 @@
+import type { ApiEvent, ApiResult, Decorator, HandlerParams } from '../types.js';
+import type { ApiErrorOptions } from '../../wrappers/error.js';
+export declare const withApiError: (options?: ApiErrorOptions<HandlerParams<ApiEvent>, ApiResult>) => Decorator<ApiEvent, ApiResult>;
+export type { ApiErrorHandler, ApiErrorOptions } from '../../wrappers/error.js';

package/api/wrappers/error.js

@@ -0,0 +1,18 @@
+import { STATUS_CODES } from 'node:http';
+const defaultErrorResult = () => ({
+    statusCode: 500,
+    headers: {
+        'content-type': 'application/json',
+    },
+    body: JSON.stringify({
+        message: STATUS_CODES[500],
+    }),
+});
+export const withApiError = (options = {}) => (handler) => async (event, context) => {
+    try {
+        return await handler(event, context);
+    }
+    catch (err) {
+        return options.errorHandler?.(err, [event, context]) ?? defaultErrorResult();
+    }
+};