@my-devkit/firebase 1.0.194 → 1.0.195

package/src/decorators/controller/body.spec.ts

@@ -32,10 +32,7 @@ describe('Given a Body decorator', () => {
 
             const request1 = <any>{ body: '2021-02-08T11:14:23.318Z' };
 
-            expect(config.routes[0].argumentInjectors.length).equal(
-                1,
-                'Wrong argumentInjectors length'
-            );
+            expect(config.routes[0].argumentInjectors.length).equal(1, 'Wrong argumentInjectors length');
             expect(config.routes[0].argumentInjectors[0](request1)).to.be.a('Date');
             expect(config.routes[0].argumentInjectors[0](request1).toISOString()).equals(
                 new Date('2021-02-08T11:14:23.318Z').toISOString()
@@ -47,10 +44,7 @@ describe('Given a Body decorator', () => {
             expectedBody2.testString = 'test';
             expectedBody2.testDate = null;
 
-            expect(config.routes[1].argumentInjectors.length).equal(
-                1,
-                'Wrong argumentInjectors length'
-            );
+            expect(config.routes[1].argumentInjectors.length).equal(1, 'Wrong argumentInjectors length');
             expect(config.routes[1].argumentInjectors[0](request2)).to.be.instanceOf(Command);
             expect(config.routes[1].argumentInjectors[0](request2)).deep.equal(expectedBody2);
         });

package/src/decorators/controller/body.ts

@@ -7,17 +7,11 @@ export function Body(): ParameterDecorator {
     return (target, propertyKey, parameterIndex) => {
         const methodArguments = reflect(target, propertyKey).getParameters();
         if (!methodArguments.hasOwnProperty(parameterIndex)) {
-            throw new Error(
-                `Body: can't find argument ${parameterIndex} on ${target.constructor.name}.${propertyKey.toString()}`
-            );
+            throw new Error(`Body: can't find argument ${parameterIndex} on ${target.constructor.name}.${propertyKey.toString()}`);
         }
 
-        const injector: RequestArgumentInjector = (req: Server.Request) =>
-            deserialize(req.body, methodArguments[parameterIndex]);
+        const injector: RequestArgumentInjector = (req: Server.Request) => deserialize(req.body, methodArguments[parameterIndex]);
 
-        reflect(target, propertyKey).registerControllerRouteArgumentInjector(
-            injector,
-            parameterIndex
-        );
+        reflect(target, propertyKey).registerControllerRouteArgumentInjector(injector, parameterIndex);
     };
 }

package/src/decorators/controller/param.spec.ts

@@ -19,10 +19,7 @@ describe('Given a Param decorator', () => {
         }
 
         @Get(':gender/:minDate')
-        public getByGenderOlderThan(
-            @Param('minDate') minDate: Date,
-            @Param('gender') gender: Gender
-        ): string {
+        public getByGenderOlderThan(@Param('minDate') minDate: Date, @Param('gender') gender: Gender): string {
             return `getByGenderOlderThan: ${gender} ${minDate.toISOString()}`;
         }
     }
@@ -33,19 +30,13 @@ describe('Given a Param decorator', () => {
             expect(config.routes.length).equal(2, 'Wrong route count detected');
 
             const request1 = <any>{ params: { id: 'guid 1' } };
-            expect(config.routes[0].argumentInjectors.length).equal(
-                1,
-                'Wrong argumentInjectors length for getById'
-            );
+            expect(config.routes[0].argumentInjectors.length).equal(1, 'Wrong argumentInjectors length for getById');
             expect(config.routes[0].argumentInjectors[0](request1)).to.be.a('string');
             expect(config.routes[0].argumentInjectors[0](request1)).equals('guid 1');
 
             const request2 = <any>{ params: { gender: 0, minDate: '2021-02-15T14:23:00.318Z' } };
 
-            expect(config.routes[1].argumentInjectors.length).equal(
-                2,
-                'Wrong argumentInjectors length for getByGenderOlderThan'
-            );
+            expect(config.routes[1].argumentInjectors.length).equal(2, 'Wrong argumentInjectors length for getByGenderOlderThan');
 
             expect(config.routes[1].argumentInjectors[0](request2)).to.be.a('Date');
             expect(config.routes[1].argumentInjectors[0](request2).toISOString()).equals(

package/src/decorators/controller/param.ts

@@ -7,9 +7,7 @@ export function Param(key: string): ParameterDecorator {
     return (target, propertyKey, parameterIndex) => {
         const methodArguments = reflect(target, propertyKey).getParameters();
         if (!methodArguments.hasOwnProperty(parameterIndex)) {
-            throw new Error(
-                `Param: can't find argument ${parameterIndex} on ${target.constructor.name}.${propertyKey.toString()}`
-            );
+            throw new Error(`Param: can't find argument ${parameterIndex} on ${target.constructor.name}.${propertyKey.toString()}`);
         }
 
         const injector: RequestArgumentInjector = (req: Server.Request) => {
@@ -18,9 +16,6 @@ export function Param(key: string): ParameterDecorator {
             }
         };
 
-        reflect(target, propertyKey).registerControllerRouteArgumentInjector(
-            injector,
-            parameterIndex
-        );
+        reflect(target, propertyKey).registerControllerRouteArgumentInjector(injector, parameterIndex);
     };
 }

package/src/decorators/controller/query.spec.ts

@@ -30,19 +30,13 @@ describe('Given a Query decorator', () => {
             expect(config.routes.length).equal(2, 'Wrong route count detected');
 
             const request1 = <any>{ query: { id: 'guid 1' } };
-            expect(config.routes[0].argumentInjectors.length).equal(
-                1,
-                'Wrong argumentInjectors length for getById'
-            );
+            expect(config.routes[0].argumentInjectors.length).equal(1, 'Wrong argumentInjectors length for getById');
             expect(config.routes[0].argumentInjectors[0](request1)).to.be.a('string');
             expect(config.routes[0].argumentInjectors[0](request1)).equals('guid 1');
 
             const request2 = <any>{ query: { gender: 0, minDate: '2021-02-15T14:23:00.318Z' } };
 
-            expect(config.routes[1].argumentInjectors.length).equal(
-                2,
-                'Wrong argumentInjectors length for getByGenderOlderThan'
-            );
+            expect(config.routes[1].argumentInjectors.length).equal(2, 'Wrong argumentInjectors length for getByGenderOlderThan');
 
             expect(config.routes[1].argumentInjectors[0](request2)).to.be.a('Date');
             expect(config.routes[1].argumentInjectors[0](request2).toISOString()).equals(

package/src/decorators/controller/query.ts

@@ -7,9 +7,7 @@ export function Query(key: string): ParameterDecorator {
     return (target, propertyKey, parameterIndex) => {
         const methodArguments = reflect(target, propertyKey).getParameters();
         if (!methodArguments.hasOwnProperty(parameterIndex)) {
-            throw new Error(
-                `Query: can't find argument ${parameterIndex} on ${target.constructor.name}.${propertyKey.toString()}`
-            );
+            throw new Error(`Query: can't find argument ${parameterIndex} on ${target.constructor.name}.${propertyKey.toString()}`);
         }
 
         const injector: RequestArgumentInjector = (req: Server.Request) => {
@@ -18,9 +16,6 @@ export function Query(key: string): ParameterDecorator {
             }
         };
 
-        reflect(target, propertyKey).registerControllerRouteArgumentInjector(
-            injector,
-            parameterIndex
-        );
+        reflect(target, propertyKey).registerControllerRouteArgumentInjector(injector, parameterIndex);
     };
 }

package/src/decorators/handler/command-handler.spec.ts

@@ -56,9 +56,7 @@ describe('Given a CommandHandler decorator', () => {
 
                     reflect(TestClass).getHandlerConfiguration();
                 } catch (error) {
-                    expect(error.message).equal(
-                        'TestClass.create should have a command as argument!'
-                    );
+                    expect(error.message).equal('TestClass.create should have a command as argument!');
                 }
             });
         });
@@ -80,9 +78,7 @@ describe('Given a CommandHandler decorator', () => {
                 }
             }
             it('Then we should retrieve information via reflect', async () => {
-                const commandHandlers = Array.from(
-                    reflect(TestClass).getHandlerConfiguration().commandHandlers.values()
-                );
+                const commandHandlers = Array.from(reflect(TestClass).getHandlerConfiguration().commandHandlers.values());
 
                 expect(commandHandlers.length).equal(2, 'Wrong route count detected');
 

package/src/decorators/handler/command-handler.ts

@@ -7,21 +7,15 @@ export function CommandHandler(): MethodDecorator {
         const paramTypes = reflect(target, propertyKey).getParameters();
 
         if (paramTypes.length === 0) {
-            throw new Error(
-                `${target.constructor.name}.${propertyKey.toString()} should have one argument!`
-            );
+            throw new Error(`${target.constructor.name}.${propertyKey.toString()} should have one argument!`);
         }
 
         if (paramTypes.length > 1) {
-            throw new Error(
-                `${target.constructor.name}.${propertyKey.toString()} should have only one argument!`
-            );
+            throw new Error(`${target.constructor.name}.${propertyKey.toString()} should have only one argument!`);
         }
 
         if (!(paramTypes[0].prototype instanceof Command)) {
-            throw new Error(
-                `${target.constructor.name}.${propertyKey.toString()} should have a command as argument!`
-            );
+            throw new Error(`${target.constructor.name}.${propertyKey.toString()} should have a command as argument!`);
         }
 
         reflect(target, propertyKey).registerCommandHandler(<any>paramTypes[0].prototype);

package/src/decorators/handler/event-handler.spec.ts

@@ -57,9 +57,7 @@ describe('Given a EventHandler decorator', () => {
 
                     reflect(TestClass).getHandlerConfiguration();
                 } catch (error) {
-                    expect(error.message).equal(
-                        'TestClass.created should have an event as argument!'
-                    );
+                    expect(error.message).equal('TestClass.created should have an event as argument!');
                 }
             });
         });
@@ -81,9 +79,7 @@ describe('Given a EventHandler decorator', () => {
                 }
             }
             it('Then we should retrieve information via reflect', async () => {
-                const eventHandlers = Array.from(
-                    reflect(TestClass).getHandlerConfiguration().eventHandlers.values()
-                );
+                const eventHandlers = Array.from(reflect(TestClass).getHandlerConfiguration().eventHandlers.values());
 
                 expect(eventHandlers.length).equal(2, 'Wrong route count detected');
 

package/src/decorators/handler/event-handler.ts

@@ -8,21 +8,15 @@ export function EventHandler(mode: ExecutionMode): MethodDecorator {
         const paramTypes = reflect(target, propertyKey).getParameters();
 
         if (paramTypes.length === 0) {
-            throw new Error(
-                `${target.constructor.name}.${propertyKey.toString()} should have one argument!`
-            );
+            throw new Error(`${target.constructor.name}.${propertyKey.toString()} should have one argument!`);
         }
 
         if (paramTypes.length > 1) {
-            throw new Error(
-                `${target.constructor.name}.${propertyKey.toString()} should have only one argument!`
-            );
+            throw new Error(`${target.constructor.name}.${propertyKey.toString()} should have only one argument!`);
         }
 
         if (!(paramTypes[0].prototype instanceof Event)) {
-            throw new Error(
-                `${target.constructor.name}.${propertyKey.toString()} should have an event as argument!`
-            );
+            throw new Error(`${target.constructor.name}.${propertyKey.toString()} should have an event as argument!`);
         }
 
         reflect(target, propertyKey).registerEventHandler(<any>paramTypes[0].prototype, mode);

package/src/firestore-client.ts

@@ -1,12 +1,4 @@
-import {
-    _orderBy,
-    Cacheable,
-    deserialize,
-    Document,
-    Logger,
-    NotFoundError,
-    serialize
-} from '@my-devkit/core';
+import { _orderBy, Cacheable, deserialize, Document, Logger, NotFoundError, serialize } from '@my-devkit/core';
 import { getFirestore } from 'firebase-admin/firestore';
 
 import { Injectable, TransactionalClient } from './decorators';
@@ -60,9 +52,7 @@ export class FirestoreClient implements ITransactionalClient {
         const documents = await this._getWhere<T>(collection, whereClauses, options);
 
         if (documents.length > 1) {
-            throw new Error(
-                `Transactional Repository: Too many documents found (${documents.length})`
-            );
+            throw new Error(`Transactional Repository: Too many documents found (${documents.length})`);
         }
 
         return documents[0] || null;
@@ -78,10 +68,7 @@ export class FirestoreClient implements ITransactionalClient {
         return result;
     }
 
-    public async _getAll<T extends Document>(
-        collection: string,
-        options?: FirestoreClient.QueryOptions
-    ): Promise<T[]> {
+    public async _getAll<T extends Document>(collection: string, options?: FirestoreClient.QueryOptions): Promise<T[]> {
         return this._getWhere(collection, [], options);
     }
 
@@ -90,9 +77,7 @@ export class FirestoreClient implements ITransactionalClient {
         whereClauses: [string, FirestoreClient.Operator, any | any[]][] = [],
         options?: FirestoreClient.QueryOptions
     ): Promise<T[]> {
-        Logger.info(
-            `Repository: getWhere ${collection} whereClauses: ${JSON.stringify(whereClauses)}`
-        );
+        Logger.info(`Repository: getWhere ${collection} whereClauses: ${JSON.stringify(whereClauses)}`);
         const documentMap = await this.queryCollection<T>(collection, whereClauses, options);
 
         for (const operation of Array.from(this.operations.values())) {
@@ -102,36 +87,26 @@ export class FirestoreClient implements ITransactionalClient {
                 case FirestoreClient.Action.Create:
                     if (this.doesDocumentMatchQuery(operation.document, collection, whereClauses)) {
                         documentMap.set(operation.document._path, <T>operation.document);
-                        Logger.info(
-                            `Repository: Document ${operation.document._path} added to result`
-                        );
+                        Logger.info(`Repository: Document ${operation.document._path} added to result`);
                     }
                     break;
                 case FirestoreClient.Action.Update:
                     if (this.doesDocumentMatchQuery(operation.document, collection, whereClauses)) {
-                        Logger.info(
-                            `Repository: Document ${operation.document._path} ${exists ? 'updated from' : 'added to'} result`
-                        );
+                        Logger.info(`Repository: Document ${operation.document._path} ${exists ? 'updated from' : 'added to'} result`);
                         documentMap.set(operation.document._path, <T>operation.document);
                     } else if (exists) {
                         documentMap.delete(operation.document._path);
-                        Logger.info(
-                            `Repository: Document ${operation.document._path} removed from result`
-                        );
+                        Logger.info(`Repository: Document ${operation.document._path} removed from result`);
                     }
                     break;
                 case FirestoreClient.Action.Delete:
                     if (exists) {
                         documentMap.delete(operation.document._path);
-                        Logger.info(
-                            `Repository: Document ${operation.document._path} removed from result`
-                        );
+                        Logger.info(`Repository: Document ${operation.document._path} removed from result`);
                     }
                     break;
                 default:
-                    throw new Error(
-                        `FirestoreClient: Unhandled existing operation ${operation.action} on ${operation.document._path}`
-                    );
+                    throw new Error(`FirestoreClient: Unhandled existing operation ${operation.action} on ${operation.document._path}`);
             }
         }
 
@@ -156,21 +131,15 @@ export class FirestoreClient implements ITransactionalClient {
         if (existingOperation) {
             switch (existingOperation.action) {
                 case FirestoreClient.Action.Create:
-                    throw new Error(
-                        `FirestoreClient: can't create twice document ${document._path}`
-                    );
+                    throw new Error(`FirestoreClient: can't create twice document ${document._path}`);
                 case FirestoreClient.Action.Update:
-                    throw new Error(
-                        `FirestoreClient: can't create already existing document ${document._path}`
-                    );
+                    throw new Error(`FirestoreClient: can't create already existing document ${document._path}`);
                 case FirestoreClient.Action.Delete:
                     existingOperation.action = FirestoreClient.Action.Update;
                     existingOperation.document = document;
                     break;
                 default:
-                    throw new Error(
-                        `FirestoreClient: Unhandled existing operation ${existingOperation.action} on ${document._path}`
-                    );
+                    throw new Error(`FirestoreClient: Unhandled existing operation ${existingOperation.action} on ${document._path}`);
             }
         } else {
             this.operations.set(document._path, {
@@ -191,13 +160,9 @@ export class FirestoreClient implements ITransactionalClient {
                     existingOperation.document = document;
                     break;
                 case FirestoreClient.Action.Delete:
-                    throw new Error(
-                        `FirestoreClient: can't update deleted document ${document._path}`
-                    );
+                    throw new Error(`FirestoreClient: can't update deleted document ${document._path}`);
                 default:
-                    throw new Error(
-                        `FirestoreClient: Unhandled existing operation ${existingOperation.action} on ${document._path}`
-                    );
+                    throw new Error(`FirestoreClient: Unhandled existing operation ${existingOperation.action} on ${document._path}`);
             }
         } else {
             this.operations.set(document._path, {
@@ -221,13 +186,9 @@ export class FirestoreClient implements ITransactionalClient {
                     existingOperation.action = FirestoreClient.Action.Delete;
                     break;
                 case FirestoreClient.Action.Delete:
-                    throw new Error(
-                        `FirestoreClient: can't delete already deleted document ${document._path}`
-                    );
+                    throw new Error(`FirestoreClient: can't delete already deleted document ${document._path}`);
                 default:
-                    throw new Error(
-                        `FirestoreClient: Unhandled existing operation ${existingOperation.action} on ${document._path}`
-                    );
+                    throw new Error(`FirestoreClient: Unhandled existing operation ${existingOperation.action} on ${document._path}`);
             }
         } else {
             this.operations.set(document._path, {
@@ -238,9 +199,7 @@ export class FirestoreClient implements ITransactionalClient {
         }
     }
 
-    private getCollectionReference(
-        collection: string
-    ): FirebaseFirestore.CollectionReference | FirebaseFirestore.Query {
+    private getCollectionReference(collection: string): FirebaseFirestore.CollectionReference | FirebaseFirestore.Query {
         if (collection.startsWith('**/')) {
             return this.db.collectionGroup(collection.replace('**/', ''));
         } else {
@@ -313,9 +272,7 @@ export class FirestoreClient implements ITransactionalClient {
                     case '<=':
                         return documentValue <= expectedValue;
                     case 'array-contains':
-                        return (
-                            Array.isArray(documentValue) && documentValue.includes(expectedValue)
-                        );
+                        return Array.isArray(documentValue) && documentValue.includes(expectedValue);
                     case 'array-contains-any':
                         return (
                             Array.isArray(documentValue) &&
@@ -323,13 +280,9 @@ export class FirestoreClient implements ITransactionalClient {
                             documentValue.some(v => expectedValue.includes(v))
                         );
                     case 'in':
-                        return (
-                            Array.isArray(expectedValue) && expectedValue.includes(documentValue)
-                        );
+                        return Array.isArray(expectedValue) && expectedValue.includes(documentValue);
                     case 'not-in':
-                        return (
-                            Array.isArray(expectedValue) && !expectedValue.includes(documentValue)
-                        );
+                        return Array.isArray(expectedValue) && !expectedValue.includes(documentValue);
                     default:
                         throw new Error(`Operator ${operator} not handled!`);
                 }

package/src/handler-helper.ts

@@ -6,10 +6,7 @@ import { ExecutionMode } from './execution-mode-enum';
 import { FirestoreClient } from './firestore-client';
 
 export class HandlerHelper {
-    public static async create<A extends Aggregate, R>(
-        aggregate: A,
-        callback: (a: A) => Promise<R>
-    ): Promise<R> {
+    public static async create<A extends Aggregate, R>(aggregate: A, callback: (a: A) => Promise<R>): Promise<R> {
         const result = await callback(aggregate);
 
         this.client.createDocument(aggregate);
@@ -18,15 +15,10 @@ export class HandlerHelper {
         return result;
     }
 
-    public static async update<A extends Aggregate, R>(
-        aggregateOrId: A | string,
-        callback: (a: A) => Promise<R>
-    ): Promise<R> {
+    public static async update<A extends Aggregate, R>(aggregateOrId: A | string, callback: (a: A) => Promise<R>): Promise<R> {
         const aggregate = await this.getAggregate(aggregateOrId);
         if (aggregate.events.length > 0) {
-            Logger.warn(
-                `${aggregate._type} ${aggregate.id} has ${aggregate.events.length} events!!`
-            );
+            Logger.warn(`${aggregate._type} ${aggregate.id} has ${aggregate.events.length} events!!`);
         }
         const hashBefore = aggregate.hash;
 
@@ -36,19 +28,14 @@ export class HandlerHelper {
             this.client.updateDocument(aggregate);
             await this.publishEvents(aggregate);
         } else {
-            Logger.debug(
-                `${aggregate._type} ${aggregate.id} didn't change, ${aggregate.events.length} events skipped`
-            );
+            Logger.debug(`${aggregate._type} ${aggregate.id} didn't change, ${aggregate.events.length} events skipped`);
             aggregate.clearEvents();
         }
 
         return result;
     }
 
-    public static async delete<A extends Aggregate, R>(
-        aggregateOrId: A | string,
-        callback: (a: A) => Promise<R>
-    ): Promise<R> {
+    public static async delete<A extends Aggregate, R>(aggregateOrId: A | string, callback: (a: A) => Promise<R>): Promise<R> {
         const aggregate = await this.getAggregate(aggregateOrId);
 
         const result = await callback(aggregate);

package/src/interfaces/from-array.ts

@@ -1,2 +1 @@
-export type FromArray<T extends ReadonlyArray<unknown>> =
-    T extends ReadonlyArray<infer FromArray> ? FromArray : never;
+export type FromArray<T extends ReadonlyArray<unknown>> = T extends ReadonlyArray<infer FromArray> ? FromArray : never;

package/src/reflect.ts

@@ -58,10 +58,7 @@ class ReflectHelper<T extends ReflectTarget<any>> {
         this.getControllerRoute().requestMethod = route.requestMethod;
     }
 
-    public registerControllerRouteArgumentInjector<T>(
-        injector: RequestArgumentInjector<T>,
-        index: number
-    ): void {
+    public registerControllerRouteArgumentInjector<T>(injector: RequestArgumentInjector<T>, index: number): void {
         this.getControllerRoute().argumentInjectors[index] = injector;
     }
 
@@ -83,10 +80,7 @@ class ReflectHelper<T extends ReflectTarget<any>> {
         });
     }
 
-    public registerEventHandler<E extends Event>(
-        event: new () => E,
-        executionMode: ExecutionMode
-    ): void {
+    public registerEventHandler<E extends Event>(event: new () => E, executionMode: ExecutionMode): void {
         this.getHandlerConfiguration().eventHandlers.set(this.methodName.toString(), {
             methodName: this.methodName.toString(),
             executionMode,
@@ -163,10 +157,7 @@ export interface HandlerConfiguration {
 
 export type RequestArgumentInjector<T = any> = (req: Server.Request) => T;
 
-export function reflect<T extends ReflectTarget<any>>(
-    target: T,
-    methodName?: string | symbol
-): ReflectHelper<T> {
+export function reflect<T extends ReflectTarget<any>>(target: T, methodName?: string | symbol): ReflectHelper<T> {
     return new ReflectHelper(target, methodName);
 }
 

package/src/server/middlewares/authentication-middleware.ts

@@ -5,14 +5,8 @@ import { Context } from '../../context';
 import { Server } from '../server';
 
 export function AuthenticationMiddleware(auth: Auth, publicPaths: string[]): Server.RequestHandler {
-    return async (
-        request: Server.Request,
-        _response: Server.Response,
-        next: Server.NextFunction
-    ): Promise<void> => {
-        const authorizationHeader = request.headers.authorization
-            ? request.headers.authorization.toString()
-            : null;
+    return async (request: Server.Request, _response: Server.Response, next: Server.NextFunction): Promise<void> => {
+        const authorizationHeader = request.headers.authorization ? request.headers.authorization.toString() : null;
         Logger.info(`${request.method} ${request.path}: Authentication check`);
 
         if (publicPaths.includes(request.path)) {
@@ -31,9 +25,7 @@ export function AuthenticationMiddleware(auth: Auth, publicPaths: string[]): Ser
                 Context.user = await auth.getUser(userId);
                 next();
             } catch (error) {
-                throw new UnauthorizedError(
-                    `Error while verifying token ${error.message ? error.message : null}`
-                );
+                throw new UnauthorizedError(`Error while verifying token ${error.message ? error.message : null}`);
             }
         } else if (authorizationHeader.startsWith('Basic')) {
             const idToken = authorizationHeader.split('Basic ')[1];
@@ -45,9 +37,7 @@ export function AuthenticationMiddleware(auth: Auth, publicPaths: string[]): Ser
                 Context.user = await auth.getUser(userId);
                 next();
             } catch (error) {
-                throw new UnauthorizedError(
-                    `Error while verifying token ${error.message ? error.message : null}`
-                );
+                throw new UnauthorizedError(`Error while verifying token ${error.message ? error.message : null}`);
             }
         } else {
             throw new UnauthorizedError('Incorrect authorization header');

package/src/server/middlewares/create-context-middleware.ts

@@ -5,11 +5,7 @@ import { Context } from '../../context';
 import { Server } from '../server';
 
 export function CreateContextMiddleware(bus: Bus): Server.RequestHandler {
-    return async (
-        request: Server.Request,
-        _response: Server.Response,
-        next: Server.NextFunction
-    ): Promise<void> => {
+    return async (request: Server.Request, _response: Server.Response, next: Server.NextFunction): Promise<void> => {
         Context.create(bus);
         Context.correlationId = request.header('X-Correlation-ID') || guid();
 

package/src/server/middlewares/error-middleware.ts

@@ -4,11 +4,7 @@ import { Context } from '../../context';
 import { Server } from '../server';
 
 export function ErrorMiddleWare(): Server.ErrorHandler {
-    return async (
-        error: any,
-        _request: Server.Request,
-        response: Server.Response
-    ): Promise<void> => {
+    return async (error: any, _request: Server.Request, response: Server.Response): Promise<void> => {
         if (!(error instanceof Error)) {
             error = new Error(error);
         }

package/src/server/middlewares/headers-middleware.ts

@@ -2,11 +2,7 @@ import { Context } from '../../context';
 import { Server } from '../server';
 
 export function HeadersMiddleWare(): Server.RequestHandler {
-    return async (
-        _request: Server.Request,
-        response: Server.Response,
-        next: Server.NextFunction
-    ): Promise<void> => {
+    return async (_request: Server.Request, response: Server.Response, next: Server.NextFunction): Promise<void> => {
         response.removeHeader('X-Powered-By'); // Remove verbose express
         response.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate'); // HTTP 1.1.
         response.setHeader('Pragma', 'no-cache'); // HTTP 1.0.