feat(assignments): close and reopen assignment on person swap

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

@@ -832,4 +832,113 @@ describe("asset use-cases", () => {
       newStatus: "ASSIGNED",
     })
   })
+
+  it("closes the old assignment and creates a new one on person swap via updateAssetUseCase", async () => {
+    const actor = await createTestUser(prisma)
+    const personA = await createTestPerson(prisma, { firstName: "Alice" })
+    const personB = await createTestPerson(prisma, { firstName: "Bob" })
+    const category = await createTestCategory(prisma)
+    const item = await prisma.item.create({
+      data: {
+        sku: "W3-ASSET-SKU",
+        name: "Asset Item",
+        trackingType: "SERIALIZED",
+        stock: 0,
+        category: { connect: { id: category.id } },
+      },
+    })
+
+    const created = await createAssetUseCase({
+      actorId: actor.id,
+      itemId: item.id,
+      serialNumber: "W3-ASSET-001",
+      status: "ASSIGNED",
+      personId: personA.id,
+    })
+    expect(created.success).toBe(true)
+    if (!created.success) throw new Error("Expected asset creation success")
+
+    const oldAssignment = await prisma.assignment.findFirstOrThrow({
+      where: {
+        status: "OPEN",
+        assetLines: { some: { assetId: created.assetId, returnedAt: null } },
+      },
+    })
+
+    const updated = await updateAssetUseCase({
+      actorId: actor.id,
+      id: created.assetId,
+      itemId: item.id,
+      serialNumber: "W3-ASSET-001",
+      status: "ASSIGNED",
+      personId: personB.id,
+    })
+    expect(updated.success).toBe(true)
+    if (!updated.success) throw new Error("Expected asset update success")
+
+    const [oldAssignmentAfter, newAssignment, movements] = await Promise.all([
+      prisma.assignment.findUniqueOrThrow({
+        where: { id: oldAssignment.id },
+        include: { assetLines: true },
+      }),
+      prisma.assignment.findFirstOrThrow({
+        where: { personId: personB.id, status: "OPEN" },
+        include: { assetLines: true },
+      }),
+      prisma.inventoryMovement.findMany({
+        include: {
+          stockLines: true,
+          assetLines: true,
+          assignment: { select: { personId: true } },
+        },
+        orderBy: [{ createdAt: "asc" }, { id: "asc" }],
+      }),
+    ])
+
+    expect(oldAssignmentAfter.status).toBe("RETURNED")
+    expect(oldAssignmentAfter.closedAt).toBeInstanceOf(Date)
+    expect(oldAssignmentAfter.assetLines[0].returnedAt).toBeInstanceOf(Date)
+
+    expect(newAssignment.id).not.toBe(oldAssignment.id)
+    expect(newAssignment.personId).toBe(personB.id)
+    expect(newAssignment.assetLines[0]).toMatchObject({
+      assetId: created.assetId,
+      returnedAt: null,
+    })
+
+    expect(movements).toHaveLength(3)
+    expect(movements.map((m) => m.type)).toEqual([
+      "ASSIGNMENT",
+      "RETURN",
+      "ASSIGNMENT",
+    ])
+    for (const movement of movements) {
+      expect(movement.stockLines).toEqual([])
+    }
+
+    const returnMovement = movements[1]
+    const newAssignmentMovement = movements[2]
+
+    expect(returnMovement).toMatchObject({
+      type: "RETURN",
+      assignmentId: oldAssignment.id,
+    })
+    expect(returnMovement.assignment).toMatchObject({
+      personId: personA.id,
+    })
+    expect(returnMovement.assetLines[0]).toMatchObject({
+      assetId: created.assetId,
+    })
+
+    expect(newAssignmentMovement).toMatchObject({
+      type: "ASSIGNMENT",
+      assignmentId: newAssignment.id,
+    })
+    expect(newAssignmentMovement.assignment).toMatchObject({
+      personId: personB.id,
+    })
+    expect(newAssignmentMovement.assetLines[0]).toMatchObject({
+      assetId: created.assetId,
+    })
+  })
 })