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

package/dist/{es/epsilon-constants.js → epsilon-constants.js}

@@ -1,8 +1,18 @@
-import { Logger } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { EsmRatchet } from '@bitblit/ratchet-common/dist/lang/esm-ratchet.js';
 export class EpsilonConstants {
-    constructor() { }
+    static EPSILON_FINDER_DYNAMIC_IMPORT_PATH_ENV_NAME = 'EPSILON_FINDER_DYNAMIC_IMPORT_PATH';
+    static EPSILON_FINDER_FUNCTION_NAME_ENV_NAME = 'EPSILON_FINDER_FUNCTION_NAME';
+    static DEFAULT_EPSILON_FINDER_DYNAMIC_IMPORT_PATH = 'epsilon-global-handler-provider.js';
+    static DEFAULT_EPSILON_FINDER_FUNCTION_NAME = 'findEpsilonGlobalHandler';
+    static AUTH_HEADER_PREFIX = 'Bearer ';
+    static AUTH_HEADER_NAME = 'Authorization';
+    static BACKGROUND_SQS_TYPE_FIELD = 'BACKGROUND_TYPE';
+    static BACKGROUND_SNS_START_MARKER = 'BACKGROUND_START_MARKER';
+    static BACKGROUND_SNS_IMMEDIATE_RUN_FLAG = 'BACKGROUND_IMMEDIATE_RUN_FLAG';
+    static INTER_API_SNS_EVENT = 'EPSILON_INTER_API_EVENT';
     static load(filePath, className) {
-        Logger.info('Searching for %s : %s : %s', filePath, className, __dirname);
+        Logger.info('Searching for %s : %s : %s', filePath, className, EsmRatchet.fetchDirName());
         let rval = null;
         const val = require(filePath);
         if (val) {
@@ -32,14 +42,5 @@ export class EpsilonConstants {
         }
         return rval;
     }
+    constructor() { }
 }
-EpsilonConstants.EPSILON_FINDER_DYNAMIC_IMPORT_PATH_ENV_NAME = 'EPSILON_FINDER_DYNAMIC_IMPORT_PATH';
-EpsilonConstants.EPSILON_FINDER_FUNCTION_NAME_ENV_NAME = 'EPSILON_FINDER_FUNCTION_NAME';
-EpsilonConstants.DEFAULT_EPSILON_FINDER_DYNAMIC_IMPORT_PATH = 'epsilon-global-handler-provider.js';
-EpsilonConstants.DEFAULT_EPSILON_FINDER_FUNCTION_NAME = 'findEpsilonGlobalHandler';
-EpsilonConstants.AUTH_HEADER_PREFIX = 'Bearer ';
-EpsilonConstants.AUTH_HEADER_NAME = 'Authorization';
-EpsilonConstants.BACKGROUND_SQS_TYPE_FIELD = 'BACKGROUND_TYPE';
-EpsilonConstants.BACKGROUND_SNS_START_MARKER = 'BACKGROUND_START_MARKER';
-EpsilonConstants.BACKGROUND_SNS_IMMEDIATE_RUN_FLAG = 'BACKGROUND_IMMEDIATE_RUN_FLAG';
-EpsilonConstants.INTER_API_SNS_EVENT = 'EPSILON_INTER_API_EVENT';

package/dist/{types/epsilon-global-handler.d.ts → epsilon-global-handler.d.ts}

@@ -1,10 +1,7 @@
 import { Context, ProxyResult } from 'aws-lambda';
-import { BackgroundEntry } from './background/background-entry';
-import { EpsilonInstance } from './epsilon-instance';
-import { LoggerOptions } from '@bitblit/ratchet-common';
-/**
- * This class functions as the adapter from a default Lambda function to the handlers exposed via Epsilon
- */
+import { BackgroundEntry } from './background/background-entry.js';
+import { EpsilonInstance } from './epsilon-instance.js';
+import { LoggerOptions } from '@bitblit/ratchet-common/dist/logger/logger-options.js';
 export declare class EpsilonGlobalHandler {
     private _epsilon;
     private static LOGGER_CONFIGURED;

package/dist/{es/epsilon-global-handler.js → epsilon-global-handler.js}

@@ -1,23 +1,35 @@
-import { Logger } from '@bitblit/ratchet-common';
-import { EventUtil } from './http/event-util';
-import { TimeoutToken } from '@bitblit/ratchet-common';
-import { PromiseRatchet } from '@bitblit/ratchet-common';
-import { ResponseUtil } from './http/response-util';
-import { EpsilonHttpError } from './http/error/epsilon-http-error';
-import { RequestTimeoutError } from './http/error/request-timeout-error';
-import { ErrorRatchet, LoggerLevelName, LoggerOutputFunction, LogMessageFormatType, } from '@bitblit/ratchet-common';
-import { ContextUtil } from './util/context-util';
-import { WebV2Handler } from './http/web-v2-handler';
-import { InterApiEpsilonLambdaEventHandler } from './lambda-event-handler/inter-api-epsilon-lambda-event-handler';
-import { GenericSnsEpsilonLambdaEventHandler } from './lambda-event-handler/generic-sns-epsilon-lambda-event-handler';
-import { CronEpsilonLambdaEventHandler } from './lambda-event-handler/cron-epsilon-lambda-event-handler';
-import { S3EpsilonLambdaEventHandler } from './lambda-event-handler/s3-epsilon-lambda-event-handler';
-import { DynamoEpsilonLambdaEventHandler } from './lambda-event-handler/dynamo-epsilon-lambda-event-handler';
-import { EpsilonLoggingExtensionProcessor } from './epsilon-logging-extension-processor';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { EventUtil } from './http/event-util.js';
+import { ErrorRatchet } from '@bitblit/ratchet-common/dist/lang/error-ratchet.js';
+import { LoggerLevelName } from '@bitblit/ratchet-common/dist/logger/logger-level-name.js';
+import { LogMessageFormatType } from '@bitblit/ratchet-common/dist/logger/log-message-format-type.js';
+import { PromiseRatchet } from '@bitblit/ratchet-common/dist/lang/promise-ratchet.js';
+import { TimeoutToken } from '@bitblit/ratchet-common/dist/lang/timeout-token.js';
+import { ResponseUtil } from './http/response-util.js';
+import { EpsilonHttpError } from './http/error/epsilon-http-error.js';
+import { RequestTimeoutError } from './http/error/request-timeout-error.js';
+import { ContextUtil } from './util/context-util.js';
+import { WebV2Handler } from './http/web-v2-handler.js';
+import { InterApiEpsilonLambdaEventHandler } from './lambda-event-handler/inter-api-epsilon-lambda-event-handler.js';
+import { GenericSnsEpsilonLambdaEventHandler } from './lambda-event-handler/generic-sns-epsilon-lambda-event-handler.js';
+import { CronEpsilonLambdaEventHandler } from './lambda-event-handler/cron-epsilon-lambda-event-handler.js';
+import { S3EpsilonLambdaEventHandler } from './lambda-event-handler/s3-epsilon-lambda-event-handler.js';
+import { DynamoEpsilonLambdaEventHandler } from './lambda-event-handler/dynamo-epsilon-lambda-event-handler.js';
+import { EpsilonLoggingExtensionProcessor } from './epsilon-logging-extension-processor.js';
+import { LoggerOutputFunction } from '@bitblit/ratchet-common/dist/logger/logger-output-function.js';
 export class EpsilonGlobalHandler {
+    _epsilon;
+    static LOGGER_CONFIGURED = false;
+    static GLOBAL_INSTANCE_PROVIDER;
+    static set globalInstanceProvider(input) {
+        EpsilonGlobalHandler.GLOBAL_INSTANCE_PROVIDER = input;
+    }
+    static get globalInstanceProvider() {
+        return EpsilonGlobalHandler.GLOBAL_INSTANCE_PROVIDER;
+    }
+    handlers = null;
     constructor(_epsilon) {
         this._epsilon = _epsilon;
-        this.handlers = null;
         if (!EpsilonGlobalHandler.LOGGER_CONFIGURED) {
             EpsilonGlobalHandler.configureDefaultLogger();
             Logger.info('EpsilonLoggingConfiguration:Default logger configured');
@@ -36,12 +48,6 @@ export class EpsilonGlobalHandler {
             new DynamoEpsilonLambdaEventHandler(this._epsilon),
         ];
     }
-    static set globalInstanceProvider(input) {
-        EpsilonGlobalHandler.GLOBAL_INSTANCE_PROVIDER = input;
-    }
-    static get globalInstanceProvider() {
-        return EpsilonGlobalHandler.GLOBAL_INSTANCE_PROVIDER;
-    }
     static configureDefaultLogger(overrides) {
         const output = overrides ? Object.assign({}, overrides) : {};
         output.initialLevel = output.initialLevel ?? LoggerLevelName.info;
@@ -146,4 +152,3 @@ export class EpsilonGlobalHandler {
         return rval;
     }
 }
-EpsilonGlobalHandler.LOGGER_CONFIGURED = false;

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

@@ -1,14 +1,9 @@
-import { EpsilonConfig } from './config/epsilon-config';
-import { WebHandler } from './http/web-handler';
-import { BackgroundHandler } from './background/background-handler';
-import { OpenApiDocument } from './config/open-api/open-api-document';
-import { ModelValidator } from '@bitblit/ratchet-misc';
-import { BackgroundManagerLike } from './background/manager/background-manager-like';
-/**
- * This interface just wraps up everything that gets created by the config parsing process so that
- * I can hand it in a neat package to EpsilonGlobalHandler, rather than passing in a bunch of
- * params on the constructor
- */
+import { EpsilonConfig } from './config/epsilon-config.js';
+import { WebHandler } from './http/web-handler.js';
+import { BackgroundHandler } from './background/background-handler.js';
+import { OpenApiDocument } from './config/open-api/open-api-document.js';
+import { ModelValidator } from '@bitblit/ratchet-misc/dist/model-validator/model-validator.js';
+import { BackgroundManagerLike } from './background/manager/background-manager-like.js';
 export interface EpsilonInstance {
     config: EpsilonConfig;
     parsedOpenApiDoc: OpenApiDocument;

package/dist/epsilon-logging-extension-processor.d.ts

@@ -0,0 +1,6 @@
+import { LogMessage } from '@bitblit/ratchet-common/dist/logger/log-message.js';
+import { LogMessageProcessor } from '@bitblit/ratchet-common/dist/logger/log-message-processor.js';
+export declare class EpsilonLoggingExtensionProcessor implements LogMessageProcessor {
+    process(msg: LogMessage): LogMessage;
+    label(): string;
+}

package/dist/{es/epsilon-logging-extension-processor.js → epsilon-logging-extension-processor.js}

@@ -1,4 +1,4 @@
-import { ContextUtil } from './util/context-util';
+import { ContextUtil } from './util/context-util.js';
 export class EpsilonLoggingExtensionProcessor {
     process(msg) {
         msg.params = Object.assign({}, msg.params || {}, ContextUtil.fetchLogVariables());

package/dist/{types/http → http}/auth/api-gateway-adapter-authentication-handler.d.ts

@@ -1,17 +1,7 @@
 import { Callback, Context, CustomAuthorizerEvent } from 'aws-lambda';
-/**
- * This class is to simplify if the user wants to use a AWS Gateway authorizer in conjunction with Epsilon
- */
 export declare class ApiGatewayAdapterAuthenticationHandler {
     private webTokenManipulator;
     constructor(issuer: string, encryptionKeys: string);
-    /**
-     * This is the default authorizer - parses the incoming JWT token and sticks it
-     * into context (or blocks if none/invalid found)
-     * @param event
-     * @param {Context} context
-     * @param {Callback} callback
-     */
     lambdaHandler(event: CustomAuthorizerEvent, context: Context, callback: Callback): void;
     private createPolicy;
     static extractTokenStringFromAuthorizerEvent(event: CustomAuthorizerEvent): string;

package/dist/{es/http → http}/auth/api-gateway-adapter-authentication-handler.js

@@ -1,7 +1,8 @@
-import { Logger } from '@bitblit/ratchet-common';
-import { LocalWebTokenManipulator } from './local-web-token-manipulator';
-import { EpsilonConstants } from '../../epsilon-constants';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { LocalWebTokenManipulator } from './local-web-token-manipulator.js';
+import { EpsilonConstants } from '../../epsilon-constants.js';
 export class ApiGatewayAdapterAuthenticationHandler {
+    webTokenManipulator;
     constructor(issuer, encryptionKeys) {
         this.webTokenManipulator = new LocalWebTokenManipulator([encryptionKeys], issuer);
     }

package/dist/{types/http → http}/auth/auth0-web-token-manipulator.d.ts

@@ -1,5 +1,5 @@
-import { JwtTokenBase } from '@bitblit/ratchet-common';
-import { WebTokenManipulator } from './web-token-manipulator';
+import { JwtTokenBase } from '@bitblit/ratchet-common/dist/jwt/jwt-token-base.js';
+import { WebTokenManipulator } from './web-token-manipulator.js';
 export declare class Auth0WebTokenManipulator implements WebTokenManipulator<JwtTokenBase> {
     private clientId;
     private jwksUri;

package/dist/{es/http → http}/auth/auth0-web-token-manipulator.js

@@ -1,7 +1,12 @@
-import { Logger, StringRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { StringRatchet } from '@bitblit/ratchet-common/dist/lang/string-ratchet.js';
 import jwt from 'jsonwebtoken';
 import jwks from 'jwks-rsa';
 export class Auth0WebTokenManipulator {
+    clientId;
+    jwksUri;
+    issuer;
+    jwksClient;
     constructor(clientId, jwksUri, issuer) {
         this.clientId = clientId;
         this.jwksUri = jwksUri;

package/dist/{types/http → http}/auth/basic-auth-token.d.ts

@@ -1,6 +1,3 @@
-/**
- * Simple decoding of a Basic Authorization header
- */
 export interface BasicAuthToken {
     username: string;
     password: string;

package/dist/{types/http → http}/auth/google-web-token-manipulator.d.ts

@@ -1,5 +1,5 @@
-import { WebTokenManipulator } from './web-token-manipulator';
-import { JwtTokenBase } from '@bitblit/ratchet-common';
+import { WebTokenManipulator } from './web-token-manipulator.js';
+import { JwtTokenBase } from '@bitblit/ratchet-common/dist/jwt/jwt-token-base.js';
 export declare class GoogleWebTokenManipulator implements WebTokenManipulator<JwtTokenBase> {
     private clientId;
     private static readonly GOOGLE_DISCOVERY_DOCUMENT;

package/dist/{es/http → http}/auth/google-web-token-manipulator.js

@@ -1,9 +1,13 @@
-import { Logger } from '@bitblit/ratchet-common';
-import { StringRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { StringRatchet } from '@bitblit/ratchet-common/dist/lang/string-ratchet.js';
 import jwt from 'jsonwebtoken';
 import jwks from 'jwks-rsa';
 import fetch from 'cross-fetch';
 export class GoogleWebTokenManipulator {
+    clientId;
+    static GOOGLE_DISCOVERY_DOCUMENT = 'https://accounts.google.com/.well-known/openid-configuration';
+    cacheGoogleDiscoveryDocument;
+    jwksClient;
     constructor(clientId) {
         this.clientId = clientId;
     }
@@ -64,4 +68,3 @@ export class GoogleWebTokenManipulator {
         return this.cacheGoogleDiscoveryDocument;
     }
 }
-GoogleWebTokenManipulator.GOOGLE_DISCOVERY_DOCUMENT = 'https://accounts.google.com/.well-known/openid-configuration';

package/dist/http/auth/google-web-token-manipulator.spec.js

@@ -0,0 +1,10 @@
+import { GoogleWebTokenManipulator } from './google-web-token-manipulator.js';
+describe('#googleWebTokenManipulator', function () {
+    xit('should extract a token', async () => {
+        const token = 'TOKEN_HERE';
+        const clientId = 'CLIENT_HERE';
+        const svc = new GoogleWebTokenManipulator(clientId);
+        const res = await svc.parseAndValidateGoogleToken(token, false);
+        expect(res).toBeTruthy();
+    });
+});

package/dist/{types/http → http}/auth/jwt-ratchet-local-web-token-manipulator.d.ts

@@ -1,8 +1,6 @@
-import { WebTokenManipulator } from './web-token-manipulator';
-import { JwtRatchetLike, JwtTokenBase } from '@bitblit/ratchet-common';
-/**
- * Service for handling jwt tokens
- */
+import { WebTokenManipulator } from './web-token-manipulator.js';
+import { JwtTokenBase } from '@bitblit/ratchet-common/dist/jwt/jwt-token-base.js';
+import { JwtRatchetLike } from '@bitblit/ratchet-common/dist/jwt/jwt-ratchet-like.js';
 export declare class JwtRatchetLocalWebTokenManipulator<T extends JwtTokenBase> implements WebTokenManipulator<T> {
     private _jwtRatchet;
     private _issuer;

package/dist/{es/http → http}/auth/jwt-ratchet-local-web-token-manipulator.js

@@ -1,7 +1,9 @@
-import { StringRatchet } from '@bitblit/ratchet-common';
-import { RequireRatchet } from '@bitblit/ratchet-common';
-import { ExpiredJwtHandling } from '@bitblit/ratchet-common';
+import { StringRatchet } from '@bitblit/ratchet-common/dist/lang/string-ratchet.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/dist/lang/require-ratchet.js';
+import { ExpiredJwtHandling } from '@bitblit/ratchet-common/dist/jwt/expired-jwt-handling.js';
 export class JwtRatchetLocalWebTokenManipulator {
+    _jwtRatchet;
+    _issuer;
     constructor(_jwtRatchet, _issuer) {
         this._jwtRatchet = _jwtRatchet;
         this._issuer = _issuer;

package/dist/{types/http → http}/auth/local-web-token-manipulator.d.ts

@@ -1,8 +1,7 @@
-import { WebTokenManipulator } from './web-token-manipulator';
-import { JwtRatchet, JwtTokenBase, LoggerLevelName } from '@bitblit/ratchet-common';
-/**
- * Service for handling jwt tokens
- */
+import { WebTokenManipulator } from './web-token-manipulator.js';
+import { LoggerLevelName } from '@bitblit/ratchet-common/dist/logger/logger-level-name.js';
+import { JwtTokenBase } from '@bitblit/ratchet-common/dist/jwt/jwt-token-base.js';
+import { JwtRatchet } from '@bitblit/ratchet-common/dist/jwt/jwt-ratchet.js';
 export declare class LocalWebTokenManipulator<T extends JwtTokenBase> implements WebTokenManipulator<T> {
     private encryptionKeys;
     private issuer;

package/dist/{es/http → http}/auth/local-web-token-manipulator.js

@@ -1,9 +1,13 @@
-import { Logger } from '@bitblit/ratchet-common';
-import { UnauthorizedError } from '../error/unauthorized-error';
-import { StringRatchet } from '@bitblit/ratchet-common';
-import { RequireRatchet } from '@bitblit/ratchet-common';
-import { ExpiredJwtHandling, JwtRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { UnauthorizedError } from '../error/unauthorized-error.js';
+import { StringRatchet } from '@bitblit/ratchet-common/dist/lang/string-ratchet.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/dist/lang/require-ratchet.js';
+import { JwtRatchet } from '@bitblit/ratchet-common/dist/jwt/jwt-ratchet.js';
+import { ExpiredJwtHandling } from '@bitblit/ratchet-common/dist/jwt/expired-jwt-handling.js';
 export class LocalWebTokenManipulator {
+    encryptionKeys;
+    issuer;
+    _ratchet;
     constructor(encryptionKeys, issuer) {
         this.encryptionKeys = encryptionKeys;
         this.issuer = issuer;

package/dist/http/auth/local-web-token-manipulator.spec.js

@@ -0,0 +1,24 @@
+import { LocalWebTokenManipulator } from './local-web-token-manipulator.js';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { LoggerLevelName } from '@bitblit/ratchet-common/dist/logger/logger-level-name.js';
+describe('#localWebTokenManipulator', function () {
+    it('should round trip a JWT token', async () => {
+        const svc = new LocalWebTokenManipulator(['1234567890'], 'test')
+            .withParseFailureLogLevel(LoggerLevelName.info)
+            .withExtraDecryptionKeys(['abcdefabcdef'])
+            .withOldKeyUseLogLevel(LoggerLevelName.info);
+        const testUser = {
+            data1: 'test',
+            data2: 15,
+        };
+        const token = await svc.createJWTStringAsync('test123@test.com', testUser);
+        Logger.info('Generated token : %s', token);
+        expect(token).toBeTruthy();
+        const outputUser = await svc.parseAndValidateJWTStringAsync(token);
+        Logger.info('Got result : %j', outputUser);
+        expect(outputUser).toBeTruthy();
+        expect(outputUser.user).toBeTruthy();
+        expect(outputUser.user['data1']).toEqual(testUser.data1);
+        expect(outputUser.user['data2']).toEqual(testUser.data2);
+    });
+});

package/dist/{types/http → http}/auth/web-token-manipulator.d.ts

@@ -1,7 +1,4 @@
-/**
- * Service for handling auth tokens
- */
-import { JwtTokenBase } from '@bitblit/ratchet-common';
+import { JwtTokenBase } from '@bitblit/ratchet-common/dist/jwt/jwt-token-base.js';
 export interface WebTokenManipulator<T extends JwtTokenBase> {
     extractTokenFromAuthorizationHeader(header: string): Promise<T>;
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,9 +1,16 @@
 import util from 'util';
-import { NumberRatchet } from '@bitblit/ratchet-common';
+import { NumberRatchet } from '@bitblit/ratchet-common/dist/lang/number-ratchet.js';
 export class EpsilonHttpError extends Error {
+    static EPSILON_HTTP_ERROR_FLAG_KEY = '__epsilonHttpErrorFlag';
+    _httpStatusCode = 500;
+    _errors;
+    _detailErrorCode;
+    _endUserErrors;
+    _details;
+    _requestId;
+    _wrappedError;
     constructor(...errors) {
         super(EpsilonHttpError.combineErrorStringsWithDefault(errors));
-        this._httpStatusCode = 500;
         Object.setPrototypeOf(this, EpsilonHttpError.prototype);
         this._errors = errors;
         this[EpsilonHttpError.EPSILON_HTTP_ERROR_FLAG_KEY] = true;
@@ -124,4 +131,3 @@ export class EpsilonHttpError extends Error {
         return EpsilonHttpError.errorIsX0x(err, 5);
     }
 }
-EpsilonHttpError.EPSILON_HTTP_ERROR_FLAG_KEY = '__epsilonHttpErrorFlag';

package/dist/http/error/epsilon-http-error.spec.js

@@ -0,0 +1,11 @@
+import { EpsilonHttpError } from './epsilon-http-error.js';
+describe('#epsilonHttpError', function () {
+    it('chould check if the error is a given class', async () => {
+        const testError = new EpsilonHttpError('test').withHttpStatusCode(404);
+        const nonHttpError = new Error('Not HTTP');
+        expect(EpsilonHttpError.errorIs40x(testError)).toBeTruthy();
+        expect(EpsilonHttpError.errorIs50x(testError)).toBeFalsy();
+        expect(EpsilonHttpError.errorIs40x(nonHttpError)).toBeFalsy();
+        expect(EpsilonHttpError.errorIs50x(testError)).toBeFalsy();
+    });
+});

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

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

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

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

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

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

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

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

package/dist/{types/http → http}/error/method-not-allowed-error.d.ts

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

package/dist/{es/http → http}/error/method-not-allowed-error.js

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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