lamprox v0.15.2

Lamprox

Framework for development lambda-proxy function of AWS Lambda.

Setup

$ npm install lamprox

Concept and Usage

Lamprox is a minimal and flexible framework for lambda-proxy function of AWS Lambda.
When building multiple endpoints with AWS Lambda, authentication, response processing, and error handling can be applied across functions in each function.

Process

Lamprox defines a handler with multiple Process.
Process is a function as shown below.

interface Process<T, U, E> {
  (ambience: ProcessAmbience<T, E>): Promise<U | undefined>
}

interface ProcessAmbience<T, E> {
  /** Variables that pssed lambda function. */
  lambda: {
    event: APIGatewayEvent
    context: Context
    callback: ProxyCallback
  }
  /** Result that preceding process. */
  result?: T
  /** Shared variables accross that processes. */
  environments: E
}

Processor

Processor is a class that collects processes and executes them in order.
Processor holds the processes before, main, after, response, onError and executes it as a handler.

/** Preparing before main process. */
type BeforeProcess<T, E> = Process<undefined, T, E>
/** Main process for request. */
type MainProcess<T, U, E> = Process<T, U, E>
/** After process. */
type AfterProcess<U, E> = Process<U, U, E>
/** Process that creating proxy result. */
type ResponseProcess<U, E> = Process<U, ProxyResult, E>
/** Process that called when error occured. */
type OnErrorProcess<E> = Process<Error, ProxyResult, E>

interface IProcessor<T, U, E> {
  before: BeforeProcess<T, E>
  main: MainProcess<T, U, E>
  after: AfterProcess<U, E>
  response: ResponseProcess<U, E>
  onError: OnErrorProcess<E>

  toHandler: () => LambdaProxyHandler
}

Functions

Generally, it is not necessary to directly generate a processor.
Lamprox provides several functions for creating handler.

lamprox()

Create simple lambda proxy handler.
You can create a handler for lambda-proxy by simply writing a method to generate the response body.

lamprox: <U>(main: MainProcess<undefined, U, undefined>) => LambdaProxyHandler

buildHandler()

Create lambda function with various processes - befire, after, response, onError - and enviroments.
Enviroments is value shared across processes.

buildHandler: <T, U, E>(parmas: LambdaProxyHandlerBuilder.Params<T, U, E>) => LambdaProxyHandler

prepareHandlerBuilder()

prepareHandlerBuilder() is a function for creating buildHandler function.
Assuming that there are many Lambda functions, you can generate a buildHandler function that defines a common process.

prepareHandlerBuilder: <T, U, E>(preparedOptions?: ProcessorOptions<T, U, E>) => LambdaProxyHandlerBuilder<T, U, E>

Utilities

Lamprox contains node-lambda-utilities, but provides some utility functions for lambda-proxy.

generateDummyAPIGatewayEvent()

This is a function for generating a dummy APIGatewayEvent.
You can test the handler by using it together with invokeHandler() of node-lambda-utilities.

generateDummyAPIGatewayEvent: (params?: GenerateDummyAPIGatewayEvent.Params) => APIGatewayEvent

generateProcessAmbience()

A function that generates ProcessAmbience which is an argument when Process is executed.
By using this, it is possible to test each Process.

generateProcessAmbience: <T, E>(params: GenerateProcessAmbience.Params<T, E>) => ProcessAmbience<T, E>