feat: implement updatemany, deletemany, getmany (#15)

* feat: implement updatemany, deletemany, getmany

Implemented new updateMany, deleteMany, getMany methods on InMemoryDBService

impl #14

Author: wesleygrimes

lib/services/in-memory-db.service.spec.ts

@@ -11,6 +11,7 @@ describe('In Memory DB Service', () => {
   const sampleRecords: TestEntity[] = [
     { id: 1, someField: 'AAA' },
     { id: 2, someField: 'BBB' },
+    { id: 3, someField: 'CCC' },
   ];
 
   beforeEach(() => {
@@ -42,6 +43,31 @@ describe('In Memory DB Service', () => {
       expect(actualRecord).toEqual(expectedRecord);
     });
   });
+  describe('getMany', () => {
+    it('should return expected records if given valid ids', () => {
+      // arrange
+      service.records = [...sampleRecords];
+      const expectedRecords = [...[sampleRecords[0], sampleRecords[1]]];
+
+      // act
+      const actualRecords = service.getMany([1, 2]);
+
+      // assert
+      expect(actualRecords).toEqual(expectedRecords);
+    });
+
+    it('should return only expected records if given an invalid id', () => {
+      // arrange
+      service.records = [...sampleRecords];
+      const expectedRecords = [sampleRecords[0]];
+
+      // act
+      const actualRecords = service.getMany([-1, 1]);
+
+      // assert
+      expect(actualRecords).toEqual(expectedRecords);
+    });
+  });
   describe('getAll', () => {
     it('should return all expected records', () => {
       // arrange
@@ -148,6 +174,31 @@ describe('In Memory DB Service', () => {
       expect(actualUpdatedRecord).toEqual(expectedUpdatedRecord);
     });
   });
+  describe('updateMany', () => {
+    it('should update records as expected', () => {
+      // arrange
+      const originalRecords: TestEntity[] = [
+        { id: 1, someField: 'AAA' },
+        { id: 2, someField: 'BBB' },
+        { id: 3, someField: 'CCC' },
+      ];
+      const expectedUpdatedRecords: TestEntity[] = [
+        { id: 1, someField: 'YYY' },
+        { id: 2, someField: 'ZZZ' },
+      ];
+      service.records = [...originalRecords];
+
+      // act
+      service.updateMany(expectedUpdatedRecords);
+
+      // assert
+      const actualUpdatedRecords = service.records.filter(record =>
+        expectedUpdatedRecords.map(o => o.id).includes(record.id),
+      );
+
+      expect(actualUpdatedRecords).toEqual(expectedUpdatedRecords);
+    });
+  });
   describe('delete', () => {
     it('should remove record as expected', () => {
       // arrange
@@ -165,6 +216,24 @@ describe('In Memory DB Service', () => {
       expect(service.records.length).toEqual(1);
     });
   });
+  describe('deleteMany', () => {
+    it('should remove records as expected', () => {
+      // arrange
+      service.records = [
+        { id: 1, someField: 'AAA' },
+        { id: 2, someField: 'BBB' },
+        { id: 3, someField: 'CCC' },
+      ];
+
+      // act
+      service.deleteMany([1, 2]);
+
+      // assert
+      const thirdRecord = service.records[0];
+      expect(thirdRecord).toEqual({ id: 3, someField: 'CCC' });
+      expect(service.records.length).toEqual(1);
+    });
+  });
   describe('query', () => {
     it('should return expected records for given predicate', () => {
       // arrange

lib/services/in-memory-db.service.ts

@@ -71,20 +71,10 @@ export class InMemoryDBService<T extends InMemoryDBEntity> {
    * Add the supplied `records` partials array to in-memory data store of records.
    * Get the `id` of the record by getting the next available `id` value.
    * Returns a sequential array of the records with the newly generated `ids`.
-   * @param records any array of partial records of type `T` to create
+   * @param records an array of partial records of type `T` to create
    */
   public createMany(records: Array<Partial<T>>): T[] {
-    const newRecords = records.map(record => {
-      const id = record.id || this.getNextId();
-      const newRecord: T = { ...record, id } as T;
-      this.recordMap = {
-        ...this.recordMap,
-        [id]: newRecord,
-      };
-      return newRecord;
-    });
-
-    return newRecords;
+    return records.map(record => this.create(record));
   }
 
   /**
@@ -94,10 +84,20 @@ export class InMemoryDBService<T extends InMemoryDBEntity> {
   public update(record: T): void {
     this.recordMap = {
       ...this.recordMap,
-      [record.id]: record,
+      [record.id]: { ...record },
     };
   }
 
+  /**
+   * Update records in the in-memory data store of type `T` using the supplied records.
+   * @param records an array of records of type `T` to update
+   */
+  public updateMany(records: T[]): void {
+    for (const record of records) {
+      this.update(record);
+    }
+  }
+
   /**
    * Remove the record of type `T` from the in-memory data store using the supplied PK id.
    * @param id the PK id of the record
@@ -110,13 +110,37 @@ export class InMemoryDBService<T extends InMemoryDBEntity> {
   }
 
   /**
-   * Get a single record of type `T` with the supplid id value.
+   * Remove the records of type `T` from the in-memory data store using the supplied PK ids.
+   * @param ids the PK ids of the records
+   */
+  public deleteMany(ids: number[]): void {
+    for (const id of ids) {
+      this.delete(id);
+    }
+  }
+
+  /**
+   * Get a single record of type `T` with the supplied id value.
    * @param id the PK id of the record
    */
   public get(id: number): T {
     return this.recordMap[id];
   }
 
+  /**
+   * Get records of type `T` with the supplied id values.
+   * @param ids the PK ids of the records
+   */
+  public getMany(ids: number[]): T[] {
+    const records = ids
+      .filter(id => this.recordMap[id])
+      .map(id => {
+        return this.recordMap[id];
+      });
+
+    return records;
+  }
+
   /**
    * Return all of the records of type `T`.
    */