LaunchWare · nour-aldin · Sep 25, 2025
diff --git a/...isma-generator-vault/src/prisma-generator-vault/__tests__/ExposedPrismaRepository.test.ts b/...isma-generator-vault/src/prisma-generator-vault/__tests__/ExposedPrismaRepository.test.ts
@@ -3,17 +3,21 @@ import { ExposedPrismaRepository } from "../../../test/prisma/prisma-vault"
 
 class UserPrismaProxy extends ExposedPrismaRepository<Prisma.UserDelegate> {}
 
-describe("prisma proxy", () => {
+describe("ExposedPrismaRepository", () => {
   let client: PrismaClient
   let proxy: UserPrismaProxy
 
-  beforeEach(async () => {
+  beforeAll(async () => {
     client = new PrismaClient()
     proxy = new UserPrismaProxy(client.user, client)
+  })
+
+  beforeEach(async () => {
     await proxy.deleteMany({})
   })
 
   afterAll(async () => {
+    await proxy.deleteMany({})
     await client.$disconnect()
   })
 
@@ -24,4 +28,85 @@ describe("prisma proxy", () => {
     expect(user?.id).toEqual(record.id)
     expect(user?.posts).toBeDefined()
   })
+
+  it("exposes findUniqueOrThrow - success case", async () => {
+    const record = await proxy.create({ data: { email: "jane@example.com", firstName: "Jane", lastName: "Doe" } })
+    const user = await proxy.findUniqueOrThrow({ where: { id: record.id }, include: { posts: true } })
+    expect(user).not.toBeNull()
+    expect(user.id).toEqual(record.id)
+    expect(user.email).toEqual("jane@example.com")
+    expect(user.firstName).toEqual("Jane")
+    expect(user.lastName).toEqual("Doe")
+    expect(user.posts).toBeDefined()
+  })
+
+  it("exposes findUniqueOrThrow - throws error when record not found", async () => {
+    const nonExistentId = 999999
+    await expect(proxy.findUniqueOrThrow({ where: { id: nonExistentId } })).rejects.toThrow()
+  })
+
+  it("exposes findFirstOrThrow - success case", async () => {
+    const record = await proxy.create({ data: { email: "jane@example.com", firstName: "Jane", lastName: "Doe" } })
+    const user = await proxy.findFirstOrThrow({ where: { id: record.id }, include: { posts: true } })
+    expect(user).not.toBeNull()
+    expect(user.id).toEqual(record.id)
+    expect(user.email).toEqual("jane@example.com")
+    expect(user.firstName).toEqual("Jane")
+    expect(user.lastName).toEqual("Doe")
+    expect(user.posts).toBeDefined()
+  })
+
+  it("exposes findFirstOrThrow - throws error when record not found", async () => {
+    const nonExistentId = 999999
+    await expect(proxy.findFirstOrThrow({ where: { id: nonExistentId } })).rejects.toThrow()
+  })
+
+  it("exposes updateManyAndReturn", async () => {
+    await proxy.createManyAndReturn({
+      data: [
+        { email: "john@example.com", firstName: "John", lastName: "Doe" },
+        { email: "max@example.com", firstName: "Max", lastName: "Doe" },
+      ],
+    })
+
+    const updatedRecords = await proxy.updateManyAndReturn({
+      where: {
+        lastName: "Doe",
+      },
+      data: {
+        lastName: "Update_Many",
+      },
+    })
+
+    expect(updatedRecords.every(record => record.lastName === "Update_Many")).toBe(true)
+  })
+
+  it("exposes count", async () => {
+    const record = await proxy.create({ data: { email: "bob@example.com", firstName: "Bob", lastName: "Smith" } })
+
+    const count = await proxy.count({
+      where: {
+        id: record.id,
+      },
+    })
+
+    expect(count).toBe(1)
+  })
+
+  it("exposes aggregate", async () => {
+    await proxy.createManyAndReturn({
+      data: [
+        { email: "john@example.com", firstName: "John", lastName: "Doe" },
+        { email: "max@example.com", firstName: "Max", lastName: "Doe" },
+      ],
+    })
+
+    const clientsAgg = await proxy.aggregate({
+      _count: {
+        id: true,
+      },
+    })
+
+    expect(clientsAgg._count.id).toBe(2)
+  })
 })
diff --git a/packages/prisma-generator-vault/src/prisma-generator-vault/__tests__/PrismaProxy.test.ts b/packages/prisma-generator-vault/src/prisma-generator-vault/__tests__/PrismaProxy.test.ts
@@ -5,17 +5,21 @@ class UserPrismaProxy extends PrismaProxy<Prisma.UserDelegate> {}
 
 //class UserRepository extends EncapsulatedRepository<"user"> {}
 
-describe("prisma proxy", () => {
+describe("PrismaProxy", () => {
   let client: PrismaClient
   let proxy: UserPrismaProxy
 
-  beforeEach(async () => {
+  beforeAll(async () => {
     client = new PrismaClient()
     proxy = new UserPrismaProxy(client.user, client)
+  })
+
+  beforeEach(async () => {
     await proxy.deleteMany({})
   })
 
   afterAll(async () => {
+    await proxy.deleteMany({})
     await client.$disconnect()
   })
 
@@ -25,4 +29,85 @@ describe("prisma proxy", () => {
     expect(user).not.toBeNull()
     expect(user?.id).toEqual(record.id)
   })
+
+  it("exposes findUniqueOrThrow - success case", async () => {
+    const record = await proxy.create({ data: { email: "bob@example.com", firstName: "Bob", lastName: "Smith" } })
+    const user = await proxy.findUniqueOrThrow({ where: { id: record.id }, include: { posts: true } })
+    expect(user).not.toBeNull()
+    expect(user.id).toEqual(record.id)
+    expect(user.email).toEqual("bob@example.com")
+    expect(user.firstName).toEqual("Bob")
+    expect(user.lastName).toEqual("Smith")
+    expect(user.posts).toBeDefined()
+  })
+
+  it("exposes findUniqueOrThrow - throws error when record not found", async () => {
+    const nonExistentId = 888888
+    await expect(proxy.findUniqueOrThrow({ where: { id: nonExistentId } })).rejects.toThrow()
+  })
+
+  it("exposes findFirstOrThrow - success case", async () => {
+    const record = await proxy.create({ data: { email: "bob@example.com", firstName: "Bob", lastName: "Smith" } })
+    const user = await proxy.findFirstOrThrow({ where: { id: record.id }, include: { posts: true } })
+    expect(user).not.toBeNull()
+    expect(user.id).toEqual(record.id)
+    expect(user.email).toEqual("bob@example.com")
+    expect(user.firstName).toEqual("Bob")
+    expect(user.lastName).toEqual("Smith")
+    expect(user.posts).toBeDefined()
+  })
+
+  it("exposes findFirstOrThrow - throws error when record not found", async () => {
+    const nonExistentId = 888888
+    await expect(proxy.findFirstOrThrow({ where: { id: nonExistentId } })).rejects.toThrow()
+  })
+
+  it("exposes updateManyAndReturn", async () => {
+    await proxy.createManyAndReturn({
+      data: [
+        { email: "john@example.com", firstName: "John", lastName: "Doe" },
+        { email: "max@example.com", firstName: "Max", lastName: "Doe" },
+      ],
+    })
+
+    const updatedRecords = await proxy.updateManyAndReturn({
+      where: {
+        lastName: "Doe",
+      },
+      data: {
+        lastName: "Update_Many",
+      },
+    })
+
+    expect(updatedRecords.every(record => record.lastName === "Update_Many")).toBe(true)
+  })
+
+  it("exposes count", async () => {
+    const record = await proxy.create({ data: { email: "bob@example.com", firstName: "Bob", lastName: "Smith" } })
+
+    const count = await proxy.count({
+      where: {
+        id: record.id,
+      },
+    })
+
+    expect(count).toBe(1)
+  })
+
+  it("exposes aggregate", async () => {
+    await proxy.createManyAndReturn({
+      data: [
+        { email: "john@example.com", firstName: "John", lastName: "Doe" },
+        { email: "max@example.com", firstName: "Max", lastName: "Doe" },
+      ],
+    })
+
+    const clientsAgg = await proxy.aggregate({
+      _count: {
+        id: true,
+      },
+    })
+
+    expect(clientsAgg._count.id).toBe(2)
+  })
 })
diff --git a/...-generator-vault/src/prisma-generator-vault/generator/EncapsulatedPrismaRepository.ts.hbs b/...-generator-vault/src/prisma-generator-vault/generator/EncapsulatedPrismaRepository.ts.hbs
@@ -45,6 +45,12 @@ export abstract class EncapsulatedPrismaRepository<TModel extends IPrismaDelegat
     return this.prismaProxy.findFirst(args)
   }
 
+  protected findFirstOrThrow<TArgs extends Prisma.Args<TModel, "findFirstOrThrow">>(
+    args: TArgs
+  ): PrismaPromise<Prisma.Result<TModel, TArgs, "findFirstOrThrow">> {
+    return this.prismaProxy.findFirstOrThrow(args)
+  }
+
   protected findMany<TArgs extends Prisma.Args<TModel, "findMany">>(
     args: TArgs
   ): PrismaPromise<Prisma.Result<TModel, TArgs, "findMany">> {
@@ -57,6 +63,12 @@ export abstract class EncapsulatedPrismaRepository<TModel extends IPrismaDelegat
     return this.prismaProxy.findUnique(args)
   }
 
+  protected findUniqueOrThrow<TArgs extends Prisma.Args<TModel, "findUniqueOrThrow">>(
+    args: TArgs
+  ): PrismaPromise<Prisma.Result<TModel, TArgs, "findUniqueOrThrow">> {
+    return this.prismaProxy.findUniqueOrThrow(args)
+  }
+
   protected update<TArgs extends Prisma.Args<TModel, "update">>(
     args: TArgs
   ): PrismaPromise<Prisma.Result<TModel, TArgs, "update">> {
@@ -69,11 +81,35 @@ export abstract class EncapsulatedPrismaRepository<TModel extends IPrismaDelegat
     return this.prismaProxy.updateMany(args)
   }
 
+  protected updateManyAndReturn<TArgs extends Prisma.Args<TModel, "updateManyAndReturn">>(
+    args: TArgs
+  ): PrismaPromise<Prisma.Result<TModel, TArgs, "updateManyAndReturn">> {
+    return this.prismaProxy.updateManyAndReturn(args)
+  }
+
   protected upsert<TArgs extends Prisma.Args<TModel, "upsert">>(
     args: TArgs
   ): PrismaPromise<Prisma.Result<TModel, TArgs, "upsert">> {
     return this.prismaProxy.upsert(args)
   }
+
+  protected count<TArgs extends Prisma.Args<TModel, "count">>(
+    args: TArgs
+  ): PrismaPromise<Prisma.Result<TModel, TArgs, "count">> {
+    return this.prismaProxy.count(args)
+  }
+
+  protected aggregate<TArgs extends Prisma.Args<TModel, "aggregate">>(
+    args: TArgs
+  ): PrismaPromise<Prisma.Result<TModel, TArgs, "aggregate">> {
+    return this.prismaProxy.aggregate(args)
+  }
+
+  protected groupBy<TArgs extends Prisma.Args<TModel, "groupBy">>(
+    args: TArgs
+  ): PrismaPromise<Prisma.Result<TModel, TArgs, "groupBy">> {
+    return this.prismaProxy.groupBy(args)
+  }
 
   protected $transaction(...args: Parameters<PrismaClient["$transaction"]>) {
     return this.prismaProxy.$transaction(...args)

diff --git a/...risma-generator-vault/src/prisma-generator-vault/generator/ExposedPrismaRepository.ts.hbs b/...risma-generator-vault/src/prisma-generator-vault/generator/ExposedPrismaRepository.ts.hbs
@@ -45,6 +45,12 @@ export abstract class ExposedPrismaRepository<TModel extends IPrismaDelegate<TMo
     return this.prismaProxy.findFirst(args)
   }
 
+  findFirstOrThrow<TArgs extends Prisma.Args<TModel, "findFirstOrThrow">>(
+    args: TArgs
+  ): PrismaPromise<Prisma.Result<TModel, TArgs, "findFirstOrThrow">> {
+    return this.prismaProxy.findFirstOrThrow(args)
+  }
+
   findMany<TArgs extends Prisma.Args<TModel, "findMany">>(
     args: TArgs
   ): PrismaPromise<Prisma.Result<TModel, TArgs, "findMany">> {
@@ -57,6 +63,12 @@ export abstract class ExposedPrismaRepository<TModel extends IPrismaDelegate<TMo
     return this.prismaProxy.findUnique(args)
   }
 
+  findUniqueOrThrow<TArgs extends Prisma.Args<TModel, "findUniqueOrThrow">>(
+    args: TArgs
+  ): PrismaPromise<Prisma.Result<TModel, TArgs, "findUniqueOrThrow">> {
+    return this.prismaProxy.findUniqueOrThrow(args)
+  }
+
   update<TArgs extends Prisma.Args<TModel, "update">>(
     args: TArgs
   ): PrismaPromise<Prisma.Result<TModel, TArgs, "update">> {
@@ -69,11 +81,35 @@ export abstract class ExposedPrismaRepository<TModel extends IPrismaDelegate<TMo
     return this.prismaProxy.updateMany(args)
   }
 
+  updateManyAndReturn<TArgs extends Prisma.Args<TModel, "updateManyAndReturn">>(
+    args: TArgs
+  ): PrismaPromise<Prisma.Result<TModel, TArgs, "updateManyAndReturn">> {
+    return this.prismaProxy.updateManyAndReturn(args)
+  }
+
   upsert<TArgs extends Prisma.Args<TModel, "upsert">>(
     args: TArgs
   ): PrismaPromise<Prisma.Result<TModel, TArgs, "upsert">> {
     return this.prismaProxy.upsert(args)
   }
+
+  count<TArgs extends Prisma.Args<TModel, "count">>(
+    args: TArgs
+  ): PrismaPromise<Prisma.Result<TModel, TArgs, "count">> {
+    return this.prismaProxy.count(args)
+  }
+
+  aggregate<TArgs extends Prisma.Args<TModel, "aggregate">>(
+    args: TArgs
+  ): PrismaPromise<Prisma.Result<TModel, TArgs, "aggregate">> {
+    return this.prismaProxy.aggregate(args)
+  }
+
+  groupBy<TArgs extends Prisma.Args<TModel, "groupBy">>(
+    args: TArgs
+  ): PrismaPromise<Prisma.Result<TModel, TArgs, "groupBy">> {
+    return this.prismaProxy.groupBy(args)
+  }
 
   $transaction(...args: Parameters<PrismaClient["$transaction"]>) {
     return this.prismaProxy.$transaction(...args)

diff --git a/packages/prisma-generator-vault/src/prisma-generator-vault/generator/IPrismaDelegate.ts.hbs b/packages/prisma-generator-vault/src/prisma-generator-vault/generator/IPrismaDelegate.ts.hbs
@@ -23,6 +23,10 @@ export interface IPrismaDelegate<TModel> {
     args: Prisma.Args<TModel, "findFirst">
   ): PrismaPromise<Prisma.Result<TModel, Prisma.Args<TModel, "findFirst">, "findFirst">>
 
+  findFirstOrThrow(
+    args: Prisma.Args<TModel, "findFirstOrThrow">
+  ): PrismaPromise<Prisma.Result<TModel, Prisma.Args<TModel, "findFirstOrThrow">, "findFirstOrThrow">>
+
   findMany(
     args: Prisma.Args<TModel, "findMany">
   ): PrismaPromise<Prisma.Result<TModel, Prisma.Args<TModel, "findMany">, "findMany">>
@@ -31,16 +35,36 @@ export interface IPrismaDelegate<TModel> {
     args: Prisma.Args<TModel, "findUnique">
   ): PrismaPromise<Prisma.Result<TModel, Prisma.Args<TModel, "findUnique">, "findUnique">>
 
+  findUniqueOrThrow(
+    args: Prisma.Args<TModel, "findUniqueOrThrow">
+  ): PrismaPromise<Prisma.Result<TModel, Prisma.Args<TModel, "findUniqueOrThrow">, "findUniqueOrThrow">>
+
   update(
     args: Prisma.Args<TModel, "update">
   ): PrismaPromise<Prisma.Result<TModel, Prisma.Args<TModel, "update">, "update">>
 
   updateMany(
     args: Prisma.Args<TModel, "updateMany">
   ): PrismaPromise<Prisma.Result<TModel, Prisma.Args<TModel, "updateMany">, "updateMany">>
+
+  updateManyAndReturn(
+    args: Prisma.Args<TModel, "updateManyAndReturn">
+  ): PrismaPromise<Prisma.Result<TModel, Prisma.Args<TModel, "updateManyAndReturn">, "updateManyAndReturn">>
 
   upsert(
     args: Prisma.Args<TModel, "upsert">
   ): PrismaPromise<Prisma.Result<TModel, Prisma.Args<TModel, "upsert">, "upsert">>
+
+  count(
+    args: Prisma.Args<TModel, "count">
+  ): PrismaPromise<Prisma.Result<TModel, Prisma.Args<TModel, "count">, "count">>
+
+  aggregate(
+    args: Prisma.Args<TModel, "aggregate">
+  ): PrismaPromise<Prisma.Result<TModel, Prisma.Args<TModel, "aggregate">, "aggregate">>
+
+  groupBy(
+    args: Prisma.Args<TModel, "groupBy">
+  ): PrismaPromise<Prisma.Result<TModel, Prisma.Args<TModel, "groupBy">, "groupBy">>
 
 }