@xcelsior/lambda-http

HTTP utilities for AWS Lambda functions in the Xcelsior ecosystem.

Installation

pnpm add @xcelsior/lambda-http

Features

Request Handler

Type-safe request handling with middleware support:

import { createHandler, HttpError } from '@xcelsior/lambda-http';

const handler = createHandler()
  .use(cors())
  .use(bodyParser())
  .use(errorHandler())
  .handle(async (event, context) => {
    const { body } = event;
    
    if (!body.userId) {
      throw new HttpError(400, 'Missing userId');
    }

    return {
      statusCode: 200,
      body: JSON.stringify({ message: 'Success' }),
    };
  });

export const main = handler;

Error Handling

Standardized error responses:

import { HttpError, errorHandler } from '@xcelsior/lambda-http';

// Custom error handler
const customErrorHandler = errorHandler({
  logger: console,
  formatError: (error) => ({
    code: error.code,
    message: error.message,
    details: error.details,
  }),
});

// Throwing errors
throw new HttpError(400, 'Bad Request', { field: 'userId' });
throw new HttpError(404, 'User not found');
throw new HttpError(500, 'Internal server error');

Logging

Request/response logging with correlation IDs:

import { logger } from '@xcelsior/lambda-http';

const handler = createHandler()
  .use(logger({
    level: 'info',
    format: 'json',
  }))
  .handle(async (event) => {
    logger.info('Processing request', { path: event.path });
    return { statusCode: 200 };
  });

Middleware

Built-in Middleware

• CORS
• Body Parser
• Query Parser
• Error Handler
• Logger
• Validator

import {
  cors,
  bodyParser,
  queryParser,
  errorHandler,
  logger,
  validator,
} from '@xcelsior/lambda-http';

const handler = createHandler()
  .use(cors())
  .use(bodyParser())
  .use(queryParser())
  .use(errorHandler())
  .use(logger())
  .use(validator(schema))
  .handle(async (event) => {
    // Your handler logic
  });

Custom Middleware

import { Middleware } from '@xcelsior/lambda-http';

const authMiddleware: Middleware = async (event, context, next) => {
  const token = event.headers.authorization;
  if (!token) {
    throw new HttpError(401, 'Unauthorized');
  }
  return next(event, context);
};

const handler = createHandler()
  .use(authMiddleware)
  .handle(async (event) => {
    // Your handler logic
  });

Types

interface LambdaResponse {
  statusCode: number;
  body?: string;
  headers?: Record<string, string>;
  isBase64Encoded?: boolean;
}

interface HttpError {
  statusCode: number;
  message: string;
  details?: any;
}

License

MIT