@bitblit/ratchet-epsilon-common 4.0.85-alpha

package/dist/es/built-in/background/log-and-enqueue-echo-processor.js

@@ -0,0 +1,12 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { EchoProcessor } from './echo-processor';
+export class LogAndEnqueueEchoProcessor {
+    get typeName() {
+        return 'EpsilonLogAndEnqueueEcho';
+    }
+    async handleEvent(data, cfg) {
+        Logger.info('LogAndEnqueueEchoProcessor : %j', data);
+        await cfg.fireImmediateProcessRequestByParts(EchoProcessor.TYPE_NAME, { upstream: data });
+        Logger.info('Completed : LogAndEnqueueEchoProcessor');
+    }
+}

package/dist/es/built-in/background/log-message-background-error-processor.js

@@ -0,0 +1,6 @@
+import { Logger } from '@bitblit/ratchet-common';
+export class LogMessageBackgroundErrorProcessor {
+    async handleError(submission, error) {
+        Logger.error('-------- ERROR PROCESSED : %j : %s----', submission, error);
+    }
+}

package/dist/es/built-in/background/no-op-processor.js

@@ -0,0 +1,9 @@
+import { Logger } from '@bitblit/ratchet-common';
+export class NoOpProcessor {
+    get typeName() {
+        return 'EpsilonNoOp';
+    }
+    async handleEvent(data, mgr) {
+        Logger.silly('Hit the no-op proc');
+    }
+}

package/dist/es/built-in/background/retry-processor.js

@@ -0,0 +1,36 @@
+import { DurationRatchet, Logger, PromiseRatchet } from '@bitblit/ratchet-common';
+import { StringRatchet } from '@bitblit/ratchet-common';
+import { NumberRatchet } from '@bitblit/ratchet-common';
+export class RetryProcessor {
+    constructor(delegate, opts) {
+        this.delegate = delegate;
+        this.opts = opts;
+    }
+    get typeName() {
+        return StringRatchet.trimToEmpty(this.opts?.typePrefix) + this.delegate.typeName + StringRatchet.trimToEmpty(this.opts?.typeSuffix);
+    }
+    async handleEvent(data, mgr) {
+        const tryNumber = data && data[RetryProcessor.RETRY_FIELD_NAME] ? NumberRatchet.safeNumber(data[RetryProcessor.RETRY_FIELD_NAME]) : 1;
+        const dataCopy = data ? Object.assign({}, data) : null;
+        delete dataCopy[RetryProcessor.RETRY_FIELD_NAME];
+        Logger.info('RetryProcessor : %s : Try %d of %d', this.delegate.typeName, tryNumber, this.opts.retryCount);
+        try {
+            await this.delegate.handleEvent(dataCopy, mgr);
+        }
+        catch (err) {
+            Logger.error('Failed to process : %s', err, err);
+            if (tryNumber < this.opts.retryCount) {
+                const waitTimeMS = tryNumber * this.opts.baseDelayMS;
+                Logger.info('Firing automatic retry after a wait of %s', DurationRatchet.formatMsDuration(waitTimeMS));
+                await PromiseRatchet.wait(waitTimeMS);
+                const wrapped = dataCopy || {};
+                wrapped[RetryProcessor.RETRY_FIELD_NAME] = tryNumber + 1;
+                await mgr.fireImmediateProcessRequestByParts(this.typeName, wrapped);
+            }
+            else {
+                Logger.error('That was the last try - giving up');
+            }
+        }
+    }
+}
+RetryProcessor.RETRY_FIELD_NAME = '___RetryProcessorTryNumber';

package/dist/es/built-in/background/sample-delay-processor.js

@@ -0,0 +1,12 @@
+import { Logger, PromiseRatchet } from '@bitblit/ratchet-common';
+export class SampleDelayProcessor {
+    get typeName() {
+        return 'EpsilonSampleDelay';
+    }
+    async handleEvent(data, mgr) {
+        const delayMS = Math.floor(Math.random() * 5000);
+        Logger.info('Running sample processor for %d', delayMS);
+        await PromiseRatchet.wait(delayMS);
+        Logger.info('Sample processor complete');
+    }
+}

package/dist/es/built-in/background/sample-input-validated-processor-data.js

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

package/dist/es/built-in/background/sample-input-validated-processor.js

@@ -0,0 +1,12 @@
+import { Logger } from '@bitblit/ratchet-common';
+export class SampleInputValidatedProcessor {
+    get typeName() {
+        return 'EpsilonSampleInputValidated';
+    }
+    async handleEvent(data, mgr) {
+        Logger.info('Running SampleInputValidatedProcessor, data was : %j', data);
+    }
+    get dataSchemaName() {
+        return 'BackgroundSampleInputValidatedProcessorData';
+    }
+}

package/dist/es/built-in/built-in-trace-id-generators.js

@@ -0,0 +1,21 @@
+import { StringRatchet } from '@bitblit/ratchet-common';
+import { ContextUtil } from '../util/context-util';
+export class BuiltInTraceIdGenerators {
+    static fullAwsRequestId() {
+        let rval = ContextUtil.currentRequestId();
+        rval = rval ?? StringRatchet.createType4Guid();
+        return rval;
+    }
+    static shortAwsRequestId() {
+        let rval = BuiltInTraceIdGenerators.fullAwsRequestId();
+        if (rval.length > 10) {
+            let idx = rval.lastIndexOf('-');
+            idx = idx === -1 ? rval.length - 10 : idx;
+            rval = rval.substring(idx);
+        }
+        return rval;
+    }
+    static fixedLengthHex(length = 10) {
+        return StringRatchet.createRandomHexString(length);
+    }
+}

package/dist/es/built-in/daemon/daemon-authorizer-function.js

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

package/dist/es/built-in/daemon/daemon-config.js

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

package/dist/es/built-in/daemon/daemon-group-selection-function.js

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

package/dist/es/built-in/daemon/daemon-handler.js

@@ -0,0 +1,58 @@
+var _a;
+import { Logger } from '@bitblit/ratchet-common';
+import { NotFoundError } from '../../http/error/not-found-error';
+import { StringRatchet } from '@bitblit/ratchet-common';
+export class DaemonHandler {
+    constructor(daemon, inConfig) {
+        this.daemon = daemon;
+        this.inConfig = inConfig;
+        this.config = inConfig || {};
+        this.config.authorizer = this.config.authorizer || DaemonHandler.ALLOW_EVERYTHING_AUTHORIZER;
+        this.config.groupSelector = this.config.groupSelector || ((evt) => Promise.resolve(daemon.defaultGroup));
+        this.config.fetchDaemonStatusByPublicTokenPathParameter =
+            StringRatchet.trimToNull(this.config.fetchDaemonStatusByPublicTokenPathParameter) || 'publicToken';
+        this.config.fetchDaemonStatusPathParameter = StringRatchet.trimToNull(this.config.fetchDaemonStatusPathParameter) || 'key';
+    }
+    async fetchDaemonStatusByPublicToken(evt) {
+        const publicToken = evt.pathParameters[this.config.fetchDaemonStatusByPublicTokenPathParameter];
+        Logger.info('Fetching daemon status for token: %s', publicToken);
+        let rval = await this.daemon.statFromPublicToken(publicToken);
+        const canRead = rval ? await this.config.authorizer(evt, rval) : false;
+        rval = canRead ? rval : null;
+        if (rval === null) {
+            throw new NotFoundError('No such token : ' + publicToken);
+        }
+        return rval;
+    }
+    async fetchDaemonStatus(evt) {
+        const daemonKey = evt.pathParameters[this.config.fetchDaemonStatusPathParameter];
+        Logger.info('Fetching daemon status for : %s', daemonKey);
+        let rval = await this.daemon.stat(daemonKey);
+        const canRead = rval ? await this.config.authorizer(evt, rval) : false;
+        rval = canRead ? rval : null;
+        if (rval === null) {
+            throw new NotFoundError('No such key : ' + daemonKey);
+        }
+        return rval;
+    }
+    async listDaemonStatus(evt) {
+        const group = await this.config.groupSelector(evt);
+        const keys = await this.daemon.list(group);
+        const allowed = [];
+        for (let i = 0; i < keys.length; i++) {
+            const canRead = await this.config.authorizer(evt, keys[i]);
+            if (canRead) {
+                allowed.push(keys[i]);
+            }
+        }
+        const rval = {
+            results: allowed,
+            nextToken: null,
+        };
+        return rval;
+    }
+}
+_a = DaemonHandler;
+DaemonHandler.ALLOW_EVERYTHING_AUTHORIZER = async (evt, proc) => {
+    return true;
+};

package/dist/es/built-in/daemon/daemon-process-state-list.js

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

package/dist/es/built-in/http/apollo-filter.js

@@ -0,0 +1,58 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { PromiseRatchet } from '@bitblit/ratchet-common';
+import { TimeoutToken } from '@bitblit/ratchet-common';
+import { RequestTimeoutError } from '../../http/error/request-timeout-error';
+import { StringRatchet } from '@bitblit/ratchet-common';
+export class ApolloFilter {
+    static async handlePathWithApollo(fCtx, apolloPathRegex, apolloServer, createHandlerOptions) {
+        if (fCtx.event?.path && apolloPathRegex && apolloPathRegex.test(fCtx.event.path)) {
+            fCtx.result = await ApolloFilter.processApolloRequest(fCtx.event, fCtx.context, apolloServer, createHandlerOptions);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    static async processApolloRequest(event, context, apolloServer, createHandlerOptions) {
+        Logger.silly('Processing event with apollo: %j', event);
+        let rval = null;
+        if (!ApolloFilter.CACHE_APOLLO_HANDLER) {
+            ApolloFilter.CACHE_APOLLO_HANDLER = apolloServer.createHandler(createHandlerOptions);
+        }
+        event.multiValueHeaders = event.multiValueHeaders || {};
+        Object.keys(event.headers).forEach((k) => {
+            event.multiValueHeaders[k] = [event.headers[k]];
+        });
+        event.httpMethod = event.httpMethod.toUpperCase();
+        if (event.isBase64Encoded && !!event.body) {
+            event.body = Buffer.from(event.body, 'base64').toString();
+            event.isBase64Encoded = false;
+        }
+        const apolloPromise = ApolloFilter.CACHE_APOLLO_HANDLER(event, context, null) || Promise.resolve(null);
+        const timeoutMS = context.getRemainingTimeInMillis() - 500;
+        let result = null;
+        if (timeoutMS) {
+            result = await PromiseRatchet.timeout(apolloPromise, 'Apollo timed out after ' + timeoutMS + ' ms.', timeoutMS);
+        }
+        else {
+            Logger.warn('No timeout set even after defaulting for Apollo');
+            result = await apolloPromise;
+        }
+        if (TimeoutToken.isTimeoutToken(result)) {
+            result.writeToLog();
+            throw new RequestTimeoutError('Timed out');
+        }
+        rval = result;
+        if (StringRatchet.trimToEmpty(rval?.body).startsWith('<!DOCTYPE html>')) {
+            Logger.info('Forcing content type to html');
+            rval.headers = rval.headers || {};
+            rval.headers['content-type'] = 'text/html';
+        }
+        return rval;
+    }
+    static addApolloFilterToList(filters, apolloPathRegex, apolloServer, createHandlerOptions) {
+        if (filters) {
+            filters.push((fCtx) => ApolloFilter.handlePathWithApollo(fCtx, apolloPathRegex, apolloServer, createHandlerOptions));
+        }
+    }
+}

package/dist/es/built-in/http/built-in-auth-filters.js

@@ -0,0 +1,107 @@
+import { StringRatchet } from '@bitblit/ratchet-common';
+import { UnauthorizedError } from '../../http/error/unauthorized-error';
+import { MisconfiguredError } from '../../http/error/misconfigured-error';
+import { ForbiddenError } from '../../http/error/forbidden-error';
+import { EventUtil } from '../../http/event-util';
+export class BuiltInAuthFilters {
+    static async requireAllRolesInCommonJwt(fCtx, requiredRoleAllOf) {
+        if (!requiredRoleAllOf || requiredRoleAllOf.length === 0) {
+            throw new MisconfiguredError('You must require at least 1 role');
+        }
+        if (!fCtx.event?.authorization?.auth) {
+            throw new UnauthorizedError('May not proceed, not authenticated');
+        }
+        else {
+            const asJwt = fCtx.event.authorization.auth;
+            if (!asJwt.roles || asJwt.roles.length === 0) {
+                throw new UnauthorizedError('Required role not found');
+            }
+            else {
+                requiredRoleAllOf.forEach((r) => {
+                    if (!asJwt.roles.includes(r)) {
+                        throw new UnauthorizedError('Required role not found');
+                    }
+                });
+            }
+        }
+        return true;
+    }
+    static async requireAnyRoleInCommonJwt(fCtx, requiredRoleOneOf) {
+        if (!requiredRoleOneOf || requiredRoleOneOf.length === 0) {
+            throw new MisconfiguredError('You must require at least 1 role');
+        }
+        if (!fCtx.event?.authorization?.auth) {
+            throw new UnauthorizedError('May not proceed, not authenticated');
+        }
+        else {
+            const asJwt = fCtx.event.authorization.auth;
+            if (!asJwt.roles || asJwt.roles.length === 0) {
+                throw new UnauthorizedError('Required role not found');
+            }
+            else {
+                let found = false;
+                requiredRoleOneOf.forEach((r) => {
+                    if (!found && asJwt.roles.includes(r)) {
+                        found = true;
+                    }
+                });
+                if (!found) {
+                    throw new UnauthorizedError('Required role not found');
+                }
+            }
+        }
+        return true;
+    }
+    static async parseAuthorizationHeader(fCtx, webTokenManipulators) {
+        if (!fCtx?.event || !webTokenManipulators || (Array.isArray(webTokenManipulators) && !webTokenManipulators.length)) {
+            throw new MisconfiguredError('Cannot continue - missing event or encryption');
+        }
+        else {
+            const tokenString = EventUtil.extractBearerTokenFromEvent(fCtx?.event);
+            if (!Array.isArray(webTokenManipulators)) {
+                webTokenManipulators = [webTokenManipulators];
+            }
+            for (let i = 0; i < webTokenManipulators.length && !fCtx?.event?.authorization?.auth; i++) {
+                const manipulator = webTokenManipulators[i];
+                try {
+                    const token = await manipulator.extractTokenFromAuthorizationHeader(tokenString);
+                    fCtx.event.authorization = {
+                        raw: tokenString,
+                        auth: token,
+                        error: null,
+                    };
+                }
+                catch (err) {
+                    fCtx.event.authorization = {
+                        raw: tokenString,
+                        auth: null,
+                        error: err['message'],
+                    };
+                }
+            }
+        }
+        return true;
+    }
+    static async applyOpenApiAuthorization(fCtx) {
+        if (StringRatchet.trimToNull(fCtx?.routeAndParse?.mapping?.authorizerName)) {
+            const authorizer = fCtx?.authenticators?.get(fCtx.routeAndParse.mapping.authorizerName);
+            if (authorizer) {
+                if (fCtx?.event?.authorization?.auth) {
+                    const allowed = await authorizer(fCtx.event.authorization, fCtx.event, fCtx.routeAndParse.mapping);
+                    if (!allowed) {
+                        throw new ForbiddenError('You lack privileges to see this endpoint');
+                    }
+                }
+                else {
+                    throw new UnauthorizedError('You need to supply credentials for this endpoint');
+                }
+            }
+            else {
+                throw new MisconfiguredError().withFormattedErrorMessage('Authorizer %s requested but not found', fCtx.routeAndParse.mapping.authorizerName);
+            }
+        }
+        else {
+        }
+        return true;
+    }
+}

package/dist/es/built-in/http/built-in-authorizers.js

@@ -0,0 +1,39 @@
+import { Logger } from '@bitblit/ratchet-common';
+export class BuiltInAuthorizers {
+    static async simpleNoAuthenticationLogAccess(authorizationContext, evt) {
+        Logger.debug('Auth requested for %s : %j', evt.path, authorizationContext?.auth);
+        return true;
+    }
+    static async simpleLoggedInAuth(authorizationContext, evt) {
+        const rval = !!authorizationContext?.auth;
+        Logger.silly('SimpleLoggedInAuth returning %s for %s', rval, evt.path);
+        return rval;
+    }
+    static async simpleRoleRouteAuth(authorizationContext, event, route, requiredRoleOneOf = null, requiredRoleAllOf = null) {
+        let rval = true;
+        const token = authorizationContext?.auth;
+        if (token) {
+            if (requiredRoleOneOf) {
+                requiredRoleOneOf.forEach((r) => {
+                    rval = rval || token.roles.indexOf(r) > -1;
+                });
+                if (!rval) {
+                    Logger.warn('Request to %s failed to find at least one of %j', route.path, requiredRoleOneOf);
+                }
+            }
+            if (rval && requiredRoleAllOf) {
+                requiredRoleAllOf.forEach((r) => {
+                    rval = rval && token.roles.indexOf(r) > -1;
+                });
+                if (!rval) {
+                    Logger.warn('Request to %s failed to find all of %j', route.path, requiredRoleAllOf);
+                }
+            }
+        }
+        else {
+            Logger.warn('Cannot authenticate - no parsed auth found');
+            rval = false;
+        }
+        return rval;
+    }
+}

package/dist/es/built-in/http/built-in-filters.js

@@ -0,0 +1,208 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { StringRatchet } from '@bitblit/ratchet-common';
+import { MapRatchet } from '@bitblit/ratchet-common';
+import { EventUtil } from '../../http/event-util';
+import { BadRequestError } from '../../http/error/bad-request-error';
+import { ResponseUtil } from '../../http/response-util';
+import { EpsilonHttpError } from '../../http/error/epsilon-http-error';
+import { MisconfiguredError } from '../../http/error/misconfigured-error';
+export class BuiltInFilters {
+    static async combineFilters(fCtx, filters) {
+        let cont = true;
+        if (filters && filters.length > 0) {
+            for (let i = 0; i < filters.length && cont; i++) {
+                cont = await filters[i](fCtx);
+            }
+        }
+        return cont;
+    }
+    static async applyGzipIfPossible(fCtx) {
+        if (fCtx.event?.headers && fCtx.result) {
+            const encodingHeader = fCtx.event && fCtx.event.headers ? MapRatchet.extractValueFromMapIgnoreCase(fCtx.event.headers, 'accept-encoding') : null;
+            fCtx.result = await ResponseUtil.applyGzipIfPossible(encodingHeader, fCtx.result);
+        }
+        return true;
+    }
+    static async addConstantHeaders(fCtx, headers) {
+        if (headers && fCtx.result) {
+            fCtx.result.headers = Object.assign({}, headers, fCtx.result.headers);
+        }
+        else {
+            Logger.warn('Could not add headers - either result or headers were missing');
+        }
+        return true;
+    }
+    static async addAWSRequestIdHeader(fCtx, headerName = 'X-REQUEST-ID') {
+        if (fCtx.result && StringRatchet.trimToNull(headerName) && headerName.startsWith('X-')) {
+            fCtx.result.headers = fCtx.result.headers || {};
+            fCtx.result.headers[headerName] = fCtx.context?.awsRequestId || 'Request-Id-Missing';
+        }
+        else {
+            Logger.warn('Could not add request id header - either result or context were missing or name was invalid');
+        }
+        return true;
+    }
+    static async addAllowEverythingCORSHeaders(fCtx) {
+        return BuiltInFilters.addConstantHeaders(fCtx, {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': '*',
+            'Access-Control-Allow-Headers': '*',
+        });
+    }
+    static async addAllowReflectionCORSHeaders(fCtx) {
+        return BuiltInFilters.addConstantHeaders(fCtx, {
+            'Access-Control-Allow-Origin': MapRatchet.caseInsensitiveAccess(fCtx.event.headers, 'Origin') || '*',
+            'Access-Control-Allow-Methods': MapRatchet.caseInsensitiveAccess(fCtx.event.headers, 'Access-Control-Request-Method') || '*',
+            'Access-Control-Allow-Headers': MapRatchet.caseInsensitiveAccess(fCtx.event.headers, 'Access-Control-Request-Headers') || '*',
+        });
+    }
+    static async uriDecodeQueryParams(fCtx) {
+        if (fCtx?.event?.queryStringParameters) {
+            Object.keys(fCtx.event.queryStringParameters).forEach((k) => {
+                const val = fCtx.event.queryStringParameters[k];
+                if (val) {
+                    fCtx.event.queryStringParameters[k] = decodeURIComponent(val);
+                }
+            });
+        }
+        if (fCtx?.event?.multiValueQueryStringParameters) {
+            Object.keys(fCtx.event.multiValueQueryStringParameters).forEach((k) => {
+                const val = fCtx.event.multiValueQueryStringParameters[k];
+                if (val && val.length) {
+                    const cleaned = val.map((v) => decodeURIComponent(v));
+                    fCtx.event.multiValueQueryStringParameters[k] = cleaned;
+                }
+            });
+        }
+        return true;
+    }
+    static async fixStillEncodedQueryParams(fCtx) {
+        EventUtil.fixStillEncodedQueryParams(fCtx.event);
+        return true;
+    }
+    static async disallowStringNullAsPathParameter(fCtx) {
+        if (fCtx?.event?.pathParameters) {
+            Object.keys(fCtx.event.pathParameters).forEach((k) => {
+                if ('null' === StringRatchet.trimToEmpty(fCtx.event.pathParameters[k]).toLowerCase()) {
+                    throw new BadRequestError().withFormattedErrorMessage('Path parameter %s was string -null-', k);
+                }
+            });
+        }
+        return true;
+    }
+    static async disallowStringNullAsQueryStringParameter(fCtx) {
+        if (fCtx?.event?.queryStringParameters) {
+            Object.keys(fCtx.event.queryStringParameters).forEach((k) => {
+                if ('null' === StringRatchet.trimToEmpty(fCtx.event.queryStringParameters[k]).toLowerCase()) {
+                    throw new BadRequestError().withFormattedErrorMessage('Query parameter %s was string -null-', k);
+                }
+            });
+        }
+        return true;
+    }
+    static async ensureEventMaps(fCtx) {
+        fCtx.event.queryStringParameters = fCtx.event.queryStringParameters || {};
+        fCtx.event.headers = fCtx.event.headers || {};
+        fCtx.event.pathParameters = fCtx.event.pathParameters || {};
+        return true;
+    }
+    static async parseJsonBodyToObject(fCtx) {
+        if (fCtx.event?.body) {
+            try {
+                fCtx.event.parsedBody = EventUtil.jsonBodyToObject(fCtx.event);
+            }
+            catch (err) {
+                throw new EpsilonHttpError('Supplied body was not parsable as valid JSON').withHttpStatusCode(400);
+            }
+        }
+        return true;
+    }
+    static async checkMaximumLambdaBodySize(fCtx) {
+        if (fCtx.result?.body && fCtx.result.body.length > BuiltInFilters.MAXIMUM_LAMBDA_BODY_SIZE_BYTES) {
+            const delta = fCtx.result.body.length - BuiltInFilters.MAXIMUM_LAMBDA_BODY_SIZE_BYTES;
+            throw new EpsilonHttpError('Response size is ' + fCtx.result.body.length + ' bytes, which is ' + delta + ' bytes too large for this handler').withHttpStatusCode(500);
+        }
+        return true;
+    }
+    static async validateInboundBody(fCtx) {
+        if (fCtx?.event?.parsedBody && fCtx.routeAndParse) {
+            if (fCtx.routeAndParse.mapping.validation) {
+                if (!fCtx.modelValidator) {
+                    throw new MisconfiguredError('Requested body validation but supplied no validator');
+                }
+                const errors = fCtx.modelValidator.validate(fCtx.routeAndParse.mapping.validation.modelName, fCtx.event.parsedBody, fCtx.routeAndParse.mapping.validation.emptyAllowed, fCtx.routeAndParse.mapping.validation.extraPropertiesAllowed);
+                if (errors.length > 0) {
+                    Logger.info('Found errors while validating %s object %j', fCtx.routeAndParse.mapping.validation.modelName, errors);
+                    const newError = new BadRequestError(...errors);
+                    throw newError;
+                }
+            }
+        }
+        else {
+            Logger.debug('No validation since no route specified or no parsed body');
+        }
+        return true;
+    }
+    static async validateInboundQueryParams(fCtx) {
+        return true;
+    }
+    static async validateInboundPathParams(fCtx) {
+        return true;
+    }
+    static async validateOutboundResponse(fCtx) {
+        if (fCtx?.rawResult) {
+            if (fCtx.routeAndParse.mapping.outboundValidation) {
+                Logger.debug('Applying outbound check to %j', fCtx.rawResult);
+                const errors = fCtx.modelValidator.validate(fCtx.routeAndParse.mapping.outboundValidation.modelName, fCtx.rawResult, fCtx.routeAndParse.mapping.outboundValidation.emptyAllowed, fCtx.routeAndParse.mapping.outboundValidation.extraPropertiesAllowed);
+                if (errors.length > 0) {
+                    Logger.error('Found outbound errors while validating %s object %j', fCtx.routeAndParse.mapping.outboundValidation.modelName, errors);
+                    errors.unshift('Server sent object invalid according to spec');
+                    throw new EpsilonHttpError().withErrors(errors).withHttpStatusCode(500).withDetails(fCtx.rawResult);
+                }
+            }
+            else {
+                Logger.debug('Applied no outbound validation because none set');
+            }
+        }
+        else {
+            Logger.debug('No validation since no outbound body or disabled');
+        }
+        return true;
+    }
+    static async autoRespondToOptionsRequestWithCors(fCtx) {
+        if (StringRatchet.trimToEmpty(fCtx?.event?.httpMethod).toLowerCase() === 'options') {
+            fCtx.result = {
+                statusCode: 200,
+                body: '{"cors":true, "m":2}',
+            };
+            await BuiltInFilters.addAllowReflectionCORSHeaders(fCtx);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    static async autoRespond(fCtx, inBody) {
+        const body = inBody || {
+            message: 'Not Implemented',
+        };
+        fCtx.result = {
+            statusCode: 200,
+            body: JSON.stringify(body),
+        };
+        return false;
+    }
+    static async secureOutboundServerErrorForProduction(fCtx, errorMessage, errCode) {
+        if (fCtx?.result?.statusCode) {
+            if (errCode === null || fCtx.result.statusCode === errCode) {
+                Logger.warn('Securing outbound error info (was : %j)', fCtx.result.body);
+                fCtx.rawResult = new EpsilonHttpError(errorMessage).withHttpStatusCode(fCtx.result.statusCode);
+                const oldResult = fCtx.result;
+                fCtx.result = ResponseUtil.errorResponse(fCtx.rawResult);
+                fCtx.result.headers = Object.assign({}, oldResult.headers || {}, fCtx.result.headers || {});
+            }
+        }
+        return true;
+    }
+}
+BuiltInFilters.MAXIMUM_LAMBDA_BODY_SIZE_BYTES = 1024 * 1024 * 5 - 1024 * 100;