@bitblit/ratchet-epsilon-common 6.0.146-alpha → 6.0.147-alpha

package/src/http/route/router-util.ts

@@ -0,0 +1,314 @@
+import { EpsilonRouter } from './epsilon-router.js';
+import { MisconfiguredError } from '../error/misconfigured-error.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { RouteMapping } from './route-mapping.js';
+import { RouteValidatorConfig } from './route-validator-config.js';
+import { JwtTokenBase } from '@bitblit/ratchet-common/jwt/jwt-token-base';
+import { BooleanRatchet } from '@bitblit/ratchet-common/lang/boolean-ratchet';
+import { OpenApiDocument } from '../../config/open-api/open-api-document.js';
+import { ModelValidator } from '@bitblit/ratchet-misc/model-validator/model-validator';
+import { BackgroundHttpAdapterHandler } from '../../background/background-http-adapter-handler.js';
+import { HandlerFunction } from '../../config/http/handler-function.js';
+import { HttpConfig } from '../../config/http/http-config.js';
+import { AuthorizerFunction } from '../../config/http/authorizer-function.js';
+import { HttpProcessingConfig } from '../../config/http/http-processing-config.js';
+import { NullReturnedObjectHandling } from '../../config/http/null-returned-object-handling.js';
+import { MappedHttpProcessingConfig } from '../../config/http/mapped-http-processing-config.js';
+import { BuiltInFilters } from '../../built-in/http/built-in-filters.js';
+import { WebTokenManipulator } from '../auth/web-token-manipulator.js';
+import { BuiltInHandlers } from '../../built-in/http/built-in-handlers.js';
+import { FilterFunction } from '../../config/http/filter-function.js';
+import { BuiltInAuthFilters } from '../../built-in/http/built-in-auth-filters.js';
+import { LogLevelManipulationFilter } from '../../built-in/http/log-level-manipulation-filter.js';
+
+/**
+ * Endpoints about the api itself
+ */
+export class RouterUtil {
+  // Prevent instantiation
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  private constructor() {}
+
+  public static defaultAuthenticationHeaderParsingEpsilonPreFilters(
+    webTokenManipulator: WebTokenManipulator<JwtTokenBase>,
+  ): FilterFunction[] {
+    return [
+      (fCtx) => BuiltInAuthFilters.parseAuthorizationHeader(fCtx, webTokenManipulator),
+      (fCtx) => BuiltInAuthFilters.applyOpenApiAuthorization(fCtx),
+    ].concat(RouterUtil.defaultEpsilonPreFilters());
+  }
+
+  public static defaultEpsilonPreFilters(): FilterFunction[] {
+    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),
+    ];
+  }
+
+  public static defaultEpsilonPostFilters(): FilterFunction[] {
+    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),
+    ];
+  }
+
+  public static defaultEpsilonErrorFilters(): FilterFunction[] {
+    return [
+      (fCtx) => BuiltInFilters.addAWSRequestIdHeader(fCtx),
+      (fCtx) => BuiltInFilters.addAllowReflectionCORSHeaders(fCtx),
+      (fCtx) => LogLevelManipulationFilter.clearLogLevelForTransaction(fCtx),
+    ];
+  }
+
+  public static defaultHttpMetaProcessingConfigWithAuthenticationHeaderParsing(
+    webTokenManipulator: WebTokenManipulator<JwtTokenBase>,
+  ): HttpProcessingConfig {
+    const defaults: HttpProcessingConfig = {
+      configName: 'EpsilonDefaultHttpMetaProcessingConfig',
+      timeoutMS: 30_000,
+      overrideAuthorizerName: null,
+      preFilters: RouterUtil.defaultAuthenticationHeaderParsingEpsilonPreFilters(webTokenManipulator),
+      postFilters: RouterUtil.defaultEpsilonPostFilters(),
+      errorFilters: RouterUtil.defaultEpsilonErrorFilters(),
+      nullReturnedObjectHandling: NullReturnedObjectHandling.Return404NotFoundResponse,
+    };
+    return defaults;
+  }
+
+  public static defaultHttpMetaProcessingConfig(): HttpProcessingConfig {
+    const defaults: HttpProcessingConfig = {
+      configName: 'EpsilonDefaultHttpMetaProcessingConfig',
+      timeoutMS: 30_000,
+      overrideAuthorizerName: null,
+      preFilters: RouterUtil.defaultEpsilonPreFilters(),
+      postFilters: RouterUtil.defaultEpsilonPostFilters(),
+      errorFilters: RouterUtil.defaultEpsilonErrorFilters(),
+      nullReturnedObjectHandling: NullReturnedObjectHandling.Return404NotFoundResponse,
+    };
+    return defaults;
+  }
+
+  public static assignDefaultsOnHttpConfig(cfg: HttpConfig): HttpConfig {
+    const defaults: HttpConfig = {
+      handlers: new Map<string, HandlerFunction<any>>(),
+      authorizers: new Map<string, AuthorizerFunction>(),
+      defaultMetaHandling: this.defaultHttpMetaProcessingConfig(),
+      staticContentRoutes: {},
+      prefixesToStripBeforeRouteMatch: [],
+      filterHandledRouteMatches: ['options .*'], // Ignore all Options since they are handled by the default prefilter
+    };
+    const rval: HttpConfig = Object.assign({}, defaults, cfg || {});
+    return rval;
+  }
+
+  // Search the overrides in order to find a match, otherwise return default
+  public static findApplicableMeta(httpConfig: HttpConfig, method: string, path: string): HttpProcessingConfig {
+    let rval: HttpProcessingConfig = null;
+    if (httpConfig?.overrideMetaHandling) {
+      for (let i = 0; i < httpConfig.overrideMetaHandling.length && !rval; i++) {
+        const test: MappedHttpProcessingConfig = httpConfig.overrideMetaHandling[i];
+        if (
+          !test.methods ||
+          test.methods.length === 0 ||
+          test.methods.map((s) => s.toLocaleLowerCase()).includes(method.toLocaleLowerCase())
+        ) {
+          const matches: boolean = !!path.match(test.pathRegex); // .match(path);
+          if ((matches && !test.invertPathMatching) || (!matches && test.invertPathMatching)) {
+            rval = test.config;
+          }
+        }
+      }
+    }
+    if (!rval) {
+      rval = httpConfig.defaultMetaHandling || RouterUtil.defaultHttpMetaProcessingConfig(); // If nothing found, use epsilon defaults
+    }
+
+    return rval;
+  }
+
+  // Parses an open api file to create a router config
+  public static openApiYamlToRouterConfig(
+    httpConfig: HttpConfig,
+    openApiDoc: OpenApiDocument,
+    modelValidator: ModelValidator,
+    backgroundHttpAdapterHandler: BackgroundHttpAdapterHandler,
+  ): EpsilonRouter {
+    if (!openApiDoc || !httpConfig) {
+      throw new MisconfiguredError('Cannot configure, missing either yaml or cfg');
+    }
+    const rval: EpsilonRouter = {
+      routes: [],
+      openApiModelValidator: modelValidator,
+      config: RouterUtil.assignDefaultsOnHttpConfig(httpConfig),
+    };
+
+    if (openApiDoc?.components?.securitySchemes) {
+      // Just validation, nothing to wire here
+      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: string[] = [];
+    const filterHandledPathMatches: string[] = httpConfig.filterHandledRouteMatches || [];
+
+    if (openApiDoc?.paths) {
+      Object.keys(openApiDoc.paths).forEach((path) => {
+        Object.keys(openApiDoc.paths[path]).forEach((method) => {
+          const convertedPath: string = RouterUtil.openApiPathToRouteParserPath(path);
+          const finder: string = method + ' ' + path;
+          const applicableMeta: HttpProcessingConfig = RouterUtil.findApplicableMeta(httpConfig, method, path);
+
+          const entry: any = openApiDoc.paths[path][method];
+          const isBackgroundEndpoint: boolean = path.startsWith(backgroundHttpAdapterHandler.httpSubmissionPath);
+          const isBackgroundMetaEndpoint: boolean = path === backgroundHttpAdapterHandler.httpMetaEndpoint;
+          const isBackgroundStatusEndpoint: boolean = path === backgroundHttpAdapterHandler.httpStatusPath;
+          // Auto-assign the background handler endpoints
+          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: string = filterHandledPathMatches.find((reg) => finder.match(reg));
+            if (match) {
+              Logger.debug('Adding filter-handled handler for %s', finder);
+              // Insert a placeholder for these, which still handles them in runtime if the filter is misconfigured
+              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: string = entry['security'] && entry['security'].length == 1 ? Object.keys(entry['security'][0])[0] : null;
+
+          const newRoute: RouteMapping = {
+            path: convertedPath,
+            method: method,
+            function: rval.config.handlers.get(finder),
+            authorizerName: applicableMeta.overrideAuthorizerName || authorizerName,
+            metaProcessingConfig: applicableMeta,
+            validation: null,
+            outboundValidation: null,
+          };
+
+          // Add inbound validation, if available
+          if (
+            entry['requestBody'] &&
+            entry['requestBody']['content'] &&
+            entry['requestBody']['content']['application/json'] &&
+            entry['requestBody']['content']['application/json']['schema']
+          ) {
+            // TODO: this is brittle as hell, need to firm up
+            const schema: any = 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: boolean = BooleanRatchet.parseBool(entry['requestBody']['required']);
+            const validation: RouteValidatorConfig = {
+              extraPropertiesAllowed: true,
+              emptyAllowed: !required,
+              modelName: modelName,
+            } as RouteValidatorConfig;
+
+            newRoute.validation = validation;
+          }
+
+          // Add outbound validation, if available
+          if (
+            entry['responses'] &&
+            entry['responses']['200'] &&
+            entry['responses']['200']['content'] &&
+            entry['responses']['200']['content']['application/json'] &&
+            entry['responses']['200']['content']['application/json']['schema']
+          ) {
+            // TODO: this is brittle as hell, need to firm up
+            const schema: any = 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: RouteValidatorConfig = {
+              extraPropertiesAllowed: false,
+              emptyAllowed: false, // Its a 200 response, must be non-null
+              modelName: modelName,
+            } as RouteValidatorConfig;
+
+            newRoute.outboundValidation = validation;
+          }
+
+          rval.routes.push(newRoute);
+        });
+      });
+    }
+
+    if (missingPaths.length > 0) {
+      throw new MisconfiguredError().withFormattedErrorMessage('Missing expected handlers : %j', missingPaths);
+    }
+
+    return rval;
+  }
+
+  private static findAndValidateModelName(method: string, path: string, schema: any, modelValidator: ModelValidator): string | undefined {
+    let rval: string | undefined = undefined;
+    const schemaPath: string = schema['application/json']['schema']['$ref'];
+    const inlinePath: string = 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;
+  }
+
+  public static openApiPathToRouteParserPath(input: string): string {
+    let rval: string = input;
+
+    if (rval) {
+      let sIdx: number = rval.indexOf('{');
+      while (sIdx > -1) {
+        const eIdx: number = rval.indexOf('}');
+        rval = rval.substring(0, sIdx) + ':' + rval.substring(sIdx + 1, eIdx) + rval.substring(eIdx + 1);
+        sIdx = rval.indexOf('{');
+      }
+    }
+
+    return rval;
+  }
+}

package/src/http/web-handler.spec.ts

@@ -0,0 +1,99 @@
+import { APIGatewayEvent, APIGatewayEventRequestContext, Context, ProxyResult } from 'aws-lambda';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { EpsilonGlobalHandler } from '../epsilon-global-handler.js';
+import { SampleServerComponents } from '../sample/sample-server-components.js';
+import { LoggerLevelName } from '@bitblit/ratchet-common/logger/logger-level-name';
+import { describe, expect, test } from 'vitest';
+
+describe('#errorToProxyResult', function () {
+  /*
+    test('should set the default status code to 500', function() {
+
+        let err:Error = new BadRequestError('this is a test','a1','a2');
+        let res:ProxyResult = ResponseUtil.errorToProxyResult(err);
+
+        expect(res.statusCode).toEqual(400);
+    });
+
+    test('should parse a request body correctly', function() {
+
+        let evt:APIGatewayEvent = {
+            httpMethod:'post',
+            path:'/test',
+            pathParameters: null,
+            queryStringParameters: null,
+            stageVariables:null,
+            requestContext:{} as APIGatewayEventRequestContext,
+            resource:'/test',
+            headers: {
+                'content-type':'application/json'
+            },
+            isBase64Encoded: true,
+            body: 'ew0KICJtZXNzYWdlIiA6ICJ0aGlzIGlzIGEgdGVzdCIsDQogIm51bWJlciIgOiAxDQp9'
+
+        } as APIGatewayEvent;
+
+        let body = EventUtil.bodyObject(evt);
+        expect(body).toBeTruthy();
+        expect(body.message).toEqual('this is a test');
+        expect(body.number).toEqual(1);
+
+    });
+
+    test('should parse a request body correctly part 2', function() {
+
+        let evt:APIGatewayEvent = {
+            httpMethod:'post',
+            path:'/test',
+            pathParameters: null,
+            queryStringParameters: null,
+            stageVariables:null,
+            requestContext:{} as APIGatewayEventRequestContext,
+            resource:'/test',
+            headers: {
+                'content-type':'application/json; charset=UTF-8'
+            },
+            isBase64Encoded: true,
+            body: 'ew0KICJtZXNzYWdlIiA6ICJ0aGlzIGlzIGEgdGVzdCIsDQogIm51bWJlciIgOiAxDQp9'
+
+        } as APIGatewayEvent;
+
+        let body = EventUtil.bodyObject(evt);
+        expect(body).toBeTruthy();
+        expect(body.message).toEqual('this is a test');
+        expect(body.number).toEqual(1);
+    });
+    */
+
+  test('should gzip responses correctly', async () => {
+    const inst: EpsilonGlobalHandler = await SampleServerComponents.createSampleEpsilonGlobalHandler('jest-gzip');
+
+    expect(inst.epsilon.modelValidator).toBeTruthy();
+
+    const evt: APIGatewayEvent = {
+      httpMethod: 'get',
+      multiValueHeaders: {},
+      multiValueQueryStringParameters: {},
+      path: '/meta/server',
+      pathParameters: null,
+      queryStringParameters: null,
+      stageVariables: null,
+      requestContext: {} as APIGatewayEventRequestContext,
+      resource: '/meta/server',
+      headers: {
+        'content-type': 'application/json; charset=UTF-8',
+        'accept-encoding': 'gzip, deflate, br',
+      },
+      isBase64Encoded: true,
+      body: null,
+    } as APIGatewayEvent;
+
+    Logger.setLevel(LoggerLevelName.silly);
+    const result: ProxyResult = await inst.epsilon.webHandler.processEvent(evt, {} as Context);
+
+    expect(result).toBeTruthy();
+    expect(result.isBase64Encoded).toEqual(true);
+    expect(result.headers).toBeTruthy();
+    expect(result.headers['Content-Encoding']).toEqual('gzip');
+  });
+});

package/src/http/web-handler.ts

@@ -0,0 +1,157 @@
+import { EpsilonRouter } from './route/epsilon-router.js';
+import { APIGatewayEvent, Context, ProxyResult } from 'aws-lambda';
+
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { RestfulApiHttpError } from '@bitblit/ratchet-common/network/restful-api-http-error';
+import { ResponseUtil } from './response-util.js';
+import { ExtendedAPIGatewayEvent } from '../config/http/extended-api-gateway-event.js';
+import { BuiltInFilters } from '../built-in/http/built-in-filters.js';
+import { HttpProcessingConfig } from '../config/http/http-processing-config.js';
+import { FilterFunction } from '../config/http/filter-function.js';
+import { RunHandlerAsFilter } from '../built-in/http/run-handler-as-filter.js';
+import { FilterChainContext } from '../config/http/filter-chain-context.js';
+import { ContextUtil } from '../util/context-util.js';
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler.js';
+import { LambdaEventDetector } from '@bitblit/ratchet-aws/lambda/lambda-event-detector';
+import { RouteAndParse } from './route/route-and-parse.js';
+import Route from 'route-parser';
+
+/**
+ * This class functions as the adapter from a default lambda function to the handlers exposed via Epsilon
+ */
+export class WebHandler implements EpsilonLambdaEventHandler<APIGatewayEvent> {
+  public static readonly MAXIMUM_LAMBDA_BODY_SIZE_BYTES: number = 1024 * 1024 * 5 - 1024 * 100; // 5Mb - 100k buffer
+
+  constructor(private routerConfig: EpsilonRouter) {
+    RequireRatchet.notNullOrUndefined(routerConfig);
+  }
+
+  public get router(): EpsilonRouter {
+    return this.routerConfig;
+  }
+
+  public extractLabel(evt: APIGatewayEvent, _context: Context): string {
+    return 'WEB:' + StringRatchet.trimToEmpty(evt.httpMethod).toUpperCase() + ':' + evt.path;
+  }
+
+  public handlesEvent(evt: any): boolean {
+    return LambdaEventDetector.isValidApiGatewayEvent(evt);
+  }
+
+  public async processEvent(event: APIGatewayEvent, context: Context): Promise<ProxyResult> {
+    if (!this.routerConfig) {
+      throw new Error('Router config not found');
+    }
+    const asExtended: ExtendedAPIGatewayEvent = Object.assign(
+      {},
+      { parsedBody: null, authorization: null, convertedFromV2Event: false },
+      event,
+    );
+    const rval: ProxyResult = await this.openApiLambdaHandler(asExtended, context);
+    ContextUtil.addTraceToProxyResult(rval);
+    Logger.updateTracePrefix(null); // Just in case it was set
+    return rval;
+  }
+
+  public async openApiLambdaHandler(evt: ExtendedAPIGatewayEvent, context: Context): Promise<ProxyResult> {
+    const rm: RouteAndParse = this.findBestMatchingRoute(evt);
+    const procConfig: HttpProcessingConfig = rm?.mapping?.metaProcessingConfig
+      ? rm.mapping.metaProcessingConfig
+      : this.routerConfig.config.defaultMetaHandling;
+    const fCtx: FilterChainContext = {
+      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: FilterFunction[] = Object.assign([], procConfig.preFilters || []);
+      RunHandlerAsFilter.addRunHandlerAsFilterToList(filterChain, rm);
+      filterChain = filterChain.concat(procConfig.postFilters || []);
+      await BuiltInFilters.combineFilters(fCtx, filterChain);
+    } catch (err) {
+      // Convert to an epsilon error
+      const wrapper: RestfulApiHttpError = RestfulApiHttpError.wrapError(err as Error);
+      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;
+  }
+
+  public findBestMatchingRoute(event: APIGatewayEvent): RouteAndParse {
+    let rval: RouteAndParse = null;
+    // See: https://www.npmjs.com/package/route-parser
+    const cleanPath: string = this.cleanPath(event);
+
+    // Filter routes to only matches
+    const methodLower: string = event.httpMethod.toLowerCase();
+    const matchRoutes: RouteAndParse[] = this.routerConfig.routes
+      .map((r) => {
+        let rval: RouteAndParse = null;
+        if (r.method && r.method.toLowerCase() === methodLower) {
+          const routeParser: Route = new Route(r.path);
+          const parsed: any = routeParser.match(cleanPath);
+          if (parsed !== false) {
+            rval = {
+              mapping: r,
+              route: routeParser,
+              parsed: parsed,
+            };
+          }
+        }
+        return rval;
+      })
+      .filter((r) => r != null);
+    // Pick the 'best' match
+    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;
+  }
+
+  private cleanPath(event: APIGatewayEvent): string {
+    let rval: string = event.path;
+    // First, strip any leading /
+    while (rval.startsWith('/')) {
+      rval = rval.substring(1);
+    }
+    // If there are any listed prefixes, strip them
+    if (this.routerConfig.config.prefixesToStripBeforeRouteMatch) {
+      this.routerConfig.config.prefixesToStripBeforeRouteMatch.forEach((prefix) => {
+        if (rval.toLowerCase().startsWith(prefix.toLowerCase() + '/')) {
+          rval = rval.substring(prefix.length);
+        }
+      });
+    }
+
+    // Strip any more leading /
+    while (rval.startsWith('/')) {
+      rval = rval.substring(1);
+    }
+    // Finally, put back exactly 1 leading / to match what comes out of open api
+    rval = '/' + rval;
+
+    return rval;
+  }
+}

package/src/http/web-v2-handler.ts

@@ -0,0 +1,34 @@
+import { APIGatewayEvent, APIGatewayProxyEventV2, Context, ProxyResult } from 'aws-lambda';
+import { ExtendedAPIGatewayEvent } from '../config/http/extended-api-gateway-event.js';
+import { AwsUtil } from '../util/aws-util.js';
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler.js';
+import { LambdaEventDetector } from '@bitblit/ratchet-aws/lambda/lambda-event-detector';
+import { WebHandler } from './web-handler.js';
+
+/**
+ * This class functions as the adapter from a default lambda function to the handlers exposed via Epsilon
+ */
+export class WebV2Handler implements EpsilonLambdaEventHandler<APIGatewayProxyEventV2> {
+  constructor(private webHandler: WebHandler) {}
+
+  public extractLabel(evt: APIGatewayProxyEventV2, context: Context): string {
+    let rval: string = this.webHandler.extractLabel(AwsUtil.apiGatewayV2ToApiGatewayV1(evt), context);
+    rval = rval.replace('WEB:', 'WEB2:');
+    return rval;
+  }
+
+  public handlesEvent(evt: any): boolean {
+    return LambdaEventDetector.isValidApiGatewayV2WithRequestContextEvent(evt);
+  }
+
+  public async processEvent(evt: APIGatewayProxyEventV2, context: Context): Promise<ProxyResult> {
+    const conv: APIGatewayEvent = AwsUtil.apiGatewayV2ToApiGatewayV1(evt);
+    const asExtended: ExtendedAPIGatewayEvent = Object.assign(
+      {},
+      { parsedBody: null, authorization: null, convertedFromV2Event: true },
+      conv,
+    );
+    const rval: ProxyResult = await this.webHandler.openApiLambdaHandler(asExtended, context);
+    return rval;
+  }
+}

package/src/inter-api/inter-api-entry.ts

@@ -0,0 +1,8 @@
+export interface InterApiEntry<T> {
+  source: string;
+  type: string;
+  data: T;
+
+  traceId?: string;
+  traceDepth?: number;
+}