feat(core): add getByIdOrThrow on AggregateRepo

.changeset/spotty-moles-cover.md

@@ -0,0 +1,5 @@
+---
+"@fizzbuds/ddd-toolkit": patch
+---
+
+add getByIdOrThrow to IAggregateRepo

packages/ddd-toolkit/src/errors.ts

@@ -15,3 +15,9 @@ export class RepoHookError extends Error {
         super(message);
     }
 }
+
+export class AggregateNotFoundError extends Error {
+    constructor(message: string) {
+        super(message);
+    }
+}

packages/ddd-toolkit/src/repo/mongo-aggregate-repo.ts

@@ -1,14 +1,15 @@
 import { IRepoHooks } from './repo-hooks';
-import { Collection, Document, MongoClient } from 'mongodb';
+import { Collection, Document, MongoClient, WithId } from 'mongodb';
 import { ISerializer } from './serializer.interface';
 import { merge } from 'lodash';
-import { DuplicatedIdError, OptimisticLockError, RepoHookError } from '../errors';
+import { AggregateNotFoundError, DuplicatedIdError, OptimisticLockError, RepoHookError } from '../errors';
 import { ILogger } from '../logger';
 import { IInit } from '../init.interface';
 
 export interface IAggregateRepo<A> {
     // TODO add id as a generic type
     getById: (id: string) => Promise<WithVersion<A> | null>;
+    getByIdOrThrow: (id: string) => Promise<WithVersion<A>>;
     save: (aggregate: A) => Promise<void>;
 }
 
@@ -23,6 +24,7 @@ const MONGODB_UNIQUE_INDEX_CONSTRAINT_ERROR = 11000;
 
 export class MongoAggregateRepo<A, AM extends DocumentWithId> implements IAggregateRepo<A>, IInit {
     protected readonly collection: Collection<AM>;
+
     constructor(
         protected readonly serializer: ISerializer<A, AM>,
         protected readonly mongoClient: MongoClient,
@@ -94,11 +96,21 @@ export class MongoAggregateRepo<A, AM extends DocumentWithId> implements IAggreg
         }
     }
 
-    // TODO evaluate to implement getOrThrow
     async getById(id: string): Promise<WithVersion<A> | null> {
         const aggregateModel = await this.collection.findOne({ id: id } as any);
         this.logger.debug(`Retrieving aggregate ${id}. Found: ${JSON.stringify(aggregateModel)}`);
         if (!aggregateModel) return null;
+
+        return this.modelToAggregateWithVersion(aggregateModel);
+    }
+
+    async getByIdOrThrow(id: string): Promise<WithVersion<A>> {
+        const aggregate = await this.getById(id);
+        if (!aggregate) throw new AggregateNotFoundError(`Aggregate ${id} not found.`);
+        return aggregate;
+    }
+
+    private modelToAggregateWithVersion(aggregateModel: WithId<AM>): WithVersion<A> {
         const aggregate = this.serializer.modelToAggregate(aggregateModel as AM);
         return merge<A, { __version: number }>(aggregate, { __version: aggregateModel.__version });
     }

packages/ddd-toolkit/src/repo/tests/mongo-aggregate-repo.integration-spec.ts

@@ -2,6 +2,7 @@ import { MongoAggregateRepo } from '../mongo-aggregate-repo';
 import { MongoMemoryReplSet } from 'mongodb-memory-server';
 import { MongoClient } from 'mongodb';
 import { TestAggregate, TestModel, TestSerializer } from './example.serializer';
+import { AggregateNotFoundError } from '../../errors';
 
 describe('MongoAggregateRepo MongoDB Integration', () => {
     let mongodb: MongoMemoryReplSet;
@@ -39,7 +40,7 @@ describe('MongoAggregateRepo MongoDB Integration', () => {
     });
 
     describe('Save and Get', () => {
-        describe('Given an aggregate', () => {
+        describe('Given an existing aggregate', () => {
             describe('When saving', () => {
                 const id1 = 'id1';
                 beforeEach(async () => {
@@ -54,6 +55,22 @@ describe('MongoAggregateRepo MongoDB Integration', () => {
                 });
             });
         });
+
+        describe('Given an un-existing aggregate', () => {
+            describe('When getById', () => {
+                it('should return null', async () => {
+                    expect(await aggregateRepo.getById('not-existing-id')).toBeNull();
+                });
+            });
+
+            describe('When getByIdOrThrow', () => {
+                it('should throw AggregateNotFoundError', async () => {
+                    await expect(() => aggregateRepo.getByIdOrThrow('not-existing-id')).rejects.toThrowError(
+                        AggregateNotFoundError,
+                    );
+                });
+            });
+        });
     });
 
     describe('Optimistic Lock', () => {