@lambda-middleware/compose
    TypeScript icon, indicating that this package has built-in type declarations

    1.2.0 • Public • Published

    @lambda-middleware/compose

    npm version downloads open issues debug build status codecov dependency status devDependency status

    A compose function for lambda middleware. This is a pure convenience copy of ramda's compose, using it directly or using other compose functions works as well.

    Lambda middleware

    This middleware is part of the lambda middleware series. It can be used independently.

    Usage

    import { compose } from "@lambda-middleware/compose";
    import { PromiseHandler } from "@lambda-middleware/utils";
    import { Context, ProxyHandler, APIGatewayEvent } from "aws-lambda";
    
    // This is your AWS handler
    async function helloWorld(): Promise<object> {
      return {
        message: "Hello world!",
      };
    }
    
    // Write your own middleware
    const stringifyToBody = () => (
      handle: PromiseHandler<APIGatewayEvent, object>
    ) => async (event: APIGatewayEvent, context: Context) => {
      const response = await handle(event, context);
      return {
        body: JSON.stringify(response),
      };
    };
    
    const addStatusCode = (statusCode: number) => (
      handle: PromiseHandler<APIGatewayEvent, { body: string }>
    ) => async (event: APIGatewayEvent, context: Context) => {
      const response = await handle(event, context);
      return {
        ...response,
        statusCode,
      };
    };
    
    // Wrap the handler with the middleware.
    // With compose you can wrap multiple middlewares around one handler.
    export const handler: ProxyHandler = compose(
      addStatusCode(200),
      stringifyToBody()
    )(helloWorld);

    Usage in TypeScript strict mode

    There's a known issue with TypeScript that pipe and compose functions cannot infer types correctly if the innermost function is generic (in this case the last argument to compose). To get around it, this package also exports composeHandler:

    import "reflect-metadata";
    
    import { classValidator } from "@lambda-middleware/class-validator";
    import { compose } from "@lambda-middleware/compose";
    import { errorHandler } from "@lambda-middleware/http-error-handler";
    import { IsString } from "class-validator";
    import { APIGatewayProxyResult } from "aws-lambda";
    
    class NameBody {
      constructor(firstName: string, lastName: string) {
        this.firstName = firstName;
        this.lastName = lastName;
      }
    
      @IsString()
      public firstName: string;
    
      @IsString()
      public lastName: string;
    }
    
    async function helloWorld(event: {
      body: NameBody;
    }): Promise<APIGatewayProxyResult> {
      return {
        body: `Hello ${event.body.firstName} ${event.body.lastName}`,
        headers: {
          "content-type": "text",
        },
        statusCode: 200,
      };
    }
    
    export const handler = composeHandler(
      errorHandler(),
      classValidator({
        bodyType: NameBody,
      }),
      // The following function solves the type trouble:
      helloWorld
    );

    Install

    npm i @lambda-middleware/compose

    DownloadsWeekly Downloads

    2,687

    Version

    1.2.0

    License

    MIT

    Unpacked Size

    16.5 kB

    Total Files

    14

    Last publish

    Collaborators

    • dbartholomae