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

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

@@ -11,17 +11,20 @@ let prisma: PrismaClient
 let createCategoryUseCase: typeof import("@/use-cases/category.use-cases").createCategoryUseCase
 let updateCategoryUseCase: typeof import("@/use-cases/category.use-cases").updateCategoryUseCase
 let deleteCategoryUseCase: typeof import("@/use-cases/category.use-cases").deleteCategoryUseCase
+let CategoryService: typeof import("@/services/category.service").CategoryService
 
 beforeAll(async () => {
   await startIntegrationTestDatabase()
 
   const prismaModule = await import("@/lib/prisma")
   const categoryUseCases = await import("@/use-cases/category.use-cases")
+  const categoryService = await import("@/services/category.service")
 
   prisma = prismaModule.prisma
   createCategoryUseCase = categoryUseCases.createCategoryUseCase
   updateCategoryUseCase = categoryUseCases.updateCategoryUseCase
   deleteCategoryUseCase = categoryUseCases.deleteCategoryUseCase
+  CategoryService = categoryService.CategoryService
 })
 
 beforeEach(async () => {
@@ -35,77 +38,83 @@ afterAll(async () => {
 
 describe("category use-cases", () => {
   it("creates a category and rejects duplicate names", async () => {
-    await expect(createCategoryUseCase({ name: "Hardware" })).resolves.toEqual({
+    expect(await createCategoryUseCase({ name: "Hardware" })).toEqual({
       success: true,
     })
 
-    await expect(
-      prisma.category.findUniqueOrThrow({ where: { name: "Hardware" } }),
-    ).resolves.toMatchObject({ name: "Hardware" })
+    expect(
+      await prisma.category.findUniqueOrThrow({ where: { name: "Hardware" } }),
+    ).toMatchObject({ name: "Hardware" })
 
-    await expect(createCategoryUseCase({ name: "Hardware" })).resolves.toEqual({
+    expect(await createCategoryUseCase({ name: "Hardware" })).toEqual({
       success: false,
       errors: { name: ["Category already exists"] },
     })
 
-    await expect(prisma.category.count()).resolves.toBe(1)
+    expect(await prisma.category.count()).toBe(1)
   })
 
   it("updates a category and rejects unchanged or duplicate names", async () => {
     const category = await createTestCategory(prisma, { name: "Peripherals" })
     const other = await createTestCategory(prisma, { name: "Networking" })
 
-    await expect(
-      updateCategoryUseCase({ id: category.id, name: "Accessories" }),
-    ).resolves.toEqual({ success: true })
+    expect(
+      await updateCategoryUseCase({ id: category.id, name: "Accessories" }),
+    ).toEqual({ success: true })
 
-    await expect(
-      prisma.category.findUniqueOrThrow({ where: { id: category.id } }),
-    ).resolves.toMatchObject({ name: "Accessories" })
+    expect(
+      await prisma.category.findUniqueOrThrow({ where: { id: category.id } }),
+    ).toMatchObject({ name: "Accessories" })
 
-    await expect(
-      updateCategoryUseCase({ id: category.id, name: "Accessories" }),
-    ).resolves.toEqual({
+    expect(
+      await updateCategoryUseCase({ id: category.id, name: "Accessories" }),
+    ).toEqual({
       success: false,
       errors: { name: ["Category name is the same as the old one"] },
     })
 
-    await expect(
-      updateCategoryUseCase({ id: category.id, name: other.name }),
-    ).resolves.toEqual({
+    expect(
+      await updateCategoryUseCase({ id: category.id, name: other.name }),
+    ).toEqual({
       success: false,
       errors: { name: ["Category already exists"] },
     })
 
-    await expect(
-      prisma.category.findUniqueOrThrow({ where: { id: category.id } }),
-    ).resolves.toMatchObject({ name: "Accessories" })
+    expect(
+      await prisma.category.findUniqueOrThrow({ where: { id: category.id } }),
+    ).toMatchObject({ name: "Accessories" })
   })
 
-  it("deletes empty categories and blocks deleting categories with items", async () => {
+  it("soft deletes empty categories and keeps deleted records out of active lists", async () => {
     const categoryWithItems = await createTestCategory(prisma, {
       name: "Computers",
     })
     await createTestItem(prisma, { categoryId: categoryWithItems.id })
 
-    await expect(deleteCategoryUseCase(categoryWithItems.id)).resolves.toEqual({
+    expect(await deleteCategoryUseCase(categoryWithItems.id)).toEqual({
       success: false,
       errors: { id: ["Category has items"] },
     })
 
-    await expect(
-      prisma.category.findUnique({ where: { id: categoryWithItems.id } }),
-    ).resolves.not.toBeNull()
-    await expect(prisma.item.count()).resolves.toBe(1)
+    expect(
+      await prisma.category.findUnique({ where: { id: categoryWithItems.id } }),
+    ).not.toBeNull()
+    expect(await prisma.item.count()).toBe(1)
 
     const emptyCategory = await createTestCategory(prisma, { name: "Cables" })
 
-    await expect(deleteCategoryUseCase(emptyCategory.id)).resolves.toEqual({
+    expect(await deleteCategoryUseCase(emptyCategory.id)).toEqual({
       success: true,
     })
 
-    await expect(
-      prisma.category.findUnique({ where: { id: emptyCategory.id } }),
-    ).resolves.toBeNull()
+    const deletedCategory = await prisma.category.findUnique({
+      where: { id: emptyCategory.id },
+    })
+    expect(deletedCategory).not.toBeNull()
+    expect(deletedCategory?.deletedAt).toBeInstanceOf(Date)
+
+    const activeCategories = await CategoryService.findAll()
+    expect(activeCategories).toHaveLength(1)
+    expect(activeCategories[0].id).toBe(categoryWithItems.id)
   })
 })