@bitblit/ratchet-epsilon-common 4.0.85-alpha

package/dist/cjs/http/auth/local-web-token-manipulator.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalWebTokenManipulator = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const unauthorized_error_1 = require("../error/unauthorized-error");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+const ratchet_common_4 = require("@bitblit/ratchet-common");
+class LocalWebTokenManipulator {
+    constructor(encryptionKeys, issuer) {
+        this.encryptionKeys = encryptionKeys;
+        this.issuer = issuer;
+        ratchet_common_3.RequireRatchet.notNullOrUndefined(encryptionKeys, 'encryptionKeys');
+        ratchet_common_3.RequireRatchet.noNullOrUndefinedValuesInArray(encryptionKeys, encryptionKeys.length);
+        this._ratchet = new ratchet_common_4.JwtRatchet(Promise.resolve(encryptionKeys));
+    }
+    withExtraDecryptionKeys(keys) {
+        ratchet_common_3.RequireRatchet.notNullOrUndefined(keys, 'keys');
+        ratchet_common_3.RequireRatchet.noNullOrUndefinedValuesInArray(keys, keys.length);
+        this._ratchet = new ratchet_common_4.JwtRatchet(this._ratchet.encryptionKeyPromise, Promise.resolve(keys), this._ratchet.jtiGenerator, this._ratchet.decryptOnlyKeyUseLogLevel, this._ratchet.parseFailureLogLevel);
+        return this;
+    }
+    withParseFailureLogLevel(logLevel) {
+        this._ratchet = new ratchet_common_4.JwtRatchet(this._ratchet.encryptionKeyPromise, this._ratchet.decryptKeysPromise, this._ratchet.jtiGenerator, this._ratchet.decryptOnlyKeyUseLogLevel, logLevel);
+        return this;
+    }
+    withOldKeyUseLogLevel(logLevel) {
+        this._ratchet = new ratchet_common_4.JwtRatchet(this._ratchet.encryptionKeyPromise, this._ratchet.decryptKeysPromise, this._ratchet.jtiGenerator, logLevel, this._ratchet.parseFailureLogLevel);
+        return this;
+    }
+    get jwtRatchet() {
+        return this._ratchet;
+    }
+    get selectRandomEncryptionKey() {
+        return this._ratchet.selectRandomEncryptionKey();
+    }
+    createRefreshedJWTString(tokenString, expirationSeconds, allowExpired) {
+        return this._ratchet.refreshJWTString(tokenString, allowExpired || false, expirationSeconds);
+    }
+    async parseAndValidateJWTStringAsync(tokenString) {
+        const payload = await this._ratchet.decodeToken(tokenString, ratchet_common_4.ExpiredJwtHandling.ADD_FLAG);
+        if (ratchet_common_4.JwtRatchet.hasExpiredFlag(payload)) {
+            throw new unauthorized_error_1.UnauthorizedError('Failing JWT token read/validate - token expired on ' + payload.exp);
+        }
+        else {
+            return payload;
+        }
+    }
+    async createJWTStringAsync(principal, userObject, roles = ['USER'], expirationSeconds = 3600, proxyUser = null) {
+        ratchet_common_1.Logger.info('Creating JWT token for %s  that expires in %s', principal, expirationSeconds);
+        const now = new Date().getTime();
+        const expires = now + expirationSeconds * 1000;
+        const tokenData = {
+            exp: expires,
+            iss: this.issuer,
+            sub: principal,
+            iat: now,
+            user: userObject,
+            proxy: proxyUser,
+            roles: roles,
+        };
+        const token = await this._ratchet.createTokenString(tokenData, expirationSeconds);
+        return token;
+    }
+    async extractTokenFromAuthorizationHeader(header) {
+        let tokenString = ratchet_common_2.StringRatchet.trimToEmpty(header);
+        if (tokenString.toLowerCase().startsWith('bearer ')) {
+            tokenString = tokenString.substring(7);
+        }
+        const validated = !!tokenString ? await this.parseAndValidateJWTStringAsync(tokenString) : null;
+        return validated;
+    }
+}
+exports.LocalWebTokenManipulator = LocalWebTokenManipulator;

package/dist/cjs/http/auth/web-token-manipulator.js

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

package/dist/cjs/http/error/bad-gateway.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BadGateway = void 0;
+const epsilon_http_error_1 = require("./epsilon-http-error");
+class BadGateway extends epsilon_http_error_1.EpsilonHttpError {
+    constructor(...errors) {
+        super(...errors);
+        this.withHttpStatusCode(BadGateway.HTTP_CODE);
+    }
+}
+exports.BadGateway = BadGateway;
+BadGateway.HTTP_CODE = 502;

package/dist/cjs/http/error/bad-request-error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BadRequestError = void 0;
+const epsilon_http_error_1 = require("./epsilon-http-error");
+class BadRequestError extends epsilon_http_error_1.EpsilonHttpError {
+    constructor(...errors) {
+        super(...errors);
+        this.withHttpStatusCode(BadRequestError.HTTP_CODE);
+    }
+}
+exports.BadRequestError = BadRequestError;
+BadRequestError.HTTP_CODE = 400;

package/dist/cjs/http/error/conflict-error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConflictError = void 0;
+const epsilon_http_error_1 = require("./epsilon-http-error");
+class ConflictError extends epsilon_http_error_1.EpsilonHttpError {
+    constructor(...errors) {
+        super(...errors);
+        this.withHttpStatusCode(ConflictError.HTTP_CODE);
+    }
+}
+exports.ConflictError = ConflictError;
+ConflictError.HTTP_CODE = 409;

package/dist/cjs/http/error/epsilon-http-error.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EpsilonHttpError = void 0;
+const tslib_1 = require("tslib");
+const util_1 = tslib_1.__importDefault(require("util"));
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class EpsilonHttpError extends Error {
+    constructor(...errors) {
+        super(EpsilonHttpError.combineErrorStringsWithDefault(errors));
+        this._httpStatusCode = 500;
+        Object.setPrototypeOf(this, EpsilonHttpError.prototype);
+        this._errors = errors;
+        this[EpsilonHttpError.EPSILON_HTTP_ERROR_FLAG_KEY] = true;
+    }
+    static combineErrorStringsWithDefault(errors, defMessage = 'Internal Server Error') {
+        return errors && errors.length > 0 ? errors.join(',') : defMessage;
+    }
+    setFormattedErrorMessage(format, ...input) {
+        const msg = util_1.default.format(format, ...input);
+        this.errors = [msg];
+    }
+    withFormattedErrorMessage(format, ...input) {
+        this.setFormattedErrorMessage(format, ...input);
+        return this;
+    }
+    withHttpStatusCode(httpStatusCode) {
+        this.httpStatusCode = httpStatusCode;
+        return this;
+    }
+    withErrors(errors) {
+        this.errors = errors;
+        return this;
+    }
+    withDetailErrorCode(detailErrorCode) {
+        this._detailErrorCode = detailErrorCode;
+        return this;
+    }
+    withEndUserErrors(endUserErrors) {
+        this._endUserErrors = endUserErrors;
+        return this;
+    }
+    withDetails(details) {
+        this._details = details;
+        return this;
+    }
+    withRequestId(requestId) {
+        this._requestId = requestId;
+        return this;
+    }
+    withWrappedError(err) {
+        this._wrappedError = err;
+        return this;
+    }
+    isWrappedError() {
+        return !!this._wrappedError;
+    }
+    static wrapError(err) {
+        let rval = null;
+        if (EpsilonHttpError.objectIsEpsilonHttpError(err)) {
+            rval = err;
+        }
+        else {
+            rval = new EpsilonHttpError(err.message).withWrappedError(err).withHttpStatusCode(500);
+        }
+        return rval;
+    }
+    static objectIsEpsilonHttpError(obj) {
+        return obj && obj['__epsilonHttpErrorFlag'] === true;
+    }
+    get httpStatusCode() {
+        return this._httpStatusCode;
+    }
+    get errors() {
+        return this._errors;
+    }
+    get detailErrorCode() {
+        return this._detailErrorCode;
+    }
+    get endUserErrors() {
+        return this._endUserErrors;
+    }
+    get details() {
+        return this._details;
+    }
+    get requestId() {
+        return this._requestId;
+    }
+    get wrappedError() {
+        return this._wrappedError;
+    }
+    set httpStatusCode(value) {
+        this._httpStatusCode = value || 500;
+    }
+    set errors(value) {
+        this._errors = value || ['Internal Server Error'];
+        this.message = EpsilonHttpError.combineErrorStringsWithDefault(this._errors);
+    }
+    set detailErrorCode(value) {
+        this._detailErrorCode = value;
+    }
+    set endUserErrors(value) {
+        this._endUserErrors = value;
+    }
+    set details(value) {
+        this._details = value;
+    }
+    set requestId(value) {
+        this._requestId = value || 'MISSING';
+    }
+    set wrappedError(value) {
+        this._wrappedError = value;
+    }
+    static errorIsX0x(errIn, xClass) {
+        let rval = false;
+        if (errIn && EpsilonHttpError.objectIsEpsilonHttpError(errIn)) {
+            const err = errIn;
+            const val = ratchet_common_1.NumberRatchet.safeNumber(err.httpStatusCode);
+            const bot = xClass * 100;
+            const top = bot + 99;
+            rval = val >= bot && val <= top;
+        }
+        return rval;
+    }
+    static errorIs40x(err) {
+        return EpsilonHttpError.errorIsX0x(err, 4);
+    }
+    static errorIs50x(err) {
+        return EpsilonHttpError.errorIsX0x(err, 5);
+    }
+}
+exports.EpsilonHttpError = EpsilonHttpError;
+EpsilonHttpError.EPSILON_HTTP_ERROR_FLAG_KEY = '__epsilonHttpErrorFlag';

package/dist/cjs/http/error/forbidden-error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForbiddenError = void 0;
+const epsilon_http_error_1 = require("./epsilon-http-error");
+class ForbiddenError extends epsilon_http_error_1.EpsilonHttpError {
+    constructor(...errors) {
+        super(...errors);
+        this.withHttpStatusCode(ForbiddenError.HTTP_CODE);
+    }
+}
+exports.ForbiddenError = ForbiddenError;
+ForbiddenError.HTTP_CODE = 403;

package/dist/cjs/http/error/gateway-timeout.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayTimeout = void 0;
+const epsilon_http_error_1 = require("./epsilon-http-error");
+class GatewayTimeout extends epsilon_http_error_1.EpsilonHttpError {
+    constructor(...errors) {
+        super(...errors);
+        this.withHttpStatusCode(GatewayTimeout.HTTP_CODE);
+    }
+}
+exports.GatewayTimeout = GatewayTimeout;
+GatewayTimeout.HTTP_CODE = 504;

package/dist/cjs/http/error/method-not-allowed-error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodNotAllowedError = void 0;
+const epsilon_http_error_1 = require("./epsilon-http-error");
+class MethodNotAllowedError extends epsilon_http_error_1.EpsilonHttpError {
+    constructor(...errors) {
+        super(...errors);
+        this.withHttpStatusCode(MethodNotAllowedError.HTTP_CODE);
+    }
+}
+exports.MethodNotAllowedError = MethodNotAllowedError;
+MethodNotAllowedError.HTTP_CODE = 405;

package/dist/cjs/http/error/misconfigured-error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MisconfiguredError = void 0;
+const epsilon_http_error_1 = require("./epsilon-http-error");
+class MisconfiguredError extends epsilon_http_error_1.EpsilonHttpError {
+    constructor(...errors) {
+        super(...errors);
+        this.withHttpStatusCode(MisconfiguredError.HTTP_CODE);
+    }
+}
+exports.MisconfiguredError = MisconfiguredError;
+MisconfiguredError.HTTP_CODE = 500;

package/dist/cjs/http/error/not-found-error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = void 0;
+const epsilon_http_error_1 = require("./epsilon-http-error");
+class NotFoundError extends epsilon_http_error_1.EpsilonHttpError {
+    constructor(...errors) {
+        super(...errors);
+        this.withHttpStatusCode(NotFoundError.HTTP_CODE);
+    }
+}
+exports.NotFoundError = NotFoundError;
+NotFoundError.HTTP_CODE = 404;

package/dist/cjs/http/error/not-implemented.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotImplemented = void 0;
+const epsilon_http_error_1 = require("./epsilon-http-error");
+class NotImplemented extends epsilon_http_error_1.EpsilonHttpError {
+    constructor(...errors) {
+        super(...errors);
+        this.withHttpStatusCode(NotImplemented.HTTP_CODE);
+    }
+}
+exports.NotImplemented = NotImplemented;
+NotImplemented.HTTP_CODE = 501;

package/dist/cjs/http/error/request-timeout-error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestTimeoutError = void 0;
+const epsilon_http_error_1 = require("./epsilon-http-error");
+class RequestTimeoutError extends epsilon_http_error_1.EpsilonHttpError {
+    constructor(...errors) {
+        super(...errors);
+        this.withHttpStatusCode(RequestTimeoutError.HTTP_CODE);
+    }
+}
+exports.RequestTimeoutError = RequestTimeoutError;
+RequestTimeoutError.HTTP_CODE = 500;

package/dist/cjs/http/error/service-unavailable.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceUnavailable = void 0;
+const epsilon_http_error_1 = require("./epsilon-http-error");
+class ServiceUnavailable extends epsilon_http_error_1.EpsilonHttpError {
+    constructor(...errors) {
+        super(...errors);
+        this.withHttpStatusCode(ServiceUnavailable.HTTP_CODE);
+    }
+}
+exports.ServiceUnavailable = ServiceUnavailable;
+ServiceUnavailable.HTTP_CODE = 503;

package/dist/cjs/http/error/too-many-requests-error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TooManyRequestsError = void 0;
+const epsilon_http_error_1 = require("./epsilon-http-error");
+class TooManyRequestsError extends epsilon_http_error_1.EpsilonHttpError {
+    constructor(...errors) {
+        super(...errors);
+        this.withHttpStatusCode(TooManyRequestsError.HTTP_CODE);
+    }
+}
+exports.TooManyRequestsError = TooManyRequestsError;
+TooManyRequestsError.HTTP_CODE = 429;

package/dist/cjs/http/error/unauthorized-error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnauthorizedError = void 0;
+const epsilon_http_error_1 = require("./epsilon-http-error");
+class UnauthorizedError extends epsilon_http_error_1.EpsilonHttpError {
+    constructor(...errors) {
+        super(...errors);
+        this.withHttpStatusCode(UnauthorizedError.HTTP_CODE);
+    }
+}
+exports.UnauthorizedError = UnauthorizedError;
+UnauthorizedError.HTTP_CODE = 401;

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

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventUtil = void 0;
+const tslib_1 = require("tslib");
+const unauthorized_error_1 = require("./error/unauthorized-error");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const bad_request_error_1 = require("./error/bad-request-error");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const jsonwebtoken_1 = tslib_1.__importDefault(require("jsonwebtoken"));
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+const ratchet_common_4 = require("@bitblit/ratchet-common");
+const epsilon_constants_1 = require("../epsilon-constants");
+const ratchet_common_5 = require("@bitblit/ratchet-common");
+class EventUtil {
+    constructor() { }
+    static extractStage(event) {
+        if (!event.path.startsWith('/')) {
+            throw new bad_request_error_1.BadRequestError('Path should start with / but does not : ' + event.path);
+        }
+        const idx = event.path.indexOf('/', 1);
+        if (idx == -1) {
+            throw new bad_request_error_1.BadRequestError('No second / found in the path : ' + event.path);
+        }
+        return event.path.substring(1, idx);
+    }
+    static extractHostHeader(event) {
+        return ratchet_common_2.MapRatchet.extractValueFromMapIgnoreCase(event.headers, 'Host');
+    }
+    static extractProtocol(event) {
+        return ratchet_common_2.MapRatchet.extractValueFromMapIgnoreCase(event.headers, 'X-Forwarded-Proto');
+    }
+    static extractApiGatewayStage(event) {
+        const rc = EventUtil.extractRequestContext(event);
+        return rc ? rc.stage : null;
+    }
+    static extractRequestContext(event) {
+        return event.requestContext;
+    }
+    static extractAuthorizer(event) {
+        const rc = EventUtil.extractRequestContext(event);
+        return rc ? rc.authorizer : null;
+    }
+    static ipAddressChain(event) {
+        const headerVal = event && event.headers ? ratchet_common_2.MapRatchet.extractValueFromMapIgnoreCase(event.headers, 'X-Forwarded-For') : null;
+        let headerList = headerVal ? String(headerVal).split(',') : [];
+        headerList = headerList.map((s) => s.trim());
+        return headerList;
+    }
+    static ipAddress(event) {
+        const list = EventUtil.ipAddressChain(event);
+        return list && list.length > 0 ? list[0] : null;
+    }
+    static extractFullPath(event, overrideProtocol = null) {
+        const protocol = overrideProtocol || EventUtil.extractProtocol(event) || 'https';
+        return protocol + '://' + event.requestContext['domainName'] + event.requestContext.path;
+    }
+    static extractFullPrefix(event, overrideProtocol = null) {
+        const protocol = overrideProtocol || EventUtil.extractProtocol(event) || 'https';
+        const prefix = event.requestContext.path.substring(0, event.requestContext.path.indexOf('/', 1));
+        return protocol + '://' + event.requestContext['domainName'] + prefix;
+    }
+    static jsonBodyToObject(event) {
+        let rval = null;
+        if (event.body) {
+            const contentType = ratchet_common_2.MapRatchet.extractValueFromMapIgnoreCase(event.headers, 'Content-Type') || 'application/octet-stream';
+            rval = event.body;
+            if (event.isBase64Encoded) {
+                rval = Buffer.from(rval, 'base64');
+            }
+            if (contentType.startsWith('application/json')) {
+                rval = JSON.parse(rval.toString('ascii'));
+            }
+        }
+        return rval;
+    }
+    static calcLogLevelViaEventOrEnvParam(curLevel, event, rConfig) {
+        let rval = curLevel;
+        if ((rConfig === null || rConfig === void 0 ? void 0 : rConfig.envParamLogLevelName) && process.env[rConfig.envParamLogLevelName]) {
+            rval = ratchet_common_5.EnumRatchet.keyToEnum(ratchet_common_5.LoggerLevelName, process.env[rConfig.envParamLogLevelName]);
+            ratchet_common_1.Logger.silly('Found env log level : %s', rval);
+        }
+        if (rConfig &&
+            rConfig.queryParamLogLevelName &&
+            event &&
+            event.queryStringParameters &&
+            event.queryStringParameters[rConfig.queryParamLogLevelName]) {
+            rval = ratchet_common_5.EnumRatchet.keyToEnum(ratchet_common_5.LoggerLevelName, event.queryStringParameters[rConfig.queryParamLogLevelName]);
+            ratchet_common_1.Logger.silly('Found query log level : %s', rval);
+        }
+        return rval;
+    }
+    static fixStillEncodedQueryParams(event) {
+        if (event === null || event === void 0 ? void 0 : event.queryStringParameters) {
+            const newParams = {};
+            Object.keys(event.queryStringParameters).forEach((k) => {
+                const val = event.queryStringParameters[k];
+                if (k.toLowerCase().startsWith('amp;')) {
+                    newParams[k.substring(4)] = val;
+                }
+                else {
+                    newParams[k] = val;
+                }
+            });
+            event.queryStringParameters = newParams;
+        }
+        if (event === null || event === void 0 ? void 0 : event.multiValueQueryStringParameters) {
+            const newParams = {};
+            Object.keys(event.multiValueQueryStringParameters).forEach((k) => {
+                const val = event.multiValueQueryStringParameters[k];
+                if (k.toLowerCase().startsWith('amp;')) {
+                    newParams[k.substring(4)] = val;
+                }
+                else {
+                    newParams[k] = val;
+                }
+            });
+            event.multiValueQueryStringParameters = newParams;
+        }
+    }
+    static applyTokenToEventForTesting(event, jwtToken) {
+        const jwtFullData = jsonwebtoken_1.default.decode(jwtToken, { complete: true });
+        if (!jwtFullData['payload']) {
+            throw new Error('No payload found in passed token');
+        }
+        const jwtData = jwtFullData['payload'];
+        event.headers = event.headers || {};
+        event.headers[epsilon_constants_1.EpsilonConstants.AUTH_HEADER_NAME.toLowerCase()] = 'Bearer ' + jwtToken;
+        event.requestContext = event.requestContext || {};
+        const newAuth = Object.assign({}, event.requestContext.authorizer);
+        newAuth.userData = jwtData;
+        newAuth.userDataJSON = jwtData ? JSON.stringify(jwtData) : null;
+        newAuth.srcData = jwtToken;
+        event.requestContext.authorizer = newAuth;
+    }
+    static extractBasicAuthenticationToken(event, throwErrorOnMissingBad = false) {
+        let rval = null;
+        if (!!event && !!event.headers) {
+            const headerVal = EventUtil.extractAuthorizationHeaderCaseInsensitive(event);
+            if (!!headerVal && headerVal.startsWith('Basic ')) {
+                const parsed = ratchet_common_3.Base64Ratchet.base64StringToString(headerVal.substring(6));
+                const sp = parsed.split(':');
+                ratchet_common_1.Logger.silly('Parsed to %j', sp);
+                if (!!sp && sp.length === 2) {
+                    rval = {
+                        username: sp[0],
+                        password: sp[1],
+                    };
+                }
+            }
+        }
+        if (!rval && throwErrorOnMissingBad) {
+            throw new unauthorized_error_1.UnauthorizedError('Could not find valid basic authentication header');
+        }
+        return rval;
+    }
+    static eventIsAGraphQLIntrospection(event) {
+        let rval = false;
+        if (!!event) {
+            if (!!event.httpMethod && 'post' === event.httpMethod.toLowerCase()) {
+                if (!!event.path && event.path.endsWith('/graphql')) {
+                    const body = EventUtil.jsonBodyToObject(event);
+                    rval = !!body && !!body['operationName'] && body['operationName'] === 'IntrospectionQuery';
+                }
+            }
+        }
+        return rval;
+    }
+    static extractAuthorizationHeaderCaseInsensitive(evt) {
+        return ratchet_common_2.MapRatchet.caseInsensitiveAccess((evt === null || evt === void 0 ? void 0 : evt.headers) || {}, epsilon_constants_1.EpsilonConstants.AUTH_HEADER_NAME);
+    }
+    static extractBearerTokenFromEvent(evt) {
+        let rval = null;
+        const authHeader = ratchet_common_4.StringRatchet.trimToEmpty(EventUtil.extractAuthorizationHeaderCaseInsensitive(evt));
+        if (authHeader.toLowerCase().startsWith('bearer ')) {
+            rval = authHeader.substring(7);
+        }
+        return rval;
+    }
+}
+exports.EventUtil = EventUtil;