test(qb): add findOrFail method

src/models/builders/ModelQueryBuilder.ts

@@ -11,6 +11,7 @@ import type { Model } from '#src/models/Model'
 import type { Driver } from '#src/drivers/Driver'
 import { QueryBuilder } from '#src/database/builders/QueryBuilder'
 import { ModelGenerator } from '#src/models/factories/ModelGenerator'
+import { NotFoundDataException } from '#src/exceptions/NotFoundDataException'
 
 export class ModelQueryBuilder<
   M extends Model = any,
@@ -26,9 +27,27 @@ export class ModelQueryBuilder<
     this.generator = new ModelGenerator<M>(this.Model as any)
   }
 
+  /**
+   * Find a value in database.
+   */
   public async find() {
     const data = await super.find()
 
     return this.generator.generateOne(data)
   }
+
+  /**
+   * Find a value in database or throw exception if undefined.
+   */
+  public async findOrFail() {
+    const data = await this.find()
+
+    if (!data) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      throw new NotFoundDataException(this.Model.connection())
+    }
+
+    return data
+  }
 }

tests/unit/models/builders/ModelQueryBuilderTest.ts

@@ -14,6 +14,7 @@ import { Database } from '#src/facades/Database'
 import { Column } from '#src/models/annotations/Column'
 import { FakeDriver } from '#tests/fixtures/drivers/FakeDriver'
 import { DatabaseProvider } from '#src/providers/DatabaseProvider'
+import { NotFoundDataException } from '#src/exceptions/NotFoundDataException'
 import { Test, Mock, AfterEach, type Context, BeforeEach } from '@athenna/test'
 
 class User extends Model {
@@ -180,13 +181,24 @@ export default class ModelQueryBuilderTest {
   @Test()
   public async shouldBeAbleToFindDataUsingFindOrFail({ assert }: Context) {
     const expectedData = { id: '1', name: 'John Doe' }
-    Mock.when(FakeDriver, 'findOrFail').resolve(expectedData)
+    Mock.when(FakeDriver, 'find').resolve(expectedData)
 
     const queryBuilder = User.query()
     const result = await queryBuilder.findOrFail()
 
-    assert.calledOnce(FakeDriver.findOrFail)
+    assert.calledOnce(FakeDriver.find)
     assert.deepEqual(result, expectedData)
+    assert.instanceOf(result, User)
+  }
+
+  @Test()
+  public async shouldThrownNotFoundDataExceptionWhenFindOrFailReturnsUndefined({ assert }: Context) {
+    Mock.when(FakeDriver, 'find').resolve(undefined)
+
+    const queryBuilder = User.query()
+
+    await assert.rejects(() => queryBuilder.findOrFail(), NotFoundDataException)
+    assert.calledOnce(FakeDriver.find)
   }
 
   @Test()