Add course repository for Mongo

Author: rsaladocid

src/Contexts/Mooc/Courses/infrastructure/persistence/MongoCourseRepository.ts

@@ -0,0 +1,40 @@
+import { Collection } from 'mongodb';
+import { Nullable } from '../../../../Shared/domain/Nullable';
+import { MongoRepository } from '../../../../Shared/infrastructure/persistence/mongo/MongoRepository';
+import { CourseId } from '../../../Shared/domain/Courses/CourseId';
+import { Course } from '../../domain/Course';
+import { CourseDuration } from '../../domain/CourseDuration';
+import { CourseName } from '../../domain/CourseName';
+import { CourseRepository } from '../../domain/CourseRepository';
+import { CourseDocument } from './mongo/CourseDocument';
+
+export class MongoCourseRepository extends MongoRepository<CourseDocument> implements CourseRepository {
+  public async save(course: Course): Promise<void> {
+    const document = toPersistence(course);
+
+    const collection = await this.coursesCollection();
+
+    await this.persist(document, collection);
+  }
+
+  private async coursesCollection(): Promise<Collection<CourseDocument>> {
+    return this.collection('courses');
+  }
+
+  public async search(id: CourseId): Promise<Nullable<Course>> {
+    const collection = await this.coursesCollection();
+
+    const document = await collection.findOne({ _id: id.value });
+
+    return document ? toDomain(document) : null;
+  }
+}
+
+const toPersistence = (source: Course): CourseDocument => ({
+  _id: source.id.value,
+  name: source.name.value,
+  duration: source.duration.value
+});
+
+const toDomain = (source: CourseDocument): Course =>
+  new Course(new CourseId(source._id), new CourseName(source.name), new CourseDuration(source.duration));

src/Contexts/Mooc/Courses/infrastructure/persistence/mongo/CourseDocument.ts

@@ -0,0 +1,6 @@
+import { MongoDocument } from '../../../../../Shared/infrastructure/persistence/mongo/MongoDocument';
+
+export type CourseDocument = MongoDocument & {
+  name: string;
+  duration: string;
+};

src/Contexts/Shared/infrastructure/persistence/mongo/MongoClientFactory.ts

@@ -22,7 +22,7 @@ export class MongoClientFactory {
   }
 
   private static async createAndConnectClient(): Promise<MongoClient> {
-    const client = new MongoClient(config.get('mongo.url'));
+    const client = new MongoClient(config.get('mongo.url'), { useUnifiedTopology: true });
 
     await client.connect();
 

src/Contexts/Shared/infrastructure/persistence/mongo/MongoDocument.ts

@@ -0,0 +1,3 @@
+export type MongoDocument = {
+  _id: string;
+};

src/Contexts/Shared/infrastructure/persistence/mongo/MongoRepository.ts

@@ -0,0 +1,18 @@
+import { Collection, MongoClient } from 'mongodb';
+import { MongoDocument } from './MongoDocument';
+
+export class MongoRepository<T extends MongoDocument> {
+  constructor(private _client: Promise<MongoClient>) {}
+
+  protected client(): Promise<MongoClient> {
+    return this._client;
+  }
+
+  protected async collection(name: string): Promise<Collection<T>> {
+    return (await this._client).db().collection(name);
+  }
+
+  protected async persist(document: T, collection: Collection<T>): Promise<void> {
+    await collection.updateOne({ _id: document._id } as any, { $set: document }, { upsert: true });
+  }
+}

src/apps/mooc_backend/config/config.ts

@@ -12,11 +12,6 @@ const convictConfig = convict({
       doc: 'The Mongo connection URL',
       format: String,
       env: 'MONGO_URL'
-    },
-    name: {
-      doc: 'The Mongo database name',
-      format: String,
-      env: 'MONGO_DB_NAME'
     }
   }
 });

src/apps/mooc_backend/config/dependency-injection/application.yaml

@@ -1,7 +1,13 @@
 services:
+  Mooc.ConnectionManager:
+    factory:
+      class: ../../../../Contexts/Shared/infrastructure/persistence/mongo/MongoClientFactory
+      method: "createClient"
+    arguments: ["mooc"]
+
   Mooc.courses.CourseRepository:
-    class: ../../../../Contexts/Mooc/Courses/infrastructure/FileCourseRepository
-    arguments: []
+    class: ../../../../Contexts/Mooc/Courses/infrastructure/persistence/MongoCourseRepository
+    arguments: ["@Mooc.ConnectionManager"]
 
   Mooc.courses.CourseCreator:
     class: ../../../../Contexts/Mooc/Courses/application/CourseCreator

src/apps/mooc_backend/config/dependency-injection/application_test.yaml

@@ -1,2 +1,9 @@
 imports:
   - { resource: ./application.yaml }
+
+services:
+  Mooc.EnvironmentArranger:
+    factory:
+      class: ../../../../../tests/Contexts/Shared/infrastructure/arranger/EnvironmentArrangerFactory
+      method: createEnvironmentArranger
+    arguments: ["@Mooc.ConnectionManager"]

tests/Contexts/Mooc/Courses/infrastructure/persistence/CourseRepository.test.ts

@@ -0,0 +1,37 @@
+import container from '../../../../../../src/apps/mooc_backend/config/dependency-injection';
+import { CourseRepository } from '../../../../../../src/Contexts/Mooc/Courses/domain/CourseRepository';
+import { EnvironmentArranger } from '../../../../Shared/infrastructure/arranger/EnvironmentArranger';
+import { CourseMother } from '../../domain/CourseMother';
+
+const repository: CourseRepository = container.get('Mooc.courses.CourseRepository');
+const environmentArranger: Promise<EnvironmentArranger> = container.get('Mooc.EnvironmentArranger');
+
+beforeAll(async () => {
+  await (await environmentArranger).arrange('courses');
+});
+
+afterAll(async () => {
+  await (await environmentArranger).close();
+});
+
+describe('Save Course', () => {
+  it('should save a course', async () => {
+    const course = CourseMother.random();
+
+    await repository.save(course);
+  });
+});
+
+describe('Search Course', () => {
+  it('should return an existing course', async () => {
+    const course = CourseMother.random();
+
+    await repository.save(course);
+
+    expect(course).toEqual(await repository.search(course.id));
+  });
+
+  it('should not return a non existing course', async () => {
+    expect(await repository.search(CourseMother.random().id)).toBeFalsy();
+  });
+});