@my-devkit/firebase 1.0.76 → 1.0.77

package/src/aggregate.ts

@@ -1,54 +0,0 @@
-import { autoserializeAs, Document, DomainError, Event, guid, serialize } from '@my-devkit/core';
-
-import { Context } from './context';
-
-export abstract class Aggregate implements Document {
-    @autoserializeAs(String) public id: string = null;
-    @autoserializeAs(String) public _type: string = null;
-    private _events: Event[] = [];
-
-    public constructor() {
-        this.id = guid();
-        this._type = this.constructor.name;
-    }
-
-    public get _path(): string {
-        return `/aggregates/${this.id}`;
-    }
-
-    public get hash(): string {
-        return JSON.stringify(serialize(this));
-    }
-
-    protected assert(value: boolean, errorMessage: string): void {
-        if (!value) {
-            throw new DomainError(errorMessage);
-        }
-    }
-
-    protected apply<E extends Event>(event: E): void {
-        const methodName = `apply${event._type}`;
-        if (!(methodName in this)) {
-            throw new Error(`${this._type}.${methodName} method is missing!`);
-        }
-
-        event._aggregateId = this.id;
-        event._aggregateType = this._type;
-
-        event._correlationId = Context.correlationId;
-        event._publishedBy = Context.user ? Context.user.uid : null;
-        event.publishedAt = new Date();
-
-        this[methodName](event);
-
-        this._events.push(event);
-    }
-
-    public get events(): Event[] {
-        return [...this._events];
-    }
-
-    public clearEvents(): void {
-        this._events = [];
-    }
-}

package/src/app-factory.ts

@@ -1,252 +0,0 @@
-import { deserialize, Event, guid, Logger, retry } from '@my-devkit/core';
-import { initializeApp } from 'firebase-admin/app';
-import { Auth, getAuth } from 'firebase-admin/auth';
-import { DocumentSnapshot, Firestore, getFirestore } from 'firebase-admin/firestore';
-import { CloudFunction, config, FunctionBuilder, HttpsFunction, logger, region, RuntimeOptions, SUPPORTED_REGIONS, VALID_MEMORY_OPTIONS } from 'firebase-functions';
-
-import { Bus } from './bus';
-import { MODULE_METADATA } from './constants';
-import { Context } from './context';
-import { ExecutionMode } from './execution-mode-enum';
-import { FirestoreClient } from './firestore-client';
-import { Type } from './interfaces';
-import { reflect } from './reflect';
-import { Server } from './server';
-
-export class AppFactory {
-    private static functionInRegion: FunctionBuilder;
-    private static firestore: Firestore;
-    private static auth: Auth;
-    private static publicPaths: string[];
-    private static instanceId: string;
-
-    public static isActive(name: string): boolean {
-        const functionName = process.env.FUNCTION_NAME || process.env.K_SERVICE;
-        return !functionName || functionName === name;
-    }
-
-    public static initializeApp(options: AppFactory.Options): void {
-        this.instanceId = guid();
-
-        Context.init();
-        this.registerLogger();
-
-        this.publicPaths = options.publicPaths || [];
-
-        const app = initializeApp(config().firebase);
-        this.firestore = getFirestore(app);
-        this.firestore.settings({});
-
-        this.auth = getAuth(app);
-
-        const runtimeOptions: RuntimeOptions = {
-            timeoutSeconds: options.timeoutSeconds,
-            memory: options.memory
-        }
-
-        this.functionInRegion = region(this.isEmulator ? 'functions' : options.region).runWith(runtimeOptions);
-    }
-
-    public static createHttpFunction(name: string, module: Type): HttpsFunction {
-        if (!this.isActive(name)) {
-            return null;
-        }
-
-        Logger.info(`Cold Start Http function ${name}`);
-
-        const bus = new Bus();
-
-        const server = new Server({
-            bus,
-            firebaseAuth: this.auth,
-            firestore: this.firestore,
-            publicPaths: this.publicPaths
-        });
-
-        this.registerControllers(server, module);
-
-        this.registerEventPersisterHandler(bus);
-
-        this.registerHandlers(bus, module);
-
-        return this.functionInRegion.https.onRequest(server.app);
-    }
-
-    public static createEventListener(name: string, module: Type, mode: ExecutionMode = ExecutionMode.Asynchronous): CloudFunction<DocumentSnapshot> {
-        if (!this.isActive(name)) {
-            return null;
-        }
-
-        Logger.info(`Cold Start Event Listener ${mode}`);
-
-        const bus = new Bus();
-
-        this.registerEventPersisterHandler(bus);
-
-        this.registerHandlers(bus, module);
-
-        return this.functionInRegion
-            .firestore
-            .document('events/{eventId}')
-            .onCreate(this.getFunctionEventHandler(bus, ExecutionMode.Asynchronous));
-    }
-
-    private static registerEventPersisterHandler(bus: Bus): void {
-        bus.onEachEvent(async (event: Event): Promise<void> => {
-            Context.resolve(FirestoreClient).createDocument(event);
-        }, ExecutionMode.Synchronous);
-    }
-
-    private static registerControllers(server: Server, module: Type): void {
-        const controllers = Reflect.getMetadata(MODULE_METADATA.CONTROLLERS, module) || [];
-        for (const controller of controllers) {
-            this.registerController(server, controller);
-        }
-
-        const imports: any[] = Reflect.getMetadata(MODULE_METADATA.IMPORTS, module) || [];
-        for (const importedModule of imports) {
-            this.registerControllers(server, importedModule);
-        }
-    }
-
-    private static registerController(server: Server, controller: Type): void {
-        const router = new Server.Router();
-
-        const config = reflect(controller).getControllerConfiguration();
-
-        for (const route of config.routes) {
-            router.registerRoute(route.requestMethod, `/${route.path}`, async (request: Server.Request, response: Server.Response): Promise<void> => {
-                Logger.info(`${route.requestMethod}/${route.path}: executing handler method ${controller.name}.${route.methodName}`);
-                const controllerInstance = Context.resolve(controller);
-                const args = route.argumentInjectors.map(injector => injector(request));
-                const result = await controllerInstance[route.methodName](...args);
-
-                for (const client of Context.getTransactionalClients()) {
-                    Logger.info(`Saving transactions...`);
-                    await client.save();
-                }
-
-                Context.destroy();
-                response.status(Server.statusCodes.OK).send({ result });
-            });
-        }
-
-        router.registerOnServer(`/${config.basePath}`, server);
-    }
-
-    private static registerHandlers(bus: Bus, module: Type): void {
-        const handlers = Reflect.getMetadata(MODULE_METADATA.HANDLERS, module) || [];
-        for (const handler of handlers) {
-            const handlerConfiguration = reflect(handler).getHandlerConfiguration();
-
-            const instance = new handler();
-            for (const commandHandler of Array.from(handlerConfiguration.commandHandlers.values())) {
-                Logger.debug(`onCommand ${commandHandler.command.constructor.name} => ${handler.name}.${commandHandler.methodName}`);
-                bus.onCommand(commandHandler.command, (command) => {
-                    const startDate = new Date();
-                    Logger.info(`${handler.name}.${commandHandler.methodName} handle ${command._type}`);
-                    const result = instance[commandHandler.methodName](command);
-                    Logger.infoWithElapesedTime(`${command._type} handled by ${handler.name}.${commandHandler.methodName}`, startDate);
-                    return result;
-                });
-            }
-
-            for (const eventHandler of Array.from(handlerConfiguration.eventHandlers.values())) {
-                Logger.debug(`onEvent ${eventHandler.event.constructor.name} => ${handler.name}.${eventHandler.methodName} (mode: ${eventHandler.executionMode})`);
-                bus.onEvent(eventHandler.event, async (event) => {
-                    const startDate = new Date();
-                    Logger.info(`${handler.name}.${eventHandler.methodName} handle ${event._type}`);
-                    await instance[eventHandler.methodName](event);
-                    Logger.infoWithElapesedTime(`${event._type} handled by ${handler.name}.${eventHandler.methodName}`, startDate);
-                }, eventHandler.executionMode);
-            }
-        }
-
-        const imports: any[] = Reflect.getMetadata(MODULE_METADATA.IMPORTS, module) || [];
-        for (const importedModule of imports) {
-            this.registerHandlers(bus, importedModule);
-        }
-    }
-
-    private static registerLogger(): void {
-        if (this.isEmulator) {
-            Logger.registerLogger(new Logger.ConsoleImplementation());
-            return;
-        }
-
-        const completeMetaData = (data: Logger.LogMetaData): Logger.LogMetaData => {
-            return {
-                instanceId: this.instanceId,
-                correlationId: Context.correlationId,
-                eventId: Context.eventId,
-                userId: Context.user?.uid,
-                userEmail: Context.user?.email,
-                ...data
-            };
-        };
-
-        Logger.registerLogger({
-            debug: (message: string, data: Logger.LogMetaData): void => {
-                logger.debug(message, completeMetaData(data));
-            },
-            info: (message: string, data: Logger.LogMetaData): void => {
-                logger.info(message, completeMetaData(data));
-            },
-            warn: (message: string, data: Logger.LogMetaData): void => {
-                logger.warn(message, completeMetaData(data));
-            },
-            error: (message: string, data: Logger.LogMetaData): void => {
-                logger.error(message, completeMetaData(data));
-            }
-        });
-    }
-
-    public static getFunctionEventHandler(bus: Bus, mode: ExecutionMode): (snapshot: DocumentSnapshot) => any {
-        return async (snapshot: DocumentSnapshot): Promise<void> => {
-            const startDate = new Date();
-            const unserializedEvent = snapshot.data();
-
-            const event = deserialize<Event>(unserializedEvent);
-
-            Context.create(bus);
-            Context.correlationId = event._correlationId;
-            Context.eventId = event.id;
-
-            if (unserializedEvent['_restored'] === true) {
-                Logger.debug(`Event ${event._type} is ignored as it is restored from backup.`);
-                return;
-            }
-
-            try {
-                await retry(async (): Promise<void> => {
-                    Logger.info(`${'-'.repeat(5)} handling ${event._type} ${'-'.repeat(5)}`);
-
-                    await bus.publish(event, mode);
-
-                    for (const client of Context.getTransactionalClients()) {
-                        await client.save();
-                    }
-
-                    Logger.infoWithElapesedTime(`${'-'.repeat(5)} ${event._type} handled successfully ${'-'.repeat(5)}`, startDate);
-                });
-            } catch (error) {
-                Logger.error(`${'-'.repeat(5)} ${event._type} couldn't be handled correctly ${'-'.repeat(5)}`, { error });
-            } finally {
-                Context.destroy();
-            }
-        };
-    }
-
-    private static get isEmulator(): boolean {
-        return !!process.env.FUNCTIONS_EMULATOR;
-    }
-}
-
-export namespace AppFactory {
-    export interface Options {
-        region: typeof SUPPORTED_REGIONS[number];
-        timeoutSeconds: number;
-        memory: typeof VALID_MEMORY_OPTIONS[number];
-        publicPaths?: string[]
-    }
-}

package/src/bus.ts

@@ -1,70 +0,0 @@
-import { Command, DomainError, Event, Logger, serialize, Validators } from '@my-devkit/core';
-
-import { ExecutionMode } from './execution-mode-enum';
-
-export class Bus {
-    private commandHandlers = new Map<string, Bus.Handler<Command, any>>();
-    private eventHandlers = new Map<string, Bus.Handler<Event, void>[]>();
-
-    public async send<T, C extends Command>(command: C): Promise<T> {
-        Logger.info(`Bus.send ${command._type}`, { command: serialize(command) });
-
-        const validationErrors = Validators.validate(command);
-        if (validationErrors.length > 0) {
-            throw new DomainError(validationErrors[0].getErrorMessage());
-        }
-
-        const handler: Bus.Handler<C, T> = this.commandHandlers.get(command._type);
-        if (!handler) {
-            throw new Error(`No command handler for ${command._type}`);
-        }
-        Logger.info(`Run command handler ${handler.name}`);
-
-        return handler(command);
-    }
-
-    public async publish<E extends Event>(event: E, mode: ExecutionMode = ExecutionMode.Synchronous): Promise<void> {
-        Logger.info(`Bus.publish ${event._type} `, { event: serialize(event) });
-
-        const handlers = [...this.getEventHandlers(event._type, mode), ...this.getEventHandlers('**', mode)];
-        for (const handler of handlers) {
-            Logger.info(`Run event handler ${handler.name}`);
-            await handler(event);
-        }
-    }
-
-    public onCommand<C extends Command, R>(commandType: new () => C, handler: Bus.Handler<C, R>): void {
-        const commandName = commandType.constructor.name;
-        this.commandHandlers.set(commandName, handler);
-    }
-
-    public onEvent<E extends Event>(eventType: new () => E, handler: Bus.Handler<E, void>, mode: ExecutionMode): void {
-        this.registerEventHandler(eventType.constructor.name, mode, handler);
-    }
-
-    public onEachEvent<E extends Event>(handler: Bus.Handler<E, void>, mode: ExecutionMode): void {
-        this.registerEventHandler('**', mode, handler);
-    }
-
-    private getDictionaryKey(eventType: string, mode: ExecutionMode): string {
-        return `${eventType}_${mode.toString()}`;
-    }
-
-    private registerEventHandler<E extends Event>(type: string, mode: ExecutionMode, handler: Bus.Handler<E, void>): void {
-        const key = this.getDictionaryKey(type, mode);
-
-        if (!this.eventHandlers.has(key)) {
-            this.eventHandlers.set(key, []);
-        }
-        this.eventHandlers.get(key).push(handler);
-    }
-
-    private getEventHandlers(type: string, mode: ExecutionMode) {
-        const key = this.getDictionaryKey(type, mode);
-        return this.eventHandlers.get(key) || [];
-    }
-}
-
-export namespace Bus {
-    export type Handler<T, R> = (arg: T) => Promise<R>;
-}

package/src/constants.ts

@@ -1,5 +0,0 @@
-export const MODULE_METADATA = {
-    IMPORTS: 'imports',
-    CONTROLLERS: 'controllers',
-    HANDLERS: 'handlers'
-};

package/src/context.ts

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

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

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

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

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

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

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

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