@bitblit/ratchet-epsilon-common 4.0.98-alpha → 4.0.102-alpha

package/dist/{types/http → http}/error/unauthorized-error.d.ts

@@ -1,4 +1,4 @@
-import { EpsilonHttpError } from './epsilon-http-error';
+import { EpsilonHttpError } from './epsilon-http-error.js';
 export declare class UnauthorizedError<T = void> extends EpsilonHttpError<T> {
     static readonly HTTP_CODE: number;
     constructor(...errors: string[]);

package/dist/{es/http → http}/error/unauthorized-error.js

@@ -1,8 +1,8 @@
-import { EpsilonHttpError } from './epsilon-http-error';
+import { EpsilonHttpError } from './epsilon-http-error.js';
 export class UnauthorizedError extends EpsilonHttpError {
+    static HTTP_CODE = 401;
     constructor(...errors) {
         super(...errors);
         this.withHttpStatusCode(UnauthorizedError.HTTP_CODE);
     }
 }
-UnauthorizedError.HTTP_CODE = 401;

package/dist/{types/http → http}/event-util.d.ts

@@ -1,10 +1,7 @@
 import { APIGatewayEvent, APIGatewayEventRequestContext, AuthResponseContext } from 'aws-lambda';
-import { EpsilonLoggerConfig } from '../config/epsilon-logger-config';
-import { BasicAuthToken } from './auth/basic-auth-token';
-import { LoggerLevelName } from '@bitblit/ratchet-common';
-/**
- * Endpoints about the api itself
- */
+import { EpsilonLoggerConfig } from '../config/epsilon-logger-config.js';
+import { LoggerLevelName } from '@bitblit/ratchet-common/dist/logger/logger-level-name.js';
+import { BasicAuthToken } from './auth/basic-auth-token.js';
 export declare class EventUtil {
     private constructor();
     static extractStage(event: APIGatewayEvent): string;
@@ -19,26 +16,7 @@ export declare class EventUtil {
     static extractFullPrefix(event: APIGatewayEvent, overrideProtocol?: string): string;
     static jsonBodyToObject(event: APIGatewayEvent): any;
     static calcLogLevelViaEventOrEnvParam(curLevel: LoggerLevelName, event: APIGatewayEvent, rConfig: EpsilonLoggerConfig): LoggerLevelName;
-    /**
-     * This is a weird function - sometimes your customers will not decode their query params and it
-     * results in query params that look like 'amp;SOMETHING' instead of 'SOMETHING'.  This function
-     * looks for params that look like that, and strips the amp; from them.  If you have any
-     * params you are expecting that have 'amp;' in front of them, DON'T use this function.
-     *
-     * Also, you are a moron for having a param that looks like that
-     *
-     * Yes, it would be better to fix this on the client side, but that is not always an option
-     * in production
-     * @param event
-     */
     static fixStillEncodedQueryParams(event: APIGatewayEvent): void;
-    /**
-     * Allows you to force in a token for an arbitrary event without having to pass the whole thing
-     * through Epsilon.  Useful for when you need to test a handler that needs authorization,
-     * and don't need to instantiate all of epsilon, just the handler
-     * @param event Event to decorate
-     * @param jwtToken String containing a valid JWT token
-     */
     static applyTokenToEventForTesting(event: APIGatewayEvent, jwtToken: string): void;
     static extractBasicAuthenticationToken(event: APIGatewayEvent, throwErrorOnMissingBad?: boolean): BasicAuthToken;
     static eventIsAGraphQLIntrospection(event: APIGatewayEvent): boolean;

package/dist/{es/http → http}/event-util.js

@@ -1,12 +1,13 @@
-import { UnauthorizedError } from './error/unauthorized-error';
-import { Logger } from '@bitblit/ratchet-common';
-import { BadRequestError } from './error/bad-request-error';
-import { MapRatchet } from '@bitblit/ratchet-common';
+import { UnauthorizedError } from './error/unauthorized-error.js';
+import { BadRequestError } from './error/bad-request-error.js';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { StringRatchet } from '@bitblit/ratchet-common/dist/lang/string-ratchet.js';
+import { MapRatchet } from '@bitblit/ratchet-common/dist/lang/map-ratchet.js';
+import { LoggerLevelName } from '@bitblit/ratchet-common/dist/logger/logger-level-name.js';
+import { EnumRatchet } from '@bitblit/ratchet-common/dist/lang/enum-ratchet.js';
+import { Base64Ratchet } from '@bitblit/ratchet-common/dist/lang/base64-ratchet.js';
 import jwt from 'jsonwebtoken';
-import { Base64Ratchet } from '@bitblit/ratchet-common';
-import { StringRatchet } from '@bitblit/ratchet-common';
-import { EpsilonConstants } from '../epsilon-constants';
-import { EnumRatchet, LoggerLevelName } from '@bitblit/ratchet-common';
+import { EpsilonConstants } from '../epsilon-constants.js';
 export class EventUtil {
     constructor() { }
     static extractStage(event) {

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

@@ -0,0 +1,157 @@
+import { EventUtil } from './event-util.js';
+import fs from 'fs';
+import path from 'path';
+import { EsmRatchet } from '@bitblit/ratchet-common/dist/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(), '../../../../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(), '../../../../test-data/epsilon/sample-json/sample-request-1.json')).toString());
+        const evt2 = JSON.parse(fs
+            .readFileSync(path.join(EsmRatchet.fetchDirName(), '../../../../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/dist/{types/http → http}/response-util.d.ts

@@ -1,6 +1,6 @@
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
 import { ProxyResult } from 'aws-lambda';
-import { EpsilonHttpError } from './error/epsilon-http-error';
+import { EpsilonHttpError } from './error/epsilon-http-error.js';
 export declare class ResponseUtil {
     private constructor();
     static errorResponse<T>(err: EpsilonHttpError<T>): ProxyResult;

package/dist/{es/http → http}/response-util.js

@@ -1,5 +1,5 @@
-import { Logger } from '@bitblit/ratchet-common';
-import { MapRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { MapRatchet } from '@bitblit/ratchet-common/dist/lang/map-ratchet.js';
 import zlib from 'zlib';
 export class ResponseUtil {
     constructor() { }

package/dist/http/response-util.spec.d.ts

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

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

@@ -0,0 +1,88 @@
+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/dist/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(), '../../../../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(), '../../../../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(), '../../../../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/dist/http/route/epsilon-router.d.ts

@@ -0,0 +1,8 @@
+import { RouteMapping } from './route-mapping.js';
+import { ModelValidator } from '@bitblit/ratchet-misc/dist/model-validator/model-validator.js';
+import { HttpConfig } from '../../config/http/http-config.js';
+export interface EpsilonRouter {
+    routes: RouteMapping[];
+    openApiModelValidator: ModelValidator;
+    config: HttpConfig;
+}

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

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

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

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

package/dist/{types/http → http}/route/route-mapping.d.ts

@@ -1,6 +1,6 @@
-import { RouteValidatorConfig } from './route-validator-config';
-import { HandlerFunction } from '../../config/http/handler-function';
-import { HttpProcessingConfig } from '../../config/http/http-processing-config';
+import { RouteValidatorConfig } from './route-validator-config.js';
+import { HandlerFunction } from '../../config/http/handler-function.js';
+import { HttpProcessingConfig } from '../../config/http/http-processing-config.js';
 export interface RouteMapping {
     method: string;
     path: string;

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

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

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

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

package/dist/{types/http → http}/route/router-util.d.ts

@@ -1,15 +1,12 @@
-import { EpsilonRouter } from './epsilon-router';
-import { OpenApiDocument } from '../../config/open-api/open-api-document';
-import { ModelValidator } from '@bitblit/ratchet-misc';
-import { BackgroundHttpAdapterHandler } from '../../background/background-http-adapter-handler';
-import { HttpConfig } from '../../config/http/http-config';
-import { HttpProcessingConfig } from '../../config/http/http-processing-config';
-import { WebTokenManipulator } from '../auth/web-token-manipulator';
-import { FilterFunction } from '../../config/http/filter-function';
-import { JwtTokenBase } from '@bitblit/ratchet-common';
-/**
- * Endpoints about the api itself
- */
+import { EpsilonRouter } from './epsilon-router.js';
+import { JwtTokenBase } from '@bitblit/ratchet-common/dist/jwt/jwt-token-base.js';
+import { OpenApiDocument } from '../../config/open-api/open-api-document.js';
+import { ModelValidator } from '@bitblit/ratchet-misc/dist/model-validator/model-validator.js';
+import { BackgroundHttpAdapterHandler } from '../../background/background-http-adapter-handler.js';
+import { HttpConfig } from '../../config/http/http-config.js';
+import { HttpProcessingConfig } from '../../config/http/http-processing-config.js';
+import { WebTokenManipulator } from '../auth/web-token-manipulator.js';
+import { FilterFunction } from '../../config/http/filter-function.js';
 export declare class RouterUtil {
     private constructor();
     static defaultAuthenticationHeaderParsingEpsilonPreFilters(webTokenManipulator: WebTokenManipulator<JwtTokenBase>): FilterFunction[];

package/dist/{es/http → http}/route/router-util.js

@@ -1,11 +1,11 @@
-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';
+import { MisconfiguredError } from '../error/misconfigured-error.js';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { BooleanRatchet } from '@bitblit/ratchet-common/dist/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) {
@@ -49,7 +49,7 @@ export class RouterUtil {
     static defaultHttpMetaProcessingConfigWithAuthenticationHeaderParsing(webTokenManipulator) {
         const defaults = {
             configName: 'EpsilonDefaultHttpMetaProcessingConfig',
-            timeoutMS: 30000,
+            timeoutMS: 30_000,
             overrideAuthorizerName: null,
             preFilters: RouterUtil.defaultAuthenticationHeaderParsingEpsilonPreFilters(webTokenManipulator),
             postFilters: RouterUtil.defaultEpsilonPostFilters(),
@@ -61,7 +61,7 @@ export class RouterUtil {
     static defaultHttpMetaProcessingConfig() {
         const defaults = {
             configName: 'EpsilonDefaultHttpMetaProcessingConfig',
-            timeoutMS: 30000,
+            timeoutMS: 30_000,
             overrideAuthorizerName: null,
             preFilters: RouterUtil.defaultEpsilonPreFilters(),
             postFilters: RouterUtil.defaultEpsilonPostFilters(),

package/dist/http/route/router-util.spec.d.ts

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

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

@@ -0,0 +1,23 @@
+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');
+    });
+});

package/dist/{types/http → http}/web-handler.d.ts

@@ -1,12 +1,9 @@
-import { EpsilonRouter } from './route/epsilon-router';
+import { EpsilonRouter } from './route/epsilon-router.js';
 import { APIGatewayEvent, Context, ProxyResult } from 'aws-lambda';
 import Route from 'route-parser';
-import { RouteMapping } from './route/route-mapping';
-import { ExtendedAPIGatewayEvent } from '../config/http/extended-api-gateway-event';
-import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler';
-/**
- * This class functions as the adapter from a default lambda function to the handlers exposed via Epsilon
- */
+import { RouteMapping } from './route/route-mapping.js';
+import { ExtendedAPIGatewayEvent } from '../config/http/extended-api-gateway-event.js';
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler.js';
 export declare class WebHandler implements EpsilonLambdaEventHandler<APIGatewayEvent> {
     private routerConfig;
     static readonly MAXIMUM_LAMBDA_BODY_SIZE_BYTES: number;

package/dist/{es/http → http}/web-handler.js

@@ -1,14 +1,16 @@
-import { Logger } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
 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';
+import { ResponseUtil } from './response-util.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/dist/lang/require-ratchet.js';
+import { EpsilonHttpError } from './error/epsilon-http-error.js';
+import { BuiltInFilters } from '../built-in/http/built-in-filters.js';
+import { RunHandlerAsFilter } from '../built-in/http/run-handler-as-filter.js';
+import { ContextUtil } from '../util/context-util.js';
+import { StringRatchet } from '@bitblit/ratchet-common/dist/lang/string-ratchet.js';
+import { LambdaEventDetector } from '@bitblit/ratchet-aws/dist/lambda/lambda-event-detector.js';
 export class WebHandler {
+    routerConfig;
+    static MAXIMUM_LAMBDA_BODY_SIZE_BYTES = 1024 * 1024 * 5 - 1024 * 100;
     constructor(routerConfig) {
         this.routerConfig = routerConfig;
         RequireRatchet.notNullOrUndefined(routerConfig);
@@ -113,4 +115,3 @@ export class WebHandler {
         return rval;
     }
 }
-WebHandler.MAXIMUM_LAMBDA_BODY_SIZE_BYTES = 1024 * 1024 * 5 - 1024 * 100;

package/dist/http/web-handler.spec.d.ts

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

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

@@ -0,0 +1,32 @@
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { SampleServerComponents } from '../sample/sample-server-components.js';
+import { LoggerLevelName } from '@bitblit/ratchet-common/dist/logger/logger-level-name.js';
+describe('#errorToProxyResult', function () {
+    it('should gzip responses correctly', async () => {
+        const inst = await SampleServerComponents.createSampleEpsilonGlobalHandler('jest-gzip');
+        expect(inst.epsilon.modelValidator).toBeTruthy();
+        const evt = {
+            httpMethod: 'get',
+            multiValueHeaders: {},
+            multiValueQueryStringParameters: {},
+            path: '/meta/server',
+            pathParameters: null,
+            queryStringParameters: null,
+            stageVariables: null,
+            requestContext: {},
+            resource: '/meta/server',
+            headers: {
+                'content-type': 'application/json; charset=UTF-8',
+                'accept-encoding': 'gzip, deflate, br',
+            },
+            isBase64Encoded: true,
+            body: null,
+        };
+        Logger.setLevel(LoggerLevelName.silly);
+        const result = await inst.epsilon.webHandler.processEvent(evt, {});
+        expect(result).toBeTruthy();
+        expect(result.isBase64Encoded).toEqual(true);
+        expect(result.headers).toBeTruthy();
+        expect(result.headers['Content-Encoding']).toEqual('gzip');
+    });
+});

package/dist/{types/http → http}/web-v2-handler.d.ts

@@ -1,9 +1,6 @@
 import { APIGatewayProxyEventV2, Context, ProxyResult } from 'aws-lambda';
-import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler';
-import { WebHandler } from './web-handler';
-/**
- * This class functions as the adapter from a default lambda function to the handlers exposed via Epsilon
- */
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler.js';
+import { WebHandler } from './web-handler.js';
 export declare class WebV2Handler implements EpsilonLambdaEventHandler<APIGatewayProxyEventV2> {
     private webHandler;
     constructor(webHandler: WebHandler);

package/dist/{es/http → http}/web-v2-handler.js

@@ -1,6 +1,7 @@
-import { AwsUtil } from '../util/aws-util';
-import { LambdaEventDetector } from '@bitblit/ratchet-aws';
+import { AwsUtil } from '../util/aws-util.js';
+import { LambdaEventDetector } from '@bitblit/ratchet-aws/dist/lambda/lambda-event-detector.js';
 export class WebV2Handler {
+    webHandler;
     constructor(webHandler) {
         this.webHandler = webHandler;
     }

package/dist/index.d.ts

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

package/dist/index.js

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

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

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

package/dist/{types/inter-api → inter-api}/inter-api-util.d.ts

@@ -1,7 +1,7 @@
 import { SNSEvent } from 'aws-lambda';
-import { InterApiEntry } from './inter-api-entry';
-import { InterApiConfig } from '../config/inter-api/inter-api-config';
-import { BackgroundManagerLike } from '../background/manager/background-manager-like';
+import { InterApiEntry } from './inter-api-entry.js';
+import { InterApiConfig } from '../config/inter-api/inter-api-config.js';
+import { BackgroundManagerLike } from '../background/manager/background-manager-like.js';
 export declare class InterApiUtil {
     static isInterApiSnsEvent(event: any): boolean;
     static extractEntryFromEvent(evt: SNSEvent): InterApiEntry<any>;

package/dist/{es/inter-api → inter-api}/inter-api-util.js

@@ -1,8 +1,9 @@
-import { LambdaEventDetector } from '@bitblit/ratchet-aws';
-import { EpsilonConstants } from '../epsilon-constants';
-import { RequireRatchet } from '@bitblit/ratchet-common';
-import { Logger, StringRatchet } from '@bitblit/ratchet-common';
-import { ContextUtil } from '../util/context-util';
+import { LambdaEventDetector } from '@bitblit/ratchet-aws/dist/lambda/lambda-event-detector.js';
+import { EpsilonConstants } from '../epsilon-constants.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/dist/lang/require-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { StringRatchet } from '@bitblit/ratchet-common/dist/lang/string-ratchet.js';
+import { ContextUtil } from '../util/context-util.js';
 export class InterApiUtil {
     static isInterApiSnsEvent(event) {
         return !!InterApiUtil.extractEntryFromEvent(event);

package/dist/inter-api/inter-api-util.spec.d.ts

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