@bitblit/ratchet-epsilon-common 4.0.85-alpha

package/dist/cjs/http/response-util.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseUtil = void 0;
+const tslib_1 = require("tslib");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const zlib_1 = tslib_1.__importDefault(require("zlib"));
+class ResponseUtil {
+    constructor() { }
+    static errorResponse(err) {
+        const body = {
+            errors: err.errors,
+            httpStatusCode: err.httpStatusCode,
+            requestId: err.requestId,
+        };
+        if (err.detailErrorCode) {
+            body['detailErrorCode'] = err.detailErrorCode;
+        }
+        if (err.endUserErrors && err.endUserErrors.length > 0) {
+            body['endUserErrors'] = err.endUserErrors;
+        }
+        if (err.details) {
+            body['details'] = err.details;
+        }
+        if (err.wrappedError) {
+            body['wrappedError'] = err.wrappedError.name + ' : ' + err.wrappedError.message;
+        }
+        const errorResponse = {
+            statusCode: err.httpStatusCode,
+            isBase64Encoded: false,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body),
+        };
+        return errorResponse;
+    }
+    static redirect(target, code = 301, queryParams = null) {
+        if (code !== 301 && code !== 302 && code !== 307) {
+            throw new Error('Code must be 301 or 302 or 307 for a redirect');
+        }
+        let redirectTarget = target;
+        if (queryParams) {
+            const keys = Object.keys(queryParams);
+            if (keys.length > 0) {
+                ratchet_common_1.Logger.silly('Applying params to input target : %j', queryParams);
+                redirectTarget += redirectTarget.indexOf('?') === -1 ? '?' : '&';
+                for (let i = 0; i < keys.length; i++) {
+                    const k = keys[i];
+                    redirectTarget += k + '=' + encodeURIComponent(queryParams[k]);
+                    if (i < keys.length - 1) {
+                        redirectTarget += '&';
+                    }
+                }
+            }
+        }
+        return {
+            statusCode: code,
+            body: '{"redirect-target":"' + redirectTarget + '}',
+            headers: {
+                'Content-Type': 'application/json',
+                Location: redirectTarget,
+            },
+        };
+    }
+    static coerceToProxyResult(input) {
+        let rval = null;
+        if (input != null) {
+            if (typeof input === 'object') {
+                if (input.statusCode && input.body !== undefined) {
+                    rval = Object.assign({}, input);
+                    if (typeof input.body === 'string') {
+                    }
+                    else if (Buffer.isBuffer(input.body)) {
+                        rval.body = input.body.toString('base64');
+                        rval.headers = input.headers || {};
+                        rval.headers['Content-Type'] = input.body.contentType;
+                        rval.isBase64Encoded = true;
+                    }
+                }
+                else {
+                    const headers = input.headers || {};
+                    headers['Content-Type'] = 'application/json';
+                    rval = ResponseUtil.coerceToProxyResult({
+                        statusCode: 200,
+                        body: JSON.stringify(input),
+                        headers: headers,
+                        isBase64Encoded: false,
+                    });
+                }
+            }
+            else if (typeof input === 'string' || Buffer.isBuffer(input)) {
+                rval = ResponseUtil.coerceToProxyResult({ statusCode: 200, body: input });
+            }
+            else {
+                const headers = input.headers || {};
+                headers['Content-Type'] = 'application/json';
+                rval = ResponseUtil.coerceToProxyResult({
+                    statusCode: 200,
+                    body: JSON.stringify(input),
+                    headers: headers,
+                    isBase64Encoded: false,
+                });
+            }
+        }
+        return rval;
+    }
+    static async applyGzipIfPossible(encodingHeader, proxyResult) {
+        const rval = proxyResult;
+        if (encodingHeader && encodingHeader.toLowerCase().indexOf('gzip') > -1) {
+            const bigEnough = proxyResult.body.length > 1400;
+            let contentType = ratchet_common_2.MapRatchet.extractValueFromMapIgnoreCase(proxyResult.headers, 'content-type') || '';
+            contentType = contentType.toLowerCase();
+            const exemptContent = contentType === 'application/pdf' || contentType === 'application/zip' || contentType.startsWith('image/');
+            if (bigEnough && !exemptContent) {
+                const asBuffer = proxyResult.isBase64Encoded ? Buffer.from(proxyResult.body, 'base64') : Buffer.from(proxyResult.body);
+                const zipped = await this.gzip(asBuffer);
+                ratchet_common_1.Logger.info('Comp from %s to %d bytes', asBuffer.length, zipped.length);
+                const zipped64 = zipped.toString('base64');
+                rval.body = zipped64;
+                rval.isBase64Encoded = true;
+                rval.headers = rval.headers || {};
+                rval.headers['Content-Encoding'] = 'gzip';
+            }
+            else {
+                ratchet_common_1.Logger.silly('Not gzipping, too small or exempt content');
+            }
+        }
+        else {
+            ratchet_common_1.Logger.silly('Not gzipping, not an accepted encoding');
+        }
+        return rval;
+    }
+    static gzip(input) {
+        const promise = new Promise(function (resolve, reject) {
+            zlib_1.default.gzip(input, function (error, result) {
+                if (!error)
+                    resolve(result);
+                else
+                    reject(error);
+            });
+        });
+        return promise;
+    }
+}
+exports.ResponseUtil = ResponseUtil;

package/dist/cjs/http/route/epsilon-router.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/http/route/extended-auth-response-context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/http/route/route-mapping.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/http/route/route-validator-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/http/route/router-util.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterUtil = void 0;
+const misconfigured_error_1 = require("../error/misconfigured-error");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const null_returned_object_handling_1 = require("../../config/http/null-returned-object-handling");
+const built_in_filters_1 = require("../../built-in/http/built-in-filters");
+const built_in_handlers_1 = require("../../built-in/http/built-in-handlers");
+const built_in_auth_filters_1 = require("../../built-in/http/built-in-auth-filters");
+const log_level_manipulation_filter_1 = require("../../built-in/http/log-level-manipulation-filter");
+class RouterUtil {
+    constructor() { }
+    static defaultAuthenticationHeaderParsingEpsilonPreFilters(webTokenManipulator) {
+        return [
+            (fCtx) => built_in_auth_filters_1.BuiltInAuthFilters.parseAuthorizationHeader(fCtx, webTokenManipulator),
+            (fCtx) => built_in_auth_filters_1.BuiltInAuthFilters.applyOpenApiAuthorization(fCtx),
+        ].concat(RouterUtil.defaultEpsilonPreFilters());
+    }
+    static defaultEpsilonPreFilters() {
+        return [
+            (fCtx) => built_in_filters_1.BuiltInFilters.autoRespondToOptionsRequestWithCors(fCtx),
+            (fCtx) => built_in_filters_1.BuiltInFilters.ensureEventMaps(fCtx),
+            (fCtx) => log_level_manipulation_filter_1.LogLevelManipulationFilter.setLogLevelForTransaction(fCtx),
+            (fCtx) => built_in_filters_1.BuiltInFilters.parseJsonBodyToObject(fCtx),
+            (fCtx) => built_in_filters_1.BuiltInFilters.fixStillEncodedQueryParams(fCtx),
+            (fCtx) => built_in_filters_1.BuiltInFilters.uriDecodeQueryParams(fCtx),
+            (fCtx) => built_in_filters_1.BuiltInFilters.disallowStringNullAsPathParameter(fCtx),
+            (fCtx) => built_in_filters_1.BuiltInFilters.disallowStringNullAsQueryStringParameter(fCtx),
+            (fCtx) => built_in_filters_1.BuiltInFilters.validateInboundBody(fCtx),
+            (fCtx) => built_in_filters_1.BuiltInFilters.validateInboundQueryParams(fCtx),
+            (fCtx) => built_in_filters_1.BuiltInFilters.validateInboundQueryParams(fCtx),
+        ];
+    }
+    static defaultEpsilonPostFilters() {
+        return [
+            (fCtx) => built_in_filters_1.BuiltInFilters.validateOutboundResponse(fCtx),
+            (fCtx) => built_in_filters_1.BuiltInFilters.addAWSRequestIdHeader(fCtx),
+            (fCtx) => built_in_filters_1.BuiltInFilters.addAllowReflectionCORSHeaders(fCtx),
+            (fCtx) => built_in_filters_1.BuiltInFilters.applyGzipIfPossible(fCtx),
+            (fCtx) => built_in_filters_1.BuiltInFilters.checkMaximumLambdaBodySize(fCtx),
+            (fCtx) => log_level_manipulation_filter_1.LogLevelManipulationFilter.clearLogLevelForTransaction(fCtx),
+        ];
+    }
+    static defaultEpsilonErrorFilters() {
+        return [
+            (fCtx) => built_in_filters_1.BuiltInFilters.addAWSRequestIdHeader(fCtx),
+            (fCtx) => built_in_filters_1.BuiltInFilters.addAllowReflectionCORSHeaders(fCtx),
+            (fCtx) => log_level_manipulation_filter_1.LogLevelManipulationFilter.clearLogLevelForTransaction(fCtx),
+        ];
+    }
+    static defaultHttpMetaProcessingConfigWithAuthenticationHeaderParsing(webTokenManipulator) {
+        const defaults = {
+            configName: 'EpsilonDefaultHttpMetaProcessingConfig',
+            timeoutMS: 30000,
+            overrideAuthorizerName: null,
+            preFilters: RouterUtil.defaultAuthenticationHeaderParsingEpsilonPreFilters(webTokenManipulator),
+            postFilters: RouterUtil.defaultEpsilonPostFilters(),
+            errorFilters: RouterUtil.defaultEpsilonErrorFilters(),
+            nullReturnedObjectHandling: null_returned_object_handling_1.NullReturnedObjectHandling.Return404NotFoundResponse,
+        };
+        return defaults;
+    }
+    static defaultHttpMetaProcessingConfig() {
+        const defaults = {
+            configName: 'EpsilonDefaultHttpMetaProcessingConfig',
+            timeoutMS: 30000,
+            overrideAuthorizerName: null,
+            preFilters: RouterUtil.defaultEpsilonPreFilters(),
+            postFilters: RouterUtil.defaultEpsilonPostFilters(),
+            errorFilters: RouterUtil.defaultEpsilonErrorFilters(),
+            nullReturnedObjectHandling: null_returned_object_handling_1.NullReturnedObjectHandling.Return404NotFoundResponse,
+        };
+        return defaults;
+    }
+    static assignDefaultsOnHttpConfig(cfg) {
+        const defaults = {
+            handlers: new Map(),
+            authorizers: new Map(),
+            defaultMetaHandling: this.defaultHttpMetaProcessingConfig(),
+            staticContentRoutes: {},
+            prefixesToStripBeforeRouteMatch: [],
+            filterHandledRouteMatches: ['options .*'],
+        };
+        const rval = Object.assign({}, defaults, cfg || {});
+        return rval;
+    }
+    static findApplicableMeta(httpConfig, method, path) {
+        let rval = null;
+        if (httpConfig === null || httpConfig === void 0 ? void 0 : httpConfig.overrideMetaHandling) {
+            for (let i = 0; i < httpConfig.overrideMetaHandling.length && !rval; i++) {
+                const test = httpConfig.overrideMetaHandling[i];
+                if (!test.methods ||
+                    test.methods.length === 0 ||
+                    test.methods.map((s) => s.toLocaleLowerCase()).includes(method.toLocaleLowerCase())) {
+                    const matches = !!path.match(test.pathRegex);
+                    if ((matches && !test.invertPathMatching) || (!matches && test.invertPathMatching)) {
+                        rval = test.config;
+                    }
+                }
+            }
+        }
+        if (!rval) {
+            rval = httpConfig.defaultMetaHandling || RouterUtil.defaultHttpMetaProcessingConfig();
+        }
+        return rval;
+    }
+    static openApiYamlToRouterConfig(httpConfig, openApiDoc, modelValidator, backgroundHttpAdapterHandler) {
+        var _a;
+        if (!openApiDoc || !httpConfig) {
+            throw new misconfigured_error_1.MisconfiguredError('Cannot configure, missing either yaml or cfg');
+        }
+        const rval = {
+            routes: [],
+            openApiModelValidator: modelValidator,
+            config: RouterUtil.assignDefaultsOnHttpConfig(httpConfig),
+        };
+        if ((_a = openApiDoc === null || openApiDoc === void 0 ? void 0 : openApiDoc.components) === null || _a === void 0 ? void 0 : _a.securitySchemes) {
+            Object.keys(openApiDoc.components.securitySchemes).forEach((sk) => {
+                if (!rval.config.authorizers || !rval.config.authorizers.get(sk)) {
+                    throw new misconfigured_error_1.MisconfiguredError().withFormattedErrorMessage('Doc requires authorizer %s but not found in map', sk);
+                }
+            });
+        }
+        const missingPaths = [];
+        const filterHandledPathMatches = httpConfig.filterHandledRouteMatches || [];
+        if (openApiDoc === null || openApiDoc === void 0 ? void 0 : openApiDoc.paths) {
+            Object.keys(openApiDoc.paths).forEach((path) => {
+                Object.keys(openApiDoc.paths[path]).forEach((method) => {
+                    const convertedPath = RouterUtil.openApiPathToRouteParserPath(path);
+                    const finder = method + ' ' + path;
+                    const applicableMeta = RouterUtil.findApplicableMeta(httpConfig, method, path);
+                    const entry = openApiDoc.paths[path][method];
+                    const isBackgroundEndpoint = path.startsWith(backgroundHttpAdapterHandler.httpSubmissionPath);
+                    const isBackgroundMetaEndpoint = path === backgroundHttpAdapterHandler.httpMetaEndpoint;
+                    const isBackgroundStatusEndpoint = path === backgroundHttpAdapterHandler.httpStatusPath;
+                    if (isBackgroundEndpoint) {
+                        rval.config.handlers.set(finder, (evt, ctx) => backgroundHttpAdapterHandler.handleBackgroundSubmission(evt, ctx));
+                    }
+                    if (isBackgroundMetaEndpoint) {
+                        rval.config.handlers.set(finder, (evt, ctx) => backgroundHttpAdapterHandler.handleBackgroundMetaRequest(evt, ctx));
+                    }
+                    if (isBackgroundStatusEndpoint) {
+                        rval.config.handlers.set(finder, (evt, ctx) => backgroundHttpAdapterHandler.handleBackgroundStatusRequest(evt, ctx));
+                    }
+                    if (!rval.config.handlers || !rval.config.handlers.get(finder)) {
+                        const match = filterHandledPathMatches.find((reg) => finder.match(reg));
+                        if (match) {
+                            ratchet_common_1.Logger.debug('Adding filter-handled handler for %s', finder);
+                            rval.config.handlers.set(finder, (evt) => built_in_handlers_1.BuiltInHandlers.expectedHandledByFilter(evt));
+                        }
+                        else {
+                            missingPaths.push(finder);
+                        }
+                    }
+                    if (entry && entry['security'] && entry['security'].length > 1) {
+                        throw new misconfigured_error_1.MisconfiguredError('Epsilon does not currently support multiple security (path was ' + finder + ')');
+                    }
+                    const authorizerName = entry['security'] && entry['security'].length == 1 ? Object.keys(entry['security'][0])[0] : null;
+                    const newRoute = {
+                        path: convertedPath,
+                        method: method,
+                        function: rval.config.handlers.get(finder),
+                        authorizerName: applicableMeta.overrideAuthorizerName || authorizerName,
+                        metaProcessingConfig: applicableMeta,
+                        validation: null,
+                        outboundValidation: null,
+                    };
+                    if (entry['requestBody'] &&
+                        entry['requestBody']['content'] &&
+                        entry['requestBody']['content']['application/json'] &&
+                        entry['requestBody']['content']['application/json']['schema']) {
+                        const schema = entry['requestBody']['content'];
+                        ratchet_common_1.Logger.silly('Applying schema %j to %s', schema, finder);
+                        const modelName = this.findAndValidateModelName(method, path, schema, rval.config.overrideModelValidator || rval.openApiModelValidator);
+                        const required = ratchet_common_2.BooleanRatchet.parseBool(entry['requestBody']['required']);
+                        const validation = {
+                            extraPropertiesAllowed: true,
+                            emptyAllowed: !required,
+                            modelName: modelName,
+                        };
+                        newRoute.validation = validation;
+                    }
+                    if (entry['responses'] &&
+                        entry['responses']['200'] &&
+                        entry['responses']['200']['content'] &&
+                        entry['responses']['200']['content']['application/json'] &&
+                        entry['responses']['200']['content']['application/json']['schema']) {
+                        const schema = entry['responses']['200']['content'];
+                        ratchet_common_1.Logger.silly('Applying schema %j to %s', schema, finder);
+                        const modelName = this.findAndValidateModelName(method, path, schema, rval.config.overrideModelValidator || rval.openApiModelValidator);
+                        const validation = {
+                            extraPropertiesAllowed: false,
+                            emptyAllowed: false,
+                            modelName: modelName,
+                        };
+                        newRoute.outboundValidation = validation;
+                    }
+                    rval.routes.push(newRoute);
+                });
+            });
+        }
+        if (missingPaths.length > 0) {
+            throw new misconfigured_error_1.MisconfiguredError().withFormattedErrorMessage('Missing expected handlers : %j', missingPaths);
+        }
+        return rval;
+    }
+    static findAndValidateModelName(method, path, schema, modelValidator) {
+        let rval = undefined;
+        const schemaPath = schema['application/json']['schema']['$ref'];
+        const inlinePath = schema['application/json']['schema']['type'];
+        if (schemaPath) {
+            rval = schemaPath.substring(schemaPath.lastIndexOf('/') + 1);
+            if (!modelValidator.fetchModel(rval)) {
+                throw new misconfigured_error_1.MisconfiguredError(`Path ${method} ${path} refers to schema ${rval} but its not in the schema section`);
+            }
+        }
+        else if (inlinePath) {
+            rval = `${method}-${path}-requestBodyModel`;
+            const model = schema['application/json']['schema'];
+            modelValidator.addModel(rval, model);
+        }
+        return rval;
+    }
+    static openApiPathToRouteParserPath(input) {
+        let rval = input;
+        if (rval) {
+            let sIdx = rval.indexOf('{');
+            while (sIdx > -1) {
+                const eIdx = rval.indexOf('}');
+                rval = rval.substring(0, sIdx) + ':' + rval.substring(sIdx + 1, eIdx) + rval.substring(eIdx + 1);
+                sIdx = rval.indexOf('{');
+            }
+        }
+        return rval;
+    }
+}
+exports.RouterUtil = RouterUtil;

package/dist/cjs/http/web-handler.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebHandler = void 0;
+const tslib_1 = require("tslib");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const route_parser_1 = tslib_1.__importDefault(require("route-parser"));
+const response_util_1 = require("./response-util");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const epsilon_http_error_1 = require("./error/epsilon-http-error");
+const built_in_filters_1 = require("../built-in/http/built-in-filters");
+const run_handler_as_filter_1 = require("../built-in/http/run-handler-as-filter");
+const context_util_1 = require("../util/context-util");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+const ratchet_aws_1 = require("@bitblit/ratchet-aws");
+class WebHandler {
+    constructor(routerConfig) {
+        this.routerConfig = routerConfig;
+        ratchet_common_2.RequireRatchet.notNullOrUndefined(routerConfig);
+    }
+    get router() {
+        return this.routerConfig;
+    }
+    extractLabel(evt, context) {
+        return 'WEB:' + ratchet_common_3.StringRatchet.trimToEmpty(evt.httpMethod).toUpperCase() + ':' + evt.path;
+    }
+    handlesEvent(evt) {
+        return ratchet_aws_1.LambdaEventDetector.isValidApiGatewayEvent(evt);
+    }
+    async processEvent(event, context) {
+        if (!this.routerConfig) {
+            throw new Error('Router config not found');
+        }
+        const asExtended = Object.assign({}, { parsedBody: null, authorization: null, convertedFromV2Event: false }, event);
+        const rval = await this.openApiLambdaHandler(asExtended, context);
+        context_util_1.ContextUtil.addTraceToProxyResult(rval);
+        ratchet_common_1.Logger.updateTracePrefix(null);
+        return rval;
+    }
+    async openApiLambdaHandler(evt, context) {
+        var _a;
+        const rm = this.findBestMatchingRoute(evt);
+        const procConfig = ((_a = rm === null || rm === void 0 ? void 0 : rm.mapping) === null || _a === void 0 ? void 0 : _a.metaProcessingConfig)
+            ? rm.mapping.metaProcessingConfig
+            : this.routerConfig.config.defaultMetaHandling;
+        const fCtx = {
+            event: evt,
+            context: context,
+            result: null,
+            rawResult: null,
+            routeAndParse: rm,
+            modelValidator: this.routerConfig.config.overrideModelValidator || this.routerConfig.openApiModelValidator,
+            authenticators: this.routerConfig.config.authorizers,
+        };
+        try {
+            let filterChain = Object.assign([], procConfig.preFilters || []);
+            run_handler_as_filter_1.RunHandlerAsFilter.addRunHandlerAsFilterToList(filterChain, rm);
+            filterChain = filterChain.concat(procConfig.postFilters || []);
+            await built_in_filters_1.BuiltInFilters.combineFilters(fCtx, filterChain);
+        }
+        catch (err) {
+            const wrapper = epsilon_http_error_1.EpsilonHttpError.wrapError(err);
+            fCtx.result = response_util_1.ResponseUtil.errorResponse(wrapper);
+            try {
+                await built_in_filters_1.BuiltInFilters.combineFilters(fCtx, procConfig.errorFilters);
+            }
+            catch (convErr) {
+                ratchet_common_1.Logger.error('REALLY BAD - FAILED WHILE PROCESSING ERROR FILTERS : %s', convErr);
+            }
+        }
+        return fCtx.result;
+    }
+    findBestMatchingRoute(event) {
+        let rval = null;
+        const cleanPath = this.cleanPath(event);
+        const methodLower = event.httpMethod.toLowerCase();
+        const matchRoutes = this.routerConfig.routes
+            .map((r) => {
+            let rval = null;
+            if (r.method && r.method.toLowerCase() === methodLower) {
+                const routeParser = new route_parser_1.default(r.path);
+                const parsed = routeParser.match(cleanPath);
+                if (parsed !== false) {
+                    rval = {
+                        mapping: r,
+                        route: routeParser,
+                        parsed: parsed,
+                    };
+                }
+            }
+            return rval;
+        })
+            .filter((r) => r != null);
+        matchRoutes.sort((a, b) => {
+            return Object.keys(a.parsed).length - Object.keys(b.parsed).length;
+        });
+        rval = matchRoutes && matchRoutes.length > 0 ? matchRoutes[0] : null;
+        if (!rval) {
+            ratchet_common_1.Logger.debug('Failed to find handler for %s (cleaned path was %s, strip prefixes were %j)', event.path, cleanPath, this.routerConfig.config.prefixesToStripBeforeRouteMatch);
+        }
+        return rval;
+    }
+    cleanPath(event) {
+        let rval = event.path;
+        while (rval.startsWith('/')) {
+            rval = rval.substring(1);
+        }
+        if (this.routerConfig.config.prefixesToStripBeforeRouteMatch) {
+            this.routerConfig.config.prefixesToStripBeforeRouteMatch.forEach((prefix) => {
+                if (rval.toLowerCase().startsWith(prefix.toLowerCase() + '/')) {
+                    rval = rval.substring(prefix.length);
+                }
+            });
+        }
+        while (rval.startsWith('/')) {
+            rval = rval.substring(1);
+        }
+        rval = '/' + rval;
+        return rval;
+    }
+}
+exports.WebHandler = WebHandler;
+WebHandler.MAXIMUM_LAMBDA_BODY_SIZE_BYTES = 1024 * 1024 * 5 - 1024 * 100;

package/dist/cjs/http/web-v2-handler.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebV2Handler = void 0;
+const aws_util_1 = require("../util/aws-util");
+const ratchet_aws_1 = require("@bitblit/ratchet-aws");
+class WebV2Handler {
+    constructor(webHandler) {
+        this.webHandler = webHandler;
+    }
+    extractLabel(evt, context) {
+        let rval = this.webHandler.extractLabel(aws_util_1.AwsUtil.apiGatewayV2ToApiGatewayV1(evt), context);
+        rval = rval.replace('WEB:', 'WEB2:');
+        return rval;
+    }
+    handlesEvent(evt) {
+        return ratchet_aws_1.LambdaEventDetector.isValidApiGatewayV2WithRequestContextEvent(evt);
+    }
+    async processEvent(evt, context) {
+        const conv = aws_util_1.AwsUtil.apiGatewayV2ToApiGatewayV1(evt);
+        const asExtended = Object.assign({}, { parsedBody: null, authorization: null, convertedFromV2Event: true }, conv);
+        const rval = await this.webHandler.openApiLambdaHandler(asExtended, context);
+        return rval;
+    }
+}
+exports.WebV2Handler = WebV2Handler;