@my-devkit/firebase 1.0.192 → 1.0.194

package/src/decorators/controller/body.ts

@@ -7,11 +7,17 @@ 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/controller.spec.ts

@@ -4,10 +4,8 @@ import { reflect } from '../../reflect';
 import { Controller } from './controller';
 
 describe('Given a Controller decorator', () => {
-
     @Controller('test')
-    class TestClass {
-    }
+    class TestClass {}
 
     describe('When decorator is called', () => {
         it('Then we should retrieve information via reflect', async () => {

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

@@ -7,7 +7,6 @@ import { RequestMethod } from '../../request-method.enum';
 import { Controller } from './controller';
 
 describe('Given a Get decorator', () => {
-
     @Controller('test')
     class TestClass {
         public test = guid();

package/src/decorators/controller/get.ts

@@ -3,6 +3,9 @@ import { RequestMethod } from '../../request-method.enum';
 
 export function Get(path: string): MethodDecorator {
     return (target, propertyKey) => {
-        reflect(target.constructor, propertyKey).registerControllerRoute({ path, requestMethod: RequestMethod.GET });
-    }
+        reflect(target.constructor, propertyKey).registerControllerRoute({
+            path,
+            requestMethod: RequestMethod.GET
+        });
+    };
 }

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

@@ -6,7 +6,6 @@ import { Get } from './get';
 import { Param } from './param';
 
 describe('Given a Param decorator', () => {
-
     enum Gender {
         Male = 0,
         Female = 'Female'
@@ -20,7 +19,10 @@ 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()}`;
         }
     }
@@ -31,16 +33,24 @@ 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((new Date('2021-02-15T14:23:00.318Z')).toISOString());
+            expect(config.routes[1].argumentInjectors[0](request2).toISOString()).equals(
+                new Date('2021-02-15T14:23:00.318Z').toISOString()
+            );
 
             expect(config.routes[1].argumentInjectors[1](request2)).equals(Gender.Male);
 

package/src/decorators/controller/param.ts

@@ -7,7 +7,9 @@ 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) => {
@@ -16,6 +18,9 @@ export function Param(key: string): ParameterDecorator {
             }
         };
 
-        reflect(target, propertyKey).registerControllerRouteArgumentInjector(injector, parameterIndex);
-    }
+        reflect(target, propertyKey).registerControllerRouteArgumentInjector(
+            injector,
+            parameterIndex
+        );
+    };
 }

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

@@ -8,7 +8,6 @@ import { Controller } from './controller';
 import { Post } from './post';
 
 describe('Given a Post decorator', () => {
-
     class Command {
         @autoserializeAs(String)
         public testString: string = null;
@@ -17,7 +16,6 @@ describe('Given a Post decorator', () => {
         public testDate: Date = null;
     }
 
-
     @Controller('test')
     class TestClass {
         public test = guid();

package/src/decorators/controller/post.ts

@@ -3,6 +3,9 @@ import { RequestMethod } from '../../request-method.enum';
 
 export function Post(path: string): MethodDecorator {
     return (target, propertyKey) => {
-        reflect(target.constructor, propertyKey).registerControllerRoute({ path, requestMethod: RequestMethod.POST });
-    }
+        reflect(target.constructor, propertyKey).registerControllerRoute({
+            path,
+            requestMethod: RequestMethod.POST
+        });
+    };
 }

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

@@ -6,7 +6,6 @@ import { Get } from './get';
 import { Query } from './query';
 
 describe('Given a Query decorator', () => {
-
     enum Gender {
         Male = 0,
         Female = 'Female'
@@ -31,16 +30,24 @@ 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((new Date('2021-02-15T14:23:00.318Z')).toISOString());
+            expect(config.routes[1].argumentInjectors[0](request2).toISOString()).equals(
+                new Date('2021-02-15T14:23:00.318Z').toISOString()
+            );
 
             expect(config.routes[1].argumentInjectors[1](request2)).equals(Gender.Male);
 

package/src/decorators/controller/query.ts

@@ -7,7 +7,9 @@ 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) => {
@@ -16,6 +18,9 @@ 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

@@ -5,12 +5,9 @@ import { reflect } from '../../reflect';
 import { CommandHandler } from './command-handler';
 
 describe('Given a CommandHandler decorator', () => {
-
     describe('When decorator is called', () => {
-
         describe('And decorated method has no parameter', () => {
             it('Then we should retrieve information via reflect', async () => {
-
                 try {
                     class TestClass {
                         @CommandHandler()
@@ -28,7 +25,6 @@ describe('Given a CommandHandler decorator', () => {
 
         describe('And decorated method has more than 1 parameter', () => {
             it('Then we should retrieve information via reflect', async () => {
-
                 try {
                     class TestClass {
                         @CommandHandler()
@@ -46,7 +42,6 @@ describe('Given a CommandHandler decorator', () => {
 
         describe('And decorated method parameter is not a command', () => {
             it('Then we should retrieve information via reflect', async () => {
-
                 try {
                     class FakeCommand {
                         test: string;
@@ -61,18 +56,17 @@ 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!'
+                    );
                 }
             });
         });
 
         describe('And handler is correctly implemented', () => {
+            class CreateCommand extends Command {}
 
-            class CreateCommand extends Command {
-            }
-
-            class UpdateCommand extends Command {
-            }
+            class UpdateCommand extends Command {}
 
             class TestClass {
                 @CommandHandler()
@@ -86,7 +80,9 @@ 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');
 
@@ -95,7 +91,6 @@ describe('Given a CommandHandler decorator', () => {
 
                 expect(commandHandlers[1].methodName).equal('update');
                 expect(commandHandlers[1].command.constructor.name).equal('UpdateCommand');
-
             });
         });
     });

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

@@ -7,17 +7,23 @@ 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

@@ -6,12 +6,9 @@ import { reflect } from '../../reflect';
 import { EventHandler } from './event-handler';
 
 describe('Given a EventHandler decorator', () => {
-
     describe('When decorator is called', () => {
-
         describe('And decorated method has no parameter', () => {
             it('Then we should retrieve information via reflect', async () => {
-
                 try {
                     class TestClass {
                         @EventHandler(ExecutionMode.Asynchronous)
@@ -29,7 +26,6 @@ describe('Given a EventHandler decorator', () => {
 
         describe('And decorated method has more than 1 parameter', () => {
             it('Then we should retrieve information via reflect', async () => {
-
                 try {
                     class TestClass {
                         @EventHandler(ExecutionMode.Asynchronous)
@@ -47,7 +43,6 @@ describe('Given a EventHandler decorator', () => {
 
         describe('And decorated method parameter is not a command', () => {
             it('Then we should retrieve information via reflect', async () => {
-
                 try {
                     class FakeEvent {
                         test: string;
@@ -62,18 +57,17 @@ 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!'
+                    );
                 }
             });
         });
 
         describe('And handler is correctly implemented', () => {
+            class CreatedEvent extends Event {}
 
-            class CreatedEvent extends Event {
-            }
-
-            class UpdatedEvent extends Event {
-            }
+            class UpdatedEvent extends Event {}
 
             class TestClass {
                 @EventHandler(ExecutionMode.Asynchronous)
@@ -87,7 +81,9 @@ 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');
 
@@ -98,7 +94,6 @@ describe('Given a EventHandler decorator', () => {
                 expect(eventHandlers[1].methodName).equal('updated');
                 expect(eventHandlers[1].executionMode).equal(ExecutionMode.Synchronous);
                 expect(eventHandlers[1].event.constructor.name).equal('UpdatedEvent');
-
             });
         });
     });

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

@@ -8,17 +8,23 @@ 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);
-    }
+    };
 }