@my-devkit/firebase 1.0.81 → 1.0.85

package/src/context.ts

@@ -0,0 +1,108 @@
+import { Logger } from '@my-devkit/core';
+import { AsyncHook, createHook, executionAsyncId } from 'async_hooks';
+
+import { Bus } from './bus';
+import { Injector } from './injector';
+import { ITransactionalClient, Type } from './interfaces';
+
+interface ContextStore {
+    injector: Injector;
+    bus: Bus;
+    correlationId?: string;
+    eventId?: string;
+    user?: UserRecord;
+}
+
+interface UserRecord {
+    uid: string;
+    email?: string;
+    displayName?: string;
+    photoURL?: string;
+    disabled: boolean;
+}
+
+export class Context {
+    private static store = new Map<number, ContextStore>();
+    private static asyncHook: AsyncHook;
+
+    public static init(): void {
+        this.asyncHook = createHook({
+            init: (asyncId: number, _type: string, triggerAsyncId: number) => {
+                if (this.store.has(triggerAsyncId)) {
+                    this.store.set(asyncId, this.store.get(triggerAsyncId))
+                }
+            },
+            destroy: (asyncId: number) => {
+                this.store.delete(asyncId);
+            }
+        });
+        this.asyncHook.enable();
+    }
+
+    public static create(bus: Bus): void {
+        this.store.set(executionAsyncId(), { injector: new Injector(), bus });
+    }
+
+    public static resolve<T>(type: Type<T>): T {
+        if (!this.store.has(executionAsyncId())) {
+            throw new Error(`Create context before resolving an injection!`);
+        }
+        return this.store.get(executionAsyncId()).injector.resolve(type);
+    }
+
+    public static getTransactionalClients(): ITransactionalClient[] {
+        if (!this.store.has(executionAsyncId())) {
+            throw new Error(`Create context before getting transactional clients!`);
+        }
+        return this.store.get(executionAsyncId()).injector.getTransactionalClients();
+    }
+
+    public static get bus(): Bus {
+        return this.store.get(executionAsyncId())?.bus;
+    }
+
+    public static set correlationId(correlationId: string) {
+        if (!this.store.has(executionAsyncId())) {
+            throw new Error(`Create context before setting correlationId!`);
+        }
+        this.store.get(executionAsyncId()).correlationId = correlationId;
+    }
+
+    public static get correlationId(): string {
+        return this.store.get(executionAsyncId())?.correlationId;
+    }
+
+    public static set eventId(eventId: string) {
+        if (!this.store.has(executionAsyncId())) {
+            throw new Error(`Create context before setting eventId!`);
+        }
+        this.store.get(executionAsyncId()).eventId = eventId;
+    }
+
+    public static get eventId(): string {
+        return this.store.get(executionAsyncId())?.eventId;
+    }
+
+    public static set user(user: UserRecord) {
+        if (!this.store.has(executionAsyncId())) {
+            throw new Error(`Create context before setting user!`);
+        }
+        this.store.get(executionAsyncId()).user = user;
+    }
+
+    public static get user(): UserRecord {
+        return this.store.get(executionAsyncId())?.user;
+    }
+
+    public static destroy(): void {
+        this.store.delete(executionAsyncId());
+    }
+
+    public static size(): number {
+        return this.store.size;
+    }
+
+    public static logRemainingKeys(): void {
+        Logger.info(Array.from(this.store.keys()).join(' '));
+    }
+}

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

@@ -0,0 +1,52 @@
+import { autoserializeAs } from '@my-devkit/core';
+import { expect } from 'chai';
+
+import { reflect } from '../../reflect';
+import { Body } from './body';
+import { Controller } from './controller';
+
+describe('Given a Body decorator', () => {
+
+    class Command {
+        @autoserializeAs(String)
+        public testString: string = null;
+
+        @autoserializeAs(Date)
+        public testDate: Date = null;
+    }
+
+
+    @Controller('test')
+    class TestClass {
+        public testDate(@Body() param1: Date): string {
+            return `testDate: ${param1}`;
+        }
+
+        public testCommand(@Body() param1: Command): string {
+            return `testCommand: ${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(2, 'Wrong route count detected');
+
+            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[0](request1)).to.be.a('Date');
+            expect(config.routes[0].argumentInjectors[0](request1).toISOString()).equals((new Date('2021-02-08T11:14:23.318Z')).toISOString());
+
+            const request2 = <any>{ body: { testString: 'test' } };
+
+            const expectedBody2 = new Command();
+            expectedBody2.testString = 'test';
+            expectedBody2.testDate = null;
+
+            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

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

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

@@ -0,0 +1,19 @@
+import { expect } from 'chai';
+
+import { reflect } from '../../reflect';
+import { Controller } from './controller';
+
+describe('Given a Controller decorator', () => {
+
+    @Controller('test')
+    class TestClass {
+    }
+
+    describe('When decorator is called', () => {
+        it('Then we should retrieve information via reflect', async () => {
+            const config = reflect(TestClass).getControllerConfiguration();
+
+            expect(config.basePath).equals('test');
+        });
+    });
+});

package/src/decorators/controller/controller.ts

@@ -0,0 +1,10 @@
+import { reflect } from '../../reflect';
+import { Injectable } from './../injectable';
+
+export function Controller(basePath: string): ClassDecorator {
+    return target => {
+        reflect(target).registerController(basePath);
+        // Register controller as injectable ressource
+        Injectable()(target);
+    };
+}

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);
+    }
+}