@bitblit/ratchet-epsilon-common 4.0.115-alpha → 4.0.119-alpha

package/lib/http/event-util.spec.js

@@ -1,161 +0,0 @@
-import { EventUtil } from './event-util.js';
-import fs from 'fs';
-import path from 'path';
-import { EsmRatchet } from '@bitblit/ratchet-common/lib/lang/esm-ratchet.js';
-describe('#eventUtil', function () {
-    it('should extract pieces', function () {
-        const evt = {
-            httpMethod: 'GET',
-            path: '/cw/meta/server',
-            body: null,
-            headers: {
-                Host: 'api.test.com',
-                'X-Forwarded-Proto': 'https',
-            },
-            multiValueHeaders: {
-                Host: ['api.test.com'],
-                'X-Forwarded-Proto': ['https'],
-            },
-            multiValueQueryStringParameters: null,
-            isBase64Encoded: false,
-            pathParameters: null,
-            queryStringParameters: null,
-            stageVariables: null,
-            resource: '/{proxy+}',
-            requestContext: {
-                httpMethod: 'GET',
-                accountId: '1234',
-                apiId: '7890',
-                stage: 'v0',
-                path: '/cw/meta/server',
-                domainName: 'api.test.com',
-                identity: null,
-                requestId: 'asdf1234',
-                requestTimeEpoch: 1234,
-                resourceId: '1234',
-                resourcePath: '/{proxy+}',
-            },
-        };
-        expect(EventUtil.extractStage(evt)).toEqual('cw');
-        expect(EventUtil.extractApiGatewayStage(evt)).toEqual('v0');
-        expect(EventUtil.extractFullPrefix(evt)).toEqual('https://api.test.com/cw');
-        expect(EventUtil.extractFullPath(evt)).toEqual('https://api.test.com/cw/meta/server');
-        expect(EventUtil.extractHostHeader(evt)).toEqual('api.test.com');
-    });
-    it('should fix still encoded query params', function () {
-        const evt = {
-            httpMethod: 'GET',
-            path: '/cw/meta/server',
-            body: null,
-            headers: {
-                Host: 'api.test.com',
-                'X-Forwarded-Proto': 'https',
-            },
-            multiValueHeaders: {
-                Host: ['api.test.com'],
-                'X-Forwarded-Proto': ['https'],
-            },
-            isBase64Encoded: false,
-            pathParameters: null,
-            multiValueQueryStringParameters: {
-                a: ['b'],
-                'amp;c': ['d'],
-            },
-            queryStringParameters: {
-                a: 'b',
-                'amp;c': 'd',
-            },
-            stageVariables: null,
-            resource: '/{proxy+}',
-            requestContext: {
-                httpMethod: 'GET',
-                accountId: '1234',
-                apiId: '7890',
-                stage: 'v0',
-                path: '/cw/meta/server',
-                domainName: 'api.test.com',
-                identity: null,
-                requestId: 'asdf1234',
-                requestTimeEpoch: 1234,
-                resourceId: '1234',
-                resourcePath: '/{proxy+}',
-            },
-        };
-        expect(evt.queryStringParameters['a']).toBeTruthy();
-        expect(evt.queryStringParameters['amp;c']).toBeTruthy();
-        expect(evt.queryStringParameters['c']).toBeUndefined();
-        EventUtil.fixStillEncodedQueryParams(evt);
-        expect(evt.queryStringParameters['a']).toBeTruthy();
-        expect(evt.queryStringParameters['amp;c']).toBeUndefined();
-        expect(evt.queryStringParameters['c']).toBeTruthy();
-    });
-    it('should extract basic auth from headers', function () {
-        const evt = {
-            httpMethod: 'GET',
-            path: '/cw/meta/server',
-            body: null,
-            headers: {
-                Host: 'api.test.com',
-                'X-Forwarded-Proto': 'https',
-                Authorization: 'Basic dGVzdHVzZXI6dGVzdHBhc3M=',
-            },
-            multiValueHeaders: {
-                Host: ['api.test.com'],
-                'X-Forwarded-Proto': ['https'],
-                Authorization: ['Basic dGVzdHVzZXI6dGVzdHBhc3M='],
-            },
-            isBase64Encoded: false,
-            pathParameters: null,
-            multiValueQueryStringParameters: {
-                a: ['b'],
-                'amp;c': ['d'],
-            },
-            queryStringParameters: {
-                a: 'b',
-                'amp;c': 'd',
-            },
-            stageVariables: null,
-            resource: '/{proxy+}',
-            requestContext: {
-                httpMethod: 'GET',
-                accountId: '1234',
-                apiId: '7890',
-                stage: 'v0',
-                path: '/cw/meta/server',
-                domainName: 'api.test.com',
-                identity: null,
-                requestId: 'asdf1234',
-                requestTimeEpoch: 1234,
-                resourceId: '1234',
-                resourcePath: '/{proxy+}',
-            },
-        };
-        const basic = EventUtil.extractBasicAuthenticationToken(evt);
-        expect(basic).toBeTruthy();
-        expect(basic.username).toBeTruthy();
-        expect(basic.password).toBeTruthy();
-        expect(basic.username).toEqual('testuser');
-        expect(basic.password).toEqual('testpass');
-    });
-    it('should add a token to an event, along with downstream stuff', function () {
-        const evt = JSON.parse(fs
-            .readFileSync(path.join(EsmRatchet.fetchDirName(import.meta.url), '../../../../test-data/epsilon/sample-json/sample-request-1.json'))
-            .toString());
-        const jwtToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1ODg1MzY3NzU4ODcsImlzcyI6Im5lb24uYWRvbW5pLmNvbSIsInN1YiI6ImJpdGJsaXRAZ21haWwuY29tIiwiaWF0IjoxNTg4NTMzMTc1ODg3LCJ1c2VyIjp7ImlkIjo2LCJmaXJzdE5hbWUiOiJDaHJpcyIsImxhc3ROYW1lIjoiV2Vpc3MiLCJjb21wYW55IjoiQWRvbW5pIiwiZW1haWwiOiJiaXRibGl0QGdtYWlsLmNvbSIsImN1c3RvbWVyVHlwZSI6IkFETUlOIn0sImFjdGluZ1VzZXJJZCI6NiwiZ2xvYmFsIjp0cnVlLCJhZG1pbiI6eyJpZCI6NiwiZmlyc3ROYW1lIjoiQ2hyaXMiLCJsYXN0TmFtZSI6IldlaXNzIiwiY29tcGFueSI6IkFkb21uaSIsImVtYWlsIjoiYml0YmxpdEBnbWFpbC5jb20iLCJjdXN0b21lclR5cGUiOiJBRE1JTiJ9LCJzdWJVc2VycyI6W119.mwRSek5GwkvxpN44UTp49W6_9U_ARsFXThAyiqaF-eQ';
-        EventUtil.applyTokenToEventForTesting(evt, jwtToken);
-        const roundTripTokenString = EventUtil.extractBearerTokenFromEvent(evt);
-        expect(roundTripTokenString).toEqual(jwtToken);
-    });
-    it('should check if an event is a graphql introspection', function () {
-        const evt1 = JSON.parse(fs
-            .readFileSync(path.join(EsmRatchet.fetchDirName(import.meta.url), '../../../../test-data/epsilon/sample-json/sample-request-1.json'))
-            .toString());
-        const evt2 = JSON.parse(fs
-            .readFileSync(path.join(EsmRatchet.fetchDirName(import.meta.url), '../../../../test-data/epsilon/sample-json/sample-gql-introspection.json'))
-            .toString());
-        const res1 = EventUtil.eventIsAGraphQLIntrospection(evt1);
-        const res2 = EventUtil.eventIsAGraphQLIntrospection(evt2);
-        expect(res1).toBeFalsy();
-        expect(res2).toBeTruthy();
-    });
-});

package/lib/http/response-util.js

@@ -1,141 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { MapRatchet } from '@bitblit/ratchet-common/lib/lang/map-ratchet.js';
-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.debug('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/lib/http/response-util.spec.js

@@ -1,92 +0,0 @@
-import { ResponseUtil } from './response-util.js';
-import path from 'path';
-import fs from 'fs';
-import { BuiltInFilters } from '../built-in/http/built-in-filters.js';
-import { EpsilonConstants } from '../epsilon-constants.js';
-import { EsmRatchet } from '@bitblit/ratchet-common/lib/lang/esm-ratchet.js';
-describe('#responseUtil', function () {
-    it('should correctly combine a redirect url and query params', function () {
-        const evt = {
-            httpMethod: 'get',
-            multiValueHeaders: {},
-            multiValueQueryStringParameters: {},
-            path: '/v0/meta/server',
-            body: null,
-            headers: null,
-            isBase64Encoded: false,
-            pathParameters: null,
-            stageVariables: null,
-            resource: null,
-            queryStringParameters: {
-                a: 'b',
-                c: 'd',
-            },
-            requestContext: {
-                stage: 'v0',
-            },
-        };
-        const out1 = ResponseUtil.redirect('myTarget?e=f', 301, evt.queryStringParameters);
-        expect(out1).toBeTruthy();
-        expect(out1.headers).toBeTruthy();
-        expect(out1.headers.Location).toEqual('myTarget?e=f&a=b&c=d');
-        const out2 = ResponseUtil.redirect('myTarget', 301, evt.queryStringParameters);
-        expect(out2).toBeTruthy();
-        expect(out2.headers).toBeTruthy();
-        expect(out2.headers.Location).toEqual('myTarget?a=b&c=d');
-    });
-    it('should leave already encoded stuff alone', async () => {
-        const singlePixel = fs
-            .readFileSync(path.join(EsmRatchet.fetchDirName(import.meta.url), '../../../../test-data/epsilon/test.png'))
-            .toString('base64');
-        const temp = {
-            body: singlePixel,
-            statusCode: 200,
-            isBase64Encoded: true,
-            headers: {
-                'content-type': 'application/zip',
-                'content-disposition': 'attachment; filename="adomni_bs_' + new Date().getTime() + '.zip"',
-            },
-        };
-        const cast = ResponseUtil.coerceToProxyResult(temp);
-        expect(cast.body).toEqual(temp.body);
-        const gzip = await ResponseUtil.applyGzipIfPossible('gzip', cast);
-        expect(cast.body).toEqual(gzip.body);
-    });
-    it('should add cors to proxy result MATCH 1', async () => {
-        const evt = JSON.parse(fs
-            .readFileSync(path.join(EsmRatchet.fetchDirName(import.meta.url), '../../../../test-data/epsilon/sample-json/sample-request-1.json'))
-            .toString());
-        const proxy = {};
-        const fCtx = {
-            event: evt,
-            rawResult: null,
-            context: null,
-            result: proxy,
-            routeAndParse: null,
-            modelValidator: null,
-            authenticators: null,
-        };
-        await BuiltInFilters.addAllowReflectionCORSHeaders(fCtx);
-        expect(proxy.headers).toBeTruthy();
-        expect(proxy.headers['Access-Control-Allow-Origin']).toEqual('http://localhost:4200');
-        expect(proxy.headers['Access-Control-Allow-Methods']).toEqual('GET');
-        expect(proxy.headers['Access-Control-Allow-Headers']).toEqual(EpsilonConstants.AUTH_HEADER_NAME.toLowerCase());
-    });
-    it('should add cors to proxy result MATCH 2', async () => {
-        const evt = JSON.parse(fs
-            .readFileSync(path.join(EsmRatchet.fetchDirName(import.meta.url), '../../../../test-data/epsilon/sample-json/sample-request-2.json'))
-            .toString());
-        const proxy = {};
-        const fCtx = {
-            event: evt,
-            rawResult: null,
-            context: null,
-            result: proxy,
-            routeAndParse: null,
-            modelValidator: null,
-            authenticators: null,
-        };
-        await BuiltInFilters.addAllowReflectionCORSHeaders(fCtx);
-        expect(proxy.headers).toBeTruthy();
-    });
-});

package/lib/http/route/epsilon-router.js

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

package/lib/http/route/extended-auth-response-context.js

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

package/lib/http/route/route-mapping.js

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

package/lib/http/route/route-validator-config.js

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

package/lib/http/route/router-util.js

@@ -1,233 +0,0 @@
-import { MisconfiguredError } from '../error/misconfigured-error.js';
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { BooleanRatchet } from '@bitblit/ratchet-common/lib/lang/boolean-ratchet.js';
-import { NullReturnedObjectHandling } from '../../config/http/null-returned-object-handling.js';
-import { BuiltInFilters } from '../../built-in/http/built-in-filters.js';
-import { BuiltInHandlers } from '../../built-in/http/built-in-handlers.js';
-import { BuiltInAuthFilters } from '../../built-in/http/built-in-auth-filters.js';
-import { LogLevelManipulationFilter } from '../../built-in/http/log-level-manipulation-filter.js';
-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: 30_000,
-            overrideAuthorizerName: null,
-            preFilters: RouterUtil.defaultAuthenticationHeaderParsingEpsilonPreFilters(webTokenManipulator),
-            postFilters: RouterUtil.defaultEpsilonPostFilters(),
-            errorFilters: RouterUtil.defaultEpsilonErrorFilters(),
-            nullReturnedObjectHandling: NullReturnedObjectHandling.Return404NotFoundResponse,
-        };
-        return defaults;
-    }
-    static defaultHttpMetaProcessingConfig() {
-        const defaults = {
-            configName: 'EpsilonDefaultHttpMetaProcessingConfig',
-            timeoutMS: 30_000,
-            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/lib/http/route/router-util.spec.js

@@ -1,23 +0,0 @@
-import { RouterUtil } from './router-util.js';
-import { SampleServerComponents } from '../../sample/sample-server-components.js';
-describe('#routerUtilApplyOpenApiDoc', function () {
-    it('should create a router config from a yaml file', async () => {
-        const inst = await SampleServerComponents.createSampleEpsilonGlobalHandler('routerUtilApplyOpenApiDoc-jest');
-        expect(inst.epsilon.modelValidator).toBeTruthy();
-        expect(inst.epsilon.modelValidator.fetchModel('AccessTokenRequest')).toBeTruthy();
-        const evt = {
-            httpMethod: 'get',
-            path: '/v0/meta/server',
-            requestContext: {
-                stage: 'v0',
-            },
-        };
-        const find = await inst.epsilon.webHandler.findBestMatchingRoute(evt);
-        expect(find).toBeTruthy();
-    });
-    it('should reformat a path to match the other library', function () {
-        const inString = '/meta/item/{itemId}';
-        const outString = RouterUtil.openApiPathToRouteParserPath(inString);
-        expect(outString).toEqual('/meta/item/:itemId');
-    });
-});