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

package/src/built-in/http/log-level-manipulation-filter.ts

@@ -0,0 +1,26 @@
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { FilterChainContext } from '../../config/http/filter-chain-context.js';
+import { LoggerLevelName } from '@bitblit/ratchet-common/logger/logger-level-name';
+
+/**
+ * This only works because Node is single threaded...
+ */
+export class LogLevelManipulationFilter {
+  private static LOG_LEVEL_BEFORE_CHANGE: LoggerLevelName = null;
+
+  // TODO: Implement me!!
+  public static async setLogLevelForTransaction(_fCtx: FilterChainContext): Promise<boolean> {
+    LogLevelManipulationFilter.LOG_LEVEL_BEFORE_CHANGE = Logger.getLevel();
+    // TODO: Set me too! Logger.setTracePrefix(null);
+    return true;
+  }
+
+  public static async clearLogLevelForTransaction(_fCtx: FilterChainContext): Promise<boolean> {
+    if (LogLevelManipulationFilter.LOG_LEVEL_BEFORE_CHANGE) {
+      Logger.setLevel(LogLevelManipulationFilter.LOG_LEVEL_BEFORE_CHANGE);
+      LogLevelManipulationFilter.LOG_LEVEL_BEFORE_CHANGE = null;
+      Logger.updateTracePrefix(null);
+    }
+    return true;
+  }
+}

package/src/built-in/http/run-handler-as-filter.spec.ts

@@ -0,0 +1,67 @@
+import { 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 { RunHandlerAsFilter } from './run-handler-as-filter.js';
+import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event.js';
+import { RouterUtil } from '../../http/route/router-util.js';
+import { describe, expect, test } from 'vitest';
+import { RouteAndParse } from '../../http/route/route-and-parse';
+
+describe('#routerUtilApplyOpenApiDoc', function () {
+  test('should find the most specific route and the least specific', async () => {
+    const inst: EpsilonGlobalHandler = await SampleServerComponents.createSampleEpsilonGlobalHandler('jest-most specific route');
+
+    expect(inst.epsilon.modelValidator).toBeTruthy();
+
+    // TODO: move this to its own test
+    const evtFixed: ExtendedAPIGatewayEvent = {
+      httpMethod: 'get',
+      path: '/v0/multi/fixed',
+      requestContext: {
+        stage: 'v0',
+      },
+      queryStringParameters: {},
+    } as ExtendedAPIGatewayEvent;
+
+    const evtVar: ExtendedAPIGatewayEvent = {
+      httpMethod: 'get',
+      path: '/v0/multi/xyz',
+      requestContext: {
+        stage: 'v0',
+      },
+      queryStringParameters: {},
+    } as ExtendedAPIGatewayEvent;
+
+    const findFixedRP: RouteAndParse = await inst.epsilon.webHandler.findBestMatchingRoute(evtFixed);
+    const findVariableRP: RouteAndParse = await inst.epsilon.webHandler.findBestMatchingRoute(evtVar);
+    const findFixed: ProxyResult = await RunHandlerAsFilter.findHandler(findFixedRP, evtFixed, {} as Context, false);
+    const findVariable: ProxyResult = await RunHandlerAsFilter.findHandler(findVariableRP, evtVar, {} as Context, false);
+    expect(findFixed).toBeTruthy();
+    expect(findFixed['flag']).toEqual('fixed');
+    expect(findVariable).toBeTruthy();
+    expect(findVariable['flag']).toEqual('variable');
+    Logger.info('done');
+  });
+
+  test('should reformat a path to match the other library', function () {
+    const inString: string = '/meta/item/{itemId}';
+    const outString: string = RouterUtil.openApiPathToRouteParserPath(inString);
+    expect(outString).toEqual('/meta/item/:itemId');
+  });
+
+  test('should redact authorization values from events for logging', function () {
+    const inputEvent: any = {
+      authorization: {
+        raw: 'secret-access-token-here',
+      },
+      headers: {
+        authorization: 'Bearer secret-access-token-here',
+      },
+    };
+    // @ts-expect-error private method
+    const logEventObj: any = JSON.parse(RunHandlerAsFilter.eventToStringForLog(inputEvent));
+    expect(logEventObj.authorization.raw).toEqual(RunHandlerAsFilter.redact(inputEvent.authorization.raw));
+    expect(logEventObj.headers.authorization).toEqual(RunHandlerAsFilter.redact(logEventObj.headers.authorization));
+  });
+});

package/src/built-in/http/run-handler-as-filter.ts

@@ -0,0 +1,102 @@
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { PromiseRatchet } from '@bitblit/ratchet-common/lang/promise-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { TimeoutToken } from '@bitblit/ratchet-common/lang/timeout-token';
+import { RestfulApiHttpError } from '@bitblit/ratchet-common/network/restful-api-http-error';
+import { Context } from 'aws-lambda';
+import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event.js';
+import { RequestTimeoutError } from '../../http/error/request-timeout-error.js';
+import { ResponseUtil } from '../../http/response-util.js';
+import { NotFoundError } from '../../http/error/not-found-error.js';
+import { NullReturnedObjectHandling } from '../../config/http/null-returned-object-handling.js';
+import { FilterFunction } from '../../config/http/filter-function.js';
+import { FilterChainContext } from '../../config/http/filter-chain-context.js';
+import { RouteAndParse } from '../../http/route/route-and-parse.js';
+
+export class RunHandlerAsFilter {
+  public static async runHandler(fCtx: FilterChainContext, rm: RouteAndParse): Promise<boolean> {
+    // Check for continue
+    // Run the controller
+    const handler: Promise<any> = RunHandlerAsFilter.findHandler(rm, fCtx.event, fCtx.context);
+    Logger.debug('Processing event with epsilon: %j', RunHandlerAsFilter.eventToStringForLog(fCtx.event));
+    let tmp: any = await handler;
+    if (TimeoutToken.isTimeoutToken(tmp)) {
+      (tmp as TimeoutToken).writeToLog();
+      throw new RequestTimeoutError('Timed out');
+    }
+    Logger.debug('Initial return value : %j', tmp);
+    tmp = RunHandlerAsFilter.applyNullReturnedObjectHandling(tmp, rm.mapping.metaProcessingConfig.nullReturnedObjectHandling);
+    fCtx.rawResult = tmp;
+    fCtx.result = ResponseUtil.coerceToProxyResult(tmp);
+
+    return true;
+  }
+
+  public static applyNullReturnedObjectHandling(result: any, handling: NullReturnedObjectHandling): any {
+    let rval: any = result;
+    if (result === null || result === undefined) {
+      if (handling === NullReturnedObjectHandling.Error) {
+        Logger.error('Null object returned and Error specified, throwing 500');
+        throw new RestfulApiHttpError('Null object').withHttpStatusCode(500);
+      } else if (handling === NullReturnedObjectHandling.Return404NotFoundResponse) {
+        throw new NotFoundError('Resource not found');
+      } else if (handling === NullReturnedObjectHandling.ConvertToEmptyString) {
+        Logger.warn('Null object returned from handler and convert not specified, converting to empty string');
+        rval = '';
+      } else {
+        throw new RestfulApiHttpError('Cant happen - failed enum check').withHttpStatusCode(500);
+      }
+    }
+    return rval;
+  }
+
+  public static async findHandler(
+    rm: RouteAndParse,
+    event: ExtendedAPIGatewayEvent,
+    context: Context,
+    add404OnMissing: boolean = true,
+  ): Promise<any> {
+    let rval: Promise<any> = null;
+    // Execute
+    if (rm) {
+      // We extend with the parsed params here in case we are using the AWS any proxy
+      event.pathParameters = Object.assign({}, event.pathParameters, rm.parsed);
+
+      rval = PromiseRatchet.timeout(
+        rm.mapping.function(event, context),
+        'Timed out after ' +
+          rm.mapping.metaProcessingConfig.timeoutMS +
+          ' ms.  Request was ' +
+          RunHandlerAsFilter.eventToStringForLog(event),
+        rm.mapping.metaProcessingConfig.timeoutMS,
+      );
+    } else if (add404OnMissing) {
+      throw new NotFoundError('No such endpoint');
+    }
+    return rval;
+  }
+
+  public static addRunHandlerAsFilterToList(filters: FilterFunction[], rm: RouteAndParse): void {
+    if (filters) {
+      filters.push((fCtx) => RunHandlerAsFilter.runHandler(fCtx, rm));
+    }
+  }
+
+  private static eventToStringForLog(event: any): string {
+    const eventToLog = structuredClone(event);
+
+    if (eventToLog?.authorization?.raw) {
+      eventToLog.authorization.raw = RunHandlerAsFilter.redact(eventToLog.authorization.raw);
+    }
+    if (eventToLog?.headers?.authorization) {
+      eventToLog.headers.authorization = RunHandlerAsFilter.redact(eventToLog.headers.authorization);
+    }
+
+    return JSON.stringify(eventToLog);
+  }
+
+  public static redact(input: string): string {
+    const rval: string = input ? StringRatchet.obscure(input, 1, 1) : input;
+    return rval;
+  }
+}

package/src/cli/ratchet-cli-handler.ts

@@ -0,0 +1,23 @@
+import { AbstractRatchetCliHandler } from '@bitblit/ratchet-node-only/cli/abstract-ratchet-cli-handler';
+import { BuildInformation } from '@bitblit/ratchet-common/build/build-information';
+import { RunBackgroundProcessFromCommandLine } from './run-background-process-from-command-line.js';
+import { TestErrorServer } from '../sample/test-error-server.js';
+import { LocalContainerServer } from '../local-container-server.js';
+import { RatchetEpsilonCommonInfo } from '../build/ratchet-epsilon-common-info.js';
+import { LocalServer } from '../local-server.js';
+
+export class RatchetCliHandler extends AbstractRatchetCliHandler {
+  fetchHandlerMap(): Record<string, any> {
+    return {
+      'run-background-process': RunBackgroundProcessFromCommandLine.runFromCliArgs,
+      'run-test-error-server': TestErrorServer.runFromCliArgs,
+      'run-local-container-server': LocalContainerServer.runFromCliArgs,
+      'run-sample-local-server': LocalServer.runSampleLocalServerFromCliArgs,
+      'run-sample-local-batch-server': LocalServer.runSampleLocalServerFromCliArgs,
+    };
+  }
+
+  fetchVersionInfo(): BuildInformation {
+    return RatchetEpsilonCommonInfo.buildInformation();
+  }
+}

package/src/cli/run-background-process-from-command-line.ts

@@ -0,0 +1,32 @@
+import { EpsilonGlobalHandler } from '../epsilon-global-handler.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { BooleanRatchet } from '@bitblit/ratchet-common/lang/boolean-ratchet';
+
+/**
+ * IMPORTANT NOTE
+ * This file is part of the bootstrapper to bridge from the Epsilon Background processor
+ * to the AWS Batch processing Docker setup.
+ *
+ * DO NOT MESS WITH IT UNLESS YOU REALLY KNOW WHAT YOU ARE DOING.
+ *
+ * You are likely to mess it up otherwise.
+ */
+export class RunBackgroundProcessFromCommandLine {
+  public static async runFromCliArgs(args: string[]): Promise<void> {
+    if (args.length > 1) {
+      const procName: string = args[0];
+      const dryRun: boolean = args.length > 1 && BooleanRatchet.parseBool(args[1]);
+      const data: any = args.length > 2 ? JSON.parse(args[2]) : null;
+      const meta: any = args.length > 3 ? JSON.parse(args[3]) : null;
+      const epsilon: EpsilonGlobalHandler = null; // TODO: How to pass this in?
+
+      if (dryRun) {
+        Logger.info('Dry-Run, would have sent : %s %j %j', procName, data, meta);
+      } else {
+        await epsilon.processSingleBackgroundByParts(procName, data, meta);
+      }
+    } else {
+      console.log('Usage : run-background-process {processName} {dryRun true/false} {dataJson} {metaJson}');
+    }
+  }
+}

package/src/config/background/background-aws-config.ts

@@ -0,0 +1,8 @@
+export interface BackgroundAwsConfig {
+  queueUrl: string;
+  notificationArn: string;
+  sendNotificationOnBackgroundError?: boolean;
+  sendNotificationOnBackgroundValidationFailure?: boolean;
+  // If either of the above are set to true, notifications will be sent here
+  backgroundProcessFailureSnsArn?: string;
+}

package/src/config/background/background-config.ts

@@ -0,0 +1,15 @@
+import { BackgroundProcessor } from './background-processor.js';
+import { BackgroundErrorProcessor } from './background-error-processor.js';
+import { BackgroundExecutionListener } from '../../background/background-execution-listener.js';
+import { BackgroundTransactionLogger } from './background-transaction-logger.js';
+
+export interface BackgroundConfig {
+  transactionLogger?: BackgroundTransactionLogger;
+  errorProcessor?: BackgroundErrorProcessor;
+  httpStatusEndpoint?: string;
+  httpMetaEndpoint?: string;
+  httpSubmissionPath: string;
+  implyTypeFromPathSuffix: boolean;
+  processors: BackgroundProcessor<any>[];
+  executionListeners?: BackgroundExecutionListener<any>[];
+}

package/src/config/background/background-error-processor.ts

@@ -0,0 +1,5 @@
+import { InternalBackgroundEntry } from '../../background/internal-background-entry.js';
+
+export interface BackgroundErrorProcessor {
+  handleError(submission: InternalBackgroundEntry<any>, error: Error): Promise<void>;
+}

package/src/config/background/background-processor.ts

@@ -0,0 +1,14 @@
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
+
+export interface BackgroundProcessor<T> {
+  typeName: string; // The name for this processor
+
+  // If set, data will be validated against this before submitted
+  // Yes, if using explicitly pathed and configured routes it'll get
+  // validated twice... the price I pay to support both pathed and
+  // single-post background support
+  dataSchemaName?: string;
+
+  // Allowed to return since it may be logged
+  handleEvent(data: T, mgr: BackgroundManagerLike): Promise<any>;
+}

package/src/config/background/background-transaction-log.ts

@@ -0,0 +1,9 @@
+import { InternalBackgroundEntry } from '../../background/internal-background-entry.js';
+
+export interface BackgroundTransactionLog {
+  request: InternalBackgroundEntry<any>;
+  running: boolean;
+  runtimeMS?: number;
+  result?: any;
+  error?: any;
+}

package/src/config/background/background-transaction-logger.ts

@@ -0,0 +1,6 @@
+import { BackgroundTransactionLog } from './background-transaction-log.js';
+
+export interface BackgroundTransactionLogger {
+  logTransaction(txLog: BackgroundTransactionLog): Promise<void>;
+  readTransactionLog(txGuid: string): Promise<BackgroundTransactionLog>;
+}

package/src/config/cron/abstract-cron-entry.ts

@@ -0,0 +1,17 @@
+export interface AbstractCronEntry {
+  name?: string; // Just used for labeling in logs
+  eventFilter?: RegExp; // If set, matches against the schedule name from CloudWatch events
+  minuteFilter?: number[]; // If set and length>0, only minutes matching this array will trigger 0-59
+  hourFilter?: number[]; // If set and length>0, only hours matching this array will trigger (as defined by the timezone in cron config) 0-23
+  dayOfWeekFilter?: number[]; // If set and length>0, only days of week matching this array will trigger (as defined by the timezone in cron config) 0-6
+  dayOfMonthFilter?: number[]; // If set and length>0, only days of month matching this array will trigger (as defined by the timezone in cron config) 1-31
+  monthOfYearFilter?: number[]; // If set and length>0, only months of year matching this array will trigger (as defined by the timezone in cron config) 1-12
+  contextMatchFilter?: RegExp; // If set, the context must match this filter
+  contextNoMatchFilter?: RegExp; // If set, the context must NOT match this filter
+  // If both match and nomatch are set, the noMatch dominates over match
+
+  // If set, this will be used instead of the timezone in cron-config
+  // This override is to allow you to use a simple timezone like PT for most, while
+  // still scheduling certain things to run in UTC (Not DST switching)
+  overrideTimezone?: string;
+}

package/src/config/cron/cron-background-entry.ts

@@ -0,0 +1,17 @@
+import { AbstractCronEntry } from './abstract-cron-entry.js';
+
+/**
+  of 2020-04-30, my recommendation is that CRON should be used ONLY to fire
+ * off Background tasks (this makes your CRON stuff easier to debug since it can
+ * be called from anywhere, not just CRON, and also makes sure that your processor
+ * gets the full 15 minutes if necessary)
+ *
+ * This simplifies doing that - you can basically just configure the set of
+ * constraints, and the background task to fire off if the constraints match.
+ */
+export interface CronBackgroundEntry extends AbstractCronEntry {
+  backgroundTaskType: string;
+  fireImmediate: boolean;
+
+  data?: any;
+}

package/src/config/cron/cron-config.ts

@@ -0,0 +1,10 @@
+import { CronBackgroundEntry } from './cron-background-entry.js';
+
+export interface CronConfig {
+  // Timezone used to evaluate date and time (defaults to etc/gmt)
+  timezone: string;
+  // Define the current context of this cron executor (typically used to switch prod/qa/dev, etc)
+  context: string;
+
+  entries: CronBackgroundEntry[];
+}

package/src/config/dynamo-db-config.ts

@@ -0,0 +1,6 @@
+import { GenericAwsEventHandlerFunction } from './generic-aws-event-handler-function.js';
+import { DynamoDBStreamEvent } from 'aws-lambda';
+
+export interface DynamoDbConfig {
+  handlers: Map<string, GenericAwsEventHandlerFunction<DynamoDBStreamEvent>>;
+}

package/src/config/epsilon-config.ts

@@ -0,0 +1,30 @@
+import { HttpConfig } from './http/http-config.js';
+import { BackgroundConfig } from './background/background-config.js';
+import { CronConfig } from './cron/cron-config.js';
+import { DynamoDbConfig } from './dynamo-db-config.js';
+import { S3Config } from './s3-config.js';
+import { SnsConfig } from './sns-config.js';
+import { EpsilonLoggerConfig } from './epsilon-logger-config.js';
+import { InterApiConfig } from './inter-api/inter-api-config.js';
+import { SqsConfig } from './sqs-config.js';
+
+export interface EpsilonConfig {
+  label?: string;
+  // If disabled, last resort timeout will instead roll to lambda (not recommended)
+  disableLastResortTimeout?: boolean;
+  throwErrorIfNoSuitableEventHandlers?: boolean;
+
+  openApiYamlString: string;
+  httpConfig?: HttpConfig;
+
+  backgroundConfig?: BackgroundConfig;
+  interApiConfig?: InterApiConfig;
+
+  cron?: CronConfig;
+  dynamoDb?: DynamoDbConfig;
+  s3?: S3Config;
+  sns?: SnsConfig;
+  sqs?: SqsConfig;
+
+  loggerConfig?: EpsilonLoggerConfig;
+}

package/src/config/epsilon-lambda-event-handler.ts

@@ -0,0 +1,12 @@
+import { Context, ProxyResult } from 'aws-lambda';
+
+export interface EpsilonLambdaEventHandler<T> {
+  handlesEvent(evt: any): boolean;
+  extractLabel(evt: T, context: Context): string;
+  processEvent(evt: T, context: Context): Promise<ProxyResult>;
+  // If you define a processUncaughtError function, then any errors that are thrown while running this handler,
+  // and not caught by the handler itself, will be processed by this.  Usually you wouldn't implement this
+  // function (since you would want the default 'catch/log/return 500' logic, but if you want retries,
+  // (eg, for Dynamo, Kinesis, etc) you can override this to allow the error to slip outside Epsilon
+  processUncaughtError?(evt: T, context: Context, err: Error): Promise<ProxyResult>;
+}

package/src/config/epsilon-logger-config.ts

@@ -0,0 +1,23 @@
+import { LoggerLevelName } from '@bitblit/ratchet-common/logger/logger-level-name';
+import { LogMessageFormatType } from '@bitblit/ratchet-common/logger/log-message-format-type';
+import { LoggingTraceIdGenerator } from './logging-trace-id-generator.js';
+
+export interface EpsilonLoggerConfig {
+  // If set, the logger will be set to this instead of the default
+  envParamLogLevelName?: string;
+  // If set, and the user provides the query param, the logger level will be set to this
+  queryParamLogLevelName?: string;
+  // If set, and the user provides the query param, the logger will use this common prefix for the transaction
+  queryParamTracePrefixName?: string;
+  // If set, this will be used to generate trace ids when none are provided - otherwise, defaults to the aws request id
+  // If present, and a guid if not
+  traceIdGenerator?: LoggingTraceIdGenerator;
+  // Defaults to structured json - this is here so you can switch if you are running locally
+  logMessageFormatType?: LogMessageFormatType;
+  // Defaults to x-trace-id if not set
+  traceHeaderName?: string;
+  // Defaults to x-trace-depth if not set
+  traceDepthHeaderName?: string;
+  // Epsilon start/end messages are logged at this level (info by default)
+  epsilonStartEndMessageLogLevel?: LoggerLevelName;
+}

package/src/config/espilon-server-mode.ts

@@ -0,0 +1,10 @@
+// NOTE: This is a psuedo-enum to fix some issues with Typescript enums.  See: https://exploringjs.com/tackling-ts/ch_enum-alternatives.html for details
+export const EpsilonServerMode = {
+  Production: 'Production',
+  Development: 'Development',
+  QA: 'QA',
+  Red: 'Red',
+  Blue: 'Blue',
+  Green: 'Green',
+};
+export type EpsilonServerMode = (typeof EpsilonServerMode)[keyof typeof EpsilonServerMode];

package/src/config/generic-aws-event-handler-function.ts

@@ -0,0 +1 @@
+export type GenericAwsEventHandlerFunction<T> = (event: T) => Promise<void>;

package/src/config/http/authorizer-function.ts

@@ -0,0 +1,9 @@
+import { RouteMapping } from '../../http/route/route-mapping.js';
+import { EpsilonAuthorizationContext } from './epsilon-authorization-context.js';
+import { ExtendedAPIGatewayEvent } from './extended-api-gateway-event.js';
+
+export type AuthorizerFunction = (
+  authData: EpsilonAuthorizationContext<any>,
+  event?: ExtendedAPIGatewayEvent,
+  route?: RouteMapping,
+) => Promise<boolean>;

package/src/config/http/epsilon-authorization-context.ts

@@ -0,0 +1,5 @@
+export interface EpsilonAuthorizationContext<T> {
+  raw: string;
+  auth: T;
+  error: string;
+}

package/src/config/http/epsilon-cors-approach.ts

@@ -0,0 +1,7 @@
+// NOTE: This is a psuedo-enum to fix some issues with Typescript enums.  See: https://exploringjs.com/tackling-ts/ch_enum-alternatives.html for details
+export const EpsilonCorsApproach = {
+  None: 'None',
+  All: 'All',
+  Reflective: 'Reflective',
+};
+export type EpsilonCorsApproach = (typeof EpsilonCorsApproach)[keyof typeof EpsilonCorsApproach];

package/src/config/http/extended-api-gateway-event.ts

@@ -0,0 +1,8 @@
+import { APIGatewayEvent } from 'aws-lambda';
+import { EpsilonAuthorizationContext } from './epsilon-authorization-context.js';
+
+export interface ExtendedAPIGatewayEvent extends APIGatewayEvent {
+  parsedBody: any;
+  authorization: EpsilonAuthorizationContext<any>;
+  convertedFromV2Event: boolean;
+}

package/src/config/http/filter-chain-context.ts

@@ -0,0 +1,15 @@
+import { Context, ProxyResult } from 'aws-lambda';
+import { ExtendedAPIGatewayEvent } from './extended-api-gateway-event.js';
+import { ModelValidator } from '@bitblit/ratchet-misc/model-validator/model-validator';
+import { AuthorizerFunction } from './authorizer-function.js';
+import { RouteAndParse } from '../../http/route/route-and-parse';
+
+export interface FilterChainContext {
+  event: ExtendedAPIGatewayEvent;
+  context: Context;
+  rawResult: any; // Result before coercion to a proxyResult
+  result: ProxyResult;
+  routeAndParse: RouteAndParse;
+  modelValidator: ModelValidator;
+  authenticators: Map<string, AuthorizerFunction>;
+}

package/src/config/http/filter-function.ts

@@ -0,0 +1,3 @@
+import { FilterChainContext } from './filter-chain-context.js';
+
+export type FilterFunction = (fCtx: FilterChainContext) => Promise<boolean>;

package/src/config/http/handler-function.ts

@@ -0,0 +1,4 @@
+import { Context } from 'aws-lambda';
+import { ExtendedAPIGatewayEvent } from './extended-api-gateway-event.js';
+
+export type HandlerFunction<T> = (event: ExtendedAPIGatewayEvent, context?: Context) => Promise<T>;

package/src/config/http/http-config.ts

@@ -0,0 +1,27 @@
+import { HandlerFunction } from './handler-function.js';
+import { AuthorizerFunction } from './authorizer-function.js';
+import { HttpProcessingConfig } from './http-processing-config.js';
+import { ModelValidator } from '@bitblit/ratchet-misc/model-validator/model-validator';
+import { MappedHttpProcessingConfig } from './mapped-http-processing-config.js';
+
+export interface HttpConfig {
+  // This is used for meta handling for any route not overridden by overrideMetaHandling
+  defaultMetaHandling: HttpProcessingConfig;
+  // Allows setting meta handling for any specific routes
+  // These are evaluated IN ORDER, to allow progressively less specific configuration
+  overrideMetaHandling?: MappedHttpProcessingConfig[];
+  // Maps routes to handlers
+  handlers: Map<string, HandlerFunction<any>>;
+  // Maps names to authorization functions
+  authorizers?: Map<string, AuthorizerFunction>;
+  // If set, paths matching the key will be dereferenced to paths on the server matching the value - use with care
+  // TODO: Implement
+  staticContentRoutes?: Record<string, string>;
+  // Should typically be your stage name, but can be different in weird cases like custom name map
+  // These will be matched case insensitive
+  prefixesToStripBeforeRouteMatch?: string[];
+  // If set, the system will use this model validator instead of the OpenAPI one (Uncommon)
+  overrideModelValidator?: ModelValidator;
+  // These paths are expected to be handled by a filter, and therefore should not cause a parse failure
+  filterHandledRouteMatches?: string[];
+}

package/src/config/http/http-processing-config.ts

@@ -0,0 +1,23 @@
+import { NullReturnedObjectHandling } from './null-returned-object-handling.js';
+import { FilterFunction } from './filter-function.js';
+
+export interface HttpProcessingConfig {
+  // If set, used in logging to help debugging
+  configName?: string;
+  // If set, matching routes will timeout after this amount of time (with a 50x error)
+  timeoutMS: number;
+  // Mainly here so that I can define authorizers that aren't viewable in the public doc
+  overrideAuthorizerName?: string;
+  // Filters that run before the handler function (eg validation, authorization, authentication)
+  preFilters?: FilterFunction[];
+  // Filters that run after the handler function runs successfully (eg, compression, CORS)
+  postFilters?: FilterFunction[];
+  // Filters that run in case an error is thrown (eg, making 500's safe for public consumption, adding CORS headers)
+  errorFilters?: FilterFunction[];
+  // CAW: Defines what should be done if a handler function returns null
+  // Handler functions should NOT return null - API Gateway/ALB won't accept it.  But sometimes they do, so
+  // Epsilon can cleanup here.  The reason I have this in here, and not as a filter, is because a single piece
+  // of code (run-handler-as-filter) both runs the handler, and converts its result into a proxy object, which
+  // I don't want to break apart, but this has to happen between those 2 steps.
+  nullReturnedObjectHandling?: NullReturnedObjectHandling;
+}

package/src/config/http/mapped-http-processing-config.ts

@@ -0,0 +1,12 @@
+import { HttpProcessingConfig } from './http-processing-config.js';
+
+export interface MappedHttpProcessingConfig {
+  // If set and nonempty, only verbs in this list will match
+  methods?: string[];
+  // Must be set, only paths matching this regex will match
+  pathRegex: string;
+  // If true, paths NOT matching the regex are used instead of paths matching
+  invertPathMatching?: boolean;
+  // Config to use
+  config: HttpProcessingConfig;
+}

package/src/config/http/null-returned-object-handling.ts

@@ -0,0 +1,7 @@
+// NOTE: This is a psuedo-enum to fix some issues with Typescript enums.  See: https://exploringjs.com/tackling-ts/ch_enum-alternatives.html for details
+export const NullReturnedObjectHandling = {
+  Error: 'Error',
+  ConvertToEmptyString: 'ConvertToEmptyString',
+  Return404NotFoundResponse: 'Return404NotFoundResponse',
+};
+export type NullReturnedObjectHandling = (typeof NullReturnedObjectHandling)[keyof typeof NullReturnedObjectHandling];

package/src/config/inter-api/inter-api-aws-config.ts

@@ -0,0 +1,5 @@
+export interface InterApiAwsConfig {
+  localMode: boolean;
+  source: string; // used for publishing only
+  snsArn: string;
+}

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

@@ -0,0 +1,7 @@
+import { InterApiAwsConfig } from './inter-api-aws-config.js';
+import { InterApiProcessMapping } from './inter-api-process-mapping.js';
+
+export interface InterApiConfig {
+  aws: InterApiAwsConfig;
+  processMappings: InterApiProcessMapping[];
+}

package/src/config/inter-api/inter-api-process-mapping.ts

@@ -0,0 +1,11 @@
+/**
+ * When an event matching the source and type is received, the listed background types will be
+ * enqueued with the data from the inter-api block being treated as the data block of the background
+ * task
+ */
+export interface InterApiProcessMapping {
+  sourceRegex: string;
+  typeRegex: string;
+  disabled: boolean;
+  backgroundProcessTypes: string[];
+}

package/src/config/local-server/local-server-event-logging-style.ts

@@ -0,0 +1,8 @@
+// NOTE: This is a psuedo-enum to fix some issues with Typescript enums.  See: https://exploringjs.com/tackling-ts/ch_enum-alternatives.html for details
+export const LocalServerEventLoggingStyle = {
+  Full: 'Full', // Log the full event to output
+  FullWithBase64Decode: 'FullWithBase64Decode', // Log the full event and decode any base64 bodies
+  Summary: 'Summary', // Just log a summary to output
+  None: 'None', // Do not log events
+};
+export type LocalServerEventLoggingStyle = (typeof LocalServerEventLoggingStyle)[keyof typeof LocalServerEventLoggingStyle];