@bitblit/ratchet-epsilon-common 4.0.85-alpha

package/dist/es/http/response-util.js

@@ -0,0 +1,141 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { MapRatchet } from '@bitblit/ratchet-common';
+import zlib from 'zlib';
+export class ResponseUtil {
+    constructor() { }
+    static errorResponse(err) {
+        const body = {
+            errors: err.errors,
+            httpStatusCode: err.httpStatusCode,
+            requestId: err.requestId,
+        };
+        if (err.detailErrorCode) {
+            body['detailErrorCode'] = err.detailErrorCode;
+        }
+        if (err.endUserErrors && err.endUserErrors.length > 0) {
+            body['endUserErrors'] = err.endUserErrors;
+        }
+        if (err.details) {
+            body['details'] = err.details;
+        }
+        if (err.wrappedError) {
+            body['wrappedError'] = err.wrappedError.name + ' : ' + err.wrappedError.message;
+        }
+        const errorResponse = {
+            statusCode: err.httpStatusCode,
+            isBase64Encoded: false,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body),
+        };
+        return errorResponse;
+    }
+    static redirect(target, code = 301, queryParams = null) {
+        if (code !== 301 && code !== 302 && code !== 307) {
+            throw new Error('Code must be 301 or 302 or 307 for a redirect');
+        }
+        let redirectTarget = target;
+        if (queryParams) {
+            const keys = Object.keys(queryParams);
+            if (keys.length > 0) {
+                Logger.silly('Applying params to input target : %j', queryParams);
+                redirectTarget += redirectTarget.indexOf('?') === -1 ? '?' : '&';
+                for (let i = 0; i < keys.length; i++) {
+                    const k = keys[i];
+                    redirectTarget += k + '=' + encodeURIComponent(queryParams[k]);
+                    if (i < keys.length - 1) {
+                        redirectTarget += '&';
+                    }
+                }
+            }
+        }
+        return {
+            statusCode: code,
+            body: '{"redirect-target":"' + redirectTarget + '}',
+            headers: {
+                'Content-Type': 'application/json',
+                Location: redirectTarget,
+            },
+        };
+    }
+    static coerceToProxyResult(input) {
+        let rval = null;
+        if (input != null) {
+            if (typeof input === 'object') {
+                if (input.statusCode && input.body !== undefined) {
+                    rval = Object.assign({}, input);
+                    if (typeof input.body === 'string') {
+                    }
+                    else if (Buffer.isBuffer(input.body)) {
+                        rval.body = input.body.toString('base64');
+                        rval.headers = input.headers || {};
+                        rval.headers['Content-Type'] = input.body.contentType;
+                        rval.isBase64Encoded = true;
+                    }
+                }
+                else {
+                    const headers = input.headers || {};
+                    headers['Content-Type'] = 'application/json';
+                    rval = ResponseUtil.coerceToProxyResult({
+                        statusCode: 200,
+                        body: JSON.stringify(input),
+                        headers: headers,
+                        isBase64Encoded: false,
+                    });
+                }
+            }
+            else if (typeof input === 'string' || Buffer.isBuffer(input)) {
+                rval = ResponseUtil.coerceToProxyResult({ statusCode: 200, body: input });
+            }
+            else {
+                const headers = input.headers || {};
+                headers['Content-Type'] = 'application/json';
+                rval = ResponseUtil.coerceToProxyResult({
+                    statusCode: 200,
+                    body: JSON.stringify(input),
+                    headers: headers,
+                    isBase64Encoded: false,
+                });
+            }
+        }
+        return rval;
+    }
+    static async applyGzipIfPossible(encodingHeader, proxyResult) {
+        const rval = proxyResult;
+        if (encodingHeader && encodingHeader.toLowerCase().indexOf('gzip') > -1) {
+            const bigEnough = proxyResult.body.length > 1400;
+            let contentType = MapRatchet.extractValueFromMapIgnoreCase(proxyResult.headers, 'content-type') || '';
+            contentType = contentType.toLowerCase();
+            const exemptContent = contentType === 'application/pdf' || contentType === 'application/zip' || contentType.startsWith('image/');
+            if (bigEnough && !exemptContent) {
+                const asBuffer = proxyResult.isBase64Encoded ? Buffer.from(proxyResult.body, 'base64') : Buffer.from(proxyResult.body);
+                const zipped = await this.gzip(asBuffer);
+                Logger.info('Comp from %s to %d bytes', asBuffer.length, zipped.length);
+                const zipped64 = zipped.toString('base64');
+                rval.body = zipped64;
+                rval.isBase64Encoded = true;
+                rval.headers = rval.headers || {};
+                rval.headers['Content-Encoding'] = 'gzip';
+            }
+            else {
+                Logger.silly('Not gzipping, too small or exempt content');
+            }
+        }
+        else {
+            Logger.silly('Not gzipping, not an accepted encoding');
+        }
+        return rval;
+    }
+    static gzip(input) {
+        const promise = new Promise(function (resolve, reject) {
+            zlib.gzip(input, function (error, result) {
+                if (!error)
+                    resolve(result);
+                else
+                    reject(error);
+            });
+        });
+        return promise;
+    }
+}

package/dist/es/http/route/epsilon-router.js

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

package/dist/es/http/route/extended-auth-response-context.js

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

package/dist/es/http/route/route-mapping.js

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

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

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

package/dist/es/http/route/router-util.js

@@ -0,0 +1,233 @@
+import { MisconfiguredError } from '../error/misconfigured-error';
+import { Logger } from '@bitblit/ratchet-common';
+import { BooleanRatchet } from '@bitblit/ratchet-common';
+import { NullReturnedObjectHandling } from '../../config/http/null-returned-object-handling';
+import { BuiltInFilters } from '../../built-in/http/built-in-filters';
+import { BuiltInHandlers } from '../../built-in/http/built-in-handlers';
+import { BuiltInAuthFilters } from '../../built-in/http/built-in-auth-filters';
+import { LogLevelManipulationFilter } from '../../built-in/http/log-level-manipulation-filter';
+export class RouterUtil {
+    constructor() { }
+    static defaultAuthenticationHeaderParsingEpsilonPreFilters(webTokenManipulator) {
+        return [
+            (fCtx) => BuiltInAuthFilters.parseAuthorizationHeader(fCtx, webTokenManipulator),
+            (fCtx) => BuiltInAuthFilters.applyOpenApiAuthorization(fCtx),
+        ].concat(RouterUtil.defaultEpsilonPreFilters());
+    }
+    static defaultEpsilonPreFilters() {
+        return [
+            (fCtx) => BuiltInFilters.autoRespondToOptionsRequestWithCors(fCtx),
+            (fCtx) => BuiltInFilters.ensureEventMaps(fCtx),
+            (fCtx) => LogLevelManipulationFilter.setLogLevelForTransaction(fCtx),
+            (fCtx) => BuiltInFilters.parseJsonBodyToObject(fCtx),
+            (fCtx) => BuiltInFilters.fixStillEncodedQueryParams(fCtx),
+            (fCtx) => BuiltInFilters.uriDecodeQueryParams(fCtx),
+            (fCtx) => BuiltInFilters.disallowStringNullAsPathParameter(fCtx),
+            (fCtx) => BuiltInFilters.disallowStringNullAsQueryStringParameter(fCtx),
+            (fCtx) => BuiltInFilters.validateInboundBody(fCtx),
+            (fCtx) => BuiltInFilters.validateInboundQueryParams(fCtx),
+            (fCtx) => BuiltInFilters.validateInboundQueryParams(fCtx),
+        ];
+    }
+    static defaultEpsilonPostFilters() {
+        return [
+            (fCtx) => BuiltInFilters.validateOutboundResponse(fCtx),
+            (fCtx) => BuiltInFilters.addAWSRequestIdHeader(fCtx),
+            (fCtx) => BuiltInFilters.addAllowReflectionCORSHeaders(fCtx),
+            (fCtx) => BuiltInFilters.applyGzipIfPossible(fCtx),
+            (fCtx) => BuiltInFilters.checkMaximumLambdaBodySize(fCtx),
+            (fCtx) => LogLevelManipulationFilter.clearLogLevelForTransaction(fCtx),
+        ];
+    }
+    static defaultEpsilonErrorFilters() {
+        return [
+            (fCtx) => BuiltInFilters.addAWSRequestIdHeader(fCtx),
+            (fCtx) => BuiltInFilters.addAllowReflectionCORSHeaders(fCtx),
+            (fCtx) => LogLevelManipulationFilter.clearLogLevelForTransaction(fCtx),
+        ];
+    }
+    static defaultHttpMetaProcessingConfigWithAuthenticationHeaderParsing(webTokenManipulator) {
+        const defaults = {
+            configName: 'EpsilonDefaultHttpMetaProcessingConfig',
+            timeoutMS: 30000,
+            overrideAuthorizerName: null,
+            preFilters: RouterUtil.defaultAuthenticationHeaderParsingEpsilonPreFilters(webTokenManipulator),
+            postFilters: RouterUtil.defaultEpsilonPostFilters(),
+            errorFilters: RouterUtil.defaultEpsilonErrorFilters(),
+            nullReturnedObjectHandling: NullReturnedObjectHandling.Return404NotFoundResponse,
+        };
+        return defaults;
+    }
+    static defaultHttpMetaProcessingConfig() {
+        const defaults = {
+            configName: 'EpsilonDefaultHttpMetaProcessingConfig',
+            timeoutMS: 30000,
+            overrideAuthorizerName: null,
+            preFilters: RouterUtil.defaultEpsilonPreFilters(),
+            postFilters: RouterUtil.defaultEpsilonPostFilters(),
+            errorFilters: RouterUtil.defaultEpsilonErrorFilters(),
+            nullReturnedObjectHandling: NullReturnedObjectHandling.Return404NotFoundResponse,
+        };
+        return defaults;
+    }
+    static assignDefaultsOnHttpConfig(cfg) {
+        const defaults = {
+            handlers: new Map(),
+            authorizers: new Map(),
+            defaultMetaHandling: this.defaultHttpMetaProcessingConfig(),
+            staticContentRoutes: {},
+            prefixesToStripBeforeRouteMatch: [],
+            filterHandledRouteMatches: ['options .*'],
+        };
+        const rval = Object.assign({}, defaults, cfg || {});
+        return rval;
+    }
+    static findApplicableMeta(httpConfig, method, path) {
+        let rval = null;
+        if (httpConfig?.overrideMetaHandling) {
+            for (let i = 0; i < httpConfig.overrideMetaHandling.length && !rval; i++) {
+                const test = httpConfig.overrideMetaHandling[i];
+                if (!test.methods ||
+                    test.methods.length === 0 ||
+                    test.methods.map((s) => s.toLocaleLowerCase()).includes(method.toLocaleLowerCase())) {
+                    const matches = !!path.match(test.pathRegex);
+                    if ((matches && !test.invertPathMatching) || (!matches && test.invertPathMatching)) {
+                        rval = test.config;
+                    }
+                }
+            }
+        }
+        if (!rval) {
+            rval = httpConfig.defaultMetaHandling || RouterUtil.defaultHttpMetaProcessingConfig();
+        }
+        return rval;
+    }
+    static openApiYamlToRouterConfig(httpConfig, openApiDoc, modelValidator, backgroundHttpAdapterHandler) {
+        if (!openApiDoc || !httpConfig) {
+            throw new MisconfiguredError('Cannot configure, missing either yaml or cfg');
+        }
+        const rval = {
+            routes: [],
+            openApiModelValidator: modelValidator,
+            config: RouterUtil.assignDefaultsOnHttpConfig(httpConfig),
+        };
+        if (openApiDoc?.components?.securitySchemes) {
+            Object.keys(openApiDoc.components.securitySchemes).forEach((sk) => {
+                if (!rval.config.authorizers || !rval.config.authorizers.get(sk)) {
+                    throw new MisconfiguredError().withFormattedErrorMessage('Doc requires authorizer %s but not found in map', sk);
+                }
+            });
+        }
+        const missingPaths = [];
+        const filterHandledPathMatches = httpConfig.filterHandledRouteMatches || [];
+        if (openApiDoc?.paths) {
+            Object.keys(openApiDoc.paths).forEach((path) => {
+                Object.keys(openApiDoc.paths[path]).forEach((method) => {
+                    const convertedPath = RouterUtil.openApiPathToRouteParserPath(path);
+                    const finder = method + ' ' + path;
+                    const applicableMeta = RouterUtil.findApplicableMeta(httpConfig, method, path);
+                    const entry = openApiDoc.paths[path][method];
+                    const isBackgroundEndpoint = path.startsWith(backgroundHttpAdapterHandler.httpSubmissionPath);
+                    const isBackgroundMetaEndpoint = path === backgroundHttpAdapterHandler.httpMetaEndpoint;
+                    const isBackgroundStatusEndpoint = path === backgroundHttpAdapterHandler.httpStatusPath;
+                    if (isBackgroundEndpoint) {
+                        rval.config.handlers.set(finder, (evt, ctx) => backgroundHttpAdapterHandler.handleBackgroundSubmission(evt, ctx));
+                    }
+                    if (isBackgroundMetaEndpoint) {
+                        rval.config.handlers.set(finder, (evt, ctx) => backgroundHttpAdapterHandler.handleBackgroundMetaRequest(evt, ctx));
+                    }
+                    if (isBackgroundStatusEndpoint) {
+                        rval.config.handlers.set(finder, (evt, ctx) => backgroundHttpAdapterHandler.handleBackgroundStatusRequest(evt, ctx));
+                    }
+                    if (!rval.config.handlers || !rval.config.handlers.get(finder)) {
+                        const match = filterHandledPathMatches.find((reg) => finder.match(reg));
+                        if (match) {
+                            Logger.debug('Adding filter-handled handler for %s', finder);
+                            rval.config.handlers.set(finder, (evt) => BuiltInHandlers.expectedHandledByFilter(evt));
+                        }
+                        else {
+                            missingPaths.push(finder);
+                        }
+                    }
+                    if (entry && entry['security'] && entry['security'].length > 1) {
+                        throw new MisconfiguredError('Epsilon does not currently support multiple security (path was ' + finder + ')');
+                    }
+                    const authorizerName = entry['security'] && entry['security'].length == 1 ? Object.keys(entry['security'][0])[0] : null;
+                    const newRoute = {
+                        path: convertedPath,
+                        method: method,
+                        function: rval.config.handlers.get(finder),
+                        authorizerName: applicableMeta.overrideAuthorizerName || authorizerName,
+                        metaProcessingConfig: applicableMeta,
+                        validation: null,
+                        outboundValidation: null,
+                    };
+                    if (entry['requestBody'] &&
+                        entry['requestBody']['content'] &&
+                        entry['requestBody']['content']['application/json'] &&
+                        entry['requestBody']['content']['application/json']['schema']) {
+                        const schema = entry['requestBody']['content'];
+                        Logger.silly('Applying schema %j to %s', schema, finder);
+                        const modelName = this.findAndValidateModelName(method, path, schema, rval.config.overrideModelValidator || rval.openApiModelValidator);
+                        const required = BooleanRatchet.parseBool(entry['requestBody']['required']);
+                        const validation = {
+                            extraPropertiesAllowed: true,
+                            emptyAllowed: !required,
+                            modelName: modelName,
+                        };
+                        newRoute.validation = validation;
+                    }
+                    if (entry['responses'] &&
+                        entry['responses']['200'] &&
+                        entry['responses']['200']['content'] &&
+                        entry['responses']['200']['content']['application/json'] &&
+                        entry['responses']['200']['content']['application/json']['schema']) {
+                        const schema = entry['responses']['200']['content'];
+                        Logger.silly('Applying schema %j to %s', schema, finder);
+                        const modelName = this.findAndValidateModelName(method, path, schema, rval.config.overrideModelValidator || rval.openApiModelValidator);
+                        const validation = {
+                            extraPropertiesAllowed: false,
+                            emptyAllowed: false,
+                            modelName: modelName,
+                        };
+                        newRoute.outboundValidation = validation;
+                    }
+                    rval.routes.push(newRoute);
+                });
+            });
+        }
+        if (missingPaths.length > 0) {
+            throw new MisconfiguredError().withFormattedErrorMessage('Missing expected handlers : %j', missingPaths);
+        }
+        return rval;
+    }
+    static findAndValidateModelName(method, path, schema, modelValidator) {
+        let rval = undefined;
+        const schemaPath = schema['application/json']['schema']['$ref'];
+        const inlinePath = schema['application/json']['schema']['type'];
+        if (schemaPath) {
+            rval = schemaPath.substring(schemaPath.lastIndexOf('/') + 1);
+            if (!modelValidator.fetchModel(rval)) {
+                throw new MisconfiguredError(`Path ${method} ${path} refers to schema ${rval} but its not in the schema section`);
+            }
+        }
+        else if (inlinePath) {
+            rval = `${method}-${path}-requestBodyModel`;
+            const model = schema['application/json']['schema'];
+            modelValidator.addModel(rval, model);
+        }
+        return rval;
+    }
+    static openApiPathToRouteParserPath(input) {
+        let rval = input;
+        if (rval) {
+            let sIdx = rval.indexOf('{');
+            while (sIdx > -1) {
+                const eIdx = rval.indexOf('}');
+                rval = rval.substring(0, sIdx) + ':' + rval.substring(sIdx + 1, eIdx) + rval.substring(eIdx + 1);
+                sIdx = rval.indexOf('{');
+            }
+        }
+        return rval;
+    }
+}

package/dist/es/http/web-handler.js

@@ -0,0 +1,116 @@
+import { Logger } from '@bitblit/ratchet-common';
+import Route from 'route-parser';
+import { ResponseUtil } from './response-util';
+import { RequireRatchet } from '@bitblit/ratchet-common';
+import { EpsilonHttpError } from './error/epsilon-http-error';
+import { BuiltInFilters } from '../built-in/http/built-in-filters';
+import { RunHandlerAsFilter } from '../built-in/http/run-handler-as-filter';
+import { ContextUtil } from '../util/context-util';
+import { StringRatchet } from '@bitblit/ratchet-common';
+import { LambdaEventDetector } from '@bitblit/ratchet-aws';
+export class WebHandler {
+    constructor(routerConfig) {
+        this.routerConfig = routerConfig;
+        RequireRatchet.notNullOrUndefined(routerConfig);
+    }
+    get router() {
+        return this.routerConfig;
+    }
+    extractLabel(evt, context) {
+        return 'WEB:' + StringRatchet.trimToEmpty(evt.httpMethod).toUpperCase() + ':' + evt.path;
+    }
+    handlesEvent(evt) {
+        return LambdaEventDetector.isValidApiGatewayEvent(evt);
+    }
+    async processEvent(event, context) {
+        if (!this.routerConfig) {
+            throw new Error('Router config not found');
+        }
+        const asExtended = Object.assign({}, { parsedBody: null, authorization: null, convertedFromV2Event: false }, event);
+        const rval = await this.openApiLambdaHandler(asExtended, context);
+        ContextUtil.addTraceToProxyResult(rval);
+        Logger.updateTracePrefix(null);
+        return rval;
+    }
+    async openApiLambdaHandler(evt, context) {
+        const rm = this.findBestMatchingRoute(evt);
+        const procConfig = rm?.mapping?.metaProcessingConfig
+            ? rm.mapping.metaProcessingConfig
+            : this.routerConfig.config.defaultMetaHandling;
+        const fCtx = {
+            event: evt,
+            context: context,
+            result: null,
+            rawResult: null,
+            routeAndParse: rm,
+            modelValidator: this.routerConfig.config.overrideModelValidator || this.routerConfig.openApiModelValidator,
+            authenticators: this.routerConfig.config.authorizers,
+        };
+        try {
+            let filterChain = Object.assign([], procConfig.preFilters || []);
+            RunHandlerAsFilter.addRunHandlerAsFilterToList(filterChain, rm);
+            filterChain = filterChain.concat(procConfig.postFilters || []);
+            await BuiltInFilters.combineFilters(fCtx, filterChain);
+        }
+        catch (err) {
+            const wrapper = EpsilonHttpError.wrapError(err);
+            fCtx.result = ResponseUtil.errorResponse(wrapper);
+            try {
+                await BuiltInFilters.combineFilters(fCtx, procConfig.errorFilters);
+            }
+            catch (convErr) {
+                Logger.error('REALLY BAD - FAILED WHILE PROCESSING ERROR FILTERS : %s', convErr);
+            }
+        }
+        return fCtx.result;
+    }
+    findBestMatchingRoute(event) {
+        let rval = null;
+        const cleanPath = this.cleanPath(event);
+        const methodLower = event.httpMethod.toLowerCase();
+        const matchRoutes = this.routerConfig.routes
+            .map((r) => {
+            let rval = null;
+            if (r.method && r.method.toLowerCase() === methodLower) {
+                const routeParser = new Route(r.path);
+                const parsed = routeParser.match(cleanPath);
+                if (parsed !== false) {
+                    rval = {
+                        mapping: r,
+                        route: routeParser,
+                        parsed: parsed,
+                    };
+                }
+            }
+            return rval;
+        })
+            .filter((r) => r != null);
+        matchRoutes.sort((a, b) => {
+            return Object.keys(a.parsed).length - Object.keys(b.parsed).length;
+        });
+        rval = matchRoutes && matchRoutes.length > 0 ? matchRoutes[0] : null;
+        if (!rval) {
+            Logger.debug('Failed to find handler for %s (cleaned path was %s, strip prefixes were %j)', event.path, cleanPath, this.routerConfig.config.prefixesToStripBeforeRouteMatch);
+        }
+        return rval;
+    }
+    cleanPath(event) {
+        let rval = event.path;
+        while (rval.startsWith('/')) {
+            rval = rval.substring(1);
+        }
+        if (this.routerConfig.config.prefixesToStripBeforeRouteMatch) {
+            this.routerConfig.config.prefixesToStripBeforeRouteMatch.forEach((prefix) => {
+                if (rval.toLowerCase().startsWith(prefix.toLowerCase() + '/')) {
+                    rval = rval.substring(prefix.length);
+                }
+            });
+        }
+        while (rval.startsWith('/')) {
+            rval = rval.substring(1);
+        }
+        rval = '/' + rval;
+        return rval;
+    }
+}
+WebHandler.MAXIMUM_LAMBDA_BODY_SIZE_BYTES = 1024 * 1024 * 5 - 1024 * 100;

package/dist/es/http/web-v2-handler.js

@@ -0,0 +1,21 @@
+import { AwsUtil } from '../util/aws-util';
+import { LambdaEventDetector } from '@bitblit/ratchet-aws';
+export class WebV2Handler {
+    constructor(webHandler) {
+        this.webHandler = webHandler;
+    }
+    extractLabel(evt, context) {
+        let rval = this.webHandler.extractLabel(AwsUtil.apiGatewayV2ToApiGatewayV1(evt), context);
+        rval = rval.replace('WEB:', 'WEB2:');
+        return rval;
+    }
+    handlesEvent(evt) {
+        return LambdaEventDetector.isValidApiGatewayV2WithRequestContextEvent(evt);
+    }
+    async processEvent(evt, context) {
+        const conv = AwsUtil.apiGatewayV2ToApiGatewayV1(evt);
+        const asExtended = Object.assign({}, { parsedBody: null, authorization: null, convertedFromV2Event: true }, conv);
+        const rval = await this.webHandler.openApiLambdaHandler(asExtended, context);
+        return rval;
+    }
+}

package/dist/es/index.js

@@ -0,0 +1,133 @@
+export * from './epsilon-build-properties';
+export * from './epsilon-constants';
+export * from './epsilon-global-handler';
+export * from './epsilon-instance';
+export * from './epsilon-logging-extension-processor';
+export * from './inter-api-manager';
+export * from './local-container-server';
+export * from './local-server-cert';
+export * from './local-server';
+export * from './run-background-process-from-command-line';
+export * from './test-error-server';
+export * from './background/background-dynamo-log-table-handler';
+export * from './background/background-entry';
+export * from './background/background-execution-event-type';
+export * from './background/background-execution-event';
+export * from './background/background-execution-listener';
+export * from './background/background-handler';
+export * from './background/background-http-adapter-handler';
+export * from './background/background-meta-response-internal';
+export * from './background/background-process-handling';
+export * from './background/background-process-log-table-entry';
+export * from './background/background-queue-response-internal';
+export * from './background/background-validator';
+export * from './background/epsilon-background-process-error';
+export * from './background/internal-background-entry';
+export * from './background/s3-background-transaction-logger';
+export * from './background/manager/abstract-background-manager';
+export * from './background/manager/aws-sqs-sns-background-manager';
+export * from './background/manager/background-manager-like';
+export * from './background/manager/single-thread-local-background-manager';
+export * from './build/ratchet-epsilon-common-info';
+export * from './built-in/built-in-trace-id-generators';
+export * from './built-in/background/echo-processor';
+export * from './built-in/background/log-and-enqueue-echo-processor';
+export * from './built-in/background/log-message-background-error-processor';
+export * from './built-in/background/no-op-processor';
+export * from './built-in/background/retry-processor';
+export * from './built-in/background/sample-delay-processor';
+export * from './built-in/background/sample-input-validated-processor-data';
+export * from './built-in/background/sample-input-validated-processor';
+export * from './built-in/daemon/daemon-authorizer-function';
+export * from './built-in/daemon/daemon-config';
+export * from './built-in/daemon/daemon-group-selection-function';
+export * from './built-in/daemon/daemon-handler';
+export * from './built-in/daemon/daemon-process-state-list';
+export * from './built-in/http/apollo-filter';
+export * from './built-in/http/built-in-auth-filters';
+export * from './built-in/http/built-in-authorizers';
+export * from './built-in/http/built-in-filters';
+export * from './built-in/http/built-in-handlers';
+export * from './built-in/http/log-level-manipulation-filter';
+export * from './built-in/http/run-handler-as-filter';
+export * from './cli-bootstrap/epsilon-run-background-process-from-command-line-dry-run';
+export * from './config/dynamo-db-config';
+export * from './config/epsilon-config';
+export * from './config/epsilon-lambda-event-handler';
+export * from './config/epsilon-logger-config';
+export * from './config/generic-aws-event-handler-function';
+export * from './config/logging-trace-id-generator';
+export * from './config/s3-config';
+export * from './config/sns-config';
+export * from './config/background/background-aws-config';
+export * from './config/background/background-config';
+export * from './config/background/background-error-processor';
+export * from './config/background/background-processor';
+export * from './config/background/background-transaction-log';
+export * from './config/background/background-transaction-logger';
+export * from './config/cron/abstract-cron-entry';
+export * from './config/cron/cron-background-entry';
+export * from './config/cron/cron-config';
+export * from './config/http/authorizer-function';
+export * from './config/http/epsilon-authorization-context';
+export * from './config/http/extended-api-gateway-event';
+export * from './config/http/filter-chain-context';
+export * from './config/http/filter-function';
+export * from './config/http/handler-function';
+export * from './config/http/http-config';
+export * from './config/http/http-processing-config';
+export * from './config/http/mapped-http-processing-config';
+export * from './config/http/null-returned-object-handling';
+export * from './config/inter-api/inter-api-aws-config';
+export * from './config/inter-api/inter-api-config';
+export * from './config/inter-api/inter-api-process-mapping';
+export * from './config/open-api/open-api-document-components';
+export * from './config/open-api/open-api-document-path';
+export * from './config/open-api/open-api-document';
+export * from './http/event-util';
+export * from './http/response-util';
+export * from './http/web-handler';
+export * from './http/web-v2-handler';
+export * from './http/auth/api-gateway-adapter-authentication-handler';
+export * from './http/auth/auth0-web-token-manipulator';
+export * from './http/auth/basic-auth-token';
+export * from './http/auth/google-web-token-manipulator';
+export * from './http/auth/jwt-ratchet-local-web-token-manipulator';
+export * from './http/auth/local-web-token-manipulator';
+export * from './http/auth/web-token-manipulator';
+export * from './http/error/bad-gateway';
+export * from './http/error/bad-request-error';
+export * from './http/error/conflict-error';
+export * from './http/error/epsilon-http-error';
+export * from './http/error/forbidden-error';
+export * from './http/error/gateway-timeout';
+export * from './http/error/method-not-allowed-error';
+export * from './http/error/misconfigured-error';
+export * from './http/error/not-found-error';
+export * from './http/error/not-implemented';
+export * from './http/error/request-timeout-error';
+export * from './http/error/service-unavailable';
+export * from './http/error/too-many-requests-error';
+export * from './http/error/unauthorized-error';
+export * from './http/route/epsilon-router';
+export * from './http/route/extended-auth-response-context';
+export * from './http/route/route-mapping';
+export * from './http/route/route-validator-config';
+export * from './http/route/router-util';
+export * from './inter-api/inter-api-entry';
+export * from './inter-api/inter-api-util';
+export * from './lambda-event-handler/cron-epsilon-lambda-event-handler';
+export * from './lambda-event-handler/dynamo-epsilon-lambda-event-handler';
+export * from './lambda-event-handler/generic-sns-epsilon-lambda-event-handler';
+export * from './lambda-event-handler/inter-api-epsilon-lambda-event-handler';
+export * from './lambda-event-handler/s3-epsilon-lambda-event-handler';
+export * from './open-api-util/open-api-doc-modifications';
+export * from './open-api-util/open-api-doc-modifier';
+export * from './open-api-util/yaml-combiner';
+export * from './sample/sample-batch-only-local-server';
+export * from './sample/sample-local-server';
+export * from './sample/sample-server-components';
+export * from './util/aws-util';
+export * from './util/context-util';
+export * from './util/cron-util';
+export * from './util/epsilon-config-parser';

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

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