feat(people): align people, users, and categories with active inventory records

tests/integration/use-cases/person.use-cases.test.ts

@@ -10,16 +10,19 @@ import {
 let prisma: PrismaClient
 let createPersonUseCase: typeof import("@/use-cases/person.use-cases").createPersonUseCase
 let updatePersonUseCase: typeof import("@/use-cases/person.use-cases").updatePersonUseCase
+let PersonService: typeof import("@/services/person.service").PersonService
 
 beforeAll(async () => {
   await startIntegrationTestDatabase()
 
   const prismaModule = await import("@/lib/prisma")
   const personUseCases = await import("@/use-cases/person.use-cases")
+  const personService = await import("@/services/person.service")
 
   prisma = prismaModule.prisma
   createPersonUseCase = personUseCases.createPersonUseCase
   updatePersonUseCase = personUseCases.updatePersonUseCase
+  PersonService = personService.PersonService
 })
 
 beforeEach(async () => {
@@ -43,11 +46,11 @@ describe("person use-cases", () => {
       }),
     ).resolves.toEqual({ success: true })
 
-    await expect(
-      prisma.person.findFirstOrThrow({
+    expect(
+      await prisma.person.findFirstOrThrow({
         where: { firstName: "Person", lastName: "One" },
       }),
-    ).resolves.toMatchObject({
+    ).toMatchObject({
       firstName: "Person",
       lastName: "One",
       department: "IT",
@@ -71,11 +74,11 @@ describe("person use-cases", () => {
       }),
     ).resolves.toEqual({ success: true })
 
-    await expect(
-      prisma.person.findFirstOrThrow({
+    expect(
+      await prisma.person.findFirstOrThrow({
         where: { firstName: "Linked" },
       }),
-    ).resolves.toMatchObject({
+    ).toMatchObject({
       firstName: "Linked",
       lastName: "Person",
       department: "ENGINEERING",
@@ -102,7 +105,7 @@ describe("person use-cases", () => {
       errors: { email: ["Email already exists"] },
     })
 
-    await expect(prisma.person.count()).resolves.toBe(1)
+    expect(await prisma.person.count()).toBe(1)
   })
 
   it("updates a person and rejects duplicate emails", async () => {
@@ -125,9 +128,7 @@ describe("person use-cases", () => {
       }),
     ).resolves.toEqual({ success: true })
 
-    await expect(
-      prisma.person.findUniqueOrThrow({ where: { id: person.id } }),
-    ).resolves.toMatchObject({
+    expect(await prisma.person.findUniqueOrThrow({ where: { id: person.id } })).toMatchObject({
       firstName: "Edited",
       lastName: "Person",
       department: "ENGINEERING",
@@ -149,12 +150,10 @@ describe("person use-cases", () => {
       errors: { email: ["Email already exists"] },
     })
 
-    await expect(
-      prisma.person.findUniqueOrThrow({ where: { id: person.id } }),
-    ).resolves.toMatchObject({
+    expect(await prisma.person.findUniqueOrThrow({ where: { id: person.id } })).toMatchObject({
       email: "edited@example.test",
     })
-    await expect(prisma.person.count()).resolves.toBe(2)
+    expect(await prisma.person.count()).toBe(2)
   })
 
   it("searches by email and name in paginated results", async () => {
@@ -163,13 +162,15 @@ describe("person use-cases", () => {
       lastName: "Smith",
       email: "alice@company.com",
     })
-    await createTestPerson(prisma, {
-      firstName: "Bob",
-      lastName: "Jones",
-      email: "bob@other.com",
+    const archivedPerson = await createTestPerson(prisma, {
+      firstName: "Archive",
+      lastName: "Person",
+      email: "archive@company.com",
+    })
+    await prisma.person.update({
+      where: { id: archivedPerson.id },
+      data: { deletedAt: new Date() },
     })
-
-    const { PersonService } = await import("@/services/person.service")
 
     const emailResults = await PersonService.findAllPaginated({
       search: "company",
@@ -178,13 +179,16 @@ describe("person use-cases", () => {
     })
     expect(emailResults.data).toHaveLength(1)
     expect(emailResults.data[0].firstName).toBe("Alice")
+    expect(await PersonService.findAllPeopleCount()).toBe(1)
+
+    expect(await PersonService.findById(archivedPerson.id)).toBeNull()
 
     const nameResults = await PersonService.findAllPaginated({
-      search: "Bob",
+      search: "Alice",
       page: 1,
       pageSize: 10,
     })
     expect(nameResults.data).toHaveLength(1)
-    expect(nameResults.data[0].firstName).toBe("Bob")
+    expect(nameResults.data[0].firstName).toBe("Alice")
   })
 })