Add query bus (WIP)

Co-authored-by: aliondev <antonioleon@audiense.com>
Co-authored-by: Rubén Salado <rsaladocid@users.noreply.github.com>

Author: 3 people

src/Contexts/Shared/domain/Query.ts

@@ -0,0 +1 @@
+export abstract class Query {}

src/Contexts/Shared/domain/QueryBus.ts

@@ -0,0 +1,5 @@
+import { Query } from './Query';
+
+export interface QueryBus {
+  ask<T>(query: Query): Promise<T>;
+}

src/Contexts/Shared/domain/QueryHandler.ts

@@ -0,0 +1,7 @@
+import { Query } from './Query';
+import { Response } from './Response';
+
+export interface QueryHandler<T extends Query, R extends Response> {
+  subscribedTo(): Query;
+  handle(query: T): Promise<R>;
+}

src/Contexts/Shared/domain/QueryNotRegisteredError.ts

@@ -0,0 +1,7 @@
+import { Query } from './Query';
+
+export class QueryNotRegisteredError extends Error {
+  constructor(query: Query) {
+    super(`The query <${query.constructor.name}> hasn't a query handler associated`);
+  }
+}

src/Contexts/Shared/domain/Response.ts

@@ -0,0 +1 @@
+export interface Response {}

src/Contexts/Shared/infrastructure/QueryBus/QueryHandlersInformation.ts

@@ -0,0 +1,32 @@
+import { Query } from '../../domain/Query';
+import { QueryHandler } from '../../domain/QueryHandler';
+import { Response } from '../../domain/Response';
+import { QueryNotRegisteredError } from '../../domain/QueryNotRegisteredError';
+
+export class QueryHandlersInformation {
+  private queryHandlersMap: Map<Query, QueryHandler<Query, Response>>;
+
+  constructor(queryHandlers: Array<QueryHandler<Query, Response>>) {
+    this.queryHandlersMap = this.formatHandlers(queryHandlers);
+  }
+
+  private formatHandlers(queryHandlers: Array<QueryHandler<Query, Response>>): Map<Query, QueryHandler<Query, Response>> {
+    const handlersMap = new Map();
+
+    queryHandlers.forEach(queryHandler => {
+      handlersMap.set(queryHandler.subscribedTo(), queryHandler);
+    });
+
+    return handlersMap;
+  }
+
+  public search(query: Query): QueryHandler<Query, Response> {
+    const queryHandler = this.queryHandlersMap.get(query.constructor);
+
+    if (!queryHandler) {
+      throw new QueryNotRegisteredError(query);
+    }
+
+    return queryHandler;
+  }
+}

src/apps/mooc_backend/controllers/CoursesCounterGetController.ts

@@ -8,6 +8,9 @@ export class CoursesCounterGetController implements Controller {
   constructor(private coursesCounterFinder: CoursesCounterFinder) {}
   async run(req: Request, res: Response): Promise<void> {
     try {
+      const query = new FindCourseCounterQuery();
+      const count = await this.queryBus.query(query);
+
       const counter = await this.coursesCounterFinder.run();
       res.status(httpStatus.OK).send(counter);
     } catch (e) {

tests/Contexts/Shared/infrastructure/QueryBus/InMemoryQueryBus.test.ts

@@ -0,0 +1,49 @@
+import { Query } from '../../../../../src/Contexts/Shared/domain/Query';
+import { QueryHandlersInformation } from '../../../../../src/Contexts/Shared/infrastructure/QueryBus/QueryHandlersInformation';
+import { QueryNotRegisteredError } from '../../../../../src/Contexts/Shared/domain/QueryNotRegisteredError';
+import { QueryHandler } from '../../../../../src/Contexts/Shared/domain/QueryHandler';
+import { Response } from '../../../../../src/Contexts/Shared/domain/Response';
+
+class UnhandledQuery extends Query {
+  static QUERY_NAME = 'unhandled.query';
+}
+
+class HandledQuery extends Query {
+  static QUERY_NAME = 'handled.query';
+}
+
+class MyQueryHandler implements QueryHandler<Query, Response> {
+  subscribedTo(): HandledQuery {
+    return HandledQuery;
+  }
+
+  async handle(query: HandledQuery): Promise<Response> {return {};}
+}
+
+describe('InMemoryQueryBus', () => {
+  it('throws an error if dispatches a query without handler', async () => {
+    const unhandledQuery = new UnhandledQuery();
+    const queryHandlersInformation = new QueryHandlersInformation([]);
+    const queryBus = new InMemoryQueryBus(queryHandlersInformation);
+
+    let exception = null;
+
+    try {
+      await queryBus.ask(unhandledQuery);
+    } catch (error) {
+      exception = error;
+    }
+
+    expect(exception).toBeInstanceOf(QueryNotRegisteredError);
+    expect(exception.message).toBe(`The query <UnhandledCommand> hasn't a query handler associated`);
+  });
+
+  it('accepts a query with handler', async () => {
+    const handledQuery = new HandledQuery();
+    const myQueryHandler = new MyQueryHandler();
+    const queryHandlersInformation = new QueryHandlersInformation([myQueryHandler]);
+    const queryBus = new InMemoryQueryBus(queryHandlersInformation);
+
+    await queryBus.ask(handledQuery);
+  });
+});