@my-devkit/firebase 1.0.80 → 1.0.84

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

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

@@ -0,0 +1,24 @@
+import { Event } from '@my-devkit/core';
+
+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/execution-mode-enum.ts

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

package/src/firestore-client.ts

@@ -0,0 +1,125 @@
+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;
+}

package/src/handler-helper.ts

@@ -0,0 +1,68 @@
+import { Logger } from '@my-devkit/core';
+
+import { Aggregate } from './aggregate';
+import { Context } from './context';
+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> {
+        const result = await callback(aggregate);
+
+        this.client.createDocument(aggregate);
+        await this.publishEvents(aggregate);
+
+        return result;
+    }
+
+    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!!`);
+        }
+        const hashBefore = aggregate.hash;
+
+        const result = await callback(aggregate);
+
+        if (aggregate.hash !== hashBefore) {
+            this.client.updateDocument(aggregate);
+            await this.publishEvents(aggregate);
+        } else {
+            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> {
+        const aggregate = await this.getAggregate(aggregateOrId);
+
+        const result = await callback(aggregate);
+
+        this.client.deleteDocument(aggregate);
+        await this.publishEvents(aggregate);
+
+        return result;
+    }
+
+    private static get client(): FirestoreClient {
+        return Context.resolve(FirestoreClient);
+    }
+
+    private static async publishEvents<A extends Aggregate>(aggregate: A): Promise<void> {
+        const events = aggregate.events;
+        aggregate.clearEvents();
+
+        for (const event of events) {
+            await Context.bus.publish(event, ExecutionMode.Synchronous);
+        }
+    }
+
+    private static async getAggregate<A extends Aggregate>(aggregateOrId: A | string): Promise<A> {
+        if (typeof aggregateOrId === 'string' || aggregateOrId instanceof String) {
+            return this.client._find<A>(`/aggregates/${aggregateOrId}`);
+        }
+        return aggregateOrId;
+    }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './decorators';
+export * from './aggregate';
+export * from './context';
+export * from './app-factory';
+export * from './firestore-client';
+export * from './execution-mode-enum';
+export * from './handler-helper';

package/src/injector.ts

@@ -0,0 +1,31 @@
+import { ITransactionalClient, Type } from './interfaces';
+import { reflect } from './reflect';
+
+export class Injector {
+    private instances = new Map<string, any>();
+    private transactionalClients: ITransactionalClient[] = [];
+
+    public resolve<T>(target: Type<T>): T {
+        const injectableId = reflect(target).getInjectableId();
+        if (!injectableId) {
+            throw new Error(`${target.name} is not injectable`);
+        }
+
+        if (!this.instances.has(injectableId)) {
+            const tokens = reflect(target).getParameters();
+            const injections = tokens.map(token => this.resolve<any>(token));
+            const instance = new target(...injections);
+            this.instances.set(injectableId, instance);
+
+            if (reflect(target).isTransactionalClient()) {
+                this.transactionalClients.push(<any>instance);
+            }
+        }
+
+        return this.instances.get(injectableId);
+    }
+
+    public getTransactionalClients(): ITransactionalClient[] {
+        return [...this.transactionalClients];
+    }
+}

package/src/interfaces/app-config.ts

@@ -0,0 +1 @@
+

package/src/interfaces/from-array.ts

@@ -0,0 +1 @@
+export type FromArray<T extends ReadonlyArray<unknown>> = T extends ReadonlyArray<infer FromArray> ? FromArray : never;

package/src/interfaces/index.ts

@@ -0,0 +1,4 @@
+export * from './newable';
+export * from './from-array';
+export * from './type';
+export * from './transactional-client';

package/src/interfaces/newable.ts

@@ -0,0 +1 @@
+export type Newable<T> = new () => T;

package/src/interfaces/transactional-client.ts

@@ -0,0 +1,3 @@
+export interface ITransactionalClient {
+    save(): Promise<void>;
+}

package/src/interfaces/type.ts

@@ -0,0 +1,3 @@
+export interface Type<T = any> extends Function {
+    new(...args: any[]): T;
+}

package/src/reflect.ts

@@ -0,0 +1,164 @@
+import 'reflect-metadata';
+
+import { Command, Event, guid } from '@my-devkit/core';
+import { ExecutionMode } from 'execution-mode-enum';
+
+import { Type } from './interfaces';
+import { RequestMethod } from './request-method.enum';
+import { Server } from './server';
+
+/* eslint-disable @typescript-eslint/ban-types */
+class ReflectHelper<T extends ReflectTarget<any>> {
+    private readonly HANDLER_META_DATA = '__handler__';
+    private readonly CONTROLLER_META_DATA = '__controller__';
+    private readonly INJECTABLE_META_DATA = '__injectable__';
+    private readonly TRANSACTIONAL_CLIENT_META_DATA = '__transactional_client__';
+
+    constructor(private target: T, private methodName: string | symbol) {
+
+    }
+
+    public getParameters(): Type[] {
+        return Reflect.getMetadata('design:paramtypes', this.target, this.methodName) || [];
+    }
+
+    public registerInjectable(): void {
+        this.defineMetaData(this.INJECTABLE_META_DATA, guid());
+    }
+
+    public getInjectableId(): string {
+        return this.getMetaData<string>(this.INJECTABLE_META_DATA)
+    }
+
+    public registerTransactionalClient(): void {
+        this.defineMetaData(this.TRANSACTIONAL_CLIENT_META_DATA, guid);
+    }
+
+    public isTransactionalClient(): boolean {
+        return this.hasMetaData(this.TRANSACTIONAL_CLIENT_META_DATA)
+    }
+
+    public getControllerConfiguration(): ControllerConfiguration {
+        if (!this.hasMetaData(this.CONTROLLER_META_DATA)) {
+            this.defineMetaData<ControllerConfiguration>(this.CONTROLLER_META_DATA, {
+                basePath: null,
+                routes: []
+            });
+        }
+
+        return this.getMetaData<ControllerConfiguration>(this.CONTROLLER_META_DATA);
+    }
+
+    public registerController(basePath: string): void {
+        this.getControllerConfiguration().basePath = basePath;
+    }
+
+    public registerControllerRoute(route: { path: string, requestMethod: RequestMethod }): void {
+        this.getControllerRoute().path = route.path;
+        this.getControllerRoute().requestMethod = route.requestMethod;
+    }
+
+    public registerControllerRouteArgumentInjector<T>(injector: RequestArgumentInjector<T>, index: number): void {
+        this.getControllerRoute().argumentInjectors[index] = injector;
+    }
+
+    public getHandlerConfiguration(): HandlerConfiguration {
+        if (!this.hasMetaData(this.HANDLER_META_DATA)) {
+            this.defineMetaData<HandlerConfiguration>(this.HANDLER_META_DATA, {
+                commandHandlers: new Map<string, CommandHandler>(),
+                eventHandlers: new Map<string, EventHandler>()
+            });
+        }
+
+        return this.getMetaData<HandlerConfiguration>(this.HANDLER_META_DATA);
+    }
+
+    public registerCommandHandler<C extends Command>(command: new () => C): void {
+        this.getHandlerConfiguration().commandHandlers.set(this.methodName.toString(), {
+            methodName: this.methodName.toString(),
+            command
+        });
+    }
+
+    public registerEventHandler<E extends Event>(event: new () => E, executionMode: ExecutionMode): void {
+        this.getHandlerConfiguration().eventHandlers.set(this.methodName.toString(), {
+            methodName: this.methodName.toString(),
+            executionMode,
+            event
+        });
+    }
+
+    private getControllerRoute(): ControllerRoute {
+        const config = this.getControllerConfiguration();
+        if (!config.routes.find(r => r.methodName === this.methodName.toString())) {
+            config.routes.push({
+                methodName: this.methodName.toString(),
+                path: null,
+                requestMethod: null,
+                argumentInjectors: []
+            });
+        }
+
+        return config.routes.find(r => r.methodName === this.methodName.toString());
+    }
+
+    private getMetaData<M>(key: string): M {
+        return Reflect.getMetadata(key, this.targetConstructor);
+    }
+
+    private defineMetaData<M>(key: string, data: M): void {
+        Reflect.defineMetadata(key, data, this.targetConstructor);
+    }
+
+    private hasMetaData(key: string): boolean {
+        return Reflect.hasMetadata(key, this.targetConstructor);
+    }
+
+    private get targetConstructor() {
+        if (this.target['prototype']) {
+            return this.target['prototype'].constructor;
+        }
+
+        if (this.target.constructor) {
+            return this.target.constructor;
+        }
+
+        return this.target;
+    }
+}
+
+export interface ControllerConfiguration {
+    basePath: string;
+    routes: ControllerRoute[];
+}
+
+export interface ControllerRoute {
+    path: string;
+    methodName: string;
+    requestMethod: RequestMethod;
+    argumentInjectors: RequestArgumentInjector<any>[];
+}
+
+export interface CommandHandler {
+    methodName: string;
+    command: new () => Command;
+}
+
+export interface EventHandler {
+    methodName: string;
+    executionMode: ExecutionMode;
+    event: new () => Event;
+}
+
+export interface HandlerConfiguration {
+    commandHandlers: Map<string, CommandHandler>;
+    eventHandlers: Map<string, EventHandler>;
+}
+
+export type RequestArgumentInjector<T = any> = (req: Server.Request) => T;
+
+export function reflect<T extends ReflectTarget<any>>(target: T, methodName?: string | symbol): ReflectHelper<T> {
+    return new ReflectHelper(target, methodName);
+}
+
+type ReflectTarget<T> = T | (new (...args: any[]) => T);

package/src/request-method.enum.ts

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

package/src/server/index.ts

@@ -0,0 +1 @@
+export * from './server';

package/src/server/middlewares/authentication-middleware.ts

@@ -0,0 +1,47 @@
+import { Logger, UnauthorizedError } from '@my-devkit/core';
+import { Auth } from 'firebase-admin/auth';
+
+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;
+        Logger.info(`${request.method} ${request.path}: Authentication check`);
+
+        if (publicPaths.includes(request.path)) {
+            Logger.info(`${request.path} is a public path, no authorization check`);
+            Context.user = null;
+            next();
+        } else if (request.method === 'OPTIONS') {
+            next();
+        } else if (!authorizationHeader) {
+            throw new UnauthorizedError('No authorization header found');
+        } else if (authorizationHeader.startsWith('Bearer')) {
+            const idToken = authorizationHeader.split('Bearer ')[1];
+            try {
+                const decodedIdToken = await auth.verifyIdToken(idToken, true);
+                const userId = decodedIdToken.uid;
+                Context.user = await auth.getUser(userId);
+                next();
+            } catch (error) {
+                throw new UnauthorizedError(`Error while verifying token ${error.message ? error.message : null}`);
+            }
+        } else if (authorizationHeader.startsWith('Basic')) {
+            const idToken = authorizationHeader.split('Basic ')[1];
+            try {
+                const [userId, password] = Buffer.from(idToken, 'base64').toString().split(':');
+                if (password !== '20V0anV4M!we') {
+                    throw new Error('Wrong password!!');
+                }
+                Context.user = await auth.getUser(userId);
+                next();
+            } catch (error) {
+                throw new UnauthorizedError(`Error while verifying token ${error.message ? error.message : null}`);
+            }
+        } else {
+            throw new UnauthorizedError('Incorrect authorization header');
+        }
+    };
+}