@vyriy/handler 0.7.8 → 0.8.1

package/s3/index.d.ts

@@ -0,0 +1 @@
+export { createS3, createS3 as create, s3 } from './s3.js';

package/s3/index.js

@@ -0,0 +1 @@
+export { createS3, createS3 as create, s3 } from './s3.js';

package/s3/s3.d.ts

@@ -0,0 +1,4 @@
+import type { S3Event } from 'aws-lambda';
+import type { Decorator, EventHandlerOptions } from '../types.js';
+export declare const createS3: (options?: EventHandlerOptions<S3Event>) => Decorator<S3Event, void>;
+export declare const s3: Decorator<S3Event, void>;

package/s3/s3.js

@@ -0,0 +1,8 @@
+import { compose } from '../compose/index.js';
+import { withContext } from '../wrappers/context.js';
+import { withError } from '../wrappers/error.js';
+import { withLogger } from '../wrappers/logger.js';
+import { withSmoke } from '../wrappers/smoke.js';
+import { withTimeout } from '../wrappers/timeout.js';
+export const createS3 = (options = {}) => compose(withError(options.error), withLogger(options.logger), withTimeout(), withContext(), withSmoke());
+export const s3 = createS3();

package/schedule/index.d.ts

@@ -0,0 +1 @@
+export { createSchedule, createSchedule as create, schedule } from './schedule.js';

package/schedule/index.js

@@ -0,0 +1 @@
+export { createSchedule, createSchedule as create, schedule } from './schedule.js';

package/schedule/schedule.d.ts

@@ -0,0 +1,4 @@
+import type { ScheduledEvent } from 'aws-lambda';
+import type { Decorator, EventHandlerOptions } from '../types.js';
+export declare const createSchedule: (options?: EventHandlerOptions<ScheduledEvent>) => Decorator<ScheduledEvent, void>;
+export declare const schedule: Decorator<ScheduledEvent<any>, void>;

package/schedule/schedule.js

@@ -0,0 +1,8 @@
+import { compose } from '../compose/index.js';
+import { withContext } from '../wrappers/context.js';
+import { withError } from '../wrappers/error.js';
+import { withLogger } from '../wrappers/logger.js';
+import { withSmoke } from '../wrappers/smoke.js';
+import { withTimeout } from '../wrappers/timeout.js';
+export const createSchedule = (options = {}) => compose(withError(options.error), withLogger(options.logger), withTimeout(), withContext(), withSmoke());
+export const schedule = createSchedule();

package/ses/index.d.ts

@@ -0,0 +1 @@
+export { createSes, createSes as create, ses } from './ses.js';

package/ses/index.js

@@ -0,0 +1 @@
+export { createSes, createSes as create, ses } from './ses.js';

package/ses/ses.d.ts

@@ -0,0 +1,4 @@
+import type { SESEvent } from 'aws-lambda';
+import type { Decorator, EventHandlerOptions } from '../types.js';
+export declare const createSes: (options?: EventHandlerOptions<SESEvent>) => Decorator<SESEvent, void>;
+export declare const ses: Decorator<SESEvent, void>;

package/ses/ses.js

@@ -0,0 +1,8 @@
+import { compose } from '../compose/index.js';
+import { withContext } from '../wrappers/context.js';
+import { withError } from '../wrappers/error.js';
+import { withLogger } from '../wrappers/logger.js';
+import { withSmoke } from '../wrappers/smoke.js';
+import { withTimeout } from '../wrappers/timeout.js';
+export const createSes = (options = {}) => compose(withError(options.error), withLogger(options.logger), withTimeout(), withContext(), withSmoke());
+export const ses = createSes();

package/sns/index.d.ts

@@ -0,0 +1 @@
+export { createSns, createSns as create, sns } from './sns.js';

package/sns/index.js

@@ -0,0 +1 @@
+export { createSns, createSns as create, sns } from './sns.js';

package/sns/sns.d.ts

@@ -0,0 +1,4 @@
+import type { SNSEvent } from 'aws-lambda';
+import type { Decorator, EventHandlerOptions } from '../types.js';
+export declare const createSns: (options?: EventHandlerOptions<SNSEvent>) => Decorator<SNSEvent, void>;
+export declare const sns: Decorator<SNSEvent, void>;

package/sns/sns.js

@@ -0,0 +1,8 @@
+import { compose } from '../compose/index.js';
+import { withContext } from '../wrappers/context.js';
+import { withError } from '../wrappers/error.js';
+import { withLogger } from '../wrappers/logger.js';
+import { withSmoke } from '../wrappers/smoke.js';
+import { withTimeout } from '../wrappers/timeout.js';
+export const createSns = (options = {}) => compose(withError(options.error), withLogger(options.logger), withTimeout(), withContext(), withSmoke());
+export const sns = createSns();

package/sqs/index.d.ts

@@ -0,0 +1 @@
+export { createSqs, createSqs as create, sqs } from './sqs.js';

package/sqs/index.js

@@ -0,0 +1 @@
+export { createSqs, createSqs as create, sqs } from './sqs.js';

package/sqs/sqs.d.ts

@@ -0,0 +1,4 @@
+import type { SQSEvent } from 'aws-lambda';
+import type { Decorator, EventHandlerOptions } from '../types.js';
+export declare const createSqs: (options?: EventHandlerOptions<SQSEvent>) => Decorator<SQSEvent, void>;
+export declare const sqs: Decorator<SQSEvent, void>;

package/sqs/sqs.js

@@ -0,0 +1,8 @@
+import { compose } from '../compose/index.js';
+import { withContext } from '../wrappers/context.js';
+import { withError } from '../wrappers/error.js';
+import { withLogger } from '../wrappers/logger.js';
+import { withSmoke } from '../wrappers/smoke.js';
+import { withTimeout } from '../wrappers/timeout.js';
+export const createSqs = (options = {}) => compose(withError(options.error), withLogger(options.logger), withTimeout(), withContext(), withSmoke());
+export const sqs = createSqs();

package/types.d.ts

@@ -1,41 +1,24 @@
-import type { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
-import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Context } from 'aws-lambda';
+import type { ErrorOptions } from './wrappers/error.js';
+import type { LoggerOptions } from './wrappers/logger.js';
 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 * from './api/types.js';
+export type { Api as HttpApi, ApiOptions as HttpApiOptions, Compose as HttpCompose, Decorator as HttpDecorator, Factory as HttpFactory, Handler as HttpHandler, HandlerParams as HttpHandlerParams, Wrapper as HttpWrapper, } from './api/http/types.js';
+export type { HealthcheckOptions as HttpHealthcheckOptions } from './api/http/wrappers/healthcheck.js';
+export type { Api as StreamApi, ApiOptions as StreamApiOptions, Compose as StreamCompose, Decorator as StreamDecorator, Factory as StreamFactory, Handler as StreamHandler, HandlerParams as StreamHandlerParams, ResponseStream, TypedWrapper as StreamTypedWrapper, Wrapper as StreamWrapper, } from './api/stream/types.js';
+export type { StreamMetadata } from './api/stream/wrappers/stream.js';
 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 HttpHandler = (request: IncomingMessage, response: ServerResponse) => Promise<void> | void;
-export type HttpHandlerParams = [request: IncomingMessage, response: ServerResponse];
 export type Decorator<Event, Result> = (handler: Handler<Event, Result>) => Handler<Event, Result>;
-export type StreamDecorator<Event> = (handler: StreamHandler<Event>) => StreamHandler<Event>;
-export type HttpDecorator = (handler: HttpHandler) => HttpHandler;
+export type EventHandlerOptions<Event> = {
+    error?: ErrorOptions<HandlerParams<Event>>;
+    logger?: LoggerOptions;
+};
 export type Compose = <Event, Result>(...decorators: Array<Decorator<Event, Result>>) => Decorator<Event, Result>;
-export type StreamCompose = <Event>(...decorators: Array<StreamDecorator<Event>>) => StreamDecorator<Event>;
-export type HttpCompose = (...decorators: Array<HttpDecorator>) => HttpDecorator;
 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 HttpWrapper<Options> = (handler: HttpHandler, args: HttpHandlerParams, 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>;
-};
-export type HttpFactory = <Options = undefined>(wrapper: HttpWrapper<Options>) => (options?: Options) => HttpDecorator;

package/{wrapper → wrappers}/chaos.d.ts

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

@@ -0,0 +1,35 @@
+import { chaos } from '@vyriy/chaos';
+import { getConfig } from '@vyriy/config';
+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');
+const getChaosTimeoutMs = () => getConfig('CHAOS_TIMEOUT_MS', 10000, 'number');
+const getStrategy = (options) => {
+    if (options.strategy) {
+        return options.strategy;
+    }
+    const isErrorEnabled = getChaosErrorEnabled();
+    const isTimeoutEnabled = getChaosTimeoutEnabled();
+    if (isErrorEnabled && isTimeoutEnabled) {
+        return 'random';
+    }
+    if (isErrorEnabled) {
+        return 'error';
+    }
+    if (isTimeoutEnabled) {
+        return 'timeout';
+    }
+    return 'random';
+};
+export const withChaos = factory(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 → wrappers}/context.d.ts

@@ -1,2 +1 @@
 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/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/{wrapper → wrappers}/error.d.ts

@@ -1,4 +1,4 @@
-import type { ApiEvent, ApiResult, Decorator, HandlerParams, HttpDecorator, HttpHandlerParams, StreamDecorator, StreamHandlerParams } from '../types.js';
+import type { Decorator, HandlerParams } 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[]> = {
@@ -8,6 +8,3 @@ 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>;
-export declare const httpWithError: (options?: ErrorOptions<HttpHandlerParams>) => HttpDecorator;

package/wrappers/error.js

@@ -0,0 +1,9 @@
+export const withError = (options = {}) => (handler) => async (event, context) => {
+    try {
+        return await handler(event, context);
+    }
+    catch (err) {
+        await options.errorHandler?.(err, [event, context]);
+        throw err;
+    }
+};

package/wrappers/index.d.ts

@@ -0,0 +1,6 @@
+export * from './chaos.js';
+export * from './context.js';
+export * from './error.js';
+export * from './logger.js';
+export * from './smoke.js';
+export * from './timeout.js';

package/wrappers/index.js

@@ -0,0 +1,6 @@
+export * from './chaos.js';
+export * from './context.js';
+export * from './error.js';
+export * from './logger.js';
+export * from './smoke.js';
+export * from './timeout.js';

package/wrappers/logger.d.ts

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

package/wrappers/logger.js

@@ -0,0 +1,21 @@
+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 {
+        const result = await handler(...args);
+        logger.info('Result:', result);
+        return result;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            logger.error('Error:', error.message);
+        }
+        logger.error(error);
+        throw error;
+    }
+});

package/wrappers/smoke.d.ts

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

package/wrappers/smoke.js

@@ -0,0 +1,5 @@
+import { smoke } from '@vyriy/smoke';
+export const withSmoke = () => (handler) => async (event, context) => {
+    const result = smoke(event);
+    return (result || (await handler(event, context)));
+};

package/{wrapper → wrappers}/timeout.d.ts

@@ -1,2 +1 @@
 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/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.d.ts

@@ -1,3 +0,0 @@
-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>;
-export declare const httpApi: import("./types.js").HttpDecorator;

package/api.js

@@ -1,30 +0,0 @@
-import { compose, httpCompose, streamCompose } from './compose.js';
-import { httpWithError, streamWithApiError, withApiError } from './wrapper/error.js';
-import { httpWithLogger, 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 { httpWithHealthcheck, streamWithHealthcheck, withHealthcheck } from './wrapper/healthcheck.js';
-import { httpWithHeaders, streamWithHeaders, withHeaders } from './wrapper/headers.js';
-import { httpWithCors, 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());
-export const httpApi = httpCompose(httpWithError(), httpWithLogger(), httpWithHealthcheck(), httpWithHeaders({
-    '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',
-}), httpWithCors());

package/compose.d.ts

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

package/compose.js

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

package/dynamodb.d.ts

@@ -1,2 +0,0 @@
-import type { DynamoDBStreamEvent } from 'aws-lambda';
-export declare const dynamodb: import("./types.js").Decorator<DynamoDBStreamEvent, void>;

package/dynamodb.js

@@ -1,7 +0,0 @@
-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';
-export const dynamodb = compose(withError(), withLogger(), withTimeout(), withContext(), withSmoke());

package/eventBridge.d.ts

@@ -1,2 +0,0 @@
-import type { EventBridgeEvent } from 'aws-lambda';
-export declare const eventBridge: import("./types.js").Decorator<EventBridgeEvent<string, unknown>, void>;

package/eventBridge.js

@@ -1,7 +0,0 @@
-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';
-export const eventBridge = compose(withError(), withLogger(), withTimeout(), withContext(), withSmoke());

package/factory.d.ts

@@ -1,8 +0,0 @@
-import type { Context } from 'aws-lambda';
-import type { Factory, HandlerParams, HttpFactory, 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;
-export declare const httpFactory: HttpFactory;

package/factory.js

@@ -1,6 +0,0 @@
-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);
-export const httpFactory = (wrapper) => (options) => (handler) => async (request, response) => wrapper(handler, [request, response], options);

package/s3.d.ts

@@ -1,2 +0,0 @@
-import type { S3Event } from 'aws-lambda';
-export declare const s3: import("./types.js").Decorator<S3Event, void>;

package/s3.js

@@ -1,7 +0,0 @@
-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';
-export const s3 = compose(withError(), withLogger(), withTimeout(), withContext(), withSmoke());

package/schedule.d.ts

@@ -1,2 +0,0 @@
-import type { ScheduledEvent } from 'aws-lambda';
-export declare const schedule: import("./types.js").Decorator<ScheduledEvent<any>, void>;

package/schedule.js

@@ -1,7 +0,0 @@
-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';
-export const schedule = compose(withError(), withLogger(), withTimeout(), withContext(), withSmoke());

package/ses.d.ts

@@ -1,2 +0,0 @@
-import type { SESEvent } from 'aws-lambda';
-export declare const ses: import("./types.js").Decorator<SESEvent, void>;

package/ses.js

@@ -1,7 +0,0 @@
-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';
-export const ses = compose(withError(), withLogger(), withTimeout(), withContext(), withSmoke());

package/sns.d.ts

@@ -1,2 +0,0 @@
-import type { SNSEvent } from 'aws-lambda';
-export declare const sns: import("./types.js").Decorator<SNSEvent, void>;

package/sns.js

@@ -1,7 +0,0 @@
-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';
-export const sns = compose(withError(), withLogger(), withTimeout(), withContext(), withSmoke());

package/sqs.d.ts

@@ -1,2 +0,0 @@
-import type { SQSEvent } from 'aws-lambda';
-export declare const sqs: import("./types.js").Decorator<SQSEvent, void>;

package/sqs.js

@@ -1,7 +0,0 @@
-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';
-export const sqs = compose(withError(), withLogger(), withTimeout(), withContext(), withSmoke());

package/wrapper/context.js

@@ -1,11 +0,0 @@
-import { factory, getContext, getStreamContext, streamFactory } from '../factory.js';
-export const withContext = factory(async (handler, 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,3 +0,0 @@
-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>;
-export declare const httpWithCors: (options?: undefined) => import("../types.js").HttpDecorator;

package/wrapper/cors.js

@@ -1,28 +0,0 @@
-import { factory, httpFactory, streamFactory } from '../factory.js';
-import { responseStream } from './stream.js';
-export const withCors = factory(async (handler, args) => {
-    const [request] = args;
-    if (request.httpMethod === 'OPTIONS') {
-        return {
-            body: '',
-            statusCode: 204,
-        };
-    }
-    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);
-});
-export const httpWithCors = httpFactory(async (handler, args) => {
-    const [request, response] = args;
-    if (request.method === 'OPTIONS') {
-        response.writeHead(204).end();
-        return;
-    }
-    await handler(...args);
-});

package/wrapper/error.js

@@ -1,62 +0,0 @@
-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 {
-        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) => {
-    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);
-        }
-    }
-};
-export const httpWithError = (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/wrapper/headers.d.ts

@@ -1,3 +0,0 @@
-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>;
-export declare const httpWithHeaders: (options?: Record<string, string> | undefined) => import("../types.js").HttpDecorator;