@leanstacks/serverless-common/dist/cjs/types/utils/middyfy.d.ts

LeanStacks organization common serverless components.

import middy from '@middy/core';
import { APIGatewayProxyEvent, APIGatewayProxyEventBase, APIGatewayProxyEventPathParameters, APIGatewayProxyEventQueryStringParameters, APIGatewayProxyResult, Context, ScheduledEvent, SNSEvent, SQSEvent, SQSBatchResponse } from 'aws-lambda';
import { ObjectSchema } from 'joi';
/**
 * An API Gateway authorizer context for requests authorized with the
 * LeanStacks client token.
 */
export type LSAPIClientAuthorizerContext = {
    preferred_username: string;
};
/**
 * An API Gateway authorizer context for requests authorized with a
 * Cognito token.
 */
export type LSCognitoAuthorizerContext = {
    email: string;
    family_name: string;
    given_name: string;
    permissions: {
        [teamId: string]: string[];
    };
    preferred_username: string;
    user_id: string;
};
/**
 * An API Gateway event which has been normalized by middleware.
 * @template TAuthorizerContext - The authorizer context type.
 * @template TBody - Optional. The body type. Default: `null`.
 * @template TPathParameters - Optional. The path parameters type. Default: `APIGatewayProxyEventPathParameters`.
 * @template TQueryString - Optional. The query string parameters type. Default: `APIGatewayProxyEventQueryStringParameters`.
 * @see {@link APIGatewayProxyEventBase}
 * @see {@link APIGatewayProxyEventPathParameters}
 * @see {@link APIGatewayProxyEventQueryStringParameters}
 */
export type NormalizedAPIGatewayProxyEvent<TAuthorizerContext, TBody = null, TPathParameters = APIGatewayProxyEventPathParameters, TQueryString = APIGatewayProxyEventQueryStringParameters> = Omit<APIGatewayProxyEventBase<TAuthorizerContext>, 'body' | 'pathParameters' | 'queryStringParameters'> & {
    body: TBody;
    pathParameters: TPathParameters;
    queryStringParameters: TQueryString;
};
/**
 * The AWS Lambda handler function signature for API Gateway proxy events.
 */
export type APIGatewayHandlerFn<TEvent = APIGatewayProxyEvent> = (event: TEvent, context: Context) => Promise<APIGatewayProxyResult>;
/**
 * The AWS Lambda handler function signature for Scheduled events
 * (e.g. cron events from AWS EventBridge).
 */
export type ScheduledHandlerFn = (event: ScheduledEvent, context: Context) => Promise<void>;
/**
 * The AWS Lambda handler function signature for SNS events.
 */
export type SNSHandlerFn = (event: SNSEvent, context: Context) => Promise<void>;
/**
 * The AWS Lambda handler function signature for SQS events.
 */
export type SQSHandlerFn = (event: SQSEvent, context: Context) => Promise<SQSBatchResponse | void>;
/**
 * A Lambda function for invocation by another Lambda function.
 */
export type LambdaEvent<TEvent = unknown> = TEvent;
/**
 * A Lambda function result for invocation by another Lambda function.
 */
export type LambdaResult<TResult = unknown> = {
    status: number;
    statusText: string;
    data: TResult;
};
/**
 * The AWS Lambda handler function signature for Lambda events, i.e. Lambda to
 * Lambda function invocations.
 * Note: This is generally considered an anti-pattern. Search for another
 * design pattern before utilizing Lambda-to-Lambda.
 */
export type LambdaHandler<TEvent = unknown, TResult = unknown> = (event: LambdaEvent<TEvent>, context: Context) => Promise<LambdaResult<TResult>>;
/**
 * Base options for `middyfy` functions.
 */
export type MiddyfyOptions<THandler> = {
    handler: THandler;
};
/**
 * Options for middyfied API Gateway event handler functions.
 */
export type APIGatewayMiddyfyOptions = MiddyfyOptions<APIGatewayHandlerFn> & {
    eventSchema?: ObjectSchema;
    defaultErrorMessage?: string;
    defaultErrorStatusCode?: number;
};
/**
 * Options for middyfied Scheduled event handler functions.
 */
export type ScheduledMiddyfyOptions = MiddyfyOptions<ScheduledHandlerFn> & {
    eventSchema?: ObjectSchema;
};
/**
 * Options for middyfied SNS event handler functions.
 */
export type SNSMiddyfyOptions = MiddyfyOptions<SNSHandlerFn> & {
    eventSchema?: ObjectSchema;
};
/**
 * Options for middyfied SQS event handler functions.
 */
export type SQSMiddyfyOptions = MiddyfyOptions<SQSHandlerFn> & {
    eventSchema?: ObjectSchema;
};
/**
 * Options for middyfied Lambda event handler functions.
 */
export type LambdaMiddyfyOptions<TEvent = unknown, TResult = unknown> = MiddyfyOptions<LambdaHandler<TEvent, TResult>> & {
    eventSchema?: ObjectSchema;
};
/**
 * Wraps an AWS Gateway proxy event handler function in middleware, returning the
 * AWS Lambda handler function.
 * @param options - The `APIGatewayMiddyfyOptions` object.
 * @returns A middyfied handler function.
 */
export declare const middyfyAPIGateway: (options: APIGatewayMiddyfyOptions) => middy.MiddyfiedHandler<APIGatewayProxyEvent & Omit<APIGatewayProxyEvent, "body"> & {
    body: import("type-fest").JsonValue;
} & {
    multiValueQueryStringParameters: import("aws-lambda").APIGatewayProxyEventMultiValueQueryStringParameters;
    pathParameters: APIGatewayProxyEventPathParameters;
    queryStringParameters: APIGatewayProxyEventQueryStringParameters;
}, APIGatewayProxyResult, Error, Context>;
/**
 * Wraps a Scheduled event handler function in middleware, returning the
 * AWS Lambda handler function.
 * @param options - The `ScheduledMiddyfyOptions` object.
 * @returns A middyfied handler function.
 */
export declare const middyfyScheduled: (options: ScheduledMiddyfyOptions) => middy.MiddyfiedHandler<ScheduledEvent<any>, void, Error, Context>;
/**
 * Wraps a SNS event handler function in middleware, returning the
 * AWS Lambda handler function.
 * @param options - The `SNSMiddyfyOptions` object.
 * @returns A middyfied handler function.
 */
export declare const middyfySNS: (options: SNSMiddyfyOptions) => middy.MiddyfiedHandler<SNSEvent, void, Error, Context>;
/**
 * Wraps a SQS event handler function in middleware, returning the AWS Lambda
 * handler function.
 * @param options - The `SQSMiddyfyOptions` object.
 * @returns A middyfied handler function.
 */
export declare const middyfySQS: (options: SQSMiddyfyOptions) => middy.MiddyfiedHandler<SQSEvent, void | SQSBatchResponse, Error, Context>;
/**
 * Wraps a Lambda event handler function in middleware, returning the AWS
 * Lambda handler function.
 * Note: Lambda-to-Lambda invocations are considered an anti-pattern. Search
 * for an alternative approach.
 * @param options - The `LambdaMiddyfyOptions` object.
 * @returns A middyfied handler function.
 * @see {@link https://docs.aws.amazon.com/lambda/latest/operatorguide/functions-calling-functions.html}
 */
export declare const middyfyLambda: <TEvent, TResult>(options: LambdaMiddyfyOptions<TEvent, TResult>) => middy.MiddyfiedHandler<TEvent, LambdaResult<TResult>, Error, Context>;