@my-devkit/firebase 1.0.76 → 1.0.80

package/src/handler-helper.ts

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

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

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

@@ -1 +0,0 @@
-

package/src/interfaces/from-array.ts

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

package/src/interfaces/index.ts

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

package/src/interfaces/newable.ts

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

package/src/interfaces/transactional-client.ts

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

package/src/interfaces/type.ts

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

package/src/reflect.ts

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

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

package/src/server/index.ts

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

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

@@ -1,47 +0,0 @@
-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');
-        }
-    };
-}

package/src/server/middlewares/create-context-middleware.ts

@@ -1,16 +0,0 @@
-import { guid, Logger } from '@my-devkit/core';
-
-import { Bus } from '../../bus';
-import { Context } from '../../context';
-import { Server } from '../server';
-
-export function CreateContextMiddleware(bus: Bus): Server.RequestHandler {
-    return async (request: Server.Request, _response: Server.Response, next: Server.NextFunction): Promise<void> => {
-        Context.create(bus);
-        Context.correlationId = request.header('X-Correlation-ID') || guid();
-
-        Logger.info(`${request.method} ${request.path}: context created`);
-
-        next();
-    };
-}

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

@@ -1,33 +0,0 @@
-import { Logger } from '@my-devkit/core';
-
-import { Context } from '../../context';
-import { Server } from '../server';
-
-export function ErrorMiddleWare(): Server.ErrorHandler {
-    return async (error: any, _request: Server.Request, response: Server.Response): Promise<void> => {
-        if (!(error instanceof Error)) {
-            error = new Error(error);
-        }
-
-        let status = Server.statusCodes.INTERNAL_SERVER_ERROR;
-        if (error.name === 'UnauthorizedError') {
-            status = Server.statusCodes.UNAUTHORIZED;
-        } else if (error.name === 'BadRequestError') {
-            status = Server.statusCodes.BAD_REQUEST;
-        } else if (error.name === 'DomainError') {
-            status = Server.statusCodes.BAD_REQUEST;
-        } else if (error.name === 'ForbiddenError') {
-            status = Server.statusCodes.FORBIDDEN;
-        } else if (error.name === 'NotImplemented') {
-            status = Server.statusCodes.NOT_IMPLEMENTED;
-        } else if (error.name === 'NotFoundError') {
-            status = Server.statusCodes.NOT_FOUND;
-        }
-
-        Logger.error(`${error.name}: ${error.message}`);
-
-        Context.destroy();
-
-        response.status(status).send({ message: error.message });
-    };
-}

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

@@ -1,16 +0,0 @@
-import { Context } from '../../context';
-import { Server } from '../server';
-
-export function HeadersMiddleWare(): Server.RequestHandler {
-    return async (_request: Server.Request, response: Server.Response, next: Server.NextFunction): Promise<void> => {
-        response.removeHeader('X-Powered-By'); // Remove verbose express
-        response.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate'); // HTTP 1.1.
-        response.setHeader('Pragma', 'no-cache'); // HTTP 1.0.
-        response.setHeader('Expires', '0'); // Proxies.
-        response.setHeader('Content-Type', 'application/json'); // default response type
-        response.setHeader('Access-Control-Allow-Credentials', 'true');
-        response.setHeader('X-Correlation-ID', Context.correlationId);
-
-        next();
-    };
-}

package/src/server/middlewares/index.ts

@@ -1,5 +0,0 @@
-export * from './create-context-middleware';
-export * from './authentication-middleware';
-export * from './headers-middleware';
-export * from './not-found-middleware';
-export * from './error-middleware';

package/src/server/middlewares/not-found-middleware.ts

@@ -1,9 +0,0 @@
-import { NotFoundError } from '@my-devkit/core';
-
-import { Server } from '../server';
-
-export function NotFoundMiddleware(): Server.RequestHandler {
-    return async (req: Server.Request): Promise<void> => {
-        throw new NotFoundError(`No controller found for ${req.method} ${req.path}`);
-    };
-}

package/src/server/server.ts

@@ -1,96 +0,0 @@
-import * as cors from 'cors';
-import * as express from 'express';
-import { auth, firestore } from 'firebase-admin';
-import { StatusCodes } from 'http-status-codes';
-
-import { Bus } from '../bus';
-import { RequestMethod } from '../request-method.enum';
-import * as middlewares from './middlewares';
-
-function encapsulate(handler: Server.RequestHandler): Server.RequestHandler {
-    return async (request: Server.Request, response: Server.Response, next: Server.NextFunction): Promise<void> => {
-        try {
-            await handler(request, response, next);
-        } catch (error) {
-            next(error);
-        }
-    };
-}
-
-export class Server {
-    private _app: express.Express;
-    public static statusCodes = StatusCodes;
-
-    constructor(options: Server.Options) {
-        this._app = express();
-        this.registerRequestHandler(cors({ origin: true }));
-        this.registerRequestHandler(middlewares.CreateContextMiddleware(options.bus));
-        this.registerRequestHandler(middlewares.HeadersMiddleWare());
-        this.registerRequestHandler(middlewares.AuthenticationMiddleware(options.firebaseAuth, options.publicPaths));
-    }
-
-    public registerRequestHandler(handler: Server.RequestHandler): void {
-        this._app.use(encapsulate(handler));
-    }
-
-    public registerErrorHandler(handler: Server.ErrorHandler): void {
-        this._app.use(async (error: any, request: Server.Request, response: Server.Response, next: Server.NextFunction): Promise<void> => {
-            try {
-                await handler(error, request, response, next);
-            } catch (error) {
-                next(error);
-            }
-        });
-    }
-
-    public registerRouter(path: string, router: express.Router): void {
-        this._app.use(path, router);
-    }
-
-    public get app(): express.Express {
-        this.registerRequestHandler(middlewares.NotFoundMiddleware());
-        this.registerErrorHandler(middlewares.ErrorMiddleWare());
-
-        return this._app;
-    }
-}
-
-export namespace Server {
-
-    export interface Options {
-        bus: Bus;
-        firebaseAuth: auth.Auth;
-        firestore: firestore.Firestore;
-        publicPaths: string[];
-    }
-
-    export class Router {
-        private router: express.Router;
-        constructor() {
-            this.router = express.Router();
-        }
-
-        public registerRoute(method: RequestMethod, path: string, handler: RequestHandler): void {
-            switch (method) {
-                case RequestMethod.GET:
-                    this.router.get(path, encapsulate(handler));
-                    break;
-                case RequestMethod.POST:
-                    this.router.post(path, encapsulate(handler));
-                    break;
-                default:
-                    throw new Error(`Server.Router:registerRoute: ${method} is not managed yet...`);
-            }
-        }
-
-        public registerOnServer(path: string, server: Server): void {
-            server.registerRouter(path, this.router);
-        }
-    }
-
-    export type Request = express.Request;
-    export type Response = express.Response;
-    export type NextFunction = express.NextFunction;
-    export type RequestHandler = (request: Request, response: Response, next: NextFunction) => Promise<void> | void;
-    export type ErrorHandler = (error: any, request: Request, response: Response, next: NextFunction) => Promise<void> | void;
-}

package/tsconfig.json

@@ -1,24 +0,0 @@
-{
-    "compileOnSave": false,
-    "compilerOptions": {
-        "target": "es5",
-        "lib": [
-            "es2016"
-        ],
-        "incremental": true,
-        "baseUrl": "src",
-        "outDir": "./dist",
-        "sourceMap": true,
-        "declaration": true,
-        "moduleResolution": "node",
-        "emitDecoratorMetadata": true,
-        "experimentalDecorators": true,
-        "typeRoots": [
-            "node_modules/@types"
-        ],
-        "types": [
-            "reflect-metadata",
-            "mocha"
-        ],
-    }
-}