npm - @bitblit/ratchet-epsilon-common - Versions diffs - 4.0.85-alpha - Mend

@bitblit/ratchet-epsilon-common 4.0.85-alpha

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (409) hide show

package/dist/cjs/built-in/http/apollo-filter.js ADDED Viewed

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApolloFilter = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+const request_timeout_error_1 = require("../../http/error/request-timeout-error");
+const ratchet_common_4 = require("@bitblit/ratchet-common");
+class ApolloFilter {
+    static async handlePathWithApollo(fCtx, apolloPathRegex, apolloServer, createHandlerOptions) {
+        var _a;
+        if (((_a = fCtx.event) === null || _a === void 0 ? void 0 : _a.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) {
+        ratchet_common_1.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 ratchet_common_2.PromiseRatchet.timeout(apolloPromise, 'Apollo timed out after ' + timeoutMS + ' ms.', timeoutMS);
+        }
+        else {
+            ratchet_common_1.Logger.warn('No timeout set even after defaulting for Apollo');
+            result = await apolloPromise;
+        }
+        if (ratchet_common_3.TimeoutToken.isTimeoutToken(result)) {
+            result.writeToLog();
+            throw new request_timeout_error_1.RequestTimeoutError('Timed out');
+        }
+        rval = result;
+        if (ratchet_common_4.StringRatchet.trimToEmpty(rval === null || rval === void 0 ? void 0 : rval.body).startsWith('<!DOCTYPE html>')) {
+            ratchet_common_1.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));
+        }
+    }
+}
+exports.ApolloFilter = ApolloFilter;

package/dist/cjs/built-in/http/built-in-auth-filters.js ADDED Viewed

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuiltInAuthFilters = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const unauthorized_error_1 = require("../../http/error/unauthorized-error");
+const misconfigured_error_1 = require("../../http/error/misconfigured-error");
+const forbidden_error_1 = require("../../http/error/forbidden-error");
+const event_util_1 = require("../../http/event-util");
+class BuiltInAuthFilters {
+    static async requireAllRolesInCommonJwt(fCtx, requiredRoleAllOf) {
+        var _a, _b;
+        if (!requiredRoleAllOf || requiredRoleAllOf.length === 0) {
+            throw new misconfigured_error_1.MisconfiguredError('You must require at least 1 role');
+        }
+        if (!((_b = (_a = fCtx.event) === null || _a === void 0 ? void 0 : _a.authorization) === null || _b === void 0 ? void 0 : _b.auth)) {
+            throw new unauthorized_error_1.UnauthorizedError('May not proceed, not authenticated');
+        }
+        else {
+            const asJwt = fCtx.event.authorization.auth;
+            if (!asJwt.roles || asJwt.roles.length === 0) {
+                throw new unauthorized_error_1.UnauthorizedError('Required role not found');
+            }
+            else {
+                requiredRoleAllOf.forEach((r) => {
+                    if (!asJwt.roles.includes(r)) {
+                        throw new unauthorized_error_1.UnauthorizedError('Required role not found');
+                    }
+                });
+            }
+        }
+        return true;
+    }
+    static async requireAnyRoleInCommonJwt(fCtx, requiredRoleOneOf) {
+        var _a, _b;
+        if (!requiredRoleOneOf || requiredRoleOneOf.length === 0) {
+            throw new misconfigured_error_1.MisconfiguredError('You must require at least 1 role');
+        }
+        if (!((_b = (_a = fCtx.event) === null || _a === void 0 ? void 0 : _a.authorization) === null || _b === void 0 ? void 0 : _b.auth)) {
+            throw new unauthorized_error_1.UnauthorizedError('May not proceed, not authenticated');
+        }
+        else {
+            const asJwt = fCtx.event.authorization.auth;
+            if (!asJwt.roles || asJwt.roles.length === 0) {
+                throw new unauthorized_error_1.UnauthorizedError('Required role not found');
+            }
+            else {
+                let found = false;
+                requiredRoleOneOf.forEach((r) => {
+                    if (!found && asJwt.roles.includes(r)) {
+                        found = true;
+                    }
+                });
+                if (!found) {
+                    throw new unauthorized_error_1.UnauthorizedError('Required role not found');
+                }
+            }
+        }
+        return true;
+    }
+    static async parseAuthorizationHeader(fCtx, webTokenManipulators) {
+        var _a, _b;
+        if (!(fCtx === null || fCtx === void 0 ? void 0 : fCtx.event) || !webTokenManipulators || (Array.isArray(webTokenManipulators) && !webTokenManipulators.length)) {
+            throw new misconfigured_error_1.MisconfiguredError('Cannot continue - missing event or encryption');
+        }
+        else {
+            const tokenString = event_util_1.EventUtil.extractBearerTokenFromEvent(fCtx === null || fCtx === void 0 ? void 0 : fCtx.event);
+            if (!Array.isArray(webTokenManipulators)) {
+                webTokenManipulators = [webTokenManipulators];
+            }
+            for (let i = 0; i < webTokenManipulators.length && !((_b = (_a = fCtx === null || fCtx === void 0 ? void 0 : fCtx.event) === null || _a === void 0 ? void 0 : _a.authorization) === null || _b === void 0 ? void 0 : _b.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) {
+        var _a, _b, _c, _d, _e;
+        if (ratchet_common_1.StringRatchet.trimToNull((_b = (_a = fCtx === null || fCtx === void 0 ? void 0 : fCtx.routeAndParse) === null || _a === void 0 ? void 0 : _a.mapping) === null || _b === void 0 ? void 0 : _b.authorizerName)) {
+            const authorizer = (_c = fCtx === null || fCtx === void 0 ? void 0 : fCtx.authenticators) === null || _c === void 0 ? void 0 : _c.get(fCtx.routeAndParse.mapping.authorizerName);
+            if (authorizer) {
+                if ((_e = (_d = fCtx === null || fCtx === void 0 ? void 0 : fCtx.event) === null || _d === void 0 ? void 0 : _d.authorization) === null || _e === void 0 ? void 0 : _e.auth) {
+                    const allowed = await authorizer(fCtx.event.authorization, fCtx.event, fCtx.routeAndParse.mapping);
+                    if (!allowed) {
+                        throw new forbidden_error_1.ForbiddenError('You lack privileges to see this endpoint');
+                    }
+                }
+                else {
+                    throw new unauthorized_error_1.UnauthorizedError('You need to supply credentials for this endpoint');
+                }
+            }
+            else {
+                throw new misconfigured_error_1.MisconfiguredError().withFormattedErrorMessage('Authorizer %s requested but not found', fCtx.routeAndParse.mapping.authorizerName);
+            }
+        }
+        else {
+        }
+        return true;
+    }
+}
+exports.BuiltInAuthFilters = BuiltInAuthFilters;

package/dist/cjs/built-in/http/built-in-authorizers.js ADDED Viewed

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuiltInAuthorizers = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class BuiltInAuthorizers {
+    static async simpleNoAuthenticationLogAccess(authorizationContext, evt) {
+        ratchet_common_1.Logger.debug('Auth requested for %s : %j', evt.path, authorizationContext === null || authorizationContext === void 0 ? void 0 : authorizationContext.auth);
+        return true;
+    }
+    static async simpleLoggedInAuth(authorizationContext, evt) {
+        const rval = !!(authorizationContext === null || authorizationContext === void 0 ? void 0 : authorizationContext.auth);
+        ratchet_common_1.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 === null || authorizationContext === void 0 ? void 0 : authorizationContext.auth;
+        if (token) {
+            if (requiredRoleOneOf) {
+                requiredRoleOneOf.forEach((r) => {
+                    rval = rval || token.roles.indexOf(r) > -1;
+                });
+                if (!rval) {
+                    ratchet_common_1.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) {
+                    ratchet_common_1.Logger.warn('Request to %s failed to find all of %j', route.path, requiredRoleAllOf);
+                }
+            }
+        }
+        else {
+            ratchet_common_1.Logger.warn('Cannot authenticate - no parsed auth found');
+            rval = false;
+        }
+        return rval;
+    }
+}
+exports.BuiltInAuthorizers = BuiltInAuthorizers;

package/dist/cjs/built-in/http/built-in-filters.js ADDED Viewed

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuiltInFilters = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+const event_util_1 = require("../../http/event-util");
+const bad_request_error_1 = require("../../http/error/bad-request-error");
+const response_util_1 = require("../../http/response-util");
+const epsilon_http_error_1 = require("../../http/error/epsilon-http-error");
+const misconfigured_error_1 = require("../../http/error/misconfigured-error");
+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) {
+        var _a;
+        if (((_a = fCtx.event) === null || _a === void 0 ? void 0 : _a.headers) && fCtx.result) {
+            const encodingHeader = fCtx.event && fCtx.event.headers ? ratchet_common_3.MapRatchet.extractValueFromMapIgnoreCase(fCtx.event.headers, 'accept-encoding') : null;
+            fCtx.result = await response_util_1.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 {
+            ratchet_common_1.Logger.warn('Could not add headers - either result or headers were missing');
+        }
+        return true;
+    }
+    static async addAWSRequestIdHeader(fCtx, headerName = 'X-REQUEST-ID') {
+        var _a;
+        if (fCtx.result && ratchet_common_2.StringRatchet.trimToNull(headerName) && headerName.startsWith('X-')) {
+            fCtx.result.headers = fCtx.result.headers || {};
+            fCtx.result.headers[headerName] = ((_a = fCtx.context) === null || _a === void 0 ? void 0 : _a.awsRequestId) || 'Request-Id-Missing';
+        }
+        else {
+            ratchet_common_1.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': ratchet_common_3.MapRatchet.caseInsensitiveAccess(fCtx.event.headers, 'Origin') || '*',
+            'Access-Control-Allow-Methods': ratchet_common_3.MapRatchet.caseInsensitiveAccess(fCtx.event.headers, 'Access-Control-Request-Method') || '*',
+            'Access-Control-Allow-Headers': ratchet_common_3.MapRatchet.caseInsensitiveAccess(fCtx.event.headers, 'Access-Control-Request-Headers') || '*',
+        });
+    }
+    static async uriDecodeQueryParams(fCtx) {
+        var _a, _b;
+        if ((_a = fCtx === null || fCtx === void 0 ? void 0 : fCtx.event) === null || _a === void 0 ? void 0 : _a.queryStringParameters) {
+            Object.keys(fCtx.event.queryStringParameters).forEach((k) => {
+                const val = fCtx.event.queryStringParameters[k];
+                if (val) {
+                    fCtx.event.queryStringParameters[k] = decodeURIComponent(val);
+                }
+            });
+        }
+        if ((_b = fCtx === null || fCtx === void 0 ? void 0 : fCtx.event) === null || _b === void 0 ? void 0 : _b.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) {
+        event_util_1.EventUtil.fixStillEncodedQueryParams(fCtx.event);
+        return true;
+    }
+    static async disallowStringNullAsPathParameter(fCtx) {
+        var _a;
+        if ((_a = fCtx === null || fCtx === void 0 ? void 0 : fCtx.event) === null || _a === void 0 ? void 0 : _a.pathParameters) {
+            Object.keys(fCtx.event.pathParameters).forEach((k) => {
+                if ('null' === ratchet_common_2.StringRatchet.trimToEmpty(fCtx.event.pathParameters[k]).toLowerCase()) {
+                    throw new bad_request_error_1.BadRequestError().withFormattedErrorMessage('Path parameter %s was string -null-', k);
+                }
+            });
+        }
+        return true;
+    }
+    static async disallowStringNullAsQueryStringParameter(fCtx) {
+        var _a;
+        if ((_a = fCtx === null || fCtx === void 0 ? void 0 : fCtx.event) === null || _a === void 0 ? void 0 : _a.queryStringParameters) {
+            Object.keys(fCtx.event.queryStringParameters).forEach((k) => {
+                if ('null' === ratchet_common_2.StringRatchet.trimToEmpty(fCtx.event.queryStringParameters[k]).toLowerCase()) {
+                    throw new bad_request_error_1.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) {
+        var _a;
+        if ((_a = fCtx.event) === null || _a === void 0 ? void 0 : _a.body) {
+            try {
+                fCtx.event.parsedBody = event_util_1.EventUtil.jsonBodyToObject(fCtx.event);
+            }
+            catch (err) {
+                throw new epsilon_http_error_1.EpsilonHttpError('Supplied body was not parsable as valid JSON').withHttpStatusCode(400);
+            }
+        }
+        return true;
+    }
+    static async checkMaximumLambdaBodySize(fCtx) {
+        var _a;
+        if (((_a = fCtx.result) === null || _a === void 0 ? void 0 : _a.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 epsilon_http_error_1.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) {
+        var _a;
+        if (((_a = fCtx === null || fCtx === void 0 ? void 0 : fCtx.event) === null || _a === void 0 ? void 0 : _a.parsedBody) && fCtx.routeAndParse) {
+            if (fCtx.routeAndParse.mapping.validation) {
+                if (!fCtx.modelValidator) {
+                    throw new misconfigured_error_1.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) {
+                    ratchet_common_1.Logger.info('Found errors while validating %s object %j', fCtx.routeAndParse.mapping.validation.modelName, errors);
+                    const newError = new bad_request_error_1.BadRequestError(...errors);
+                    throw newError;
+                }
+            }
+        }
+        else {
+            ratchet_common_1.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 === null || fCtx === void 0 ? void 0 : fCtx.rawResult) {
+            if (fCtx.routeAndParse.mapping.outboundValidation) {
+                ratchet_common_1.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) {
+                    ratchet_common_1.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 epsilon_http_error_1.EpsilonHttpError().withErrors(errors).withHttpStatusCode(500).withDetails(fCtx.rawResult);
+                }
+            }
+            else {
+                ratchet_common_1.Logger.debug('Applied no outbound validation because none set');
+            }
+        }
+        else {
+            ratchet_common_1.Logger.debug('No validation since no outbound body or disabled');
+        }
+        return true;
+    }
+    static async autoRespondToOptionsRequestWithCors(fCtx) {
+        var _a;
+        if (ratchet_common_2.StringRatchet.trimToEmpty((_a = fCtx === null || fCtx === void 0 ? void 0 : fCtx.event) === null || _a === void 0 ? void 0 : _a.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) {
+        var _a;
+        if ((_a = fCtx === null || fCtx === void 0 ? void 0 : fCtx.result) === null || _a === void 0 ? void 0 : _a.statusCode) {
+            if (errCode === null || fCtx.result.statusCode === errCode) {
+                ratchet_common_1.Logger.warn('Securing outbound error info (was : %j)', fCtx.result.body);
+                fCtx.rawResult = new epsilon_http_error_1.EpsilonHttpError(errorMessage).withHttpStatusCode(fCtx.result.statusCode);
+                const oldResult = fCtx.result;
+                fCtx.result = response_util_1.ResponseUtil.errorResponse(fCtx.rawResult);
+                fCtx.result.headers = Object.assign({}, oldResult.headers || {}, fCtx.result.headers || {});
+            }
+        }
+        return true;
+    }
+}
+exports.BuiltInFilters = BuiltInFilters;
+BuiltInFilters.MAXIMUM_LAMBDA_BODY_SIZE_BYTES = 1024 * 1024 * 5 - 1024 * 100;

package/dist/cjs/built-in/http/built-in-handlers.js ADDED Viewed

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuiltInHandlers = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+const bad_request_error_1 = require("../../http/error/bad-request-error");
+const epsilon_http_error_1 = require("../../http/error/epsilon-http-error");
+const unauthorized_error_1 = require("../../http/error/unauthorized-error");
+const not_found_error_1 = require("../../http/error/not-found-error");
+const forbidden_error_1 = require("../../http/error/forbidden-error");
+const not_implemented_1 = require("../../http/error/not-implemented");
+const misconfigured_error_1 = require("../../http/error/misconfigured-error");
+class BuiltInHandlers {
+    static async expectedHandledByFilter(evt, flag) {
+        throw new misconfigured_error_1.MisconfiguredError().withFormattedErrorMessage('Should not happen - it was expected that route %s would be handled by a filter', evt.path);
+    }
+    static async handleNotImplemented(evt, flag) {
+        ratchet_common_2.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: ratchet_common_1.StringRatchet.createRandomHexString(2000),
+            flag: flag,
+        };
+        if (context) {
+            rval['context'] = context;
+        }
+        const errNumber = ratchet_common_3.NumberRatchet.safeNumber(evt.queryStringParameters['error']);
+        if (errNumber) {
+            switch (errNumber) {
+                case -1:
+                    throw new Error('Test random failure');
+                case 400:
+                    throw new bad_request_error_1.BadRequestError('Bad request error');
+                case 401:
+                    throw new unauthorized_error_1.UnauthorizedError('Unauthorized error');
+                case 403:
+                    throw new forbidden_error_1.ForbiddenError('Forbidden error');
+                case 404:
+                    throw new not_found_error_1.NotFoundError('Not Found error');
+                case 501:
+                    throw new not_implemented_1.NotImplemented('Not Implemented');
+                default:
+                    throw new epsilon_http_error_1.EpsilonHttpError()
+                        .withFormattedErrorMessage('Default error - %s', errNumber)
+                        .withHttpStatusCode(500)
+                        .withDetails({ src: errNumber })
+                        .withEndUserErrors(['msg1', 'msg2']);
+            }
+        }
+        let test = ratchet_common_1.StringRatchet.trimToNull(evt.queryStringParameters['test']);
+        if (test) {
+            test = test.toLowerCase();
+            if (test === 'null') {
+                return null;
+            }
+        }
+        return rval;
+    }
+    static async defaultErrorProcessor(event, err, cfg) {
+        ratchet_common_2.Logger.warn('Unhandled error (in promise catch) : %s \nStack was: %s\nEvt was: %j\nConfig was: %j', err.message, err.stack, event, cfg);
+    }
+}
+exports.BuiltInHandlers = BuiltInHandlers;

package/dist/cjs/built-in/http/log-level-manipulation-filter.js ADDED Viewed

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevelManipulationFilter = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class LogLevelManipulationFilter {
+    static async setLogLevelForTransaction(fCtx) {
+        LogLevelManipulationFilter.LOG_LEVEL_BEFORE_CHANGE = ratchet_common_1.Logger.getLevel();
+        return true;
+    }
+    static async clearLogLevelForTransaction(fCtx) {
+        if (LogLevelManipulationFilter.LOG_LEVEL_BEFORE_CHANGE) {
+            ratchet_common_1.Logger.setLevel(LogLevelManipulationFilter.LOG_LEVEL_BEFORE_CHANGE);
+            LogLevelManipulationFilter.LOG_LEVEL_BEFORE_CHANGE = null;
+            ratchet_common_1.Logger.updateTracePrefix(null);
+        }
+        return true;
+    }
+}
+exports.LogLevelManipulationFilter = LogLevelManipulationFilter;
+LogLevelManipulationFilter.LOG_LEVEL_BEFORE_CHANGE = null;

package/dist/cjs/built-in/http/run-handler-as-filter.js ADDED Viewed

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunHandlerAsFilter = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+const request_timeout_error_1 = require("../../http/error/request-timeout-error");
+const response_util_1 = require("../../http/response-util");
+const not_found_error_1 = require("../../http/error/not-found-error");
+const null_returned_object_handling_1 = require("../../config/http/null-returned-object-handling");
+const epsilon_http_error_1 = require("../../http/error/epsilon-http-error");
+class RunHandlerAsFilter {
+    static async runHandler(fCtx, rm) {
+        const handler = RunHandlerAsFilter.findHandler(rm, fCtx.event, fCtx.context);
+        ratchet_common_1.Logger.debug('Processing event with epsilon: %j', fCtx.event);
+        let tmp = await handler;
+        if (ratchet_common_3.TimeoutToken.isTimeoutToken(tmp)) {
+            tmp.writeToLog();
+            throw new request_timeout_error_1.RequestTimeoutError('Timed out');
+        }
+        ratchet_common_1.Logger.debug('Initial return value : %j', tmp);
+        tmp = RunHandlerAsFilter.applyNullReturnedObjectHandling(tmp, rm.mapping.metaProcessingConfig.nullReturnedObjectHandling);
+        fCtx.rawResult = tmp;
+        fCtx.result = response_util_1.ResponseUtil.coerceToProxyResult(tmp);
+        return true;
+    }
+    static applyNullReturnedObjectHandling(result, handling) {
+        let rval = result;
+        if (result === null || result === undefined) {
+            if (handling === null_returned_object_handling_1.NullReturnedObjectHandling.Error) {
+                ratchet_common_1.Logger.error('Null object returned and Error specified, throwing 500');
+                throw new epsilon_http_error_1.EpsilonHttpError('Null object').withHttpStatusCode(500);
+            }
+            else if (handling === null_returned_object_handling_1.NullReturnedObjectHandling.Return404NotFoundResponse) {
+                throw new not_found_error_1.NotFoundError('Resource not found');
+            }
+            else if (handling === null_returned_object_handling_1.NullReturnedObjectHandling.ConvertToEmptyString) {
+                ratchet_common_1.Logger.warn('Null object returned from handler and convert not specified, converting to empty string');
+                rval = '';
+            }
+            else {
+                throw new epsilon_http_error_1.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 = ratchet_common_2.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 not_found_error_1.NotFoundError('No such endpoint');
+        }
+        return rval;
+    }
+    static addRunHandlerAsFilterToList(filters, rm) {
+        if (filters) {
+            filters.push((fCtx) => RunHandlerAsFilter.runHandler(fCtx, rm));
+        }
+    }
+}
+exports.RunHandlerAsFilter = RunHandlerAsFilter;

package/dist/cjs/cli-bootstrap/epsilon-run-background-process-from-command-line-dry-run.js ADDED Viewed

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const run_background_process_from_command_line_1 = require("../run-background-process-from-command-line");
+const ratchet_node_only_1 = require("@bitblit/ratchet-node-only");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+if (((_a = process === null || process === void 0 ? void 0 : process.argv) === null || _a === void 0 ? void 0 : _a.length) &&
+    ratchet_node_only_1.CliRatchet.isCalledFromCLI([
+        'epsilon-run-background-process-from-command-line-dry-run.js',
+        'epsilon-run-background-process-from-command-line-dry-run',
+    ])) {
+    run_background_process_from_command_line_1.RunBackgroundProcessFromCommandLine.processBackgroundCliRequest(null, true)
+        .then((out) => {
+        ratchet_common_1.Logger.info('Result : %s', out);
+    })
+        .catch((err) => ratchet_common_1.Logger.error('Failed : %s', err));
+}
+else {
+}

package/dist/cjs/config/background/background-aws-config.js ADDED Viewed

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

package/dist/cjs/config/background/background-config.js ADDED Viewed

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

package/dist/cjs/config/background/background-error-processor.js ADDED Viewed

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

package/dist/cjs/config/background/background-processor.js ADDED Viewed

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

package/dist/cjs/config/background/background-transaction-log.js ADDED Viewed

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

package/dist/cjs/config/background/background-transaction-logger.js ADDED Viewed

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

package/dist/cjs/config/cron/abstract-cron-entry.js ADDED Viewed

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

package/dist/cjs/config/cron/cron-background-entry.js ADDED Viewed

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