feat(movements): gate StockMovementLine on trackingType QUANTITY

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

@@ -1,6 +1,7 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest"
 import type { PrismaClient } from "@/generated/prisma/client"
 import {
+  createTestCategory,
   createTestItem,
   createTestPerson,
   createTestUser,
@@ -185,6 +186,102 @@ describe("asset use-cases", () => {
     expect(await AssetService.findAll()).toHaveLength(0)
   })
 
+  it("creates a SERIALIZED asset in AVAILABLE status without writing a stock line or incrementing stock", async () => {
+    const actor = await createTestUser(prisma)
+    const category = await createTestCategory(prisma)
+    const item = await prisma.item.create({
+      data: {
+        sku: "PHONE-SKU",
+        name: "Phone",
+        trackingType: "SERIALIZED",
+        stock: 0,
+        category: { connect: { id: category.id } },
+      },
+    })
+
+    const result = await createAssetUseCase({
+      actorId: actor.id,
+      itemId: item.id,
+      serialNumber: "SERIALIZED-AVAILABLE-001",
+      status: "AVAILABLE",
+    })
+
+    expect(result.success).toBe(true)
+    if (!result.success) throw new Error("Expected asset creation success")
+
+    const [updatedItem, movements] = await Promise.all([
+      prisma.item.findUniqueOrThrow({ where: { id: item.id } }),
+      prisma.inventoryMovement.findMany({
+        include: { stockLines: true, assetLines: true },
+        orderBy: [{ createdAt: "asc" }, { id: "asc" }],
+      }),
+    ])
+
+    expect(updatedItem.stock).toBe(0)
+    expect(movements).toHaveLength(1)
+    expect(movements[0]).toMatchObject({
+      type: "RECEIPT",
+      performedById: actor.id,
+    })
+    expect(movements[0].stockLines).toEqual([])
+    expect(movements[0].assetLines).toHaveLength(1)
+    expect(movements[0].assetLines[0]).toMatchObject({
+      assetId: result.assetId,
+    })
+  })
+
+  it("updates a SERIALIZED asset from AVAILABLE to ASSIGNED without writing a stock line", async () => {
+    const actor = await createTestUser(prisma)
+    const person = await createTestPerson(prisma)
+    const category = await createTestCategory(prisma)
+    const item = await prisma.item.create({
+      data: {
+        sku: "LAPTOP-SKU",
+        name: "Laptop",
+        trackingType: "SERIALIZED",
+        stock: 0,
+        category: { connect: { id: category.id } },
+      },
+    })
+
+    const created = await createAssetUseCase({
+      actorId: actor.id,
+      itemId: item.id,
+      serialNumber: "SERIALIZED-ASSIGN-001",
+      status: "AVAILABLE",
+    })
+
+    expect(created.success).toBe(true)
+    if (!created.success) throw new Error("Expected asset creation success")
+
+    const updated = await updateAssetUseCase({
+      actorId: actor.id,
+      id: created.assetId,
+      itemId: item.id,
+      serialNumber: "SERIALIZED-ASSIGN-001",
+      status: "ASSIGNED",
+      personId: person.id,
+    })
+
+    expect(updated.success).toBe(true)
+
+    const [updatedItem, movements] = await Promise.all([
+      prisma.item.findUniqueOrThrow({ where: { id: item.id } }),
+      prisma.inventoryMovement.findMany({
+        include: { stockLines: true, assetLines: true },
+        orderBy: [{ createdAt: "asc" }, { id: "asc" }],
+      }),
+    ])
+
+    expect(updatedItem.stock).toBe(0)
+    expect(movements).toHaveLength(2)
+    expect(movements[1].stockLines).toEqual([])
+    expect(movements[1].assetLines).toHaveLength(1)
+    expect(movements[1].assetLines[0]).toMatchObject({
+      assetId: created.assetId,
+    })
+  })
+
   it("creates an assigned asset with assignment and ASSIGNMENT movement", async () => {
     const actor = await createTestUser(prisma)
     const person = await createTestPerson(prisma)

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

@@ -1,6 +1,7 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest"
 import type { PrismaClient } from "@/generated/prisma/client"
 import {
+  createTestCategory,
   createTestItem,
   createTestPerson,
   createTestUser,
@@ -38,6 +39,56 @@ afterAll(async () => {
 })
 
 describe("assignment use-cases", () => {
+  it("creates a SERIALIZED assignment without writing a stock line", async () => {
+    const actor = await createTestUser(prisma)
+    const person = await createTestPerson(prisma)
+    const category = await createTestCategory(prisma)
+    const item = await prisma.item.create({
+      data: {
+        sku: "SERIALIZED-ASSIGNMENT-SKU",
+        name: "Serial Item",
+        trackingType: "SERIALIZED",
+        stock: 0,
+        category: { connect: { id: category.id } },
+      },
+    })
+    const asset = await prisma.asset.create({
+      data: {
+        serialNumber: "SERIALIZED-ASSIGNMENT-ASSET-001",
+        itemId: item.id,
+        status: "AVAILABLE",
+      },
+    })
+
+    const result = await createAssignmentUseCase({
+      actorId: actor.id,
+      personId: person.id,
+      assetId: asset.id,
+      lines: [{ itemId: item.id, quantity: 1 }],
+    })
+
+    expect(result.success).toBe(true)
+    if (!result.success) throw new Error("Expected assignment creation success")
+
+    const [updatedItem, updatedAsset, movements] = await Promise.all([
+      prisma.item.findUniqueOrThrow({ where: { id: item.id } }),
+      prisma.asset.findUniqueOrThrow({ where: { id: asset.id } }),
+      prisma.inventoryMovement.findMany({
+        include: { stockLines: true, assetLines: true },
+        orderBy: [{ createdAt: "asc" }, { id: "asc" }],
+      }),
+    ])
+
+    expect(updatedItem.stock).toBe(0)
+    expect(updatedAsset.status).toBe("ASSIGNED")
+    expect(movements).toHaveLength(1)
+    expect(movements[0].stockLines).toEqual([])
+    expect(movements[0].assetLines).toHaveLength(1)
+    expect(movements[0].assetLines[0]).toMatchObject({
+      assetId: asset.id,
+    })
+  })
+
   it("creates an assignment, decrements stock, and records an ASSIGNMENT movement", async () => {
     const actor = await createTestUser(prisma)
     const person = await createTestPerson(prisma)

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

@@ -151,6 +151,12 @@ describe("item use-cases", () => {
       minStock: 2,
       targetStock: 8,
     })
+
+    const stockMovements = await prisma.inventoryMovement.findMany({
+      where: { stockLines: { some: { itemId: item.id } } },
+    })
+
+    expect(stockMovements).toHaveLength(1)
   })
 
   it("rejects duplicate item names", async () => {
@@ -285,6 +291,78 @@ describe("item use-cases", () => {
     })
   })
 
+  it("creates a SERIALIZED item with stock value and persists stock as 0 with no movement", async () => {
+    const actor = await createTestUser(prisma)
+    const category = await createTestCategory(prisma)
+
+    const result = await createItemUseCase({
+      actorId: actor.id,
+      name: "Phone",
+      categoryId: category.id,
+      stock: 3,
+      trackingType: "SERIALIZED",
+    })
+
+    expect(result).toEqual({ success: true })
+
+    const item = await prisma.item.findUniqueOrThrow({
+      where: { sku: "PHONE" },
+    })
+
+    expect(item).toMatchObject({
+      stock: 0,
+      trackingType: "SERIALIZED",
+    })
+
+    const movements = await prisma.inventoryMovement.findMany({
+      where: { stockLines: { some: { itemId: item.id } } },
+    })
+
+    expect(movements).toHaveLength(0)
+  })
+
+  it("updates a SERIALIZED item with stock value and leaves stock unchanged with no movement", async () => {
+    const actor = await createTestUser(prisma)
+    const category = await createTestCategory(prisma)
+
+    const created = await createItemUseCase({
+      actorId: actor.id,
+      name: "Tablet",
+      categoryId: category.id,
+      stock: 0,
+      trackingType: "SERIALIZED",
+    })
+
+    expect(created).toEqual({ success: true })
+
+    const item = await prisma.item.findUniqueOrThrow({
+      where: { sku: "TABLET" },
+    })
+
+    const updated = await updateItemUseCase({
+      actorId: actor.id,
+      id: item.id,
+      name: "Tablet",
+      categoryId: category.id,
+      stock: 5,
+      trackingType: "SERIALIZED",
+    })
+
+    expect(updated).toEqual({ success: true })
+
+    const refreshedItem = await prisma.item.findUniqueOrThrow({
+      where: { id: item.id },
+    })
+
+    expect(refreshedItem.stock).toBe(0)
+
+    const movements = await prisma.inventoryMovement.findMany({
+      where: { stockLines: { some: { itemId: item.id } } },
+    })
+
+    expect(movements).toHaveLength(0)
+  })
+
   it("blocks deleting items with stock and soft deletes empty items", async () => {
     const actor = await createTestUser(prisma)
     const category = await createTestCategory(prisma)