@spytecgps/lambda-utils 3.0.4 → 3.0.6-rc.0

package/dist/index.js

@@ -1,660 +1,76 @@
 'use strict';
 
+var index = require('./config/index.js');
+var BadRequestError = require('./errors/BadRequestError.js');
+var BaseError = require('./errors/BaseError.js');
+var ConflictError = require('./errors/ConflictError.js');
+var ForbiddenError = require('./errors/ForbiddenError.js');
+var GoneError = require('./errors/GoneError.js');
+var HttpError = require('./errors/HttpError.js');
+var NotFoundError = require('./errors/NotFoundError.js');
+var UnauthorizedError = require('./errors/UnauthorizedError.js');
+var index$1 = require('./middleware/index.js');
 var merge = require('deepmerge');
-var core = require('@middy/core');
+var cache = require('./utils/cache.js');
+var cacheWrapper = require('./utils/cacheWrapper.js');
+var timeOut = require('./utils/timeOut.js');
+var index$2 = require('./validation/index.js');
+var validateEvent = require('./validation/validateEvent.js');
+var contextualLogger = require('./middleware/contextualLogger.js');
 var httpErrorHandler = require('@middy/http-error-handler');
 var httpResponseSerializer = require('@middy/http-response-serializer');
+var ioLogger = require('./middleware/ioLogger.js');
+var core = require('@middy/core');
+var offlineAuthorizer = require('./middleware/offlineAuthorizer.js');
+var responseWrapper = require('./middleware/responseWrapper.js');
 var sqsJsonBodyParser = require('@middy/sqs-json-body-parser');
-var inputOutputLogger = require('@middy/input-output-logger');
-var clientLambda = require('@aws-sdk/client-lambda');
-var dayjs = require('dayjs');
-var timezone = require('dayjs/plugin/timezone');
-var utc = require('dayjs/plugin/utc');
-var Joi = require('joi');
-var qs = require('qs');
-
-function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n.default = e;
-    return Object.freeze(n);
-}
-
-var Joi__namespace = /*#__PURE__*/_interopNamespaceDefault(Joi);
-var qs__namespace = /*#__PURE__*/_interopNamespaceDefault(qs);
-
-const getEnvKey = () => {
-    if (process.env.NODE_ENV === 'test') {
-        return 'test';
-    }
-    if (isOffline() && process.env.STAGE === 'dev') {
-        return 'local';
-    }
-    return (process.env.STAGE ?? process.env.NODE_ENV ?? 'dev');
-};
-const isOffline = () => !!process.env.IS_OFFLINE;
-const isLocal = () => getEnvKey() === 'local';
-const isTest = () => getEnvKey() === 'test';
-const isDev = () => getEnvKey() === 'dev';
-const isProduction = () => getEnvKey() === 'prod';
-const setupEnvConfig = (envConfigs) => {
-    const baseConfig = envConfigs['base'];
-    const envConfig = envConfigs[getEnvKey()] ?? {};
-    return merge(baseConfig, envConfig);
-};
-
-class HttpError extends Error {
-}
-
-class BadRequestError extends HttpError {
-    code = 400;
-    statusCode = 400;
-    name = 'BadRequestError';
-}
-
-class BaseError extends Error {
-    code;
-    statusCode;
-}
-
-class ConflictError extends HttpError {
-    code = 409;
-    statusCode = 409;
-    name = 'ConflictError';
-}
-
-class ForbiddenError extends HttpError {
-    code = 403;
-    statusCode = 403;
-    name = 'ForbiddenError';
-}
-
-class GoneError extends HttpError {
-    code = 410;
-    statusCode = 410;
-    name = 'GoneError';
-}
-
-class NotFoundError extends HttpError {
-    code = 404;
-    statusCode = 404;
-    name = 'NotFoundError';
-}
-
-class UnauthorizedError extends HttpError {
-    code = 401;
-    statusCode = 401;
-    name = 'UnauthorizedError';
-}
-
-const AMAZON_TRACE_ID = '_X_AMZN_TRACE_ID';
-const CORRELATION_HEADER = 'x-correlation-';
-const CORRELATION_ID = `${CORRELATION_HEADER}id`;
-const CORRELATION_TRACE_ID = `${CORRELATION_HEADER}trace-id`;
-const contextualLogger = ({ logger }) => {
-    const before = async ({ event, context }) => {
-        const ctx = {
-            awsRequestId: context?.awsRequestId,
-        };
-        // capture api gateway request ID
-        const apiRequestId = event?.requestContext?.requestId;
-        if (apiRequestId) {
-            ctx.apiRequestId = apiRequestId;
-        }
-        // capture any correlation headers sent from upstream callers
-        if (event.headers) {
-            Object.keys(event.headers).forEach((header) => {
-                if (header.toLowerCase().startsWith(CORRELATION_HEADER)) {
-                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    ctx[header] = event.headers[header];
-                }
-            });
-        }
-        // capture the xray trace id if its enabled
-        if (process.env[AMAZON_TRACE_ID]) {
-            ctx[CORRELATION_TRACE_ID] = process.env[AMAZON_TRACE_ID];
-        }
-        // set the correlation id if not already set by upstream callers
-        /* istanbul ignore next */
-        if (!ctx[CORRELATION_ID]) {
-            ctx[CORRELATION_ID] = context.awsRequestId;
-        }
-        logger.setHapnContext(ctx);
-    };
-    return {
-        before,
-    };
-};
-
-const ioLogger = ({ logger }) => inputOutputLogger({
-    omitPaths: [
-        'event.multiValueHeaders',
-        'event.multiValueQueryStringParameters',
-        'event.resource',
-        'event.httpMethod',
-        'event.headers',
-        'event.stageVariables',
-        'event.requestContext.resourceId',
-        'event.requestContext.resourcePath',
-        'event.requestContext.httpMethod',
-        'event.requestContext.extendedRequestId',
-        'event.requestContext.requestTime',
-        'event.requestContext.path',
-        'event.requestContext.accountId',
-        'event.requestContext.protocol',
-        'event.requestContext.stage',
-        'event.requestContext.domainPrefix',
-        'event.requestContext.requestTimeEpoch',
-        'event.requestContext.apiId',
-        'event.requestContext.domainName',
-        'event.requestContext.identity',
-        'event.isBase64Encoded',
-        'event.body',
-        'response.body',
-        'response.headers',
-    ],
-    logger: (req) => {
-        if (isLocal() || isTest()) {
-            return;
-        }
-        const message = req?.event ? 'event' : 'response';
-        logger.info(req.event ?? req.response, message);
-    },
-});
-
-const normalizerMiddleware = () => {
-    return {
-        before: async (request) => {
-            const event = request.event;
-            event.queryStringParameters = event.queryStringParameters || {};
-            event.pathParameters = event.pathParameters || {};
-        },
-    };
-};
-
-const offlineAuth = ({ authFunctionName = 'spytec-web-api-auth-prod-AuthorizerFunctionV4', enabled = isOffline(), logger, }) => {
-    const lambdaClient = new clientLambda.LambdaClient({ region: process.env.AWS_REGION });
-    return {
-        before: async (request) => {
-            if (!enabled)
-                return;
-            const { event } = request;
-            // Extract Bearer token from the Authorization header
-            const authHeader = event.headers?.Authorization || event.headers?.authorization;
-            if (!authHeader || !authHeader.startsWith('Bearer ')) {
-                // throw new Error('Authorization header is missing or invalid')
-                // if we can't extract the token, this is is a public route, ignore it
-                logger.warn('Authorization header is missing or invalid, skipping fake offline authorization');
-                return;
-            }
-            const token = authHeader.slice(7); // Remove 'Bearer ' prefix
-            // Prepare payload for the auth function
-            const payload = {
-                authorizationToken: token,
-            };
-            // Invoke the auth function manually
-            const command = new clientLambda.InvokeCommand({
-                FunctionName: authFunctionName,
-                Payload: Buffer.from(JSON.stringify(payload)),
-            });
-            try {
-                const response = await lambdaClient.send(command);
-                const responsePayload = JSON.parse(Buffer.from(response.Payload ?? '').toString());
-                if (responsePayload.errorMessage) {
-                    throw new Error(responsePayload.errorMessage);
-                }
-                event.requestContext.authorizer = responsePayload.context;
-            }
-            catch (error) {
-                logger.error(error, 'Error invoking auth function');
-                throw new Error('Authorization failed');
-            }
-        },
-    };
-};
-
-const baseHeaders = {
-    'Content-Type': 'application/json',
-    'Access-Control-Allow-Origin': '*',
-    'Access-Control-Allow-Credentials': true,
-};
-const buildResponseBody = (statusCode, message, data) => {
-    return {
-        success: statusCode < 400,
-        message,
-        result: typeof data !== 'undefined' ? data : undefined,
-    };
-};
-const buildProxyResult = ({ statusCode = 200, message = 'ok', data, headers = {}, multiValueHeaders = {}, rawResult = false, stringifyBody = true, }) => {
-    const resp = rawResult ? data : buildResponseBody(statusCode, message, data);
-    const body = stringifyBody ? resp && JSON.stringify(resp) : data;
-    return {
-        headers: { ...baseHeaders, ...headers },
-        multiValueHeaders,
-        statusCode,
-        body,
-    };
-};
-
-const responseWrapper = ({ logger }) => {
-    const responseWrapperMiddlewareAfter = (req) => {
-        req.response = buildProxyResult(req.response);
-    };
-    const responseWrapperMiddlewareError = (req) => {
-        const statusCode = req.error?.code ?? 500;
-        const errorMessage = req.error?.message || 'Error';
-        const loggerMethod = statusCode >= 500 ? 'error' : 'info';
-        logger[loggerMethod](req.error, 'Request failed');
-        req.response = buildProxyResult({
-            statusCode,
-            message: errorMessage,
-        });
-    };
-    return {
-        after: responseWrapperMiddlewareAfter,
-        onError: responseWrapperMiddlewareError,
-    };
-};
-
-const validator = ({ schema, allowUnknown = true, logger }) => {
-    const validatorMiddlewareBefore = (request) => {
-        const { error, value } = schema.validate(request.event, {
-            allowUnknown,
-            errors: {
-                label: 'key',
-                wrap: {
-                    label: false,
-                },
-            },
-        });
-        if (error) {
-            logger.warn(error, 'Validation error');
-            throw error.isJoi ? new BadRequestError(error.message) : error;
-        }
-        request.event = value;
-    };
-    return {
-        before: validatorMiddlewareBefore,
-    };
-};
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const defaults = {
-    isWarmingUp: (event) => event.source === 'serverless-plugin-warmup',
-};
-const warmupMiddleware = (opt = {}) => {
-    const options = { ...defaults, ...opt };
-    const warmupMiddlewareBefore = (request) => {
-        if (options.isWarmingUp(request.event)) {
-            return 'warmup';
-        }
-    };
-    return {
-        before: warmupMiddlewareBefore,
-    };
-};
-
-// Function that returns base middlewares with required logger
-const getBaseMiddlewares = ({ logger }) => [
-    warmupMiddleware(),
-    contextualLogger({ logger }),
-    ioLogger({ logger }),
-];
-// Function that returns API Gateway middlewares with required logger
-const getApiGatewayMiddlewares = ({ logger, offlineAuthEnabled }) => [
-    httpResponseSerializer({
-        serializers: [
-            {
-                regex: /^application\/xml$/,
-                serializer: ({ body }) => `<message>${body}</message>`,
-            },
-            {
-                regex: /^application\/json$/,
-                serializer: ({ body }) => JSON.stringify(body),
-            },
-            {
-                regex: /^text\/plain$/,
-                serializer: ({ body }) => body,
-            },
-        ],
-        default: 'application/json',
-    }),
-    responseWrapper({ logger }),
-    offlineAuth({ logger, enabled: offlineAuthEnabled }),
-    normalizerMiddleware(),
-];
-
-class LambdaCache {
-    collectionName;
-    /**
-     * @param {String} collectionName (not required) - The collection key used to store the cache values.
-     *                                If not provide default collection name uses :
-     *                                ${process.env.AWS_LAMBDA_FUNCTION_NAME}-${process.env.AWS_LAMBDA_FUNCTION_VERSION}
-     * */
-    constructor(collectionName) {
-        this.collectionName =
-            collectionName ?? `${process.env.AWS_LAMBDA_FUNCTION_NAME}-${process.env.AWS_LAMBDA_FUNCTION_VERSION}`;
-        if (!global['CACHE_STORAGE']) {
-            global['CACHE_STORAGE'] = {};
-        }
-        if (!global['CACHE_STORAGE'][this.collectionName]) {
-            global['CACHE_STORAGE'][this.collectionName] = new Map();
-        }
-    }
-    /**
-     * @param {String} key (required) - cache key
-     * @param {Object} value (required) - cache value
-     * @param {Number} expire (required) - cache expiration time (seconds)
-     * */
-    set(key, value, ttl) {
-        const expire = 1000 * ttl + Date.now();
-        global['CACHE_STORAGE'][this.collectionName].set(key, { value, expire });
-    }
-    /**
-     * @param {String} key (required) - cache key to get
-     * */
-    get(key) {
-        if (!key) {
-            throw new Error('key is required!');
-        }
-        const record = global['CACHE_STORAGE'][this.collectionName].get(key);
-        if (!record) {
-            return null;
-        }
-        if (!record.expire || record.expire > Date.now()) {
-            return record.value;
-        }
-        else {
-            return this.remove(key);
-        }
-    }
-    /**
-     * @param {String} key (required) - cache key to remove
-     * */
-    remove(key) {
-        const record = global['CACHE_STORAGE'][this.collectionName].get(key);
-        if (!record) {
-            return;
-        }
-        global['CACHE_STORAGE'][this.collectionName].delete(key);
-    }
-}
-
-const promiseWithCache = async (promise, cacheInstance, cacheKey, ttl) => {
-    let instance = cacheInstance.get(cacheKey);
-    if (!instance) {
-        instance = await promise();
-        cacheInstance.set(cacheKey, instance, ttl);
-    }
-    return instance;
-};
-
-const promiseWithTimeout = (promise, ms, timeoutError = new Error('Promise timed out')) => {
-    // create a promise that rejects in milliseconds
-    const timeout = new Promise((_, reject) => {
-        setTimeout(() => {
-            reject(timeoutError);
-        }, ms);
-    });
-    // returns a race between timeout and the passed promise
-    return Promise.race([promise, timeout]);
-    //Adding comment to test
-};
-
-dayjs.extend(utc);
-dayjs.extend(timezone);
-const json = Joi__namespace.extend((joi) => {
-    return {
-        type: 'object',
-        base: joi.object(),
-        messages: {
-            'json.valid': 'must be valid JSON',
-        },
-        coerce(value) {
-            try {
-                return { value: JSON.parse(value) };
-            }
-            catch (err) {
-                return null;
-            }
-        },
-        validate(value, helpers) {
-            if (!value) {
-                return { value, errors: helpers.error('json.valid') };
-            }
-            return { value };
-        },
-    };
-});
-const urlEncoded = Joi__namespace.extend((joi) => {
-    return {
-        type: 'object',
-        base: joi.object(),
-        coerce(value) {
-            return { value: qs__namespace.parse(value) };
-        },
-    };
-});
-const imeiSchema = Joi__namespace.string()
-    .regex(/^\d{15,16}$/)
-    .message('Invalid IMEI');
-const iccidSchema = Joi__namespace.string()
-    .regex(/^[0-9A-Za-z]{18,22}$/)
-    .message('Invalid ICCID');
-const SpytecJoi = Joi__namespace.extend((joi) => ({
-    type: 'imei',
-    messages: 'Invalid IMEI',
-    base: joi.string().regex(/^\d{15,16}$/),
-}), (joi) => ({
-    type: 'iccid',
-    messages: 'Invalid ICCID',
-    base: joi.string().regex(/^[0-9A-Za-z]{18,22}$/),
-}), (joi) => ({
-    type: 'urlEncodedObject',
-    base: joi.object(),
-    coerce(value) {
-        return { value: qs__namespace.parse(value) };
-    },
-}), (joi) => ({
-    type: 'jsonObject',
-    base: joi.object(),
-    coerce(value) {
-        try {
-            return { value: JSON.parse(value) };
-        }
-        catch (err) {
-            return null;
-        }
-    },
-    validate(value, helpers) {
-        if (!value) {
-            return { value, errors: helpers.error('json.valid') };
-        }
-        return { value };
-    },
-}), (joi) => ({
-    type: 'delimitedArray',
-    base: joi.array().default([]),
-    coerce: (value) => ({
-        value: value.split ? value.split(',') : value,
-    }),
-}), (joi) => ({
-    type: 'queryStringParameters',
-    messages: 'Missing query parameters',
-    base: joi.object().required(),
-}), (joi) => ({
-    type: 'date',
-    base: joi.date(),
-    prepare(value, helpers) {
-        try {
-            const dayjsDate = dayjs.tz(value, 'UTC');
-            if (dayjsDate.isValid()) {
-                return { value: dayjsDate.toDate() };
-            }
-        }
-        catch (error) {
-            return helpers.error('any.invalid');
-        }
-    },
-}), (joi) => ({
-    type: 'jsonArray',
-    base: joi.array(),
-    coerce(value) {
-        try {
-            return { value: JSON.parse(value) };
-        }
-        catch (err) {
-            return { value: null };
-        }
-    },
-    validate(value, helpers) {
-        if (!Array.isArray(value)) {
-            return { value, errors: helpers.error('jsonArray.schema') };
-        }
-        return { value };
-    },
-}), (joi) => ({
-    type: 'base64ThenUriEncodedObject',
-    base: joi.object(),
-    coerce(value) {
-        try {
-            const decodedValue = decodeURIComponent(Buffer.from(value, 'base64').toString());
-            return { value: JSON.parse(decodedValue) };
-        }
-        catch (err) {
-            return null;
-        }
-    },
-    validate(value, helpers) {
-        if (!value) {
-            return { value, errors: helpers.error('json.valid') };
-        }
-        return { value };
-    },
-}));
-
-const getAuthorizerValidator = (params = {}) => {
-    return Joi__namespace.object({
-        clientId: Joi__namespace.number().greater(0).required(),
-        userId: Joi__namespace.string().guid( /*{ version: 'uuidv4' }*/).required(),
-        resources: json.object({}),
-        scope: Joi__namespace.string().optional(),
-        //       .error(() => new UnauthorizedError(`missing scope ${scope}`))
-        type: Joi__namespace.string().optional(),
-        //       .error(() => new UnauthorizedError(`missing user type ${type}`))
-        enterprise: Joi__namespace.boolean().default(false),
-        maintenanceModule: Joi__namespace.boolean().default(false),
-        billingMethod: Joi__namespace.string().optional(),
-        customerSegment: Joi__namespace.string().optional(),
-        securityGroupTagId: Joi__namespace.number().optional().allow(null),
-        securityRole: Joi__namespace.string().optional().allow(null),
-        ...params,
-    });
-};
-const getAuthorizerValidatorV4 = (params = {}) => {
-    return Joi__namespace.object({
-        clientId: Joi__namespace.number().greater(0).required(),
-        userId: Joi__namespace.string().guid( /*{ version: 'uuidv4' }*/).required(),
-        scope: Joi__namespace.string().optional(),
-        type: Joi__namespace.string().optional(),
-        ...params,
-    });
-};
-/**
- * @deprecated
- */
-const requestContextValidator = Joi__namespace.object({
-    authorizer: getAuthorizerValidator(),
-});
-const getRequestContextValidator = (params = {}) => {
-    return Joi__namespace.object({
-        authorizer: getAuthorizerValidator(params),
-    });
-};
-const getRequestContextValidatorV4 = (params = {}) => {
-    return Joi__namespace.object({
-        authorizer: getAuthorizerValidatorV4(params),
-    });
-};
-
-/**
- * @deprecated
- */
-const validateEvent = (event, schema, validateOptions) => {
-    if (!schema) {
-        console.warn(`skipping validation`);
-        return event;
-    }
-    const { error, value } = schema.validate(event, {
-        allowUnknown: validateOptions?.allowUnknown || true,
-        errors: {
-            label: 'key',
-            wrap: {
-                label: false,
-            },
-        },
-    });
-    if (error) {
-        console.error({ error }, 'Validation error');
-        throw error.isJoi ? new BadRequestError(error.message) : error;
-    }
-    return value;
-};
-
-const defaultApiSchema = SpytecJoi.object({
-    requestContext: getRequestContextValidator(),
-});
-
+var validation = require('./middleware/validation.js');
+var warmup = require('./middleware/warmup.js');
+var custom = require('./validation/custom.js');
+var requestContext = require('./validation/requestContext.js');
+
+
+
+exports.getEnvKey = index.getEnvKey;
+exports.isDev = index.isDev;
+exports.isLocal = index.isLocal;
+exports.isOffline = index.isOffline;
+exports.isProduction = index.isProduction;
+exports.isTest = index.isTest;
+exports.setupEnvConfig = index.setupEnvConfig;
+exports.BadRequestError = BadRequestError.default;
+exports.BaseError = BaseError.default;
+exports.ConflictError = ConflictError.default;
+exports.ForbiddenError = ForbiddenError.default;
+exports.GoneError = GoneError.default;
+exports.HttpError = HttpError.default;
+exports.NotFoundError = NotFoundError.default;
+exports.UnauthorizedError = UnauthorizedError.default;
+exports.getApiGatewayMiddlewares = index$1.getApiGatewayMiddlewares;
+exports.getBaseMiddlewares = index$1.getBaseMiddlewares;
 exports.merge = merge;
-exports.middy = core;
+exports.LambdaCache = cache.LambdaCache;
+exports.promiseWithCache = cacheWrapper.promiseWithCache;
+exports.promiseWithTimeout = timeOut.promiseWithTimeout;
+exports.defaultApiSchema = index$2.defaultApiSchema;
+exports.validateEvent = validateEvent.default;
+exports.contextualLogger = contextualLogger.contextualLogger;
 exports.httpErrorHandler = httpErrorHandler;
 exports.httpResponseSerializer = httpResponseSerializer;
+exports.ioLogger = ioLogger.ioLogger;
+exports.middy = core;
+exports.offlineAuth = offlineAuthorizer.offlineAuth;
+exports.responseWrapper = responseWrapper.responseWrapper;
 exports.sqsJsonBodyParser = sqsJsonBodyParser;
-exports.BadRequestError = BadRequestError;
-exports.BaseError = BaseError;
-exports.ConflictError = ConflictError;
-exports.ForbiddenError = ForbiddenError;
-exports.GoneError = GoneError;
-exports.HttpError = HttpError;
-exports.LambdaCache = LambdaCache;
-exports.NotFoundError = NotFoundError;
-exports.SpytecJoi = SpytecJoi;
-exports.UnauthorizedError = UnauthorizedError;
-exports.contextualLogger = contextualLogger;
-exports.defaultApiSchema = defaultApiSchema;
-exports.getApiGatewayMiddlewares = getApiGatewayMiddlewares;
-exports.getAuthorizerValidator = getAuthorizerValidator;
-exports.getAuthorizerValidatorV4 = getAuthorizerValidatorV4;
-exports.getBaseMiddlewares = getBaseMiddlewares;
-exports.getEnvKey = getEnvKey;
-exports.getRequestContextValidator = getRequestContextValidator;
-exports.getRequestContextValidatorV4 = getRequestContextValidatorV4;
-exports.iccidSchema = iccidSchema;
-exports.imeiSchema = imeiSchema;
-exports.ioLogger = ioLogger;
-exports.isDev = isDev;
-exports.isLocal = isLocal;
-exports.isOffline = isOffline;
-exports.isProduction = isProduction;
-exports.isTest = isTest;
-exports.json = json;
-exports.offlineAuth = offlineAuth;
-exports.promiseWithCache = promiseWithCache;
-exports.promiseWithTimeout = promiseWithTimeout;
-exports.requestContextValidator = requestContextValidator;
-exports.responseWrapper = responseWrapper;
-exports.setupEnvConfig = setupEnvConfig;
-exports.urlEncoded = urlEncoded;
-exports.validateEvent = validateEvent;
-exports.validator = validator;
-exports.warmupMiddleware = warmupMiddleware;
+exports.validator = validation.validator;
+exports.warmupMiddleware = warmup.warmupMiddleware;
+exports.SpytecJoi = custom.SpytecJoi;
+exports.iccidSchema = custom.iccidSchema;
+exports.imeiSchema = custom.imeiSchema;
+exports.json = custom.json;
+exports.urlEncoded = custom.urlEncoded;
+exports.getAuthorizerValidator = requestContext.getAuthorizerValidator;
+exports.getAuthorizerValidatorV4 = requestContext.getAuthorizerValidatorV4;
+exports.getRequestContextValidator = requestContext.getRequestContextValidator;
+exports.getRequestContextValidatorV4 = requestContext.getRequestContextValidatorV4;
+exports.requestContextValidator = requestContext.requestContextValidator;