@bitblit/ratchet-epsilon-common 4.0.99-alpha → 4.0.103-alpha

package/{dist/types → lib}/built-in/daemon/daemon-authorizer-function.d.ts

@@ -1,5 +1,5 @@
-import { DaemonProcessState } from '@bitblit/ratchet-aws';
-import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event';
+import { DaemonProcessState } from '@bitblit/ratchet-aws/lib/daemon/daemon-process-state.js';
+import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event.js';
 export interface DaemonAuthorizerFunction {
     (evt: ExtendedAPIGatewayEvent, proc: DaemonProcessState): Promise<boolean>;
 }

package/{dist/types → lib}/built-in/daemon/daemon-config.d.ts

@@ -1,5 +1,5 @@
-import { DaemonAuthorizerFunction } from './daemon-authorizer-function';
-import { DaemonGroupSelectionFunction } from './daemon-group-selection-function';
+import { DaemonAuthorizerFunction } from './daemon-authorizer-function.js';
+import { DaemonGroupSelectionFunction } from './daemon-group-selection-function.js';
 export interface DaemonConfig {
     authorizer?: DaemonAuthorizerFunction;
     groupSelector?: DaemonGroupSelectionFunction;

package/{dist/types → lib}/built-in/daemon/daemon-group-selection-function.d.ts

@@ -1,4 +1,4 @@
-import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event';
+import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event.js';
 export interface DaemonGroupSelectionFunction {
     (evt: ExtendedAPIGatewayEvent): Promise<string>;
 }

package/{dist/types → lib}/built-in/daemon/daemon-handler.d.ts

@@ -1,20 +1,14 @@
-import { DaemonProcessState } from '@bitblit/ratchet-aws';
-import { DaemonAuthorizerFunction } from './daemon-authorizer-function';
-import { DaemonLike } from '@bitblit/ratchet-aws';
-import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event';
-import { DaemonProcessStateList } from './daemon-process-state-list';
-import { DaemonConfig } from './daemon-config';
-/**
- * A helper class to simplify adding Ratchet "Daemon" handling to your application
- */
+import { DaemonLike } from '@bitblit/ratchet-aws/lib/daemon/daemon-like.js';
+import { DaemonProcessState } from '@bitblit/ratchet-aws/lib/daemon/daemon-process-state.js';
+import { DaemonAuthorizerFunction } from './daemon-authorizer-function.js';
+import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event.js';
+import { DaemonProcessStateList } from './daemon-process-state-list.js';
+import { DaemonConfig } from './daemon-config.js';
 export declare class DaemonHandler {
     private daemon;
     private inConfig?;
     static readonly ALLOW_EVERYTHING_AUTHORIZER: DaemonAuthorizerFunction;
     private config;
-    /**
-     * Initialize the Router
-     */
     constructor(daemon: DaemonLike, inConfig?: DaemonConfig);
     fetchDaemonStatusByPublicToken(evt: ExtendedAPIGatewayEvent): Promise<DaemonProcessState>;
     fetchDaemonStatus(evt: ExtendedAPIGatewayEvent): Promise<DaemonProcessState>;

package/{dist/es → lib}/built-in/daemon/daemon-handler.js

@@ -1,8 +1,13 @@
-var _a;
-import { Logger } from '@bitblit/ratchet-common';
-import { NotFoundError } from '../../http/error/not-found-error';
-import { StringRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { NotFoundError } from '../../http/error/not-found-error.js';
+import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
 export class DaemonHandler {
+    daemon;
+    inConfig;
+    static ALLOW_EVERYTHING_AUTHORIZER = async (evt, proc) => {
+        return true;
+    };
+    config;
     constructor(daemon, inConfig) {
         this.daemon = daemon;
         this.inConfig = inConfig;
@@ -52,7 +57,3 @@ export class DaemonHandler {
         return rval;
     }
 }
-_a = DaemonHandler;
-DaemonHandler.ALLOW_EVERYTHING_AUTHORIZER = async (evt, proc) => {
-    return true;
-};

package/lib/built-in/daemon/daemon-process-state-list.d.ts

@@ -0,0 +1,5 @@
+import { DaemonProcessState } from '@bitblit/ratchet-aws/lib/daemon/daemon-process-state.js';
+export interface DaemonProcessStateList {
+    results: DaemonProcessState[];
+    nextToken: string;
+}

package/{dist/types → lib}/built-in/http/apollo-filter.d.ts

@@ -1,7 +1,7 @@
 import { APIGatewayEvent, Context, ProxyResult } from 'aws-lambda';
 import { ApolloServer, CreateHandlerOptions } from 'apollo-server-lambda';
-import { FilterFunction } from '../../config/http/filter-function';
-import { FilterChainContext } from '../../config/http/filter-chain-context';
+import { FilterFunction } from '../../config/http/filter-function.js';
+import { FilterChainContext } from '../../config/http/filter-chain-context.js';
 export declare class ApolloFilter {
     private static CACHE_APOLLO_HANDLER;
     static handlePathWithApollo(fCtx: FilterChainContext, apolloPathRegex: RegExp, apolloServer: ApolloServer, createHandlerOptions: CreateHandlerOptions): Promise<boolean>;

package/{dist/es → lib}/built-in/http/apollo-filter.js

@@ -1,9 +1,10 @@
-import { Logger } from '@bitblit/ratchet-common';
-import { PromiseRatchet } from '@bitblit/ratchet-common';
-import { TimeoutToken } from '@bitblit/ratchet-common';
-import { RequestTimeoutError } from '../../http/error/request-timeout-error';
-import { StringRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { PromiseRatchet } from '@bitblit/ratchet-common/lib/lang/promise-ratchet.js';
+import { TimeoutToken } from '@bitblit/ratchet-common/lib/lang/timeout-token.js';
+import { RequestTimeoutError } from '../../http/error/request-timeout-error.js';
+import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
 export class ApolloFilter {
+    static CACHE_APOLLO_HANDLER;
     static async handlePathWithApollo(fCtx, apolloPathRegex, apolloServer, createHandlerOptions) {
         if (fCtx.event?.path && apolloPathRegex && apolloPathRegex.test(fCtx.event.path)) {
             fCtx.result = await ApolloFilter.processApolloRequest(fCtx.event, fCtx.context, apolloServer, createHandlerOptions);

package/{dist/types → lib}/built-in/http/built-in-auth-filters.d.ts

@@ -1,6 +1,6 @@
-import { FilterChainContext } from '../../config/http/filter-chain-context';
-import { WebTokenManipulator } from '../../http/auth/web-token-manipulator';
-import { JwtTokenBase } from '@bitblit/ratchet-common';
+import { FilterChainContext } from '../../config/http/filter-chain-context.js';
+import { WebTokenManipulator } from '../../http/auth/web-token-manipulator.js';
+import { JwtTokenBase } from '@bitblit/ratchet-common/lib/jwt/jwt-token-base.js';
 export declare class BuiltInAuthFilters {
     static requireAllRolesInCommonJwt(fCtx: FilterChainContext, requiredRoleAllOf: string[]): Promise<boolean>;
     static requireAnyRoleInCommonJwt(fCtx: FilterChainContext, requiredRoleOneOf: string[]): Promise<boolean>;

package/{dist/es → lib}/built-in/http/built-in-auth-filters.js

@@ -1,8 +1,8 @@
-import { StringRatchet } from '@bitblit/ratchet-common';
-import { UnauthorizedError } from '../../http/error/unauthorized-error';
-import { MisconfiguredError } from '../../http/error/misconfigured-error';
-import { ForbiddenError } from '../../http/error/forbidden-error';
-import { EventUtil } from '../../http/event-util';
+import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
+import { UnauthorizedError } from '../../http/error/unauthorized-error.js';
+import { MisconfiguredError } from '../../http/error/misconfigured-error.js';
+import { ForbiddenError } from '../../http/error/forbidden-error.js';
+import { EventUtil } from '../../http/event-util.js';
 export class BuiltInAuthFilters {
     static async requireAllRolesInCommonJwt(fCtx, requiredRoleAllOf) {
         if (!requiredRoleAllOf || requiredRoleAllOf.length === 0) {

package/{dist/types → lib}/built-in/http/built-in-authorizers.d.ts

@@ -1,6 +1,6 @@
 import { APIGatewayEvent } from 'aws-lambda';
-import { RouteMapping } from '../../http/route/route-mapping';
-import { EpsilonAuthorizationContext } from '../../config/http/epsilon-authorization-context';
+import { RouteMapping } from '../../http/route/route-mapping.js';
+import { EpsilonAuthorizationContext } from '../../config/http/epsilon-authorization-context.js';
 export declare class BuiltInAuthorizers {
     static simpleNoAuthenticationLogAccess(authorizationContext: EpsilonAuthorizationContext<any>, evt: APIGatewayEvent): Promise<boolean>;
     static simpleLoggedInAuth(authorizationContext: EpsilonAuthorizationContext<any>, evt: APIGatewayEvent): Promise<boolean>;

package/{dist/es → lib}/built-in/http/built-in-authorizers.js

@@ -1,4 +1,4 @@
-import { Logger } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
 export class BuiltInAuthorizers {
     static async simpleNoAuthenticationLogAccess(authorizationContext, evt) {
         Logger.debug('Auth requested for %s : %j', evt.path, authorizationContext?.auth);

package/{dist/types → lib}/built-in/http/built-in-filters.d.ts

@@ -1,5 +1,5 @@
-import { FilterFunction } from '../../config/http/filter-function';
-import { FilterChainContext } from '../../config/http/filter-chain-context';
+import { FilterFunction } from '../../config/http/filter-function.js';
+import { FilterChainContext } from '../../config/http/filter-chain-context.js';
 export declare class BuiltInFilters {
     static readonly MAXIMUM_LAMBDA_BODY_SIZE_BYTES: number;
     static combineFilters(fCtx: FilterChainContext, filters: FilterFunction[]): Promise<boolean>;

package/{dist/es → lib}/built-in/http/built-in-filters.js

@@ -1,12 +1,13 @@
-import { Logger } from '@bitblit/ratchet-common';
-import { StringRatchet } from '@bitblit/ratchet-common';
-import { MapRatchet } from '@bitblit/ratchet-common';
-import { EventUtil } from '../../http/event-util';
-import { BadRequestError } from '../../http/error/bad-request-error';
-import { ResponseUtil } from '../../http/response-util';
-import { EpsilonHttpError } from '../../http/error/epsilon-http-error';
-import { MisconfiguredError } from '../../http/error/misconfigured-error';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
+import { MapRatchet } from '@bitblit/ratchet-common/lib/lang/map-ratchet.js';
+import { EventUtil } from '../../http/event-util.js';
+import { BadRequestError } from '../../http/error/bad-request-error.js';
+import { ResponseUtil } from '../../http/response-util.js';
+import { EpsilonHttpError } from '../../http/error/epsilon-http-error.js';
+import { MisconfiguredError } from '../../http/error/misconfigured-error.js';
 export class BuiltInFilters {
+    static MAXIMUM_LAMBDA_BODY_SIZE_BYTES = 1024 * 1024 * 5 - 1024 * 100;
     static async combineFilters(fCtx, filters) {
         let cont = true;
         if (filters && filters.length > 0) {
@@ -205,4 +206,3 @@ export class BuiltInFilters {
         return true;
     }
 }
-BuiltInFilters.MAXIMUM_LAMBDA_BODY_SIZE_BYTES = 1024 * 1024 * 5 - 1024 * 100;

package/{dist/types → lib}/built-in/http/built-in-handlers.d.ts

@@ -1,6 +1,6 @@
 import { APIGatewayEvent, Context } from 'aws-lambda';
-import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event';
-import { EpsilonRouter } from '../../http/route/epsilon-router';
+import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event.js';
+import { EpsilonRouter } from '../../http/route/epsilon-router.js';
 export declare class BuiltInHandlers {
     static expectedHandledByFilter(evt: ExtendedAPIGatewayEvent, flag?: string): Promise<any>;
     static handleNotImplemented(evt: ExtendedAPIGatewayEvent, flag?: string): Promise<any>;

package/{dist/es → lib}/built-in/http/built-in-handlers.js

@@ -1,13 +1,13 @@
-import { StringRatchet } from '@bitblit/ratchet-common';
-import { Logger } from '@bitblit/ratchet-common';
-import { NumberRatchet } from '@bitblit/ratchet-common';
-import { BadRequestError } from '../../http/error/bad-request-error';
-import { EpsilonHttpError } from '../../http/error/epsilon-http-error';
-import { UnauthorizedError } from '../../http/error/unauthorized-error';
-import { NotFoundError } from '../../http/error/not-found-error';
-import { ForbiddenError } from '../../http/error/forbidden-error';
-import { NotImplemented } from '../../http/error/not-implemented';
-import { MisconfiguredError } from '../../http/error/misconfigured-error';
+import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { NumberRatchet } from '@bitblit/ratchet-common/lib/lang/number-ratchet.js';
+import { BadRequestError } from '../../http/error/bad-request-error.js';
+import { EpsilonHttpError } from '../../http/error/epsilon-http-error.js';
+import { UnauthorizedError } from '../../http/error/unauthorized-error.js';
+import { NotFoundError } from '../../http/error/not-found-error.js';
+import { ForbiddenError } from '../../http/error/forbidden-error.js';
+import { NotImplemented } from '../../http/error/not-implemented.js';
+import { MisconfiguredError } from '../../http/error/misconfigured-error.js';
 export class BuiltInHandlers {
     static async expectedHandledByFilter(evt, flag) {
         throw new MisconfiguredError().withFormattedErrorMessage('Should not happen - it was expected that route %s would be handled by a filter', evt.path);

package/{dist/types → lib}/built-in/http/log-level-manipulation-filter.d.ts

@@ -1,7 +1,4 @@
-import { FilterChainContext } from '../../config/http/filter-chain-context';
-/**
- * This only works because Node is single threaded...
- */
+import { FilterChainContext } from '../../config/http/filter-chain-context.js';
 export declare class LogLevelManipulationFilter {
     private static LOG_LEVEL_BEFORE_CHANGE;
     static setLogLevelForTransaction(fCtx: FilterChainContext): Promise<boolean>;

package/{dist/es → lib}/built-in/http/log-level-manipulation-filter.js

@@ -1,5 +1,6 @@
-import { Logger } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
 export class LogLevelManipulationFilter {
+    static LOG_LEVEL_BEFORE_CHANGE = null;
     static async setLogLevelForTransaction(fCtx) {
         LogLevelManipulationFilter.LOG_LEVEL_BEFORE_CHANGE = Logger.getLevel();
         return true;
@@ -13,4 +14,3 @@ export class LogLevelManipulationFilter {
         return true;
     }
 }
-LogLevelManipulationFilter.LOG_LEVEL_BEFORE_CHANGE = null;

package/{dist/types → lib}/built-in/http/run-handler-as-filter.d.ts

@@ -1,9 +1,9 @@
 import { Context } from 'aws-lambda';
-import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event';
-import { RouteAndParse } from '../../http/web-handler';
-import { NullReturnedObjectHandling } from '../../config/http/null-returned-object-handling';
-import { FilterFunction } from '../../config/http/filter-function';
-import { FilterChainContext } from '../../config/http/filter-chain-context';
+import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event.js';
+import { RouteAndParse } from '../../http/web-handler.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';
 export declare class RunHandlerAsFilter {
     static runHandler(fCtx: FilterChainContext, rm: RouteAndParse): Promise<boolean>;
     static applyNullReturnedObjectHandling(result: any, handling: NullReturnedObjectHandling): any;

package/{dist/es → lib}/built-in/http/run-handler-as-filter.js

@@ -1,11 +1,11 @@
-import { Logger } from '@bitblit/ratchet-common';
-import { PromiseRatchet } from '@bitblit/ratchet-common';
-import { TimeoutToken } from '@bitblit/ratchet-common';
-import { RequestTimeoutError } from '../../http/error/request-timeout-error';
-import { ResponseUtil } from '../../http/response-util';
-import { NotFoundError } from '../../http/error/not-found-error';
-import { NullReturnedObjectHandling } from '../../config/http/null-returned-object-handling';
-import { EpsilonHttpError } from '../../http/error/epsilon-http-error';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { PromiseRatchet } from '@bitblit/ratchet-common/lib/lang/promise-ratchet.js';
+import { TimeoutToken } from '@bitblit/ratchet-common/lib/lang/timeout-token.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 { EpsilonHttpError } from '../../http/error/epsilon-http-error.js';
 export class RunHandlerAsFilter {
     static async runHandler(fCtx, rm) {
         const handler = RunHandlerAsFilter.findHandler(rm, fCtx.event, fCtx.context);

package/lib/built-in/http/run-handler-as-filter.spec.js

@@ -0,0 +1,40 @@
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { SampleServerComponents } from '../../sample/sample-server-components.js';
+import { RunHandlerAsFilter } from './run-handler-as-filter.js';
+import { RouterUtil } from '../../http/route/router-util.js';
+describe('#routerUtilApplyOpenApiDoc', function () {
+    it('should find the most specific route and the least specific', async () => {
+        const inst = await SampleServerComponents.createSampleEpsilonGlobalHandler('jest-most specific route');
+        expect(inst.epsilon.modelValidator).toBeTruthy();
+        const evtFixed = {
+            httpMethod: 'get',
+            path: '/v0/multi/fixed',
+            requestContext: {
+                stage: 'v0',
+            },
+            queryStringParameters: {},
+        };
+        const evtVar = {
+            httpMethod: 'get',
+            path: '/v0/multi/xyz',
+            requestContext: {
+                stage: 'v0',
+            },
+            queryStringParameters: {},
+        };
+        const findFixedRP = await inst.epsilon.webHandler.findBestMatchingRoute(evtFixed);
+        const findVariableRP = await inst.epsilon.webHandler.findBestMatchingRoute(evtVar);
+        const findFixed = await RunHandlerAsFilter.findHandler(findFixedRP, evtFixed, {}, false);
+        const findVariable = await RunHandlerAsFilter.findHandler(findVariableRP, evtVar, {}, false);
+        expect(findFixed).toBeTruthy();
+        expect(findFixed['flag']).toEqual('fixed');
+        expect(findVariable).toBeTruthy();
+        expect(findVariable['flag']).toEqual('variable');
+        Logger.info('done');
+    });
+    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 → lib}/cli-bootstrap/ratchet-cli-handler.d.ts

@@ -1,5 +1,5 @@
-import { AbstractRatchetCliHandler } from '@bitblit/ratchet-node-only';
-import { BuildInformation } from '@bitblit/ratchet-common/dist/types/build/build-information';
+import { AbstractRatchetCliHandler } from '@bitblit/ratchet-node-only/lib/cli/abstract-ratchet-cli-handler.js';
+import { BuildInformation } from '@bitblit/ratchet-common/lib/build/build-information.js';
 export declare class RatchetCliHandler extends AbstractRatchetCliHandler {
     fetchHandlerMap(): Record<string, any>;
     fetchVersionInfo(): BuildInformation;

package/{dist/es → lib}/cli-bootstrap/ratchet-cli-handler.js

@@ -1,9 +1,9 @@
-import { AbstractRatchetCliHandler } from '@bitblit/ratchet-node-only';
-import { RunBackgroundProcessFromCommandLine } from './run-background-process-from-command-line';
-import { TestErrorServer } from '../sample/test-error-server';
-import { LocalContainerServer } from '../local-container-server';
-import { RatchetEpsilonCommonInfo } from '../build/ratchet-epsilon-common-info';
-import { LocalServer } from '../local-server';
+import { AbstractRatchetCliHandler } from '@bitblit/ratchet-node-only/lib/cli/abstract-ratchet-cli-handler.js';
+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() {
         return {

package/lib/cli-bootstrap/run-background-process-from-command-line.d.ts

@@ -0,0 +1,3 @@
+export declare class RunBackgroundProcessFromCommandLine {
+    static runFromCliArgs(args: string[]): Promise<void>;
+}

package/{dist/es → lib}/cli-bootstrap/run-background-process-from-command-line.js

@@ -1,5 +1,5 @@
-import { Logger } from '@bitblit/ratchet-common';
-import { BooleanRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { BooleanRatchet } from '@bitblit/ratchet-common/lib/lang/boolean-ratchet.js';
 export class RunBackgroundProcessFromCommandLine {
     static async runFromCliArgs(args) {
         if (args.length > 1) {

package/{dist/types → lib}/config/background/background-config.d.ts

@@ -1,7 +1,7 @@
-import { BackgroundProcessor } from './background-processor';
-import { BackgroundErrorProcessor } from './background-error-processor';
-import { BackgroundExecutionListener } from '../../background/background-execution-listener';
-import { BackgroundTransactionLogger } from './background-transaction-logger';
+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;

package/{dist/types → lib}/config/background/background-error-processor.d.ts

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

package/{dist/types → lib}/config/background/background-processor.d.ts

@@ -1,4 +1,4 @@
-import { BackgroundManagerLike } from '../../background/manager/background-manager-like';
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
 export interface BackgroundProcessor<T> {
     typeName: string;
     dataSchemaName?: string;

package/{dist/types → lib}/config/background/background-transaction-log.d.ts

@@ -1,4 +1,4 @@
-import { InternalBackgroundEntry } from '../../background/internal-background-entry';
+import { InternalBackgroundEntry } from '../../background/internal-background-entry.js';
 export interface BackgroundTransactionLog {
     request: InternalBackgroundEntry<any>;
     running: boolean;

package/{dist/types → lib}/config/background/background-transaction-logger.d.ts

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

package/lib/config/cron/cron-background-entry.d.ts

@@ -0,0 +1,6 @@
+import { AbstractCronEntry } from './abstract-cron-entry.js';
+export interface CronBackgroundEntry extends AbstractCronEntry {
+    backgroundTaskType: string;
+    fireImmediate: boolean;
+    data?: any;
+}

package/{dist/types → lib}/config/cron/cron-config.d.ts

@@ -1,4 +1,4 @@
-import { CronBackgroundEntry } from './cron-background-entry';
+import { CronBackgroundEntry } from './cron-background-entry.js';
 export interface CronConfig {
     timezone: string;
     context: string;

package/{dist/types → lib}/config/dynamo-db-config.d.ts

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

package/{dist/types → lib}/config/epsilon-config.d.ts

@@ -1,11 +1,11 @@
-import { HttpConfig } from './http/http-config';
-import { BackgroundConfig } from './background/background-config';
-import { CronConfig } from './cron/cron-config';
-import { DynamoDbConfig } from './dynamo-db-config';
-import { S3Config } from './s3-config';
-import { SnsConfig } from './sns-config';
-import { EpsilonLoggerConfig } from './epsilon-logger-config';
-import { InterApiConfig } from './inter-api/inter-api-config';
+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';
 export interface EpsilonConfig {
     label?: string;
     disableLastResortTimeout?: boolean;

package/{dist/types → lib}/config/epsilon-logger-config.d.ts

@@ -1,5 +1,6 @@
-import { LoggerLevelName, LogMessageFormatType } from '@bitblit/ratchet-common';
-import { LoggingTraceIdGenerator } from './logging-trace-id-generator';
+import { LoggerLevelName } from '@bitblit/ratchet-common/lib/logger/logger-level-name.js';
+import { LogMessageFormatType } from '@bitblit/ratchet-common/lib/logger/log-message-format-type.js';
+import { LoggingTraceIdGenerator } from './logging-trace-id-generator.js';
 export interface EpsilonLoggerConfig {
     envParamLogLevelName?: string;
     queryParamLogLevelName?: string;

package/{dist/types → lib}/config/http/authorizer-function.d.ts

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

package/{dist/types → lib}/config/http/extended-api-gateway-event.d.ts

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

package/{dist/types → lib}/config/http/filter-chain-context.d.ts

@@ -1,8 +1,8 @@
 import { Context, ProxyResult } from 'aws-lambda';
-import { ExtendedAPIGatewayEvent } from './extended-api-gateway-event';
-import { RouteAndParse } from '../../http/web-handler';
-import { ModelValidator } from '@bitblit/ratchet-misc';
-import { AuthorizerFunction } from './authorizer-function';
+import { ExtendedAPIGatewayEvent } from './extended-api-gateway-event.js';
+import { RouteAndParse } from '../../http/web-handler.js';
+import { ModelValidator } from '@bitblit/ratchet-misc/lib/model-validator/model-validator.js';
+import { AuthorizerFunction } from './authorizer-function.js';
 export interface FilterChainContext {
     event: ExtendedAPIGatewayEvent;
     context: Context;

package/{dist/types → lib}/config/http/filter-function.d.ts

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

package/{dist/types → lib}/config/http/handler-function.d.ts

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

package/{dist/types → lib}/config/http/http-config.d.ts

@@ -1,8 +1,8 @@
-import { HandlerFunction } from './handler-function';
-import { AuthorizerFunction } from './authorizer-function';
-import { HttpProcessingConfig } from './http-processing-config';
-import { ModelValidator } from '@bitblit/ratchet-misc';
-import { MappedHttpProcessingConfig } from './mapped-http-processing-config';
+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/lib/model-validator/model-validator.js';
+import { MappedHttpProcessingConfig } from './mapped-http-processing-config.js';
 export interface HttpConfig {
     defaultMetaHandling: HttpProcessingConfig;
     overrideMetaHandling?: MappedHttpProcessingConfig[];

package/{dist/types → lib}/config/http/http-processing-config.d.ts

@@ -1,5 +1,5 @@
-import { NullReturnedObjectHandling } from './null-returned-object-handling';
-import { FilterFunction } from './filter-function';
+import { NullReturnedObjectHandling } from './null-returned-object-handling.js';
+import { FilterFunction } from './filter-function.js';
 export interface HttpProcessingConfig {
     configName?: string;
     timeoutMS: number;

package/{dist/types → lib}/config/http/mapped-http-processing-config.d.ts

@@ -1,4 +1,4 @@
-import { HttpProcessingConfig } from './http-processing-config';
+import { HttpProcessingConfig } from './http-processing-config.js';
 export interface MappedHttpProcessingConfig {
     methods?: string[];
     pathRegex: string;

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

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

package/lib/config/inter-api/inter-api-process-mapping.d.ts

@@ -0,0 +1,6 @@
+export interface InterApiProcessMapping {
+    sourceRegex: string;
+    typeRegex: string;
+    disabled: boolean;
+    backgroundProcessTypes: string[];
+}

package/{dist/types → lib}/config/open-api/open-api-document.d.ts

@@ -1,5 +1,5 @@
-import { OpenApiDocumentComponents } from './open-api-document-components';
-import { OpenApiDocumentPath } from './open-api-document-path';
+import { OpenApiDocumentComponents } from './open-api-document-components.js';
+import { OpenApiDocumentPath } from './open-api-document-path.js';
 export interface OpenApiDocument {
     components: OpenApiDocumentComponents;
     paths: OpenApiDocumentPath[];

package/{dist/types → lib}/config/s3-config.d.ts

@@ -1,4 +1,4 @@
-import { GenericAwsEventHandlerFunction } from './generic-aws-event-handler-function';
+import { GenericAwsEventHandlerFunction } from './generic-aws-event-handler-function.js';
 import { S3Event } from 'aws-lambda';
 export interface S3Config {
     createHandlers: Map<string, GenericAwsEventHandlerFunction<S3Event>>;

package/{dist/types → lib}/config/sns-config.d.ts

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