@bitblit/ratchet-epsilon-common 4.0.1-alpha

package/lib/config/s3-config.d.ts

@@ -0,0 +1,6 @@
+import { GenericAwsEventHandlerFunction } from './generic-aws-event-handler-function.js';
+import { S3Event } from 'aws-lambda';
+export interface S3Config {
+    createHandlers: Map<string, GenericAwsEventHandlerFunction<S3Event>>;
+    removeHandlers: Map<string, GenericAwsEventHandlerFunction<S3Event>>;
+}

package/lib/config/sns-config.d.ts

@@ -0,0 +1,5 @@
+import { GenericAwsEventHandlerFunction } from './generic-aws-event-handler-function.js';
+import { SNSEvent } from 'aws-lambda';
+export interface SnsConfig {
+    handlers: Map<string, GenericAwsEventHandlerFunction<SNSEvent>>;
+}

package/lib/epsilon-build-properties.d.ts

@@ -0,0 +1,9 @@
+export declare class EpsilonBuildProperties {
+    private constructor();
+    static get buildVersion(): string;
+    static get buildHash(): string;
+    static get buildBranch(): string;
+    static get buildTag(): string;
+    static get buildBranchOrTag(): string;
+    static get buildTime(): string;
+}

package/lib/epsilon-constants.d.ts

@@ -0,0 +1,16 @@
+import { EpsilonGlobalHandler } from './epsilon-global-handler.js';
+export declare class EpsilonConstants {
+    static readonly EPSILON_FINDER_DYNAMIC_IMPORT_PATH_ENV_NAME = "EPSILON_FINDER_DYNAMIC_IMPORT_PATH";
+    static readonly EPSILON_FINDER_FUNCTION_NAME_ENV_NAME = "EPSILON_FINDER_FUNCTION_NAME";
+    static readonly DEFAULT_EPSILON_FINDER_DYNAMIC_IMPORT_PATH = "epsilon-global-handler-provider.js";
+    static readonly DEFAULT_EPSILON_FINDER_FUNCTION_NAME = "findEpsilonGlobalHandler";
+    static readonly AUTH_HEADER_PREFIX: string;
+    static readonly AUTH_HEADER_NAME: string;
+    static readonly BACKGROUND_SQS_TYPE_FIELD = "BACKGROUND_TYPE";
+    static readonly BACKGROUND_SNS_START_MARKER = "BACKGROUND_START_MARKER";
+    static readonly BACKGROUND_SNS_IMMEDIATE_RUN_FLAG = "BACKGROUND_IMMEDIATE_RUN_FLAG";
+    static readonly INTER_API_SNS_EVENT = "EPSILON_INTER_API_EVENT";
+    private static load;
+    static findDynamicImportEpsilonGlobalHandlerProvider(): Promise<EpsilonGlobalHandler>;
+    private constructor();
+}

package/lib/epsilon-global-handler.d.ts

@@ -0,0 +1,20 @@
+import { Context, ProxyResult } from 'aws-lambda';
+import { BackgroundEntry } from './background/background-entry.js';
+import { EpsilonInstance } from './epsilon-instance.js';
+import { LoggerOptions } from '@bitblit/ratchet-common';
+export declare class EpsilonGlobalHandler {
+    private _epsilon;
+    private static LOGGER_CONFIGURED;
+    private static GLOBAL_INSTANCE_PROVIDER;
+    static set globalInstanceProvider(input: () => Promise<EpsilonGlobalHandler>);
+    static get globalInstanceProvider(): () => Promise<EpsilonGlobalHandler>;
+    private handlers;
+    constructor(_epsilon: EpsilonInstance);
+    static configureDefaultLogger(overrides?: LoggerOptions): void;
+    get epsilon(): EpsilonInstance;
+    processSingleBackgroundByParts<T>(type: string, data?: T, overrideTraceId?: string, overrideTraceDepth?: number): Promise<boolean>;
+    processSingleBackgroundEntry(e: BackgroundEntry<any>, overrideTraceId?: string, overrideTraceDepth?: number): Promise<boolean>;
+    lambdaHandler(event: any, context: Context): Promise<any>;
+    innerLambdaHandler(event: any, context: Context): Promise<any>;
+    static defaultProcessUncaughtError(event: any, context: Context, err: any): Promise<ProxyResult>;
+}

package/lib/epsilon-instance.d.ts

@@ -0,0 +1,14 @@
+import { EpsilonConfig } from './config/epsilon-config.js';
+import { WebHandler } from './http/web-handler.js';
+import { BackgroundHandler } from './background/background-handler.js';
+import { OpenApiDocument } from './config/open-api/open-api-document.js';
+import { ModelValidator } from '@bitblit/ratchet-misc';
+import { BackgroundManagerLike } from './background/manager/background-manager-like.js';
+export interface EpsilonInstance {
+    config: EpsilonConfig;
+    parsedOpenApiDoc: OpenApiDocument;
+    modelValidator: ModelValidator;
+    webHandler: WebHandler;
+    backgroundHandler: BackgroundHandler;
+    backgroundManager: BackgroundManagerLike;
+}

package/lib/epsilon-logging-extension-processor.d.ts

@@ -0,0 +1,6 @@
+import { LogMessage } from '@bitblit/ratchet-common';
+import { LogMessageProcessor } from '@bitblit/ratchet-common';
+export declare class EpsilonLoggingExtensionProcessor implements LogMessageProcessor {
+    process(msg: LogMessage): LogMessage;
+    label(): string;
+}

package/lib/http/auth/api-gateway-adapter-authentication-handler.d.ts

@@ -0,0 +1,8 @@
+import { Callback, Context, CustomAuthorizerEvent } from 'aws-lambda';
+export declare class ApiGatewayAdapterAuthenticationHandler {
+    private webTokenManipulator;
+    constructor(issuer: string, encryptionKeys: string);
+    lambdaHandler(event: CustomAuthorizerEvent, context: Context, callback: Callback): void;
+    private createPolicy;
+    static extractTokenStringFromAuthorizerEvent(event: CustomAuthorizerEvent): string;
+}

package/lib/http/auth/auth0-web-token-manipulator.d.ts

@@ -0,0 +1,13 @@
+import { JwtTokenBase } from '@bitblit/ratchet-common';
+import { WebTokenManipulator } from './web-token-manipulator.js';
+export declare class Auth0WebTokenManipulator implements WebTokenManipulator<JwtTokenBase> {
+    private clientId;
+    private jwksUri;
+    private issuer;
+    private jwksClient;
+    constructor(clientId: string, jwksUri: string, issuer: string);
+    extractTokenFromAuthorizationHeader<T>(authHeader: string): Promise<JwtTokenBase>;
+    parseAndValidateAuth0Token<T>(auth0Token: string, allowExpired?: boolean): Promise<JwtTokenBase>;
+    private fetchSigningKey;
+    private fetchJwksClient;
+}

package/lib/http/auth/basic-auth-token.d.ts

@@ -0,0 +1,4 @@
+export interface BasicAuthToken {
+    username: string;
+    password: string;
+}

package/lib/http/auth/google-web-token-manipulator.d.ts

@@ -0,0 +1,14 @@
+import { WebTokenManipulator } from './web-token-manipulator.js';
+import { JwtTokenBase } from '@bitblit/ratchet-common';
+export declare class GoogleWebTokenManipulator implements WebTokenManipulator<JwtTokenBase> {
+    private clientId;
+    private static readonly GOOGLE_DISCOVERY_DOCUMENT;
+    private cacheGoogleDiscoveryDocument;
+    private jwksClient;
+    constructor(clientId: string);
+    extractTokenFromAuthorizationHeader<T extends JwtTokenBase>(authHeader: string): Promise<JwtTokenBase>;
+    parseAndValidateGoogleToken<T extends JwtTokenBase>(googleToken: string, allowExpired?: boolean): Promise<JwtTokenBase>;
+    private fetchSigningKey;
+    private fetchJwksClient;
+    private fetchGoogleDiscoveryDocument;
+}

package/lib/http/auth/google-web-token-manipulator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/http/auth/jwt-ratchet-local-web-token-manipulator.d.ts

@@ -0,0 +1,11 @@
+import { WebTokenManipulator } from './web-token-manipulator.js';
+import { JwtTokenBase } from '@bitblit/ratchet-common';
+import { JwtRatchetLike } from '@bitblit/ratchet-common';
+export declare class JwtRatchetLocalWebTokenManipulator<T extends JwtTokenBase> implements WebTokenManipulator<T> {
+    private _jwtRatchet;
+    private _issuer;
+    constructor(_jwtRatchet: JwtRatchetLike, _issuer: string);
+    get jwtRatchet(): JwtRatchetLike;
+    get issuer(): string;
+    extractTokenFromAuthorizationHeader<T>(header: string): Promise<T>;
+}

package/lib/http/auth/local-web-token-manipulator.d.ts

@@ -0,0 +1,19 @@
+import { WebTokenManipulator } from './web-token-manipulator.js';
+import { LoggerLevelName } from '@bitblit/ratchet-common';
+import { JwtTokenBase } from '@bitblit/ratchet-common';
+import { JwtRatchet } from '@bitblit/ratchet-common';
+export declare class LocalWebTokenManipulator<T extends JwtTokenBase> implements WebTokenManipulator<T> {
+    private encryptionKeys;
+    private issuer;
+    private _ratchet;
+    constructor(encryptionKeys: string[], issuer: string);
+    withExtraDecryptionKeys(keys: string[]): LocalWebTokenManipulator<T>;
+    withParseFailureLogLevel(logLevel: LoggerLevelName): LocalWebTokenManipulator<T>;
+    withOldKeyUseLogLevel(logLevel: LoggerLevelName): LocalWebTokenManipulator<T>;
+    get jwtRatchet(): JwtRatchet;
+    get selectRandomEncryptionKey(): Promise<string>;
+    createRefreshedJWTString(tokenString: string, expirationSeconds: number, allowExpired?: boolean): Promise<string>;
+    parseAndValidateJWTStringAsync<T extends JwtTokenBase>(tokenString: string): Promise<T>;
+    createJWTStringAsync<T>(principal: string, userObject: T, roles?: string[], expirationSeconds?: number, proxyUser?: T): Promise<string>;
+    extractTokenFromAuthorizationHeader<T extends JwtTokenBase>(header: string): Promise<T>;
+}

package/lib/http/auth/local-web-token-manipulator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/http/auth/web-token-manipulator.d.ts

@@ -0,0 +1,4 @@
+import { JwtTokenBase } from '@bitblit/ratchet-common';
+export interface WebTokenManipulator<T extends JwtTokenBase> {
+    extractTokenFromAuthorizationHeader(header: string): Promise<T>;
+}

package/lib/http/error/bad-gateway.d.ts

@@ -0,0 +1,5 @@
+import { EpsilonHttpError } from './epsilon-http-error.js';
+export declare class BadGateway<T = void> extends EpsilonHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/bad-request-error.d.ts

@@ -0,0 +1,5 @@
+import { EpsilonHttpError } from './epsilon-http-error.js';
+export declare class BadRequestError<T = void> extends EpsilonHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/conflict-error.d.ts

@@ -0,0 +1,5 @@
+import { EpsilonHttpError } from './epsilon-http-error.js';
+export declare class ConflictError<T = void> extends EpsilonHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/epsilon-http-error.d.ts

@@ -0,0 +1,41 @@
+export declare class EpsilonHttpError<T = void> extends Error {
+    private static readonly EPSILON_HTTP_ERROR_FLAG_KEY;
+    private _httpStatusCode;
+    private _errors;
+    private _detailErrorCode;
+    private _endUserErrors;
+    private _details;
+    private _requestId;
+    private _wrappedError;
+    constructor(...errors: string[]);
+    static combineErrorStringsWithDefault(errors: string[], defMessage?: string): string;
+    setFormattedErrorMessage(format: string, ...input: any[]): void;
+    withFormattedErrorMessage(format: string, ...input: any[]): EpsilonHttpError<T>;
+    withHttpStatusCode(httpStatusCode: number): EpsilonHttpError<T>;
+    withErrors(errors: string[]): EpsilonHttpError<T>;
+    withDetailErrorCode(detailErrorCode: number): EpsilonHttpError<T>;
+    withEndUserErrors(endUserErrors: string[]): EpsilonHttpError<T>;
+    withDetails(details: T): EpsilonHttpError<T>;
+    withRequestId(requestId: string): EpsilonHttpError<T>;
+    withWrappedError(err: Error): EpsilonHttpError<T>;
+    isWrappedError(): boolean;
+    static wrapError<T = void>(err: Error): EpsilonHttpError<T>;
+    static objectIsEpsilonHttpError(obj: any): boolean;
+    get httpStatusCode(): number;
+    get errors(): string[];
+    get detailErrorCode(): number;
+    get endUserErrors(): string[];
+    get details(): T;
+    get requestId(): string;
+    get wrappedError(): Error;
+    set httpStatusCode(value: number);
+    set errors(value: string[]);
+    set detailErrorCode(value: number);
+    set endUserErrors(value: string[]);
+    set details(value: T);
+    set requestId(value: string);
+    set wrappedError(value: Error);
+    static errorIsX0x(errIn: Error, xClass: number): boolean;
+    static errorIs40x(err: Error): boolean;
+    static errorIs50x(err: Error): boolean;
+}

package/lib/http/error/epsilon-http-error.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/http/error/forbidden-error.d.ts

@@ -0,0 +1,5 @@
+import { EpsilonHttpError } from './epsilon-http-error.js';
+export declare class ForbiddenError<T = void> extends EpsilonHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/gateway-timeout.d.ts

@@ -0,0 +1,5 @@
+import { EpsilonHttpError } from './epsilon-http-error.js';
+export declare class GatewayTimeout<T = void> extends EpsilonHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/method-not-allowed-error.d.ts

@@ -0,0 +1,5 @@
+import { EpsilonHttpError } from './epsilon-http-error.js';
+export declare class MethodNotAllowedError<T = void> extends EpsilonHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/misconfigured-error.d.ts

@@ -0,0 +1,5 @@
+import { EpsilonHttpError } from './epsilon-http-error.js';
+export declare class MisconfiguredError<T = void> extends EpsilonHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/not-found-error.d.ts

@@ -0,0 +1,5 @@
+import { EpsilonHttpError } from './epsilon-http-error.js';
+export declare class NotFoundError<T = void> extends EpsilonHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/not-implemented.d.ts

@@ -0,0 +1,5 @@
+import { EpsilonHttpError } from './epsilon-http-error.js';
+export declare class NotImplemented<T = void> extends EpsilonHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/request-timeout-error.d.ts

@@ -0,0 +1,5 @@
+import { EpsilonHttpError } from './epsilon-http-error.js';
+export declare class RequestTimeoutError<T = void> extends EpsilonHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/service-unavailable.d.ts

@@ -0,0 +1,5 @@
+import { EpsilonHttpError } from './epsilon-http-error.js';
+export declare class ServiceUnavailable<T = void> extends EpsilonHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/too-many-requests-error.d.ts

@@ -0,0 +1,5 @@
+import { EpsilonHttpError } from './epsilon-http-error.js';
+export declare class TooManyRequestsError<T = void> extends EpsilonHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/unauthorized-error.d.ts

@@ -0,0 +1,5 @@
+import { EpsilonHttpError } from './epsilon-http-error.js';
+export declare class UnauthorizedError<T = void> extends EpsilonHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/event-util.d.ts

@@ -0,0 +1,25 @@
+import { APIGatewayEvent, APIGatewayEventRequestContext, AuthResponseContext } from 'aws-lambda';
+import { EpsilonLoggerConfig } from '../config/epsilon-logger-config.js';
+import { LoggerLevelName } from '@bitblit/ratchet-common';
+import { BasicAuthToken } from './auth/basic-auth-token.js';
+export declare class EventUtil {
+    private constructor();
+    static extractStage(event: APIGatewayEvent): string;
+    static extractHostHeader(event: APIGatewayEvent): string;
+    static extractProtocol(event: APIGatewayEvent): string;
+    static extractApiGatewayStage(event: APIGatewayEvent): string;
+    static extractRequestContext(event: APIGatewayEvent): APIGatewayEventRequestContext;
+    static extractAuthorizer(event: APIGatewayEvent): AuthResponseContext;
+    static ipAddressChain(event: APIGatewayEvent): string[];
+    static ipAddress(event: APIGatewayEvent): string;
+    static extractFullPath(event: APIGatewayEvent, overrideProtocol?: string): string;
+    static extractFullPrefix(event: APIGatewayEvent, overrideProtocol?: string): string;
+    static jsonBodyToObject(event: APIGatewayEvent): any;
+    static calcLogLevelViaEventOrEnvParam(curLevel: LoggerLevelName, event: APIGatewayEvent, rConfig: EpsilonLoggerConfig): LoggerLevelName;
+    static fixStillEncodedQueryParams(event: APIGatewayEvent): void;
+    static applyTokenToEventForTesting(event: APIGatewayEvent, jwtToken: string): void;
+    static extractBasicAuthenticationToken(event: APIGatewayEvent, throwErrorOnMissingBad?: boolean): BasicAuthToken;
+    static eventIsAGraphQLIntrospection(event: APIGatewayEvent): boolean;
+    static extractAuthorizationHeaderCaseInsensitive(evt: APIGatewayEvent): string;
+    static extractBearerTokenFromEvent(evt: APIGatewayEvent): string;
+}

package/lib/http/event-util.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/http/response-util.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { ProxyResult } from 'aws-lambda';
+import { EpsilonHttpError } from './error/epsilon-http-error.js';
+export declare class ResponseUtil {
+    private constructor();
+    static errorResponse<T>(err: EpsilonHttpError<T>): ProxyResult;
+    static redirect(target: string, code?: number, queryParams?: any): ProxyResult;
+    static coerceToProxyResult(input: any): ProxyResult;
+    static applyGzipIfPossible(encodingHeader: string, proxyResult: ProxyResult): Promise<ProxyResult>;
+    static gzip(input: Buffer): Promise<Buffer>;
+}

package/lib/http/response-util.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/http/route/epsilon-router.d.ts

@@ -0,0 +1,8 @@
+import { RouteMapping } from './route-mapping.js';
+import { ModelValidator } from '@bitblit/ratchet-misc';
+import { HttpConfig } from '../../config/http/http-config.js';
+export interface EpsilonRouter {
+    routes: RouteMapping[];
+    openApiModelValidator: ModelValidator;
+    config: HttpConfig;
+}

package/lib/http/route/extended-auth-response-context.d.ts

@@ -0,0 +1,6 @@
+import { AuthResponseContext } from 'aws-lambda';
+export interface ExtendedAuthResponseContext extends AuthResponseContext {
+    userData: any;
+    userDataJSON: string;
+    srcData: string;
+}

package/lib/http/route/route-mapping.d.ts

@@ -0,0 +1,12 @@
+import { RouteValidatorConfig } from './route-validator-config.js';
+import { HandlerFunction } from '../../config/http/handler-function.js';
+import { HttpProcessingConfig } from '../../config/http/http-processing-config.js';
+export interface RouteMapping {
+    method: string;
+    path: string;
+    function: HandlerFunction<any>;
+    metaProcessingConfig: HttpProcessingConfig;
+    validation: RouteValidatorConfig;
+    outboundValidation: RouteValidatorConfig;
+    authorizerName: string;
+}

package/lib/http/route/route-validator-config.d.ts

@@ -0,0 +1,5 @@
+export interface RouteValidatorConfig {
+    modelName: string;
+    emptyAllowed: boolean;
+    extraPropertiesAllowed: boolean;
+}

package/lib/http/route/router-util.d.ts

@@ -0,0 +1,23 @@
+import { EpsilonRouter } from './epsilon-router.js';
+import { JwtTokenBase } from '@bitblit/ratchet-common';
+import { OpenApiDocument } from '../../config/open-api/open-api-document.js';
+import { ModelValidator } from '@bitblit/ratchet-misc';
+import { BackgroundHttpAdapterHandler } from '../../background/background-http-adapter-handler.js';
+import { HttpConfig } from '../../config/http/http-config.js';
+import { HttpProcessingConfig } from '../../config/http/http-processing-config.js';
+import { WebTokenManipulator } from '../auth/web-token-manipulator.js';
+import { FilterFunction } from '../../config/http/filter-function.js';
+export declare class RouterUtil {
+    private constructor();
+    static defaultAuthenticationHeaderParsingEpsilonPreFilters(webTokenManipulator: WebTokenManipulator<JwtTokenBase>): FilterFunction[];
+    static defaultEpsilonPreFilters(): FilterFunction[];
+    static defaultEpsilonPostFilters(): FilterFunction[];
+    static defaultEpsilonErrorFilters(): FilterFunction[];
+    static defaultHttpMetaProcessingConfigWithAuthenticationHeaderParsing(webTokenManipulator: WebTokenManipulator<JwtTokenBase>): HttpProcessingConfig;
+    static defaultHttpMetaProcessingConfig(): HttpProcessingConfig;
+    static assignDefaultsOnHttpConfig(cfg: HttpConfig): HttpConfig;
+    static findApplicableMeta(httpConfig: HttpConfig, method: string, path: string): HttpProcessingConfig;
+    static openApiYamlToRouterConfig(httpConfig: HttpConfig, openApiDoc: OpenApiDocument, modelValidator: ModelValidator, backgroundHttpAdapterHandler: BackgroundHttpAdapterHandler): EpsilonRouter;
+    private static findAndValidateModelName;
+    static openApiPathToRouteParserPath(input: string): string;
+}

package/lib/http/route/router-util.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/http/web-handler.d.ts

@@ -0,0 +1,23 @@
+import { EpsilonRouter } from './route/epsilon-router.js';
+import { APIGatewayEvent, Context, ProxyResult } from 'aws-lambda';
+import Route from 'route-parser';
+import { RouteMapping } from './route/route-mapping.js';
+import { ExtendedAPIGatewayEvent } from '../config/http/extended-api-gateway-event.js';
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler.js';
+export declare class WebHandler implements EpsilonLambdaEventHandler<APIGatewayEvent> {
+    private routerConfig;
+    static readonly MAXIMUM_LAMBDA_BODY_SIZE_BYTES: number;
+    constructor(routerConfig: EpsilonRouter);
+    get router(): EpsilonRouter;
+    extractLabel(evt: APIGatewayEvent, context: Context): string;
+    handlesEvent(evt: any): boolean;
+    processEvent(event: APIGatewayEvent, context: Context): Promise<ProxyResult>;
+    openApiLambdaHandler(evt: ExtendedAPIGatewayEvent, context: Context): Promise<ProxyResult>;
+    findBestMatchingRoute(event: APIGatewayEvent): RouteAndParse;
+    private cleanPath;
+}
+export interface RouteAndParse {
+    mapping: RouteMapping;
+    route: Route;
+    parsed: any;
+}

package/lib/http/web-handler.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/http/web-v2-handler.d.ts

@@ -0,0 +1,10 @@
+import { APIGatewayProxyEventV2, Context, ProxyResult } from 'aws-lambda';
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler.js';
+import { WebHandler } from './web-handler.js';
+export declare class WebV2Handler implements EpsilonLambdaEventHandler<APIGatewayProxyEventV2> {
+    private webHandler;
+    constructor(webHandler: WebHandler);
+    extractLabel(evt: APIGatewayProxyEventV2, context: Context): string;
+    handlesEvent(evt: any): boolean;
+    processEvent(evt: APIGatewayProxyEventV2, context: Context): Promise<ProxyResult>;
+}

package/lib/index.d.ts

@@ -0,0 +1,132 @@
+export * from './epsilon-build-properties.js';
+export * from './epsilon-constants.js';
+export * from './epsilon-global-handler.js';
+export * from './epsilon-instance.js';
+export * from './epsilon-logging-extension-processor.js';
+export * from './inter-api-manager.js';
+export * from './local-container-server.js';
+export * from './local-server-cert.js';
+export * from './local-server.js';
+export * from './background/background-dynamo-log-table-handler.js';
+export * from './background/background-entry.js';
+export * from './background/background-execution-event-type.js';
+export * from './background/background-execution-event.js';
+export * from './background/background-execution-listener.js';
+export * from './background/background-handler.js';
+export * from './background/background-http-adapter-handler.js';
+export * from './background/background-meta-response-internal.js';
+export * from './background/background-process-handling.js';
+export * from './background/background-process-log-table-entry.js';
+export * from './background/background-queue-response-internal.js';
+export * from './background/background-validator.js';
+export * from './background/epsilon-background-process-error.js';
+export * from './background/internal-background-entry.js';
+export * from './background/s3-background-transaction-logger.js';
+export * from './background/manager/abstract-background-manager.js';
+export * from './background/manager/aws-sqs-sns-background-manager.js';
+export * from './background/manager/background-manager-like.js';
+export * from './background/manager/single-thread-local-background-manager.js';
+export * from './build/ratchet-epsilon-common-info.js';
+export * from './built-in/built-in-trace-id-generators.js';
+export * from './built-in/background/echo-processor.js';
+export * from './built-in/background/log-and-enqueue-echo-processor.js';
+export * from './built-in/background/log-message-background-error-processor.js';
+export * from './built-in/background/no-op-processor.js';
+export * from './built-in/background/retry-processor.js';
+export * from './built-in/background/sample-delay-processor.js';
+export * from './built-in/background/sample-input-validated-processor-data.js';
+export * from './built-in/background/sample-input-validated-processor.js';
+export * from './built-in/daemon/daemon-authorizer-function.js';
+export * from './built-in/daemon/daemon-config.js';
+export * from './built-in/daemon/daemon-group-selection-function.js';
+export * from './built-in/daemon/daemon-handler.js';
+export * from './built-in/daemon/daemon-process-state-list.js';
+export * from './built-in/http/apollo-filter.js';
+export * from './built-in/http/built-in-auth-filters.js';
+export * from './built-in/http/built-in-authorizers.js';
+export * from './built-in/http/built-in-filters.js';
+export * from './built-in/http/built-in-handlers.js';
+export * from './built-in/http/log-level-manipulation-filter.js';
+export * from './built-in/http/run-handler-as-filter.js';
+export * from './cli/ratchet-cli-handler.js';
+export * from './cli/run-background-process-from-command-line.js';
+export * from './config/dynamo-db-config.js';
+export * from './config/epsilon-config.js';
+export * from './config/epsilon-lambda-event-handler.js';
+export * from './config/epsilon-logger-config.js';
+export * from './config/generic-aws-event-handler-function.js';
+export * from './config/logging-trace-id-generator.js';
+export * from './config/s3-config.js';
+export * from './config/sns-config.js';
+export * from './config/background/background-aws-config.js';
+export * from './config/background/background-config.js';
+export * from './config/background/background-error-processor.js';
+export * from './config/background/background-processor.js';
+export * from './config/background/background-transaction-log.js';
+export * from './config/background/background-transaction-logger.js';
+export * from './config/cron/abstract-cron-entry.js';
+export * from './config/cron/cron-background-entry.js';
+export * from './config/cron/cron-config.js';
+export * from './config/http/authorizer-function.js';
+export * from './config/http/epsilon-authorization-context.js';
+export * from './config/http/extended-api-gateway-event.js';
+export * from './config/http/filter-chain-context.js';
+export * from './config/http/filter-function.js';
+export * from './config/http/handler-function.js';
+export * from './config/http/http-config.js';
+export * from './config/http/http-processing-config.js';
+export * from './config/http/mapped-http-processing-config.js';
+export * from './config/http/null-returned-object-handling.js';
+export * from './config/inter-api/inter-api-aws-config.js';
+export * from './config/inter-api/inter-api-config.js';
+export * from './config/inter-api/inter-api-process-mapping.js';
+export * from './config/open-api/open-api-document-components.js';
+export * from './config/open-api/open-api-document-path.js';
+export * from './config/open-api/open-api-document.js';
+export * from './http/event-util.js';
+export * from './http/response-util.js';
+export * from './http/web-handler.js';
+export * from './http/web-v2-handler.js';
+export * from './http/auth/api-gateway-adapter-authentication-handler.js';
+export * from './http/auth/auth0-web-token-manipulator.js';
+export * from './http/auth/basic-auth-token.js';
+export * from './http/auth/google-web-token-manipulator.js';
+export * from './http/auth/jwt-ratchet-local-web-token-manipulator.js';
+export * from './http/auth/local-web-token-manipulator.js';
+export * from './http/auth/web-token-manipulator.js';
+export * from './http/error/bad-gateway.js';
+export * from './http/error/bad-request-error.js';
+export * from './http/error/conflict-error.js';
+export * from './http/error/epsilon-http-error.js';
+export * from './http/error/forbidden-error.js';
+export * from './http/error/gateway-timeout.js';
+export * from './http/error/method-not-allowed-error.js';
+export * from './http/error/misconfigured-error.js';
+export * from './http/error/not-found-error.js';
+export * from './http/error/not-implemented.js';
+export * from './http/error/request-timeout-error.js';
+export * from './http/error/service-unavailable.js';
+export * from './http/error/too-many-requests-error.js';
+export * from './http/error/unauthorized-error.js';
+export * from './http/route/epsilon-router.js';
+export * from './http/route/extended-auth-response-context.js';
+export * from './http/route/route-mapping.js';
+export * from './http/route/route-validator-config.js';
+export * from './http/route/router-util.js';
+export * from './inter-api/inter-api-entry.js';
+export * from './inter-api/inter-api-util.js';
+export * from './lambda-event-handler/cron-epsilon-lambda-event-handler.js';
+export * from './lambda-event-handler/dynamo-epsilon-lambda-event-handler.js';
+export * from './lambda-event-handler/generic-sns-epsilon-lambda-event-handler.js';
+export * from './lambda-event-handler/inter-api-epsilon-lambda-event-handler.js';
+export * from './lambda-event-handler/s3-epsilon-lambda-event-handler.js';
+export * from './open-api-util/open-api-doc-modifications.js';
+export * from './open-api-util/open-api-doc-modifier.js';
+export * from './open-api-util/yaml-combiner.js';
+export * from './sample/sample-server-components.js';
+export * from './sample/sample-server-static-files.js';
+export * from './sample/test-error-server.js';
+export * from './util/aws-util.js';
+export * from './util/context-util.js';
+export * from './util/cron-util.js';
+export * from './util/epsilon-config-parser.js';