Update BackofficeCourses on save method when the course already exists

Author: vilasmaciel

src/Contexts/Backoffice/Courses/infrastructure/persistence/ElasticBackofficeCourseRepository.ts

@@ -11,7 +11,12 @@ export class ElasticBackofficeCourseRepository
   }
 
   async save(course: BackofficeCourse): Promise<void> {
-    return this.persist(course);
+    const currentCourse = await this.findById(course.id.value, BackofficeCourse.fromPrimitives);
+    if (currentCourse) {
+      return this.update(course.id.value, course);
+    }
+
+    return this.persist(course.id.value, course);
   }
 
   async matching(criteria: Criteria): Promise<BackofficeCourse[]> {

src/Contexts/Shared/infrastructure/persistence/elasticsearch/ElasticRepository.ts

@@ -4,6 +4,7 @@ import bodybuilder, { Bodybuilder } from 'bodybuilder';
 import httpStatus from 'http-status';
 import { AggregateRoot } from '../../../domain/AggregateRoot';
 import { Criteria } from '../../../domain/criteria/Criteria';
+import { Nullable } from '../../../domain/Nullable';
 import ElasticConfig from './ElasticConfig';
 import { ElasticCriteriaConverter, TypeQueryEnum } from './ElasticCriteriaConverter';
 
@@ -58,10 +59,30 @@ export abstract class ElasticRepository<T extends AggregateRoot> {
     return e instanceof ResponseError && (e as ResponseError).meta.statusCode === httpStatus.NOT_FOUND;
   }
 
-  protected async persist(aggregateRoot: T): Promise<void> {
+  protected async persist(id: string, aggregateRoot: T): Promise<void> {
     const client = await this.client();
     const document = { ...aggregateRoot.toPrimitives() };
 
-    await client.index({ index: this.indexName(), body: document, refresh: 'wait_for' }); // wait_for wait for a refresh to make this operation visible to search
+    await client.index({ index: this.indexName(), id, body: document, refresh: 'wait_for' }); // wait_for wait for a refresh to make this operation visible to search
+  }
+
+  update(id: string, course: T): Promise<void> {
+    return this.persist(id, course);
+  }
+
+  protected async findById(id: string, unserializer: (data: any) => T): Promise<Nullable<T>> {
+    const client = await this.client();
+    try {
+      const { body } = await client.get({
+        index: this.indexName(),
+        id
+      });
+      return unserializer(body._source);
+    } catch (e) {
+      if (this.isNotFoundError(e)) {
+        return null;
+      }
+      throw e;
+    }
   }
 }

tests/Contexts/Backoffice/Courses/infrastructure/BackofficeCourseRepository.test.ts

@@ -17,6 +17,20 @@ afterEach(async () => {
 });
 
 describe('BackofficeCourseRepository', () => {
+  describe('#save', () => {
+    it('should be able to persist the same course twice', async () => {
+      const course = BackofficeCourseMother.random();
+
+      await repository.save(course);
+      await repository.save(course);
+
+      const persistedCourses = await repository.searchAll();
+
+      expect(persistedCourses).toHaveLength(1);
+      expect(persistedCourses).toEqual([course]);
+    });
+  });
+
   describe('#searchAll', () => {
     it('should return the existing courses', async () => {
       const courses = [BackofficeCourseMother.random(), BackofficeCourseMother.random()];