@vyriy/handler 0.1.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vyriy contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,318 @@
+# @vyriy/handler
+
+Composable AWS Lambda handler chains and wrappers for Vyriy projects.
+
+## Purpose
+
+This package provides ready-made Lambda handler chains for common Vyriy workloads and a small set of reusable wrappers for logging, timeouts, smoke checks, development chaos injection, context setup, and error handling.
+
+It is designed for projects that want a consistent handler pipeline without repeating the same boilerplate in every Lambda entrypoint.
+
+## Install
+
+With npm:
+
+```bash
+npm install @vyriy/handler
+```
+
+With Yarn:
+
+```bash
+yarn add @vyriy/handler
+```
+
+## Usage
+
+Use a prebuilt API Gateway handler chain:
+
+```ts
+import { api } from '@vyriy/handler';
+
+export const handler = api(async (event) => ({
+  statusCode: 200,
+  body: JSON.stringify({
+    path: event.path,
+  }),
+}));
+```
+
+Use a prebuilt queue or event handler chain:
+
+```ts
+import { sqs } from '@vyriy/handler';
+
+export const handler = sqs(async (event) => {
+  for (const record of event.Records) {
+    console.info(record.body);
+  }
+});
+```
+
+Use a prebuilt SNS handler chain:
+
+```ts
+import { sns } from '@vyriy/handler';
+
+export const handler = sns(async (event) => {
+  for (const record of event.Records) {
+    console.info(record.Sns.Message);
+  }
+});
+```
+
+Use a prebuilt schedule handler chain:
+
+```ts
+import { schedule } from '@vyriy/handler';
+
+export const handler = schedule(async (event) => {
+  console.info('Scheduled event:', event['detail-type']);
+});
+```
+
+Compose a custom handler pipeline from individual helpers:
+
+```ts
+import { compose, withChaos, withContext, withError, withLogger, withSmoke, withTimeout } from '@vyriy/handler';
+
+export const handler = compose(
+  withError({ throwError: true }),
+  withLogger(),
+  withChaos(),
+  withTimeout(),
+  withContext(),
+  withSmoke(),
+)(async (event) => {
+  return {
+    ok: true,
+    event,
+  };
+});
+```
+
+Create a custom wrapper with `factory(...)` and compose it with the built-in helpers:
+
+```ts
+import { compose, factory, withError, withLogger, withTimeout } from '@vyriy/handler';
+
+const withRequestId = factory<{ headerName?: string }>(async (handler, args, options = {}) => {
+  const [event] = args;
+  const headerName = options.headerName ?? 'x-request-id';
+  const requestId =
+    typeof event === 'object' && event && 'headers' in event
+      ? (event.headers as Record<string, string | undefined> | undefined)?.[headerName]
+      : undefined;
+
+  if (requestId) {
+    console.info('Request ID:', requestId);
+  }
+
+  return handler(...args);
+});
+
+export const handler = compose(
+  withError({ throwError: true }),
+  withLogger(),
+  withTimeout(),
+  withRequestId({
+    headerName: 'x-request-id',
+  }),
+)(async (event) => {
+  return {
+    ok: true,
+    event,
+  };
+});
+```
+
+## Prebuilt Chains
+
+- `api`
+  API Gateway chain with error handling, logging, timeout handling, context setup, smoke checks, healthcheck handling, default headers, and CORS preflight handling.
+
+- `schedule`
+  EventBridge schedule chain with logging, timeout handling, context setup, smoke checks, and rethrown errors.
+
+- `sns`
+  SNS chain with logging, timeout handling, context setup, smoke checks, and rethrown errors.
+
+- `sqs`
+  SQS chain with logging, timeout handling, context setup, smoke checks, and rethrown errors.
+
+## Wrappers
+
+### `withError(options?)`
+
+Catches handler failures, optionally runs an async error handler, and rethrows only when `throwError` is enabled.
+
+Options:
+
+```ts
+{
+  errorHandler?: (error: unknown) => Promise<void>;
+  throwError?: boolean;
+}
+```
+
+- `errorHandler`
+  Async callback invoked with the caught error.
+
+- `throwError`
+  Re-throws the original error after `errorHandler` runs. Defaults to `false`.
+
+Example:
+
+```ts
+import { withError } from '@vyriy/handler';
+
+export const handler = withError({
+  errorHandler: async (error) => {
+    console.error('Handler failed:', error);
+  },
+  throwError: true,
+})(async () => {
+  throw new Error('boom');
+});
+```
+
+### `withLogger(options?)`
+
+Logs the incoming event and context, then logs either the result or the thrown error.
+
+Options:
+
+```ts
+{
+  logger?: typeof console;
+}
+```
+
+- `logger`
+  Console-compatible logger implementation. By default the wrapper creates one via `@vyriy/logger`.
+
+Example:
+
+```ts
+import { withLogger } from '@vyriy/handler';
+
+export const handler = withLogger({
+  logger: console,
+})(async (event) => {
+  return {
+    ok: true,
+    event,
+  };
+});
+```
+
+### `withTimeout()`
+
+Races the handler against a timeout scheduled one second before the Lambda runtime limit.
+
+Example:
+
+```ts
+import { withTimeout } from '@vyriy/handler';
+
+export const handler = withTimeout()(async () => {
+  await doWork();
+});
+```
+
+### `withContext()`
+
+Sets `context.callbackWaitsForEmptyEventLoop = false` before calling the handler.
+
+Example:
+
+```ts
+import { withContext } from '@vyriy/handler';
+
+export const handler = withContext()(async (_event, context) => {
+  return {
+    waitForEmptyLoop: context.callbackWaitsForEmptyEventLoop,
+  };
+});
+```
+
+### `withChaos(options?)`
+
+Injects development-only random failures before the wrapped handler runs.
+
+Options:
+
+```ts
+{
+  enabled?: boolean;
+  probability?: number;
+  strategy?: 'error' | 'timeout' | 'random';
+  timeoutMs?: number;
+  error?: unknown;
+}
+```
+
+- `enabled`
+  Turns chaos injection on. By default the wrapper reads `CHAOS_ENABLED` from `@vyriy/env`.
+
+- `probability`
+  Probability from `0` to `1` that a failure is injected. By default the wrapper reads `CHAOS_PROBABILITY`.
+
+- `strategy`
+  Chooses whether to throw an error, wait and time out, or pick one randomly. Defaults to `'random'`.
+
+- `timeoutMs`
+  Timeout delay used when the timeout strategy is selected. By default the wrapper reads `CHAOS_TIMEOUT_MS`.
+
+- `error`
+  Error value normalized through `@vyriy/error` when the error strategy is selected.
+
+Example:
+
+```ts
+import { withChaos } from '@vyriy/handler';
+
+export const handler = withChaos({
+  enabled: true,
+  probability: 0.2,
+  strategy: 'random',
+  timeoutMs: 1500,
+})(async () => {
+  return {
+    ok: true,
+  };
+});
+```
+
+### `withSmoke()`
+
+Returns the smoke response when the incoming event matches the smoke request payload.
+
+Example:
+
+```ts
+import { withSmoke } from '@vyriy/handler';
+
+export const handler = withSmoke()(async () => {
+  return {
+    statusCode: 200,
+    body: JSON.stringify({
+      status: 'runtime',
+    }),
+  };
+});
+```
+
+## Types
+
+The package also exports shared handler types:
+
+```ts
+import type { Context, Decorator, Handler, 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`

package/api.d.ts

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

package/api.js

@@ -0,0 +1,17 @@
+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({
+    '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());

package/compose.d.ts

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

package/compose.js

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

package/factory.d.ts

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

package/factory.js

@@ -0,0 +1,2 @@
+const createFactory = (wrapper) => (options) => (handler) => async (event, context) => wrapper(handler, [event, context], options);
+export const factory = createFactory;

package/index.d.ts

@@ -0,0 +1,16 @@
+export * from './api.js';
+export * from './compose.js';
+export * from './factory.js';
+export * from './schedule.js';
+export * from './sns.js';
+export * from './sqs.js';
+export * from './wrapper/context.js';
+export * from './wrapper/cors.js';
+export * from './wrapper/chaos.js';
+export * from './wrapper/error.js';
+export * from './wrapper/headers.js';
+export * from './wrapper/healthcheck.js';
+export * from './wrapper/logger.js';
+export * from './wrapper/smoke.js';
+export * from './wrapper/timeout.js';
+export type * from './types.js';

package/index.js

@@ -0,0 +1,15 @@
+export * from './api.js';
+export * from './compose.js';
+export * from './factory.js';
+export * from './schedule.js';
+export * from './sns.js';
+export * from './sqs.js';
+export * from './wrapper/context.js';
+export * from './wrapper/cors.js';
+export * from './wrapper/chaos.js';
+export * from './wrapper/error.js';
+export * from './wrapper/headers.js';
+export * from './wrapper/healthcheck.js';
+export * from './wrapper/logger.js';
+export * from './wrapper/smoke.js';
+export * from './wrapper/timeout.js';

package/package.json

@@ -0,0 +1,184 @@
+{
+  "name": "@vyriy/handler",
+  "version": "0.1.9",
+  "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.1.9",
+    "@vyriy/env": "0.1.9",
+    "@vyriy/logger": "0.1.9",
+    "@vyriy/smoke": "0.1.9",
+    "@vyriy/timeout": "0.1.9"
+  },
+  "license": "MIT",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./api": {
+      "types": "./api.d.ts",
+      "import": "./api.js",
+      "default": "./api.js"
+    },
+    "./api.js": {
+      "types": "./api.d.ts",
+      "import": "./api.js",
+      "default": "./api.js"
+    },
+    "./compose": {
+      "types": "./compose.d.ts",
+      "import": "./compose.js",
+      "default": "./compose.js"
+    },
+    "./compose.js": {
+      "types": "./compose.d.ts",
+      "import": "./compose.js",
+      "default": "./compose.js"
+    },
+    "./factory": {
+      "types": "./factory.d.ts",
+      "import": "./factory.js",
+      "default": "./factory.js"
+    },
+    "./factory.js": {
+      "types": "./factory.d.ts",
+      "import": "./factory.js",
+      "default": "./factory.js"
+    },
+    "./index": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./index.js": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./schedule": {
+      "types": "./schedule.d.ts",
+      "import": "./schedule.js",
+      "default": "./schedule.js"
+    },
+    "./schedule.js": {
+      "types": "./schedule.d.ts",
+      "import": "./schedule.js",
+      "default": "./schedule.js"
+    },
+    "./sns": {
+      "types": "./sns.d.ts",
+      "import": "./sns.js",
+      "default": "./sns.js"
+    },
+    "./sns.js": {
+      "types": "./sns.d.ts",
+      "import": "./sns.js",
+      "default": "./sns.js"
+    },
+    "./sqs": {
+      "types": "./sqs.d.ts",
+      "import": "./sqs.js",
+      "default": "./sqs.js"
+    },
+    "./sqs.js": {
+      "types": "./sqs.d.ts",
+      "import": "./sqs.js",
+      "default": "./sqs.js"
+    },
+    "./wrapper/chaos": {
+      "types": "./wrapper/chaos.d.ts",
+      "import": "./wrapper/chaos.js",
+      "default": "./wrapper/chaos.js"
+    },
+    "./wrapper/chaos.js": {
+      "types": "./wrapper/chaos.d.ts",
+      "import": "./wrapper/chaos.js",
+      "default": "./wrapper/chaos.js"
+    },
+    "./wrapper/context": {
+      "types": "./wrapper/context.d.ts",
+      "import": "./wrapper/context.js",
+      "default": "./wrapper/context.js"
+    },
+    "./wrapper/context.js": {
+      "types": "./wrapper/context.d.ts",
+      "import": "./wrapper/context.js",
+      "default": "./wrapper/context.js"
+    },
+    "./wrapper/cors": {
+      "types": "./wrapper/cors.d.ts",
+      "import": "./wrapper/cors.js",
+      "default": "./wrapper/cors.js"
+    },
+    "./wrapper/cors.js": {
+      "types": "./wrapper/cors.d.ts",
+      "import": "./wrapper/cors.js",
+      "default": "./wrapper/cors.js"
+    },
+    "./wrapper/error": {
+      "types": "./wrapper/error.d.ts",
+      "import": "./wrapper/error.js",
+      "default": "./wrapper/error.js"
+    },
+    "./wrapper/error.js": {
+      "types": "./wrapper/error.d.ts",
+      "import": "./wrapper/error.js",
+      "default": "./wrapper/error.js"
+    },
+    "./wrapper/headers": {
+      "types": "./wrapper/headers.d.ts",
+      "import": "./wrapper/headers.js",
+      "default": "./wrapper/headers.js"
+    },
+    "./wrapper/headers.js": {
+      "types": "./wrapper/headers.d.ts",
+      "import": "./wrapper/headers.js",
+      "default": "./wrapper/headers.js"
+    },
+    "./wrapper/healthcheck": {
+      "types": "./wrapper/healthcheck.d.ts",
+      "import": "./wrapper/healthcheck.js",
+      "default": "./wrapper/healthcheck.js"
+    },
+    "./wrapper/healthcheck.js": {
+      "types": "./wrapper/healthcheck.d.ts",
+      "import": "./wrapper/healthcheck.js",
+      "default": "./wrapper/healthcheck.js"
+    },
+    "./wrapper/logger": {
+      "types": "./wrapper/logger.d.ts",
+      "import": "./wrapper/logger.js",
+      "default": "./wrapper/logger.js"
+    },
+    "./wrapper/logger.js": {
+      "types": "./wrapper/logger.d.ts",
+      "import": "./wrapper/logger.js",
+      "default": "./wrapper/logger.js"
+    },
+    "./wrapper/smoke": {
+      "types": "./wrapper/smoke.d.ts",
+      "import": "./wrapper/smoke.js",
+      "default": "./wrapper/smoke.js"
+    },
+    "./wrapper/smoke.js": {
+      "types": "./wrapper/smoke.d.ts",
+      "import": "./wrapper/smoke.js",
+      "default": "./wrapper/smoke.js"
+    },
+    "./wrapper/timeout": {
+      "types": "./wrapper/timeout.d.ts",
+      "import": "./wrapper/timeout.js",
+      "default": "./wrapper/timeout.js"
+    },
+    "./wrapper/timeout.js": {
+      "types": "./wrapper/timeout.d.ts",
+      "import": "./wrapper/timeout.js",
+      "default": "./wrapper/timeout.js"
+    }
+  }
+}

package/schedule.d.ts

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

package/schedule.js

@@ -0,0 +1,7 @@
+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({ throwError: true }), withLogger(), withTimeout(), withContext(), withSmoke());

package/sns.d.ts

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

package/sns.js

@@ -0,0 +1,7 @@
+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({ throwError: true }), withLogger(), withTimeout(), withContext(), withSmoke());

package/sqs.d.ts

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

package/sqs.js

@@ -0,0 +1,7 @@
+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({ throwError: true }), withLogger(), withTimeout(), withContext(), withSmoke());

package/types.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from 'aws-lambda';
+export type { Context } from 'aws-lambda';
+export type Response<Result> = Promise<Result>;
+export type Handler<Event, Result> = (event: Event, context: Context) => Response<Result>;
+export type Decorator<Event, Result> = (handler: Handler<Event, Result>) => Handler<Event, Result>;
+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 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>;
+};

package/wrapper/chaos.d.ts

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

package/wrapper/chaos.js

@@ -0,0 +1,31 @@
+import { chaos } from '@vyriy/chaos';
+import { getChaosEnabled, getChaosErrorEnabled, getChaosTimeoutEnabled, getChaosTimeoutMs } from '@vyriy/env';
+import { factory } from '../factory.js';
+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/context.d.ts

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

package/wrapper/context.js

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

package/wrapper/cors.d.ts

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

package/wrapper/cors.js

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

package/wrapper/error.d.ts

@@ -0,0 +1,5 @@
+export type ErrorOptions = {
+    errorHandler?: (err: unknown) => Promise<void>;
+    throwError?: boolean;
+};
+export declare const withError: <Event, Result>(options?: ErrorOptions | undefined) => import("../types.js").Decorator<Event, Result>;

package/wrapper/error.js

@@ -0,0 +1,17 @@
+import { factory } from '../factory.js';
+export const withError = factory(async (handler, args, options = {}) => {
+    const { errorHandler, throwError = false } = options;
+    let result;
+    try {
+        result = await handler(...args);
+    }
+    catch (err) {
+        if (errorHandler) {
+            await errorHandler(err);
+        }
+        if (throwError) {
+            throw err;
+        }
+    }
+    return result;
+});

package/wrapper/headers.d.ts

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

package/wrapper/headers.js

@@ -0,0 +1,9 @@
+import { factory } from '../factory.js';
+export const withHeaders = factory(async (handler, args, options = {}) => {
+    const result = await handler(...args);
+    result.headers = {
+        ...options,
+        ...result.headers,
+    };
+    return result;
+});

package/wrapper/healthcheck.d.ts

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

package/wrapper/healthcheck.js

@@ -0,0 +1,18 @@
+import { STATUS_CODES } from 'node:http';
+import { factory } from '../factory.js';
+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],
+            }),
+        };
+    }
+    return handler(...args);
+});

package/wrapper/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/wrapper/logger.js

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

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

package/wrapper/smoke.js

@@ -0,0 +1,4 @@
+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);

package/wrapper/timeout.d.ts

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

package/wrapper/timeout.js

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