@my-devkit/firebase 1.0.76 → 1.0.80

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

@@ -1,51 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,104 +0,0 @@
-import { Event } from '@my-devkit/core';
-import { expect } from 'chai';
-
-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

@@ -1,22 +0,0 @@
-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

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

package/src/decorators/index.ts

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

package/src/decorators/injectable.ts

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

package/src/decorators/module.ts

@@ -1,29 +0,0 @@
-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

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

package/src/execution-mode-enum.ts

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

package/src/firestore-client.ts

@@ -1,125 +0,0 @@
-import { deserialize, Document, Logger, NotFoundError, serialize } from '@my-devkit/core';
-import { getFirestore } from 'firebase-admin/firestore';
-
-import { Injectable, TransactionalClient } from './decorators';
-import { ITransactionalClient } from './interfaces';
-
-
-@TransactionalClient()
-@Injectable()
-export class FirestoreClient implements ITransactionalClient {
-    private db = getFirestore();
-    private operations: FirestoreClient.Operation[] = [];
-    private cachedDocuments = new Map<string, Document>();
-
-    public async save(): Promise<void> {
-        Logger.info(`Saving ${this.operations.length} operations`);
-
-        for (const operation of this.operations) {
-            if (operation.action === FirestoreClient.Action.Create) {
-                Logger.info(`Create document ${operation.document._path}`);
-                await this.db.doc(operation.document._path).set(serialize(operation.document));
-            } else if (operation.action === FirestoreClient.Action.Update) {
-                Logger.info(`Update document ${operation.document._path}`);
-                await this.db.doc(operation.document._path).set(serialize(operation.document));
-            } else if (operation.action === FirestoreClient.Action.Delete) {
-                Logger.info(`Delete document ${operation.document._path}`);
-                await this.db.doc(operation.document._path).delete();
-            } else {
-                throw new Error(`Transactional Repository: Not supported action ${operation.action}`);
-            }
-        }
-    }
-
-    public async _find<T>(path: string): Promise<T> {
-        Logger.info(`Repository: find ${path}`);
-        if (this.cachedDocuments.has(path)) {
-            Logger.info(`Repository: document returned from transaction`);
-            return <any>this.cachedDocuments.get(path);
-        }
-        const doc = await this.db.doc(path).get();
-        const result = doc.data();
-        return result ? deserialize(result) : null;
-    }
-
-    public async _get<T>(path: string): Promise<T> {
-        Logger.info(`Repository: get ${path}`);
-        const result = await this._find<T>(path);
-        if (!result) {
-            throw new NotFoundError(`Repository: document ${path} not found`);
-        }
-
-        return result;
-    }
-
-    public async _getAll<T>(collection: string): Promise<T[]> {
-        Logger.info(`Repository: getAll ${collection}`);
-        const documents: T[] = [];
-        const querySnapshot = await this.getCollectionReference(collection).get();
-        querySnapshot.forEach(doc => {
-            documents.push(deserialize(doc.data()));
-        });
-        return documents;
-    }
-
-    public async _getWhere<T>(collection: string, whereClauses: [string, FirestoreClient.Operator, any | any[]][] = [], orderBy: string = null): Promise<T[]> {
-        Logger.info(`Repository: getWhere ${collection} whereClauses: ${JSON.stringify(whereClauses)}`);
-        const documents: T[] = [];
-
-        let query = this.getCollectionReference(collection);
-
-        whereClauses.forEach(where => {
-            query = query.where(where[0], where[1], where[2]);
-        });
-
-        if (orderBy) {
-            query = query.orderBy(orderBy);
-        }
-
-        const querySnapshot = await query.get();
-        querySnapshot.forEach(doc => {
-            documents.push(deserialize(doc.data()));
-        });
-
-        return documents;
-    }
-
-
-    public createDocument(document: Document): void {
-        this.operations.push({ document, action: FirestoreClient.Action.Create });
-        this.cachedDocuments.set(document._path, document);
-    }
-
-    public updateDocument(document: Document): void {
-        this.operations.push({ document, action: FirestoreClient.Action.Update });
-        this.cachedDocuments.set(document._path, document);
-    }
-
-    public deleteDocument(document: Document): void {
-        this.operations.push({ document, action: FirestoreClient.Action.Delete });
-        this.cachedDocuments.delete(document._path);
-    }
-
-    private getCollectionReference(collection: string): FirebaseFirestore.CollectionReference | FirebaseFirestore.Query {
-        if (collection.startsWith('**/')) {
-            return this.db.collectionGroup(collection.replace('**/', ''));
-        } else {
-            return this.db.collection(collection);
-        }
-    }
-}
-
-export namespace FirestoreClient {
-
-    export interface Operation {
-        document: Document;
-        action: Action;
-    }
-
-    export enum Action {
-        Create = <any>'Create',
-        Update = <any>'Update',
-        Delete = <any>'Delete'
-    }
-    export type Operator = FirebaseFirestore.WhereFilterOp;
-}