complete repository test

src/modules/database/src/adapters/secondaries/prisma-repository.abstract.ts

@@ -160,4 +160,24 @@ export abstract class PrismaRepository<T> implements IRepository<T> {
       }
     }
   }
+
+  async deleteMany(where: any): Promise<void> {
+    try {
+      const entity = await this._prisma[this._model].deleteMany({
+        where: where,
+      });
+
+      return entity;
+    } catch (e) {
+      if (e instanceof PrismaClientKnownRequestError) {
+        throw new DatabaseException(
+          PrismaClientKnownRequestError.name,
+          e.code,
+          e.message,
+        );
+      } else {
+        throw new DatabaseException();
+      }
+    }
+  }
 }

src/modules/database/src/interfaces/repository.interface.ts

@@ -13,4 +13,5 @@ export interface IRepository<T> {
   update(uuid: string, entity: Partial<T>, include?: any): Promise<T>;
   updateWhere(where: any, entity: Partial<T> | any, include?: any): Promise<T>;
   delete(uuid: string): Promise<T>;
+  deleteMany(where: any): Promise<void>;
 }

src/modules/database/tests/unit/prisma-repository.spec.ts

@@ -184,6 +184,30 @@ const mockPrismaService = {
           throw new Error();
         }
       }),
+
+    deleteMany: jest
+      .fn()
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      .mockImplementationOnce((params?: any) => {
+        throw new PrismaClientKnownRequestError('unknown request', {
+          code: 'code',
+          clientVersion: 'version',
+        });
+      })
+      .mockImplementation((params: any) => {
+        let found = false;
+
+        fakeEntities.forEach((entity, index) => {
+          if (entity.uuid === params?.where?.uuid) {
+            found = true;
+            fakeEntities.splice(index, 1);
+          }
+        });
+
+        if (!found) {
+          throw new Error();
+        }
+      }),
   },
 };
 
@@ -372,4 +396,30 @@ describe('PrismaRepository', () => {
       );
     });
   });
+
+  describe('deleteMany', () => {
+    it('should throw a DatabaseException for client error', async () => {
+      await expect(
+        fakeRepository.deleteMany({ uuid: 'fake-uuid' }),
+      ).rejects.toBeInstanceOf(DatabaseException);
+    });
+
+    it('should delete entities based on their uuid', async () => {
+      const savedUuid = fakeEntities[0].uuid;
+
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const res = await fakeRepository.deleteMany({ uuid: savedUuid });
+
+      const deletedEntity = fakeEntities.find(
+        (entity) => entity.uuid === savedUuid,
+      );
+      expect(deletedEntity).toBeUndefined();
+    });
+
+    it("should throw an exception if an entity doesn't exist", async () => {
+      await expect(
+        fakeRepository.deleteMany({ uuid: 'fake-uuid' }),
+      ).rejects.toBeInstanceOf(DatabaseException);
+    });
+  });
 });