@bitblit/ratchet-epsilon-common 4.0.115-alpha → 4.0.119-alpha

package/lib/built-in/daemon/daemon-authorizer-function.js

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

package/lib/built-in/daemon/daemon-config.js

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

package/lib/built-in/daemon/daemon-group-selection-function.js

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

package/lib/built-in/daemon/daemon-handler.js

@@ -1,59 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { NotFoundError } from '../../http/error/not-found-error.js';
-import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
-export class DaemonHandler {
-    daemon;
-    inConfig;
-    static ALLOW_EVERYTHING_AUTHORIZER = async (evt, proc) => {
-        return true;
-    };
-    config;
-    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;
-    }
-}

package/lib/built-in/daemon/daemon-process-state-list.js

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

package/lib/built-in/http/apollo-filter.js

@@ -1,59 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { PromiseRatchet } from '@bitblit/ratchet-common/lib/lang/promise-ratchet.js';
-import { TimeoutToken } from '@bitblit/ratchet-common/lib/lang/timeout-token.js';
-import { RequestTimeoutError } from '../../http/error/request-timeout-error.js';
-import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
-export class ApolloFilter {
-    static CACHE_APOLLO_HANDLER;
-    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/lib/built-in/http/built-in-auth-filters.js

@@ -1,107 +0,0 @@
-import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
-import { UnauthorizedError } from '../../http/error/unauthorized-error.js';
-import { MisconfiguredError } from '../../http/error/misconfigured-error.js';
-import { ForbiddenError } from '../../http/error/forbidden-error.js';
-import { EventUtil } from '../../http/event-util.js';
-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/lib/built-in/http/built-in-authorizers.js

@@ -1,39 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-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/lib/built-in/http/built-in-filters.js

@@ -1,208 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
-import { MapRatchet } from '@bitblit/ratchet-common/lib/lang/map-ratchet.js';
-import { EventUtil } from '../../http/event-util.js';
-import { BadRequestError } from '../../http/error/bad-request-error.js';
-import { ResponseUtil } from '../../http/response-util.js';
-import { EpsilonHttpError } from '../../http/error/epsilon-http-error.js';
-import { MisconfiguredError } from '../../http/error/misconfigured-error.js';
-export class BuiltInFilters {
-    static MAXIMUM_LAMBDA_BODY_SIZE_BYTES = 1024 * 1024 * 5 - 1024 * 100;
-    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;
-    }
-}

package/lib/built-in/http/built-in-handlers.js

@@ -1,69 +0,0 @@
-import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { NumberRatchet } from '@bitblit/ratchet-common/lib/lang/number-ratchet.js';
-import { BadRequestError } from '../../http/error/bad-request-error.js';
-import { EpsilonHttpError } from '../../http/error/epsilon-http-error.js';
-import { UnauthorizedError } from '../../http/error/unauthorized-error.js';
-import { NotFoundError } from '../../http/error/not-found-error.js';
-import { ForbiddenError } from '../../http/error/forbidden-error.js';
-import { NotImplemented } from '../../http/error/not-implemented.js';
-import { MisconfiguredError } from '../../http/error/misconfigured-error.js';
-export class BuiltInHandlers {
-    static async expectedHandledByFilter(evt, flag) {
-        throw new MisconfiguredError().withFormattedErrorMessage('Should not happen - it was expected that route %s would be handled by a filter', evt.path);
-    }
-    static async handleNotImplemented(evt, flag) {
-        Logger.info('A request was made to %s with body %j - not yet implemented', evt.path, evt.body);
-        const rval = {
-            time: new Date().toLocaleString(),
-            path: evt.path,
-            message: 'NOT IMPLEMENTED YET',
-        };
-        return rval;
-    }
-    static async sample(evt, flag, context) {
-        const rval = {
-            time: new Date().toLocaleString(),
-            evt: evt,
-            pad: StringRatchet.createRandomHexString(2000),
-            flag: flag,
-        };
-        if (context) {
-            rval['context'] = context;
-        }
-        const errNumber = NumberRatchet.safeNumber(evt.queryStringParameters['error']);
-        if (errNumber) {
-            switch (errNumber) {
-                case -1:
-                    throw new Error('Test random failure');
-                case 400:
-                    throw new BadRequestError('Bad request error');
-                case 401:
-                    throw new UnauthorizedError('Unauthorized error');
-                case 403:
-                    throw new ForbiddenError('Forbidden error');
-                case 404:
-                    throw new NotFoundError('Not Found error');
-                case 501:
-                    throw new NotImplemented('Not Implemented');
-                default:
-                    throw new EpsilonHttpError()
-                        .withFormattedErrorMessage('Default error - %s', errNumber)
-                        .withHttpStatusCode(500)
-                        .withDetails({ src: errNumber })
-                        .withEndUserErrors(['msg1', 'msg2']);
-            }
-        }
-        let test = StringRatchet.trimToNull(evt.queryStringParameters['test']);
-        if (test) {
-            test = test.toLowerCase();
-            if (test === 'null') {
-                return null;
-            }
-        }
-        return rval;
-    }
-    static async defaultErrorProcessor(event, err, cfg) {
-        Logger.warn('Unhandled error (in promise catch) : %s \nStack was: %s\nEvt was: %j\nConfig was: %j', err.message, err.stack, event, cfg);
-    }
-}

package/lib/built-in/http/log-level-manipulation-filter.js

@@ -1,16 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-export class LogLevelManipulationFilter {
-    static LOG_LEVEL_BEFORE_CHANGE = null;
-    static async setLogLevelForTransaction(fCtx) {
-        LogLevelManipulationFilter.LOG_LEVEL_BEFORE_CHANGE = Logger.getLevel();
-        return true;
-    }
-    static async clearLogLevelForTransaction(fCtx) {
-        if (LogLevelManipulationFilter.LOG_LEVEL_BEFORE_CHANGE) {
-            Logger.setLevel(LogLevelManipulationFilter.LOG_LEVEL_BEFORE_CHANGE);
-            LogLevelManipulationFilter.LOG_LEVEL_BEFORE_CHANGE = null;
-            Logger.updateTracePrefix(null);
-        }
-        return true;
-    }
-}

package/lib/built-in/http/run-handler-as-filter.js

@@ -1,60 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { PromiseRatchet } from '@bitblit/ratchet-common/lib/lang/promise-ratchet.js';
-import { TimeoutToken } from '@bitblit/ratchet-common/lib/lang/timeout-token.js';
-import { RequestTimeoutError } from '../../http/error/request-timeout-error.js';
-import { ResponseUtil } from '../../http/response-util.js';
-import { NotFoundError } from '../../http/error/not-found-error.js';
-import { NullReturnedObjectHandling } from '../../config/http/null-returned-object-handling.js';
-import { EpsilonHttpError } from '../../http/error/epsilon-http-error.js';
-export class RunHandlerAsFilter {
-    static async runHandler(fCtx, rm) {
-        const handler = RunHandlerAsFilter.findHandler(rm, fCtx.event, fCtx.context);
-        Logger.debug('Processing event with epsilon: %j', fCtx.event);
-        let tmp = await handler;
-        if (TimeoutToken.isTimeoutToken(tmp)) {
-            tmp.writeToLog();
-            throw new RequestTimeoutError('Timed out');
-        }
-        Logger.debug('Initial return value : %j', tmp);
-        tmp = RunHandlerAsFilter.applyNullReturnedObjectHandling(tmp, rm.mapping.metaProcessingConfig.nullReturnedObjectHandling);
-        fCtx.rawResult = tmp;
-        fCtx.result = ResponseUtil.coerceToProxyResult(tmp);
-        return true;
-    }
-    static applyNullReturnedObjectHandling(result, handling) {
-        let rval = result;
-        if (result === null || result === undefined) {
-            if (handling === NullReturnedObjectHandling.Error) {
-                Logger.error('Null object returned and Error specified, throwing 500');
-                throw new EpsilonHttpError('Null object').withHttpStatusCode(500);
-            }
-            else if (handling === NullReturnedObjectHandling.Return404NotFoundResponse) {
-                throw new NotFoundError('Resource not found');
-            }
-            else if (handling === NullReturnedObjectHandling.ConvertToEmptyString) {
-                Logger.warn('Null object returned from handler and convert not specified, converting to empty string');
-                rval = '';
-            }
-            else {
-                throw new EpsilonHttpError('Cant happen - failed enum check').withHttpStatusCode(500);
-            }
-        }
-        return rval;
-    }
-    static async findHandler(rm, event, context, add404OnMissing = true) {
-        let rval = null;
-        if (rm) {
-            event.pathParameters = Object.assign({}, event.pathParameters, rm.parsed);
-            rval = PromiseRatchet.timeout(rm.mapping.function(event, context), 'Timed out after ' + rm.mapping.metaProcessingConfig.timeoutMS + ' ms.  Request was ' + JSON.stringify(event), rm.mapping.metaProcessingConfig.timeoutMS);
-        }
-        else if (add404OnMissing) {
-            throw new NotFoundError('No such endpoint');
-        }
-        return rval;
-    }
-    static addRunHandlerAsFilterToList(filters, rm) {
-        if (filters) {
-            filters.push((fCtx) => RunHandlerAsFilter.runHandler(fCtx, rm));
-        }
-    }
-}