@bitblit/ratchet-epsilon-common 4.0.85-alpha

package/dist/cjs/local-server.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalServer = void 0;
+const tslib_1 = require("tslib");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const http_1 = tslib_1.__importDefault(require("http"));
+const https_1 = tslib_1.__importDefault(require("https"));
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const luxon_1 = require("luxon");
+const querystring_1 = tslib_1.__importDefault(require("querystring"));
+const event_util_1 = require("./http/event-util");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+const local_server_cert_1 = require("./local-server-cert");
+class LocalServer {
+    constructor(globalHandler, port = 8888, https = false) {
+        this.globalHandler = globalHandler;
+        this.port = port;
+        this.aborted = false;
+    }
+    async runServer() {
+        return new Promise((res, rej) => {
+            try {
+                ratchet_common_1.Logger.info('Starting Epsilon server on port %d', this.port);
+                if (https_1.default) {
+                    const options = {
+                        key: local_server_cert_1.LocalServerCert.CLIENT_KEY_PEM,
+                        cert: local_server_cert_1.LocalServerCert.CLIENT_CERT_PEM,
+                    };
+                    ratchet_common_1.Logger.info('Starting https server - THIS SERVER IS NOT SECURE!  The KEYS are in the code!  Testing Server Only - Use at your own risk!');
+                    this.server = https_1.default.createServer(options, this.requestHandler.bind(this)).listen(this.port);
+                }
+                else {
+                    this.server = http_1.default.createServer(this.requestHandler.bind(this)).listen(this.port);
+                }
+                ratchet_common_1.Logger.info('Epsilon server is listening');
+                process.on('SIGINT', () => {
+                    ratchet_common_1.Logger.info('Caught SIGINT - shutting down test server...');
+                    this.aborted = true;
+                    res(true);
+                });
+            }
+            catch (err) {
+                ratchet_common_1.Logger.error('Local server failed : %s', err, err);
+                rej(err);
+            }
+        });
+    }
+    async requestHandler(request, response) {
+        const context = {
+            awsRequestId: 'LOCAL-' + ratchet_common_2.StringRatchet.createType4Guid(),
+            getRemainingTimeInMillis() {
+                return 300000;
+            },
+        };
+        const evt = await LocalServer.messageToApiGatewayEvent(request, context);
+        const logEventLevel = event_util_1.EventUtil.eventIsAGraphQLIntrospection(evt) ? ratchet_common_3.LoggerLevelName.silly : ratchet_common_3.LoggerLevelName.info;
+        if (evt.path == '/epsilon-poison-pill') {
+            this.aborted = true;
+            return true;
+        }
+        else {
+            const result = await this.globalHandler.lambdaHandler(evt, context);
+            const written = await LocalServer.writeProxyResultToServerResponse(result, response);
+            return written;
+        }
+    }
+    static async bodyAsBase64String(request) {
+        return new Promise((res, rej) => {
+            const body = [];
+            request.on('data', (chunk) => {
+                body.push(chunk);
+            });
+            request.on('end', () => {
+                const rval = Buffer.concat(body).toString('base64');
+                res(rval);
+            });
+        });
+    }
+    static async messageToApiGatewayEvent(request, context) {
+        const bodyString = await LocalServer.bodyAsBase64String(request);
+        const stageIdx = request.url.indexOf('/', 1);
+        const stage = request.url.substring(1, stageIdx);
+        const path = request.url.substring(stageIdx + 1);
+        const reqTime = new Date().getTime();
+        const formattedTime = luxon_1.DateTime.utc().toFormat('dd/MMM/yyyy:hh:mm:ss ZZ');
+        const queryIdx = request.url.indexOf('?');
+        const queryStringParams = queryIdx > -1 ? querystring_1.default.parse(request.url.substring(queryIdx + 1)) : {};
+        const headers = Object.assign({}, request.headers);
+        headers['X-Forwarded-Proto'] = 'http';
+        const rval = {
+            body: bodyString,
+            multiValueHeaders: {},
+            multiValueQueryStringParameters: {},
+            resource: '/{proxy+}',
+            path: request.url,
+            httpMethod: request.method.toLowerCase(),
+            isBase64Encoded: true,
+            queryStringParameters: queryStringParams,
+            pathParameters: {
+                proxy: path,
+            },
+            stageVariables: {
+                baz: 'qux',
+            },
+            headers: headers,
+            requestContext: {
+                accountId: '123456789012',
+                resourceId: '123456',
+                stage: stage,
+                requestId: context.awsRequestId,
+                requestTime: formattedTime,
+                requestTimeEpoch: reqTime,
+                identity: null,
+                path: request.url,
+                domainName: request.headers['host'],
+                resourcePath: '/{proxy+}',
+                httpMethod: request.method.toLowerCase(),
+                apiId: '1234567890',
+                protocol: 'HTTP/1.1',
+            },
+        };
+        return rval;
+    }
+    static async writeProxyResultToServerResponse(proxyResult, response) {
+        const isGraphQLSchemaResponse = !!proxyResult && !!proxyResult.body && proxyResult.body.indexOf('{"data":{"__schema"') > -1;
+        if (!isGraphQLSchemaResponse) {
+            ratchet_common_1.Logger.debug('Result: %j', proxyResult);
+        }
+        response.statusCode = proxyResult.statusCode;
+        if (proxyResult.headers) {
+            Object.keys(proxyResult.headers).forEach((hk) => {
+                response.setHeader(hk, String(proxyResult.headers[hk]));
+            });
+        }
+        if (proxyResult.multiValueHeaders) {
+            Object.keys(proxyResult.multiValueHeaders).forEach((hk) => {
+                response.setHeader(hk, proxyResult.multiValueHeaders[hk].join(','));
+            });
+        }
+        const toWrite = proxyResult.isBase64Encoded ? Buffer.from(proxyResult.body, 'base64') : Buffer.from(proxyResult.body);
+        response.end(toWrite);
+        return !!proxyResult.body;
+    }
+}
+exports.LocalServer = LocalServer;

package/dist/cjs/open-api-util/open-api-doc-modifications.js

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

package/dist/cjs/open-api-util/open-api-doc-modifier.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenApiDocModifier = void 0;
+const tslib_1 = require("tslib");
+const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class OpenApiDocModifier {
+    constructor(options) {
+        this.options = options;
+    }
+    modifyOpenApiDoc(yamlString) {
+        let rval;
+        if (!!yamlString && !!this.options) {
+            try {
+                const openApi = js_yaml_1.default.load(yamlString);
+                const removeTags = this.options.removeTags ? this.options.removeTags.map((t) => t.toLowerCase()) : [];
+                if (this.options.newServerPath) {
+                    openApi['servers'] = [{ url: this.options.newServerPath }];
+                }
+                if (!!this.options.removeTags && openApi['tags']) {
+                    if (openApi['tags']) {
+                        openApi['tags'] = openApi.tags.filter((f) => {
+                            const n = !!f && !!f['name'] ? f['name'].toLowerCase() : '';
+                            const i = removeTags.indexOf(n);
+                            return i === -1;
+                        });
+                    }
+                }
+                if (openApi['paths']) {
+                    let newPaths = {};
+                    Object.keys(openApi['paths']).forEach((p) => {
+                        const path = openApi['paths'][p];
+                        Object.keys(path).forEach((verb) => {
+                            const entry = path[verb];
+                            entry.tags = !!entry.tags ? entry.tags.filter((t) => removeTags.lastIndexOf(t.toLowerCase()) == -1) : entry.tags;
+                            const matcher = verb.toLowerCase() + ' ' + p.toLowerCase();
+                            if (this.matchNone(matcher, this.options.removeEndpoints)) {
+                                newPaths[p] = newPaths[p] || {};
+                                newPaths[p][verb] = entry;
+                            }
+                        });
+                    });
+                    if (this.options.sortEndpoints) {
+                        const keys = Object.keys(newPaths).sort();
+                        const newPaths2 = {};
+                        keys.forEach((k) => {
+                            newPaths2[k] = newPaths[k];
+                        });
+                        newPaths = newPaths2;
+                    }
+                    openApi['paths'] = newPaths;
+                }
+                let remSchemas = this.options.removeSchemas || [];
+                remSchemas = remSchemas.map((s) => s.toLowerCase());
+                if (openApi['components'] && openApi['components']['schemas']) {
+                    const keys = Object.keys(openApi['components']['schemas']).sort();
+                    const newComp = {};
+                    keys.forEach((k) => {
+                        if (remSchemas.indexOf(k.toLowerCase()) === -1) {
+                            newComp[k] = openApi['components']['schemas'][k];
+                        }
+                    });
+                    openApi['components']['schemas'] = newComp;
+                }
+                rval = js_yaml_1.default.dump(openApi);
+            }
+            catch (err) {
+                ratchet_common_1.Logger.error('Error processing yaml: %s', err, err);
+            }
+        }
+        return rval;
+    }
+    matchNone(input, regex) {
+        let rval = true;
+        if (!!input && !!regex) {
+            regex.forEach((r) => {
+                rval = rval && !r.test(input);
+            });
+        }
+        return rval;
+    }
+}
+exports.OpenApiDocModifier = OpenApiDocModifier;

package/dist/cjs/open-api-util/yaml-combiner.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YamlCombiner = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+class YamlCombiner {
+    static combine(files, inRootPath = []) {
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(files, 'Files argument');
+        ratchet_common_1.RequireRatchet.true(files.length > 0, 'Files argument larger than 0');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(inRootPath, 'Root path argument');
+        ratchet_common_2.Logger.info('Processing %d files into output', files.length);
+        let allElements = {};
+        for (let i = 0; i < files.length; i++) {
+            const fileContents = fs_1.default.readFileSync(files[i]).toString();
+            const openApi = js_yaml_1.default.load(fileContents);
+            allElements = Object.assign(allElements, openApi);
+        }
+        const rootPath = Object.assign([], inRootPath);
+        while (rootPath.length > 0) {
+            const next = {};
+            next[rootPath[rootPath.length - 1]] = allElements;
+            rootPath.splice(rootPath.length - 1, 1);
+            allElements = next;
+        }
+        const rval = js_yaml_1.default.dump(allElements);
+        return rval;
+    }
+}
+exports.YamlCombiner = YamlCombiner;

package/dist/cjs/run-background-process-from-command-line.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunBackgroundProcessFromCommandLine = void 0;
+const tslib_1 = require("tslib");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const commander_1 = require("commander");
+const clear_1 = tslib_1.__importDefault(require("clear"));
+class RunBackgroundProcessFromCommandLine {
+    static async processBackgroundCliRequest(epsilon, dryRun) {
+        let rval = false;
+        (0, clear_1.default)();
+        ratchet_common_1.Logger.info('Bootstrapping batch processor, args : %j', process.argv);
+        commander_1.program
+            .version('0.0.1')
+            .requiredOption('-p --process <processKey>', 'Background process key')
+            .option('-d --data <data>', 'Background data block, JSON encoded')
+            .option('-m --metadata <metadata>', 'Background metadata block, JSON encoded')
+            .parse(process.argv);
+        ratchet_common_1.Logger.info('Program definition : %s : %s : %s', commander_1.program.opts().process, commander_1.program.opts().data, commander_1.program.opts().meta);
+        let data = {};
+        if (ratchet_common_1.StringRatchet.trimToNull(commander_1.program.opts().data)) {
+            data = JSON.parse(commander_1.program.opts().data);
+        }
+        if (dryRun) {
+            ratchet_common_1.Logger.info('Dry run specified - not executing');
+            rval = false;
+        }
+        else {
+            if (!epsilon) {
+                ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot run background cli because epsilon global handler is null');
+            }
+            rval = await epsilon.processSingleBackgroundByParts(commander_1.program.opts().process, data);
+        }
+        return rval;
+    }
+}
+exports.RunBackgroundProcessFromCommandLine = RunBackgroundProcessFromCommandLine;

package/dist/cjs/sample/sample-batch-only-local-server.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const sample_server_components_1 = require("./sample-server-components");
+const local_server_1 = require("../local-server");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+ratchet_common_1.Logger.setLevel(ratchet_common_2.LoggerLevelName.debug);
+sample_server_components_1.SampleServerComponents.createSampleBatchOnlyEpsilonGlobalHandler()
+    .then((handler) => {
+    const testServer = new local_server_1.LocalServer(handler);
+    testServer.runServer().then((res) => {
+        ratchet_common_1.Logger.info('Got res server');
+        process.exit(0);
+    });
+})
+    .catch((err) => {
+    ratchet_common_1.Logger.error('Error: %s', err, err);
+    process.exit(1);
+});

package/dist/cjs/sample/sample-local-server.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const sample_server_components_1 = require("./sample-server-components");
+const local_server_1 = require("../local-server");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const local_web_token_manipulator_1 = require("../http/auth/local-web-token-manipulator");
+ratchet_common_1.Logger.setLevel(ratchet_common_2.LoggerLevelName.debug);
+const localTokenHandler = new local_web_token_manipulator_1.LocalWebTokenManipulator(['abcd1234'], 'sample-server');
+localTokenHandler
+    .createJWTStringAsync('asdf', {}, ['USER'], 3600)
+    .then((token) => {
+    ratchet_common_1.Logger.info('Use token: %s', token);
+    sample_server_components_1.SampleServerComponents.createSampleEpsilonGlobalHandler()
+        .then((handler) => {
+        const testServer = new local_server_1.LocalServer(handler, 8888, true);
+        testServer.runServer().then((res) => {
+            ratchet_common_1.Logger.info('Got res server');
+            process.exit(0);
+        });
+    })
+        .catch((err) => {
+        ratchet_common_1.Logger.error('Error: %s', err, err);
+        process.exit(1);
+    });
+})
+    .catch((tokenErr) => {
+    ratchet_common_1.Logger.error('Failed to create token : %s', tokenErr);
+    process.exit(1);
+});

package/dist/cjs/sample/sample-server-components.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SampleServerComponents = void 0;
+const tslib_1 = require("tslib");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const apollo_server_lambda_1 = require("apollo-server-lambda");
+const apollo_server_core_1 = require("apollo-server-core");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const ratchet_common_4 = require("@bitblit/ratchet-common");
+const epsilon_global_handler_1 = require("../epsilon-global-handler");
+const built_in_handlers_1 = require("../built-in/http/built-in-handlers");
+const local_web_token_manipulator_1 = require("../http/auth/local-web-token-manipulator");
+const echo_processor_1 = require("../built-in/background/echo-processor");
+const no_op_processor_1 = require("../built-in/background/no-op-processor");
+const sample_delay_processor_1 = require("../built-in/background/sample-delay-processor");
+const log_and_enqueue_echo_processor_1 = require("../built-in/background/log-and-enqueue-echo-processor");
+const epsilon_config_parser_1 = require("../util/epsilon-config-parser");
+const router_util_1 = require("../http/route/router-util");
+const sample_input_validated_processor_1 = require("../built-in/background/sample-input-validated-processor");
+const built_in_authorizers_1 = require("../built-in/http/built-in-authorizers");
+const apollo_filter_1 = require("../built-in/http/apollo-filter");
+const ratchet_common_5 = require("@bitblit/ratchet-common");
+const ratchet_common_6 = require("@bitblit/ratchet-common");
+const built_in_filters_1 = require("../built-in/http/built-in-filters");
+const event_util_1 = require("../http/event-util");
+const log_message_background_error_processor_1 = require("../built-in/background/log-message-background-error-processor");
+const single_thread_local_background_manager_1 = require("../background/manager/single-thread-local-background-manager");
+class SampleServerComponents {
+    constructor() { }
+    static async createSampleApollo() {
+        const gqlString = SampleServerComponents.loadSampleServerGQL();
+        ratchet_common_1.Logger.silly('Creating apollo from : %s', gqlString);
+        const typeDefs = (0, apollo_server_lambda_1.gql)(gqlString);
+        const resolvers = {
+            RootQueryType: {
+                serverMeta: async (root) => {
+                    return { version: 'A1', serverTime: new Date().toISOString() };
+                },
+                forceTimeout: async (root) => {
+                    await ratchet_common_4.PromiseRatchet.wait(1000 * 60 * 30);
+                    return { placeholder: 'A1' };
+                },
+            },
+        };
+        const server = new apollo_server_lambda_1.ApolloServer({
+            debug: false,
+            introspection: true,
+            typeDefs,
+            resolvers,
+            plugins: [(0, apollo_server_core_1.ApolloServerPluginLandingPageGraphQLPlayground)({ endpoint: '/graphql' })],
+            context: async ({ event, context, express }) => {
+                const authTokenSt = event_util_1.EventUtil.extractBearerTokenFromEvent(event);
+                const token = null;
+                if (!!authTokenSt && authTokenSt.startsWith('Bearer')) {
+                    ratchet_common_1.Logger.info('Got : %s', authTokenSt);
+                }
+                const rval = {
+                    user: token,
+                    headers: event.headers,
+                    functionName: context.functionName,
+                    event,
+                    context,
+                };
+                return rval;
+            },
+        });
+        return server;
+    }
+    static async createSampleEpsilonConfig() {
+        const yamlString = SampleServerComponents.loadSampleOpenApiYaml();
+        const authorizers = new Map();
+        authorizers.set('SampleAuthorizer', (token, evt) => built_in_authorizers_1.BuiltInAuthorizers.simpleLoggedInAuth(token, evt));
+        authorizers.set('LogAuthorizer', (token, evt) => built_in_authorizers_1.BuiltInAuthorizers.simpleNoAuthenticationLogAccess(token, evt));
+        const handlers = new Map();
+        handlers.set('get /', (event, context) => built_in_handlers_1.BuiltInHandlers.sample(event, null, context));
+        handlers.set('get /meta/server', (event) => built_in_handlers_1.BuiltInHandlers.sample(event));
+        handlers.set('get /meta/user', (event) => built_in_handlers_1.BuiltInHandlers.sample(event));
+        handlers.set('get /meta/item/{itemId}', (event) => built_in_handlers_1.BuiltInHandlers.sample(event));
+        handlers.set('post /secure/access-token', (event) => built_in_handlers_1.BuiltInHandlers.sample(event));
+        handlers.set('get /multi/fixed', (event) => built_in_handlers_1.BuiltInHandlers.sample(event, 'fixed'));
+        handlers.set('get /multi/{v}', (event) => built_in_handlers_1.BuiltInHandlers.sample(event, 'variable'));
+        handlers.set('get /err/{code}', (event) => {
+            const err = ratchet_common_2.ErrorRatchet.fErr('Fake Err : %j', event);
+            err['statusCode'] = ratchet_common_3.NumberRatchet.safeNumber(event.pathParameters['code']);
+            throw err;
+        });
+        handlers.set('get /meta/sample-item', async (event) => {
+            const numberToUse = ratchet_common_3.NumberRatchet.safeNumber(event.queryStringParameters['num']) || 5;
+            const rval = {
+                numberParam: numberToUse,
+                nameParam: 'Test-String',
+            };
+            return rval;
+        });
+        handlers.set('post /meta/sample-item', async (event) => {
+            const parsed = event.parsedBody;
+            const forceFail = ratchet_common_5.BooleanRatchet.parseBool(ratchet_common_6.StringRatchet.trimToNull(event.queryStringParameters['forceFail'])) === true;
+            if (forceFail) {
+                parsed['numberParam'] = 'test';
+            }
+            return parsed;
+        });
+        const tokenManipulator = new local_web_token_manipulator_1.LocalWebTokenManipulator(['abcd1234'], 'sample.erigir.com')
+            .withParseFailureLogLevel(ratchet_common_4.LoggerLevelName.debug)
+            .withExtraDecryptionKeys(['abcdefabcdef'])
+            .withOldKeyUseLogLevel(ratchet_common_4.LoggerLevelName.info);
+        const meta = router_util_1.RouterUtil.defaultHttpMetaProcessingConfigWithAuthenticationHeaderParsing(tokenManipulator);
+        meta.timeoutMS = 10000;
+        apollo_filter_1.ApolloFilter.addApolloFilterToList(meta.preFilters, new RegExp('.*graphql.*'), await SampleServerComponents.createSampleApollo(), {
+            cors: {
+                origin: '*',
+                credentials: true,
+            },
+        });
+        meta.errorFilters.push((fCtx) => built_in_filters_1.BuiltInFilters.secureOutboundServerErrorForProduction(fCtx, 'Clean Internal Server Error', 500));
+        const preFiltersAllowingNull = Object.assign({}, meta);
+        preFiltersAllowingNull.preFilters = Object.assign([], preFiltersAllowingNull.preFilters);
+        preFiltersAllowingNull.preFilters.splice(8, 1);
+        const cfg = {
+            defaultMetaHandling: meta,
+            handlers: handlers,
+            authorizers: authorizers,
+            overrideMetaHandling: [
+                {
+                    pathRegex: '/background',
+                    methods: null,
+                    config: Object.assign({}, meta, { overrideAuthorizerName: 'LogAuthorizer' }),
+                },
+                {
+                    pathRegex: '/meta/server',
+                    methods: ['GET'],
+                    config: preFiltersAllowingNull,
+                },
+            ],
+            prefixesToStripBeforeRouteMatch: ['v0'],
+            filterHandledRouteMatches: ['options .*'],
+        };
+        const background = {
+            httpMetaEndpoint: '/background/meta',
+            httpSubmissionPath: '/background',
+            implyTypeFromPathSuffix: false,
+            processors: [
+                new echo_processor_1.EchoProcessor(),
+                new no_op_processor_1.NoOpProcessor(),
+                new sample_delay_processor_1.SampleDelayProcessor(),
+                new sample_input_validated_processor_1.SampleInputValidatedProcessor(),
+                new log_and_enqueue_echo_processor_1.LogAndEnqueueEchoProcessor(),
+            ],
+            errorProcessor: new log_message_background_error_processor_1.LogMessageBackgroundErrorProcessor(),
+        };
+        const epsilonConfig = {
+            openApiYamlString: yamlString,
+            httpConfig: cfg,
+            backgroundConfig: background,
+        };
+        return epsilonConfig;
+    }
+    static async createSampleEpsilonGlobalHandler() {
+        const epsilonConfig = await SampleServerComponents.createSampleEpsilonConfig();
+        const backgroundManager = new single_thread_local_background_manager_1.SingleThreadLocalBackgroundManager();
+        const epsilonInstance = epsilon_config_parser_1.EpsilonConfigParser.epsilonConfigToEpsilonInstance(epsilonConfig, backgroundManager);
+        const rval = new epsilon_global_handler_1.EpsilonGlobalHandler(epsilonInstance);
+        return rval;
+    }
+    static async createSampleBatchOnlyEpsilonGlobalHandler() {
+        const epsilonConfig = await SampleServerComponents.createSampleEpsilonConfig();
+        epsilonConfig.httpConfig.handlers = new Map();
+        const byPassCfg = Object.assign({}, epsilonConfig.httpConfig.defaultMetaHandling);
+        byPassCfg.preFilters = byPassCfg.preFilters.concat([
+            (fCtx) => built_in_filters_1.BuiltInFilters.autoRespond(fCtx, { message: 'Background Processing Only' }),
+        ]);
+        epsilonConfig.httpConfig.overrideMetaHandling = [
+            {
+                pathRegex: '.*background.*',
+                invertPathMatching: true,
+                config: byPassCfg,
+            },
+        ];
+        epsilonConfig.httpConfig.filterHandledRouteMatches = ['.*'];
+        const backgroundManager = new single_thread_local_background_manager_1.SingleThreadLocalBackgroundManager();
+        const epsilonInstance = epsilon_config_parser_1.EpsilonConfigParser.epsilonConfigToEpsilonInstance(epsilonConfig, backgroundManager);
+        const rval = new epsilon_global_handler_1.EpsilonGlobalHandler(epsilonInstance);
+        return rval;
+    }
+    static loadSampleOpenApiYaml() {
+        const yamlString = fs_1.default.readFileSync(path_1.default.join(__dirname, '..', 'static', 'sample-open-api-doc.yaml')).toString();
+        return yamlString;
+    }
+    static loadSampleServerGQL() {
+        const yamlString = fs_1.default.readFileSync(path_1.default.join(__dirname, '..', 'static', 'sample-server.gql')).toString();
+        return yamlString;
+    }
+}
+exports.SampleServerComponents = SampleServerComponents;

package/dist/cjs/test-error-server.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestErrorServer = void 0;
+const tslib_1 = require("tslib");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_node_only_1 = require("@bitblit/ratchet-node-only");
+const net_1 = tslib_1.__importDefault(require("net"));
+class TestErrorServer {
+    constructor(port = 9999) {
+        this.port = port;
+        this.aborted = false;
+    }
+    async runServer() {
+        ratchet_common_1.Logger.info('Starting Test Error net server on port %d', this.port);
+        return new Promise((res, rej) => {
+            const server = new net_1.default.Server({});
+            server.listen(this.port, () => {
+                ratchet_common_1.Logger.info('Server listening for connection requests on socket localhost: %s', this.port);
+            });
+            server.on('connection', async (socket) => {
+                ratchet_common_1.Logger.info('X: A new connection has been established.');
+                socket.write('Hello, client.');
+                socket.on('data', (chunk) => {
+                    ratchet_common_1.Logger.info('Data received from client: %s', chunk);
+                });
+                socket.on('end', () => {
+                    ratchet_common_1.Logger.info('Closing connection with the client');
+                });
+                socket.on('error', (err) => {
+                    ratchet_common_1.Logger.info('Error: %s', err);
+                });
+            });
+        });
+    }
+    async requestHandler(request, response) {
+        ratchet_common_1.Logger.info('Got request %d - closing socket', request);
+        request.setTimeout(100);
+        response.end('x');
+    }
+}
+exports.TestErrorServer = TestErrorServer;
+if (ratchet_node_only_1.CliRatchet.isCalledFromCLISingle('test-error-server')) {
+    const testServer = new TestErrorServer();
+    testServer.runServer().then((res) => {
+        ratchet_common_1.Logger.info('Got res server');
+        process.exit(0);
+    });
+}

package/dist/cjs/util/aws-util.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsUtil = void 0;
+class AwsUtil {
+    static apiGatewayV2ToApiGatewayV1(srcEvt) {
+        const rval = {
+            requestContext: AwsUtil.apiGatewayV2RequestContextToApiGatewayV1RequestContext(srcEvt.requestContext),
+            httpMethod: srcEvt.requestContext.http.method,
+            path: srcEvt.requestContext.http.path,
+            queryStringParameters: srcEvt.queryStringParameters,
+            headers: srcEvt.headers,
+            body: srcEvt.body,
+            isBase64Encoded: srcEvt.isBase64Encoded,
+            multiValueHeaders: null,
+            multiValueQueryStringParameters: null,
+            pathParameters: srcEvt.pathParameters,
+            stageVariables: srcEvt.stageVariables,
+            resource: null,
+        };
+        return rval;
+    }
+    static apiGatewayV2RequestContextToApiGatewayV1RequestContext(srcEvt) {
+        const rval = {
+            accountId: srcEvt.accountId,
+            apiId: srcEvt.apiId,
+            authorizer: null,
+            domainName: srcEvt.domainName,
+            domainPrefix: srcEvt.domainPrefix,
+            requestId: srcEvt.requestId,
+            routeKey: srcEvt.routeKey,
+            stage: srcEvt.stage,
+            requestTime: srcEvt.time,
+            requestTimeEpoch: srcEvt.timeEpoch,
+            protocol: srcEvt.http.protocol,
+            httpMethod: srcEvt.http.method,
+            identity: null,
+            path: srcEvt.http.path,
+            resourceId: null,
+            resourcePath: null,
+        };
+        return rval;
+    }
+    static findInMap(toFind, map) {
+        let rval = null;
+        map.forEach((val, key) => {
+            if (AwsUtil.matchExact(key, toFind)) {
+                rval = val;
+            }
+        });
+        return rval;
+    }
+    static matchExact(r, str) {
+        const match = str.match(r);
+        return match != null && str == match[0];
+    }
+    static resolvePotentialFunctionToResult(src, def) {
+        let rval = def;
+        if (src) {
+            if (typeof src === 'function') {
+                rval = src();
+            }
+            else {
+                rval = src;
+            }
+        }
+        return rval;
+    }
+}
+exports.AwsUtil = AwsUtil;