@my-devkit/firebase 1.0.194 → 1.0.196

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/decorators/injectable.ts

@@ -1,7 +1,7 @@
 import { reflect } from '../reflect';
 
 export function Injectable(): ClassDecorator {
-    return target => {
+    return (target) => {
         reflect(target).registerInjectable();
     };
 }

package/src/decorators/module.ts

@@ -19,7 +19,7 @@ export interface ModuleOptions {
 }
 
 export function Module(options: ModuleOptions): ClassDecorator {
-    return target => {
+    return (target) => {
         for (const key in options) {
             if (options.hasOwnProperty(key)) {
                 Reflect.defineMetadata(key, options[key], target);

package/src/decorators/transactional-client.ts

@@ -1,7 +1,7 @@
 import { reflect } from '../reflect';
 
 export function TransactionalClient(): ClassDecorator {
-    return target => {
+    return (target) => {
         reflect(target).registerTransactionalClient();
     };
 }

package/src/execution-mode-enum.ts

@@ -1,4 +1,4 @@
 export enum ExecutionMode {
     Synchronous = <any>'Synchronous',
-    Asynchronous = <any>'Asynchronous'
+    Asynchronous = <any>'Asynchronous',
 }

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';
@@ -55,14 +47,12 @@ export class FirestoreClient implements ITransactionalClient {
     public async _findWhere<T extends Document>(
         collection: string,
         whereClauses: [string, FirestoreClient.Operator, any | any[]][] = [],
-        options?: FirestoreClient.QueryOptions
+        options?: FirestoreClient.QueryOptions,
     ): Promise<T> {
         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,21 +68,16 @@ 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);
     }
 
     public async _getWhere<T extends Document>(
         collection: string,
         whereClauses: [string, FirestoreClient.Operator, any | any[]][] = [],
-        options?: FirestoreClient.QueryOptions
+        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,27 +131,21 @@ 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, {
                 document,
                 action: FirestoreClient.Action.Create,
-                committed: false
+                committed: false,
             });
         }
     }
@@ -191,19 +160,15 @@ 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, {
                 document,
                 action: FirestoreClient.Action.Update,
-                committed: false
+                committed: false,
             });
         }
     }
@@ -221,26 +186,20 @@ 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, {
                 document,
                 action: FirestoreClient.Action.Delete,
-                committed: false
+                committed: false,
             });
         }
     }
 
-    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 {
@@ -252,11 +211,11 @@ export class FirestoreClient implements ITransactionalClient {
     private async queryCollection<T extends Document>(
         collection: string,
         whereClauses: [string, FirestoreClient.Operator, any | any[]][] = [],
-        options: FirestoreClient.QueryOptions
+        options: FirestoreClient.QueryOptions,
     ): Promise<Map<string, T>> {
         let query = this.getCollectionReference(collection);
 
-        whereClauses.forEach(where => {
+        whereClauses.forEach((where) => {
             query = query.where(where[0], where[1], where[2]);
         });
 
@@ -271,7 +230,7 @@ export class FirestoreClient implements ITransactionalClient {
         const querySnapshot = await query.get();
 
         const documents = new Map<string, T>();
-        querySnapshot.forEach(doc => {
+        querySnapshot.forEach((doc) => {
             const document = deserialize<T>(doc.data());
             documents.set(document._path, document);
         });
@@ -288,13 +247,13 @@ export class FirestoreClient implements ITransactionalClient {
     private doesDocumentMatchQuery<T extends Document>(
         document: T,
         collection: string,
-        whereClauses: [string, FirestoreClient.Operator, any | any[]][]
+        whereClauses: [string, FirestoreClient.Operator, any | any[]][],
     ): boolean {
         const serializedDocument = serialize(document);
 
         return (
             document._path.startsWith(`${collection}/`) &&
-            whereClauses.every(wc => {
+            whereClauses.every((wc) => {
                 const documentValue = serializedDocument[wc[0]];
                 const operator = wc[1];
                 const expectedValue = wc[2];
@@ -313,23 +272,17 @@ 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) &&
                             Array.isArray(expectedValue) &&
-                            documentValue.some(v => expectedValue.includes(v))
+                            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!`);
                 }
@@ -360,7 +313,7 @@ export namespace FirestoreClient {
     export enum Action {
         Create = <any>'Create',
         Update = <any>'Update',
-        Delete = <any>'Delete'
+        Delete = <any>'Delete',
     }
     export type Operator = FirebaseFirestore.WhereFilterOp;
 

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/injector.ts

@@ -13,7 +13,7 @@ export class Injector {
 
         if (!this.instances.has(injectableId)) {
             const tokens = reflect(target).getParameters();
-            const injections = tokens.map(token => this.resolve<any>(token));
+            const injections = tokens.map((token) => this.resolve<any>(token));
             const instance = new target(...injections);
             this.instances.set(injectableId, instance);
 

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

@@ -15,7 +15,7 @@ class ReflectHelper<T extends ReflectTarget<any>> {
 
     constructor(
         private target: T,
-        private methodName: string | symbol
+        private methodName: string | symbol,
     ) {}
 
     public getParameters(): Type[] {
@@ -42,7 +42,7 @@ class ReflectHelper<T extends ReflectTarget<any>> {
         if (!this.hasMetaData(this.CONTROLLER_META_DATA)) {
             this.defineMetaData<ControllerConfiguration>(this.CONTROLLER_META_DATA, {
                 basePath: null,
-                routes: []
+                routes: [],
             });
         }
 
@@ -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;
     }
 
@@ -69,7 +66,7 @@ class ReflectHelper<T extends ReflectTarget<any>> {
         if (!this.hasMetaData(this.HANDLER_META_DATA)) {
             this.defineMetaData<HandlerConfiguration>(this.HANDLER_META_DATA, {
                 commandHandlers: new Map<string, CommandHandler>(),
-                eventHandlers: new Map<string, EventHandler>()
+                eventHandlers: new Map<string, EventHandler>(),
             });
         }
 
@@ -79,33 +76,30 @@ class ReflectHelper<T extends ReflectTarget<any>> {
     public registerCommandHandler<C extends Command>(command: new () => C): void {
         this.getHandlerConfiguration().commandHandlers.set(this.methodName.toString(), {
             methodName: this.methodName.toString(),
-            command
+            command,
         });
     }
 
-    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,
-            event
+            event,
         });
     }
 
     private getControllerRoute(): ControllerRoute {
         const config = this.getControllerConfiguration();
-        if (!config.routes.find(r => r.methodName === this.methodName.toString())) {
+        if (!config.routes.find((r) => r.methodName === this.methodName.toString())) {
             config.routes.push({
                 methodName: this.methodName.toString(),
                 path: null,
                 requestMethod: null,
-                argumentInjectors: []
+                argumentInjectors: [],
             });
         }
 
-        return config.routes.find(r => r.methodName === this.methodName.toString());
+        return config.routes.find((r) => r.methodName === this.methodName.toString());
     }
 
     private getMetaData<M>(key: string): M {
@@ -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/request-method.enum.ts

@@ -1,4 +1,4 @@
 export enum RequestMethod {
     GET = 'GET',
-    POST = 'POST'
+    POST = 'POST',
 }

package/src/sanity-check/module.ts

@@ -3,6 +3,6 @@ import { Module } from '../decorators';
 import { SanityCheckController } from './controller';
 
 @Module({
-    controllers: [SanityCheckController]
+    controllers: [SanityCheckController],
 })
 export class SanityCheckModule {}

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.