@bitblit/ratchet-epsilon-common 4.0.85-alpha

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

@@ -0,0 +1,69 @@
+import { StringRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common';
+import { NumberRatchet } from '@bitblit/ratchet-common';
+import { BadRequestError } from '../../http/error/bad-request-error';
+import { EpsilonHttpError } from '../../http/error/epsilon-http-error';
+import { UnauthorizedError } from '../../http/error/unauthorized-error';
+import { NotFoundError } from '../../http/error/not-found-error';
+import { ForbiddenError } from '../../http/error/forbidden-error';
+import { NotImplemented } from '../../http/error/not-implemented';
+import { MisconfiguredError } from '../../http/error/misconfigured-error';
+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/dist/es/built-in/http/log-level-manipulation-filter.js

@@ -0,0 +1,16 @@
+import { Logger } from '@bitblit/ratchet-common';
+export class LogLevelManipulationFilter {
+    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;
+    }
+}
+LogLevelManipulationFilter.LOG_LEVEL_BEFORE_CHANGE = null;

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

@@ -0,0 +1,60 @@
+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 { ResponseUtil } from '../../http/response-util';
+import { NotFoundError } from '../../http/error/not-found-error';
+import { NullReturnedObjectHandling } from '../../config/http/null-returned-object-handling';
+import { EpsilonHttpError } from '../../http/error/epsilon-http-error';
+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));
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { RunBackgroundProcessFromCommandLine } from '../run-background-process-from-command-line';
+import { CliRatchet } from '@bitblit/ratchet-node-only';
+import { Logger } from '@bitblit/ratchet-common';
+if (process?.argv?.length &&
+    CliRatchet.isCalledFromCLI([
+        'epsilon-run-background-process-from-command-line-dry-run.js',
+        'epsilon-run-background-process-from-command-line-dry-run',
+    ])) {
+    RunBackgroundProcessFromCommandLine.processBackgroundCliRequest(null, true)
+        .then((out) => {
+        Logger.info('Result : %s', out);
+    })
+        .catch((err) => Logger.error('Failed : %s', err));
+}
+else {
+}

package/dist/es/config/background/background-aws-config.js

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

package/dist/es/config/background/background-config.js

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

package/dist/es/config/background/background-error-processor.js

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

package/dist/es/config/background/background-processor.js

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

package/dist/es/config/background/background-transaction-log.js

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

package/dist/es/config/background/background-transaction-logger.js

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

package/dist/es/config/cron/abstract-cron-entry.js

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

package/dist/es/config/cron/cron-background-entry.js

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

package/dist/es/config/cron/cron-config.js

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

package/dist/es/config/dynamo-db-config.js

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

package/dist/es/config/epsilon-config.js

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

package/dist/es/config/epsilon-lambda-event-handler.js

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

package/dist/es/config/epsilon-logger-config.js

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

package/dist/es/config/generic-aws-event-handler-function.js

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

package/dist/es/config/http/authorizer-function.js

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

package/dist/es/config/http/epsilon-authorization-context.js

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

package/dist/es/config/http/extended-api-gateway-event.js

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

package/dist/es/config/http/filter-chain-context.js

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

package/dist/es/config/http/filter-function.js

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

package/dist/es/config/http/handler-function.js

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

package/dist/es/config/http/http-config.js

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

package/dist/es/config/http/http-processing-config.js

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

package/dist/es/config/http/mapped-http-processing-config.js

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

package/dist/es/config/http/null-returned-object-handling.js

@@ -0,0 +1,6 @@
+export var NullReturnedObjectHandling;
+(function (NullReturnedObjectHandling) {
+    NullReturnedObjectHandling["Error"] = "Error";
+    NullReturnedObjectHandling["ConvertToEmptyString"] = "ConvertToEmptyString";
+    NullReturnedObjectHandling["Return404NotFoundResponse"] = "Return404NotFoundResponse";
+})(NullReturnedObjectHandling || (NullReturnedObjectHandling = {}));

package/dist/es/config/inter-api/inter-api-aws-config.js

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

package/dist/es/config/inter-api/inter-api-config.js

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

package/dist/es/config/inter-api/inter-api-process-mapping.js

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

package/dist/es/config/logging-trace-id-generator.js

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

package/dist/es/config/open-api/open-api-document-components.js

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

package/dist/es/config/open-api/open-api-document-path.js

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

package/dist/es/config/open-api/open-api-document.js

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

package/dist/es/config/s3-config.js

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

package/dist/es/config/sns-config.js

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

package/dist/es/epsilon-build-properties.js

@@ -0,0 +1,24 @@
+import { StringRatchet } from '@bitblit/ratchet-common';
+export class EpsilonBuildProperties {
+    constructor() { }
+    static get buildVersion() {
+        return 'LOCAL-SNAPSHOT';
+    }
+    static get buildHash() {
+        return 'LOCAL-HASH';
+    }
+    static get buildBranch() {
+        return 'LOCAL-BRANCH';
+    }
+    static get buildTag() {
+        return 'LOCAL-TAG';
+    }
+    static get buildBranchOrTag() {
+        return StringRatchet.trimToNull(EpsilonBuildProperties.buildBranch)
+            ? 'BRANCH:' + EpsilonBuildProperties.buildBranch
+            : 'TAG:' + EpsilonBuildProperties.buildTag;
+    }
+    static get buildTime() {
+        return 'LOCAL-TIME';
+    }
+}

package/dist/es/epsilon-constants.js

@@ -0,0 +1,45 @@
+import { Logger } from '@bitblit/ratchet-common';
+export class EpsilonConstants {
+    static load(filePath, className) {
+        Logger.info('Searching for %s : %s : %s', filePath, className, __dirname);
+        let rval = null;
+        const val = require(filePath);
+        if (val) {
+            Logger.debug('Found %s - pulling object : %j : %s', filePath, Object.keys(val), className);
+            rval = val[className];
+        }
+        return rval;
+    }
+    static async findDynamicImportEpsilonGlobalHandlerProvider() {
+        const importPath = process.env[EpsilonConstants.EPSILON_FINDER_DYNAMIC_IMPORT_PATH_ENV_NAME] ||
+            EpsilonConstants.DEFAULT_EPSILON_FINDER_DYNAMIC_IMPORT_PATH;
+        const fnName = process.env[EpsilonConstants.EPSILON_FINDER_FUNCTION_NAME_ENV_NAME] || EpsilonConstants.DEFAULT_EPSILON_FINDER_FUNCTION_NAME;
+        Logger.debug('Using epsilon finder dynamic import path : %s / %s', importPath, fnName);
+        let provider = null;
+        try {
+            provider = this.load(importPath, fnName);
+        }
+        catch (err) {
+            Logger.error('Error loading provider : %s / %s : %s', importPath, fnName, err, err);
+        }
+        let rval = null;
+        if (provider) {
+            Logger.debug('Type2 is : %s', typeof provider);
+            Logger.info('Got3 : %s : %s', provider, typeof provider);
+            rval = provider();
+            Logger.info('Rval3 is %s', rval);
+        }
+        return rval;
+    }
+    constructor() { }
+}
+EpsilonConstants.EPSILON_FINDER_DYNAMIC_IMPORT_PATH_ENV_NAME = 'EPSILON_FINDER_DYNAMIC_IMPORT_PATH';
+EpsilonConstants.EPSILON_FINDER_FUNCTION_NAME_ENV_NAME = 'EPSILON_FINDER_FUNCTION_NAME';
+EpsilonConstants.DEFAULT_EPSILON_FINDER_DYNAMIC_IMPORT_PATH = 'epsilon-global-handler-provider.js';
+EpsilonConstants.DEFAULT_EPSILON_FINDER_FUNCTION_NAME = 'findEpsilonGlobalHandler';
+EpsilonConstants.AUTH_HEADER_PREFIX = 'Bearer ';
+EpsilonConstants.AUTH_HEADER_NAME = 'Authorization';
+EpsilonConstants.BACKGROUND_SQS_TYPE_FIELD = 'BACKGROUND_TYPE';
+EpsilonConstants.BACKGROUND_SNS_START_MARKER = 'BACKGROUND_START_MARKER';
+EpsilonConstants.BACKGROUND_SNS_IMMEDIATE_RUN_FLAG = 'BACKGROUND_IMMEDIATE_RUN_FLAG';
+EpsilonConstants.INTER_API_SNS_EVENT = 'EPSILON_INTER_API_EVENT';

package/dist/es/epsilon-global-handler.js

@@ -0,0 +1,149 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { EventUtil } from './http/event-util';
+import { TimeoutToken } from '@bitblit/ratchet-common';
+import { PromiseRatchet } from '@bitblit/ratchet-common';
+import { ResponseUtil } from './http/response-util';
+import { EpsilonHttpError } from './http/error/epsilon-http-error';
+import { RequestTimeoutError } from './http/error/request-timeout-error';
+import { ErrorRatchet, LoggerLevelName, LoggerOutputFunction, LogMessageFormatType, } from '@bitblit/ratchet-common';
+import { ContextUtil } from './util/context-util';
+import { WebV2Handler } from './http/web-v2-handler';
+import { InterApiEpsilonLambdaEventHandler } from './lambda-event-handler/inter-api-epsilon-lambda-event-handler';
+import { GenericSnsEpsilonLambdaEventHandler } from './lambda-event-handler/generic-sns-epsilon-lambda-event-handler';
+import { CronEpsilonLambdaEventHandler } from './lambda-event-handler/cron-epsilon-lambda-event-handler';
+import { S3EpsilonLambdaEventHandler } from './lambda-event-handler/s3-epsilon-lambda-event-handler';
+import { DynamoEpsilonLambdaEventHandler } from './lambda-event-handler/dynamo-epsilon-lambda-event-handler';
+import { EpsilonLoggingExtensionProcessor } from './epsilon-logging-extension-processor';
+export class EpsilonGlobalHandler {
+    static set globalInstanceProvider(input) {
+        EpsilonGlobalHandler.GLOBAL_INSTANCE_PROVIDER = input;
+    }
+    static get globalInstanceProvider() {
+        return EpsilonGlobalHandler.GLOBAL_INSTANCE_PROVIDER;
+    }
+    constructor(_epsilon) {
+        this._epsilon = _epsilon;
+        this.handlers = null;
+        if (!EpsilonGlobalHandler.LOGGER_CONFIGURED) {
+            EpsilonGlobalHandler.configureDefaultLogger();
+            Logger.info('EpsilonLoggingConfiguration:Default logger configured');
+        }
+        else {
+            Logger.info('EpsilonLoggingConfiguration:Skipping default logger config - already configured');
+        }
+        this.handlers = [
+            this._epsilon.webHandler,
+            new WebV2Handler(this._epsilon.webHandler),
+            this._epsilon.backgroundHandler,
+            new InterApiEpsilonLambdaEventHandler(this._epsilon),
+            new GenericSnsEpsilonLambdaEventHandler(this._epsilon),
+            new CronEpsilonLambdaEventHandler(this._epsilon),
+            new S3EpsilonLambdaEventHandler(this._epsilon),
+            new DynamoEpsilonLambdaEventHandler(this._epsilon),
+        ];
+    }
+    static configureDefaultLogger(overrides) {
+        const output = overrides ? Object.assign({}, overrides) : {};
+        output.initialLevel = output.initialLevel ?? LoggerLevelName.info;
+        output.formatType = output.formatType ?? LogMessageFormatType.StructuredJson;
+        output.globalVars = output.globalVars ?? {};
+        output.outputFunction = output.outputFunction ?? LoggerOutputFunction.StdOut;
+        output.ringBufferSize = output.ringBufferSize ?? 0;
+        const src = output.preProcessors || [];
+        output.preProcessors = src.concat([new EpsilonLoggingExtensionProcessor()]);
+        const pre = Logger.getOptions();
+        Logger.changeDefaultOptions(output, true);
+        const post = Logger.getOptions();
+        EpsilonGlobalHandler.LOGGER_CONFIGURED = true;
+        Logger.info('EpsilonLoggingConfiguration: Updated');
+        Logger.dumpOptionsIntoLog();
+    }
+    get epsilon() {
+        return this._epsilon;
+    }
+    async processSingleBackgroundByParts(type, data, overrideTraceId, overrideTraceDepth) {
+        return this.processSingleBackgroundEntry(this._epsilon.backgroundManager.createEntry(type, data), overrideTraceId, overrideTraceDepth);
+    }
+    async processSingleBackgroundEntry(e, overrideTraceId, overrideTraceDepth) {
+        let rval = false;
+        if (e?.type) {
+            const internal = this._epsilon.backgroundManager.wrapEntryForInternal(e, overrideTraceId, overrideTraceDepth);
+            rval = await this._epsilon.backgroundHandler.processSingleBackgroundEntry(internal);
+            Logger.info('Direct processed request %j to %s', e, rval);
+        }
+        else {
+            Logger.error('Cannot process null/unnamed background entry');
+        }
+        return rval;
+    }
+    async lambdaHandler(event, context) {
+        let rval = null;
+        try {
+            if (this.epsilon.config.disableLastResortTimeout || !context || !context.getRemainingTimeInMillis()) {
+                rval = await this.innerLambdaHandler(event, context);
+            }
+            else {
+                const tmp = await PromiseRatchet.timeout(this.innerLambdaHandler(event, context), 'EpsilonLastResortTimeout', context.getRemainingTimeInMillis() - 1000);
+                if (TimeoutToken.isTimeoutToken(tmp)) {
+                    tmp.writeToLog();
+                    rval = ResponseUtil.errorResponse(EpsilonHttpError.wrapError(new RequestTimeoutError('Timed out')));
+                }
+                else {
+                    rval = tmp;
+                }
+            }
+        }
+        finally {
+            ContextUtil.clearContext();
+        }
+        return rval;
+    }
+    async innerLambdaHandler(event, context) {
+        ContextUtil.initContext(this._epsilon, event, context, 'TBD');
+        let rval = null;
+        let errorHandler = EpsilonGlobalHandler.defaultProcessUncaughtError;
+        try {
+            if (!this._epsilon) {
+                Logger.error('Config not found, abandoning');
+                return false;
+            }
+            const logLevel = EventUtil.calcLogLevelViaEventOrEnvParam(Logger.getLevel(), event, this._epsilon.config.loggerConfig);
+            Logger.setLevel(logLevel);
+            if (this._epsilon.config.loggerConfig &&
+                this._epsilon.config.loggerConfig.queryParamTracePrefixName &&
+                event.queryStringParameters &&
+                event.queryStringParameters[this._epsilon.config.loggerConfig.queryParamTracePrefixName]) {
+                Logger.info('Setting trace prefix to %s', event.queryStringParameters[this._epsilon.config.loggerConfig.queryParamTracePrefixName]);
+                Logger.updateTracePrefix(event.queryStringParameters[this._epsilon.config.loggerConfig.queryParamTracePrefixName]);
+            }
+            let found = false;
+            for (let i = 0; i < this.handlers.length && !found; i++) {
+                const handler = this.handlers[i];
+                if (handler.handlesEvent(event)) {
+                    found = true;
+                    errorHandler = handler.processUncaughtError || errorHandler;
+                    const label = handler.extractLabel(event, context);
+                    ContextUtil.setProcessLabel(label);
+                    Logger.logByLevel(this._epsilon?.config?.loggerConfig?.epsilonStartEndMessageLogLevel || LoggerLevelName.info, 'EvtStart: %s', label);
+                    rval = await handler.processEvent(event, context);
+                    Logger.logByLevel(this._epsilon?.config?.loggerConfig?.epsilonStartEndMessageLogLevel || LoggerLevelName.info, 'EvtEnd: %s', label);
+                    Logger.silly('EvtEnd:Value: %s Value: %j', label, rval);
+                }
+            }
+        }
+        catch (err) {
+            rval = await errorHandler(event, context, err);
+        }
+        return rval;
+    }
+    static async defaultProcessUncaughtError(event, context, err) {
+        Logger.error('Error slipped out to outer edge (Default).  Logging and returning log : %s', err, err);
+        const rval = {
+            statusCode: 500,
+            body: JSON.stringify({ error: ErrorRatchet.safeStringifyErr(err) }),
+            isBase64Encoded: false,
+        };
+        return rval;
+    }
+}
+EpsilonGlobalHandler.LOGGER_CONFIGURED = false;

package/dist/es/epsilon-instance.js

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

package/dist/es/epsilon-logging-extension-processor.js

@@ -0,0 +1,15 @@
+import { ContextUtil } from './util/context-util';
+export class EpsilonLoggingExtensionProcessor {
+    process(msg) {
+        msg.params = Object.assign({}, msg.params || {}, ContextUtil.fetchLogVariables());
+        msg.params['tester'] = Date.now();
+        msg.params['awsRequestId'] = ContextUtil.currentRequestId();
+        msg.params['traceId'] = ContextUtil.currentTraceId();
+        msg.params['traceDepth'] = ContextUtil.currentTraceDepth();
+        msg.params['procLabel'] = ContextUtil.currentProcessLabel();
+        return msg;
+    }
+    label() {
+        return 'EpsilonLoggingExtensionProcessor';
+    }
+}

package/dist/es/http/auth/api-gateway-adapter-authentication-handler.js

@@ -0,0 +1,71 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { LocalWebTokenManipulator } from './local-web-token-manipulator';
+import { EpsilonConstants } from '../../epsilon-constants';
+export class ApiGatewayAdapterAuthenticationHandler {
+    constructor(issuer, encryptionKeys) {
+        this.webTokenManipulator = new LocalWebTokenManipulator([encryptionKeys], issuer);
+    }
+    lambdaHandler(event, context, callback) {
+        Logger.info('Got event : %j', event);
+        const srcString = ApiGatewayAdapterAuthenticationHandler.extractTokenStringFromAuthorizerEvent(event);
+        if (srcString) {
+            const methodArn = event.methodArn;
+            this.webTokenManipulator
+                .parseAndValidateJWTStringAsync(srcString)
+                .then((parsed) => {
+                if (parsed) {
+                    callback(null, this.createPolicy(methodArn, srcString, parsed));
+                }
+                else {
+                    Logger.info('Invalid bearer token');
+                    callback(new Error('Unauthorized'));
+                }
+            })
+                .catch((err) => {
+                Logger.error('Exception parsing token : %s', err);
+                callback(new Error('Unauthorized'));
+            });
+        }
+        else {
+            Logger.info('Token not supplied');
+            callback(new Error('Unauthorized'));
+        }
+    }
+    createPolicy(methodArn, srcString, userOb) {
+        const tmp = methodArn.split(':');
+        const apiGatewayArnTmp = tmp[5].split('/');
+        const awsAccountId = tmp[4];
+        const region = tmp[3];
+        const stage = apiGatewayArnTmp[1];
+        const restApiId = apiGatewayArnTmp[0];
+        const response = {
+            principalId: 'user',
+            policyDocument: {
+                Version: '2012-10-17',
+                Statement: [
+                    {
+                        Action: 'execute-api:Invoke',
+                        Effect: 'Allow',
+                        Resource: ['arn:aws:execute-api:' + region + ':' + awsAccountId + ':' + restApiId + '/' + stage + '/*/*'],
+                    },
+                ],
+            },
+            context: {
+                userJSON: JSON.stringify(userOb),
+                srcData: srcString,
+            },
+        };
+        return response;
+    }
+    static extractTokenStringFromAuthorizerEvent(event) {
+        Logger.silly('Extracting token from event : %j', event);
+        let rval = null;
+        if (event && event.authorizationToken) {
+            const token = event.authorizationToken;
+            if (token && token.startsWith(EpsilonConstants.AUTH_HEADER_PREFIX)) {
+                rval = token.substring(EpsilonConstants.AUTH_HEADER_PREFIX.length);
+            }
+        }
+        return rval;
+    }
+}

package/dist/es/http/auth/auth0-web-token-manipulator.js

@@ -0,0 +1,56 @@
+import { Logger, StringRatchet } from '@bitblit/ratchet-common';
+import jwt from 'jsonwebtoken';
+import jwks from 'jwks-rsa';
+export class Auth0WebTokenManipulator {
+    constructor(clientId, jwksUri, issuer) {
+        this.clientId = clientId;
+        this.jwksUri = jwksUri;
+        this.issuer = issuer;
+    }
+    async extractTokenFromAuthorizationHeader(authHeader) {
+        let tokenString = StringRatchet.trimToEmpty(authHeader);
+        if (tokenString.toLowerCase().startsWith('bearer ')) {
+            tokenString = tokenString.substring(7);
+        }
+        const validated = tokenString ? await this.parseAndValidateAuth0Token(tokenString, false) : null;
+        return validated;
+    }
+    async parseAndValidateAuth0Token(auth0Token, allowExpired = false) {
+        Logger.debug('Validating Auth0 token : %s', StringRatchet.obscure(auth0Token, 4));
+        const fullToken = jwt.decode(auth0Token, { complete: true });
+        const kid = fullToken?.header?.kid;
+        const nowEpochSeconds = Math.floor(new Date().getTime() / 1000);
+        const pubKey = await this.fetchSigningKey(kid);
+        const validated = jwt.verify(auth0Token, pubKey, {
+            audience: this.clientId,
+            issuer: this.issuer,
+            ignoreExpiration: allowExpired,
+            clockTimestamp: nowEpochSeconds,
+        });
+        return validated;
+    }
+    async fetchSigningKey(kid) {
+        const jClient = await this.fetchJwksClient();
+        return new Promise((res, rej) => {
+            jClient.getSigningKey(kid, (err, key) => {
+                if (err) {
+                    rej(err);
+                }
+                else {
+                    res(key.publicKey || key.rsaPublicKey);
+                }
+            });
+        });
+    }
+    async fetchJwksClient() {
+        if (!this.jwksClient) {
+            this.jwksClient = jwks({
+                cache: true,
+                cacheMaxEntries: 5,
+                cacheMaxAge: 1000 * 60 * 60 * 10,
+                jwksUri: this.jwksUri,
+            });
+        }
+        return this.jwksClient;
+    }
+}

package/dist/es/http/auth/basic-auth-token.js

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