@my-devkit/firebase 1.0.65 → 1.0.69

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

@@ -0,0 +1,32 @@
+import { guid } from '@my-devkit/core';
+import { expect } from 'chai';
+
+import { Get } from '.';
+import { reflect } from '../../reflect';
+import { RequestMethod } from '../../request-method.enum';
+import { Controller } from './controller';
+
+describe('Given a Get decorator', () => {
+
+    @Controller('test')
+    class TestClass {
+        public test = guid();
+
+        @Get('create')
+        public get(): string {
+            return `create`;
+        }
+    }
+
+    describe('When decorator is called', () => {
+        it('Then we should retrieve information via reflect', async () => {
+            const config = reflect(TestClass).getControllerConfiguration();
+
+            expect(config.routes.length).equal(1, 'Wrong route count detected');
+
+            expect(config.routes[0].path).equal('create');
+            expect(config.routes[0].methodName).equal('get');
+            expect(config.routes[0].requestMethod).equal(RequestMethod.GET);
+        });
+    });
+});

package/src/decorators/controller/get.ts

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

package/src/decorators/controller/index.ts

@@ -0,0 +1,8 @@
+export * from './controller';
+
+export * from './body';
+export * from './param';
+export * from './query';
+
+export * from './get';
+export * from './post';

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

@@ -0,0 +1,51 @@
+import { expect } from 'chai';
+
+import { reflect } from '../../reflect';
+import { Controller } from './controller';
+import { Get } from './get';
+import { Param } from './param';
+
+describe('Given a Param decorator', () => {
+
+    enum Gender {
+        Male = 0,
+        Female = 'Female'
+    }
+
+    @Controller('test')
+    class TestClass {
+        @Get(':id')
+        public getById(@Param('id') id: string): string {
+            return `getById: ${id}`;
+        }
+
+        @Get(':gender/:minDate')
+        public getByGenderOlderThan(@Param('minDate') minDate: Date, @Param('gender') gender: Gender): string {
+            return `getByGenderOlderThan: ${gender} ${minDate.toISOString()}`;
+        }
+    }
+
+    describe('When decorator is called', () => {
+        it('Then we should retrieve information via reflect', async () => {
+            const config = reflect(TestClass).getControllerConfiguration();
+            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[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[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[1](request2)).equals(Gender.Male);
+
+            request2.params.gender = 'Female';
+            expect(config.routes[1].argumentInjectors[1](request2)).equals(Gender.Female);
+        });
+    });
+});

package/src/decorators/controller/param.ts

@@ -0,0 +1,21 @@
+import { deserialize } from '@my-devkit/core';
+
+import { reflect, RequestArgumentInjector } from '../../reflect';
+import { Server } from '../../server';
+
+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()}`);
+        }
+
+        const injector: RequestArgumentInjector = (req: Server.Request) => {
+            if (req.params.hasOwnProperty(key)) {
+                return deserialize(req.params[key], methodArguments[parameterIndex]);
+            }
+        };
+
+        reflect(target, propertyKey).registerControllerRouteArgumentInjector(injector, parameterIndex);
+    }
+}

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

@@ -0,0 +1,60 @@
+import { autoserializeAs, guid } from '@my-devkit/core';
+import { expect } from 'chai';
+
+import { reflect } from '../../reflect';
+import { RequestMethod } from '../../request-method.enum';
+import { Body } from './body';
+import { Controller } from './controller';
+import { Post } from './post';
+
+describe('Given a Post decorator', () => {
+
+    class Command {
+        @autoserializeAs(String)
+        public testString: string = null;
+
+        @autoserializeAs(Date)
+        public testDate: Date = null;
+    }
+
+
+    @Controller('test')
+    class TestClass {
+        public test = guid();
+
+        @Post('create')
+        public createMethod(@Body() param1: Date): string {
+            return `createMethod: ${param1}`;
+        }
+
+        @Post('update')
+        public updateMethod(@Body() param1: Command): string {
+            return `updateMethod: ${param1}`;
+        }
+
+        @Post('delete')
+        public deleteMethod(@Body() param1: Command): string {
+            return `deleteMethod: ${param1}`;
+        }
+    }
+
+    describe('When decorator is called', () => {
+        it('Then we should retrieve information via reflect', async () => {
+            const config = reflect(TestClass).getControllerConfiguration();
+
+            expect(config.routes.length).equal(3, 'Wrong route count detected');
+
+            expect(config.routes[0].path).equal('create');
+            expect(config.routes[0].methodName).equal('createMethod');
+            expect(config.routes[0].requestMethod).equal(RequestMethod.POST);
+
+            expect(config.routes[1].path).equal('update');
+            expect(config.routes[1].methodName).equal('updateMethod');
+            expect(config.routes[1].requestMethod).equal(RequestMethod.POST);
+
+            expect(config.routes[2].path).equal('delete');
+            expect(config.routes[2].methodName).equal('deleteMethod');
+            expect(config.routes[2].requestMethod).equal(RequestMethod.POST);
+        });
+    });
+});

package/src/decorators/controller/post.ts

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

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

@@ -0,0 +1,51 @@
+import { expect } from 'chai';
+
+import { reflect } from '../../reflect';
+import { Controller } from './controller';
+import { Get } from './get';
+import { Query } from './query';
+
+describe('Given a Query decorator', () => {
+
+    enum Gender {
+        Male = 0,
+        Female = 'Female'
+    }
+
+    @Controller('test')
+    class TestClass {
+        @Get('by-id')
+        public getById(@Query('id') id: string): string {
+            return `getById: ${id}`;
+        }
+
+        @Get('all')
+        public all(@Query('minDate') minDate: Date, @Query('gender') gender: Gender): string {
+            return `getByGenderOlderThan: ${gender} ${minDate.toISOString()}`;
+        }
+    }
+
+    describe('When decorator is called', () => {
+        it('Then we should retrieve information via reflect', async () => {
+            const config = reflect(TestClass).getControllerConfiguration();
+            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[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[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[1](request2)).equals(Gender.Male);
+
+            request2.query.gender = 'Female';
+            expect(config.routes[1].argumentInjectors[1](request2)).equals(Gender.Female);
+        });
+    });
+});

package/src/decorators/controller/query.ts

@@ -0,0 +1,21 @@
+import { deserialize } from '@my-devkit/core';
+
+import { reflect, RequestArgumentInjector } from '../../reflect';
+import { Server } from '../../server';
+
+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()}`);
+        }
+
+        const injector: RequestArgumentInjector = (req: Server.Request) => {
+            if (req.query.hasOwnProperty(key)) {
+                return deserialize(req.query[key], methodArguments[parameterIndex]);
+            }
+        };
+
+        reflect(target, propertyKey).registerControllerRouteArgumentInjector(injector, parameterIndex);
+    }
+}

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

@@ -0,0 +1,101 @@
+import { Command } from '@my-devkit/core';
+import { expect } from 'chai';
+
+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()
+                        public create(): string {
+                            return `create`;
+                        }
+                    }
+
+                    reflect(TestClass).getHandlerConfiguration();
+                } catch (error) {
+                    expect(error.message).equal('TestClass.create should have one argument!');
+                }
+            });
+        });
+
+        describe('And decorated method has more than 1 parameter', () => {
+            it('Then we should retrieve information via reflect', async () => {
+
+                try {
+                    class TestClass {
+                        @CommandHandler()
+                        public create(param1: string, param2: string): string {
+                            return `create ${param1} / ${param2}`;
+                        }
+                    }
+
+                    reflect(TestClass).getHandlerConfiguration();
+                } catch (error) {
+                    expect(error.message).equal('TestClass.create should have only one argument!');
+                }
+            });
+        });
+
+        describe('And decorated method parameter is not a command', () => {
+            it('Then we should retrieve information via reflect', async () => {
+
+                try {
+                    class FakeCommand {
+                        test: string;
+                    }
+
+                    class TestClass {
+                        @CommandHandler()
+                        public create(fakeCommand: FakeCommand): string {
+                            return `create ${fakeCommand}`;
+                        }
+                    }
+
+                    reflect(TestClass).getHandlerConfiguration();
+                } catch (error) {
+                    expect(error.message).equal('TestClass.create should have a command as argument!');
+                }
+            });
+        });
+
+        describe('And handler is correctly implemented', () => {
+
+            class CreateCommand extends Command {
+            }
+
+            class UpdateCommand extends Command {
+            }
+
+            class TestClass {
+                @CommandHandler()
+                public create(command: CreateCommand): string {
+                    return `create: ${command}`;
+                }
+
+                @CommandHandler()
+                public update(command: UpdateCommand): string {
+                    return `update: ${command}`;
+                }
+            }
+            it('Then we should retrieve information via reflect', async () => {
+                const config = reflect(TestClass).getHandlerConfiguration();
+                expect(config.commandHandlers.size).equal(2, 'Wrong route count detected');
+
+                expect(config.commandHandlers[0].methodName).equal('create');
+                expect(config.commandHandlers[0].command.constructor.name).equal('CreateCommand');
+
+                expect(config.commandHandlers[1].methodName).equal('update');
+                expect(config.commandHandlers[1].command.constructor.name).equal('UpdateCommand');
+
+            });
+        });
+    });
+});

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

@@ -0,0 +1,23 @@
+import { Command } from '@my-devkit/core';
+
+import { reflect } from '../../reflect';
+
+export function CommandHandler(): MethodDecorator {
+    return (target, propertyKey) => {
+        const paramTypes = reflect(target, propertyKey).getParameters();
+
+        if (paramTypes.length === 0) {
+            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!`);
+        }
+
+        if (!(paramTypes[0].prototype instanceof Command)) {
+            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

@@ -0,0 +1,104 @@
+import { expect } from 'chai';
+
+import { Event } from '../../event';
+import { ExecutionMode } from '../../execution-mode-enum';
+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)
+                        public created(): string {
+                            return `created`;
+                        }
+                    }
+
+                    reflect(TestClass).getHandlerConfiguration();
+                } catch (error) {
+                    expect(error.message).equal('TestClass.created should have one argument!');
+                }
+            });
+        });
+
+        describe('And decorated method has more than 1 parameter', () => {
+            it('Then we should retrieve information via reflect', async () => {
+
+                try {
+                    class TestClass {
+                        @EventHandler(ExecutionMode.Asynchronous)
+                        public created(param1: string, param2: string): string {
+                            return `created ${param1} / ${param2}`;
+                        }
+                    }
+
+                    reflect(TestClass).getHandlerConfiguration();
+                } catch (error) {
+                    expect(error.message).equal('TestClass.created should have only one argument!');
+                }
+            });
+        });
+
+        describe('And decorated method parameter is not a command', () => {
+            it('Then we should retrieve information via reflect', async () => {
+
+                try {
+                    class FakeEvent {
+                        test: string;
+                    }
+
+                    class TestClass {
+                        @EventHandler(ExecutionMode.Asynchronous)
+                        public created(fakeEvent: FakeEvent): string {
+                            return `created ${fakeEvent}`;
+                        }
+                    }
+
+                    reflect(TestClass).getHandlerConfiguration();
+                } catch (error) {
+                    expect(error.message).equal('TestClass.created should have an event as argument!');
+                }
+            });
+        });
+
+        describe('And handler is correctly implemented', () => {
+
+            class CreatedEvent extends Event {
+            }
+
+            class UpdatedEvent extends Event {
+            }
+
+            class TestClass {
+                @EventHandler(ExecutionMode.Asynchronous)
+                public created(event: CreatedEvent): string {
+                    return `created: ${event}`;
+                }
+
+                @EventHandler(ExecutionMode.Synchronous)
+                public updated(event: UpdatedEvent): string {
+                    return `updated: ${event}`;
+                }
+            }
+            it('Then we should retrieve information via reflect', async () => {
+                const config = reflect(TestClass).getHandlerConfiguration();
+                expect(config.eventHandlers.size).equal(2, 'Wrong route count detected');
+
+                expect(config.eventHandlers[0].methodName).equal('created');
+                expect(config.eventHandlers[0].executionMode).equal(ExecutionMode.Asynchronous);
+                expect(config.eventHandlers[0].event.constructor.name).equal('CreatedEvent');
+
+                expect(config.eventHandlers[1].methodName).equal('updated');
+                expect(config.eventHandlers[1].executionMode).equal(ExecutionMode.Synchronous);
+                expect(config.eventHandlers[1].event.constructor.name).equal('UpdatedEvent');
+
+            });
+        });
+    });
+});

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

@@ -0,0 +1,23 @@
+import { Event } from '../../event';
+import { ExecutionMode } from '../../execution-mode-enum';
+import { reflect } from '../../reflect';
+
+export function EventHandler(mode: ExecutionMode): MethodDecorator {
+    return (target, propertyKey) => {
+        const paramTypes = reflect(target, propertyKey).getParameters();
+
+        if (paramTypes.length === 0) {
+            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!`);
+        }
+
+        if (!(paramTypes[0].prototype instanceof Event)) {
+            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/handler/index.ts

@@ -0,0 +1,2 @@
+export * from './command-handler';
+export * from './event-handler';

package/src/decorators/index.ts

@@ -0,0 +1,5 @@
+export * from './controller';
+export * from './handler';
+export * from './injectable';
+export * from './module';
+export * from './transactional-client';

package/src/decorators/injectable.ts

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

package/src/decorators/module.ts

@@ -0,0 +1,29 @@
+import { Type } from '../interfaces';
+
+export interface ModuleOptions {
+    /**
+     * Optional list of imported modules that export the providers which are
+     * required in this module.
+     */
+    imports?: Type[];
+    /**
+     * Optional list of controllers defined in this module which have to be
+     * instantiated.
+     */
+    controllers?: Type[];
+
+    /**
+     * Optional list of handlers defined in this module which have to be instantiated.
+     */
+    handlers?: Type[];
+}
+
+export function Module(options: ModuleOptions): ClassDecorator {
+    return target => {
+        for (const key in options) {
+            if (options.hasOwnProperty(key)) {
+                Reflect.defineMetadata(key, options[key], target);
+            }
+        }
+    };
+}

package/src/decorators/transactional-client.ts

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

package/src/event.ts

@@ -0,0 +1,43 @@
+import { autoserializeAs, Document, guid } from '@my-devkit/core';
+
+import { Aggregate } from './aggregate';
+import { Context } from './context';
+
+export abstract class Event implements Document {
+    public static counter = 0;
+    @autoserializeAs(String) public id: string = null;
+    @autoserializeAs(String) public _type: string = null;
+    @autoserializeAs(String) public _correlationId: string = null;
+    @autoserializeAs(String) public _aggregateType: string = null;
+    @autoserializeAs(String) public _aggregateId: string = null;
+    @autoserializeAs(String) public _publishedBy: string = null;
+    @autoserializeAs(String) private _publishedAt: string = null;
+
+    constructor() {
+        this.id = guid();
+        this._type = this.constructor.name;
+
+        this._correlationId = Context.correlationId;
+        this._publishedBy = Context.user ? Context.user.uid : null;
+    }
+
+    public beforePublish<A extends Aggregate>(aggregate: A): void {
+        this._aggregateId = aggregate.id;
+        this._aggregateType = aggregate._type;
+
+        this._publishedAt = this.getNow();
+    }
+
+    public get _path(): string {
+        return `/events/${this.id}`;
+    }
+
+    public get publishedAt(): Date {
+        return new Date(this._publishedAt.substr(0, 23) + 'Z');
+    }
+
+    private getNow(): string {
+        Event.counter++;
+        return (new Date()).toISOString().replace('Z', '.' + (('0'.repeat(9) + Event.counter).slice(-9))) + 'Z';
+    }
+}

package/src/execution-mode-enum.ts

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