Add fromPrimitives and toPrimitives

Author: rsaladocid

src/Contexts/Mooc/Courses/domain/AggregateRoot.ts

@@ -14,4 +14,6 @@ export abstract class AggregateRoot {
   record(event: DomainEvent): void {
     this.domainEvents.push(event);
   }
+
+  abstract toPrimitives(): any;
 }

src/Contexts/Mooc/Courses/domain/Course.ts

@@ -29,4 +29,20 @@ export class Course extends AggregateRoot {
 
     return course;
   }
+
+  static fromPrimitives(plainData: any): Course {
+    return new Course(
+      new CourseId(plainData.id),
+      new CourseName(plainData.name),
+      new CourseDuration(plainData.duration)
+    );
+  }
+
+  toPrimitives(): any {
+    return {
+      id: this.id.value,
+      name: this.name.value,
+      duration: this.duration.value
+    };
+  }
 }

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

@@ -1,40 +1,23 @@
-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');
+export class MongoCourseRepository extends MongoRepository<Course> implements CourseRepository {
+  public save(course: Course): Promise<void> {
+    return this.persist(course.id.value, course);
   }
 
   public async search(id: CourseId): Promise<Nullable<Course>> {
-    const collection = await this.coursesCollection();
+    const collection = await this.collection();
 
     const document = await collection.findOne({ _id: id.value });
 
-    return document ? toDomain(document) : null;
+    return document ? Course.fromPrimitives({ ...document, id: id.value }) : 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));
+  protected moduleName(): string {
+    return 'courses';
+  }
+}

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'), { useUnifiedTopology: true });
+    const client = new MongoClient(config.get('mongo.url'), { useUnifiedTopology: true, ignoreUndefined: true });
 
     await client.connect();
 

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

@@ -1,18 +1,24 @@
 import { Collection, MongoClient } from 'mongodb';
-import { MongoDocument } from './MongoDocument';
+import { AggregateRoot } from '../../../../Mooc/Courses/domain/AggregateRoot';
 
-export class MongoRepository<T extends MongoDocument> {
+export abstract class MongoRepository<T extends AggregateRoot> {
   constructor(private _client: Promise<MongoClient>) {}
 
+  protected abstract moduleName(): string;
+
   protected client(): Promise<MongoClient> {
     return this._client;
   }
 
-  protected async collection(name: string): Promise<Collection<T>> {
-    return (await this._client).db().collection(name);
+  protected async collection(): Promise<Collection> {
+    return (await this._client).db().collection(this.moduleName());
   }
 
-  protected async persist(document: T, collection: Collection<T>): Promise<void> {
-    await collection.updateOne({ _id: document._id } as any, { $set: document }, { upsert: true });
+  protected async persist(id: string, aggregateRoot: T): Promise<void> {
+    const collection = await this.collection();
+
+    const document = { ...aggregateRoot.toPrimitives(), _id: id, id: undefined };
+
+    await collection.updateOne({ _id: id }, { $set: document }, { upsert: true });
   }
 }