@tailor-platform/erp-kit 0.4.1 → 0.5.1

package/src/modules/inventory/command/completeInventoryCount.ts

@@ -0,0 +1,70 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CountNotFoundError,
+  CountNotInProgressError,
+  UnresolvedCountLinesError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface CompleteInventoryCountInput {
+  inventoryCountId: string;
+}
+
+/**
+ * Function: completeInventoryCount
+ *
+ * Completes the inventory count, transitioning from IN_PROGRESS to COMPLETED.
+ * All count lines must be in a terminal status (APPROVED or REJECTED).
+ * Unfreezes stock if it was frozen during the count.
+ */
+export async function run(
+  db: Transaction,
+  input: CompleteInventoryCountInput,
+  _ctx: CommandContext,
+) {
+  const { inventoryCountId } = input;
+
+  // 1. Fetch count
+  const count = await db
+    .selectFrom("InventoryCount")
+    .selectAll()
+    .where("id", "=", inventoryCountId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!count) {
+    return err(new CountNotFoundError(inventoryCountId));
+  }
+
+  // 2. Validate status
+  if (count.status !== "IN_PROGRESS") {
+    return err(new CountNotInProgressError(inventoryCountId));
+  }
+
+  // 3. Check all lines are in terminal status
+  const lines = await db
+    .selectFrom("InventoryCountLine")
+    .selectAll()
+    .where("inventoryCountId", "=", inventoryCountId)
+    .execute();
+
+  const unresolvedLines = lines.filter((l) => l.status !== "APPROVED" && l.status !== "REJECTED");
+
+  if (unresolvedLines.length > 0) {
+    return err(new UnresolvedCountLinesError(inventoryCountId));
+  }
+
+  // 4. Update status to COMPLETED and unfreeze if frozen
+  const updatedCount = await db
+    .updateTable("InventoryCount")
+    .set({
+      status: "COMPLETED",
+      isFrozen: false,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", inventoryCountId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ inventoryCount: updatedCount! });
+}

package/src/modules/inventory/command/confirmInventoryAdjustment.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./confirmInventoryAdjustment";
+import { defineCommand } from "@tailor-platform/erp-kit/module";
+
+export const confirmInventoryAdjustment = defineCommand(permissions.confirmInventoryAdjustment, run);

package/src/modules/inventory/command/confirmInventoryAdjustment.test.ts

@@ -0,0 +1,324 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  AdjustmentNotFoundError,
+  AdjustmentInvalidStatusError,
+  InsufficientOnHandError,
+} from "../lib/errors.generated";
+import {
+  baseDraftAdjustment,
+  baseApprovedAdjustment,
+  baseConfirmedAdjustment,
+  baseStockLevel,
+  baseItemValuation,
+  baseLotStockLevel,
+} from "../testing/fixtures";
+import { run } from "./confirmInventoryAdjustment";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("confirmInventoryAdjustment", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["inventory:confirmInventoryAdjustment"],
+  };
+
+  it("returns error when not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AdjustmentNotFoundError);
+    }
+  });
+
+  it("returns error when already confirmed", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseConfirmedAdjustment);
+
+    const result = await run(db, { id: "adjustment-5" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AdjustmentInvalidStatusError);
+    }
+  });
+
+  it("returns error when negative adjustment exceeds on-hand", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const bigNegativeAdjustment = { ...baseDraftAdjustment, quantityDelta: -200 };
+    spies.select
+      .mockReturnValueOnce(bigNegativeAdjustment) // adjustment lookup
+      .mockReturnValueOnce(baseStockLevel); // stock level lookup (onHand = 100)
+
+    const result = await run(db, { id: "adjustment-1" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InsufficientOnHandError);
+    }
+  });
+
+  it("confirms CORRECTION from DRAFT (no approval)", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const confirmed = { ...baseDraftAdjustment, status: "CONFIRMED" };
+    spies.select
+      .mockReturnValueOnce(baseDraftAdjustment) // adjustment lookup
+      .mockReturnValueOnce(baseStockLevel) // stock level for insufficient check
+      .mockReturnValueOnce(baseStockLevel) // stock level for update
+      .mockReturnValueOnce(baseItemValuation); // valuation lookup
+    spies.insert.mockReturnValue({
+      id: "movement-new",
+      movementType: "ADJUSTMENT",
+      status: "DONE",
+    });
+    spies.update.mockReturnValue(confirmed);
+
+    const result = await run(db, { id: "adjustment-1" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.adjustment.status).toBe("CONFIRMED");
+    }
+  });
+
+  it("confirms CORRECTION from APPROVED", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const confirmed = { ...baseApprovedAdjustment, status: "CONFIRMED" };
+    // approvedAdjustment has quantityDelta: 5 (positive), so no stock check
+    spies.select
+      .mockReturnValueOnce(baseApprovedAdjustment) // adjustment lookup
+      .mockReturnValueOnce(baseStockLevel) // stock level for update
+      .mockReturnValueOnce(baseItemValuation); // valuation lookup
+    spies.insert.mockReturnValue({
+      id: "movement-new",
+      movementType: "ADJUSTMENT",
+      status: "DONE",
+    });
+    spies.update.mockReturnValue(confirmed);
+
+    const result = await run(db, { id: "adjustment-3" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.adjustment.status).toBe("CONFIRMED");
+    }
+  });
+
+  it("confirms SCRAP from DRAFT", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const scrapDraft = {
+      ...baseDraftAdjustment,
+      adjustmentType: "SCRAP" as const,
+      quantityDelta: -3,
+      reasonCode: "expired",
+    };
+    const confirmed = { ...scrapDraft, status: "CONFIRMED" };
+    spies.select
+      .mockReturnValueOnce(scrapDraft) // adjustment lookup
+      .mockReturnValueOnce(baseStockLevel) // stock level for insufficient check
+      .mockReturnValueOnce(baseStockLevel) // stock level for update
+      .mockReturnValueOnce(baseItemValuation); // valuation lookup
+    spies.insert.mockReturnValue({
+      id: "movement-new",
+      movementType: "GOODS_ISSUE",
+      status: "DONE",
+    });
+    spies.update.mockReturnValue(confirmed);
+
+    const result = await run(db, { id: "adjustment-1" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.adjustment.status).toBe("CONFIRMED");
+    }
+  });
+
+  it("confirms SCRAP from APPROVED", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const scrapApproved = {
+      ...baseApprovedAdjustment,
+      adjustmentType: "SCRAP" as const,
+      quantityDelta: -3,
+      reasonCode: "expired",
+      status: "APPROVED" as const,
+    };
+    const confirmed = { ...scrapApproved, status: "CONFIRMED" };
+    spies.select
+      .mockReturnValueOnce(scrapApproved) // adjustment lookup
+      .mockReturnValueOnce(baseStockLevel) // stock level for insufficient check
+      .mockReturnValueOnce(baseStockLevel) // stock level for update
+      .mockReturnValueOnce(baseItemValuation); // valuation lookup
+    spies.insert.mockReturnValue({
+      id: "movement-new",
+      movementType: "GOODS_ISSUE",
+      status: "DONE",
+    });
+    spies.update.mockReturnValue(confirmed);
+
+    const result = await run(db, { id: "adjustment-3" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.adjustment.status).toBe("CONFIRMED");
+    }
+  });
+
+  it("CORRECTION generates stock movement to virtual adjustment location", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const confirmed = { ...baseDraftAdjustment, status: "CONFIRMED" };
+    spies.select
+      .mockReturnValueOnce(baseDraftAdjustment) // adjustment lookup
+      .mockReturnValueOnce(baseStockLevel) // stock level for insufficient check
+      .mockReturnValueOnce(baseStockLevel) // stock level for update
+      .mockReturnValueOnce(baseItemValuation); // valuation lookup
+    spies.insert.mockReturnValue({
+      id: "movement-new",
+      movementType: "ADJUSTMENT",
+      status: "DONE",
+    });
+    spies.update.mockReturnValue(confirmed);
+
+    await run(db, { id: "adjustment-1" }, ctx);
+
+    // First insert is stock movement, second is stock move line
+    expect(spies.insert).toHaveBeenCalled();
+    expect(spies.values).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ movementType: "GOODS_RECEIPT" }),
+    );
+  });
+
+  it("SCRAP generates stock movement to virtual scrap location", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const scrapDraft = {
+      ...baseDraftAdjustment,
+      adjustmentType: "SCRAP" as const,
+      quantityDelta: -3,
+      reasonCode: "expired",
+    };
+    const confirmed = { ...scrapDraft, status: "CONFIRMED" };
+    spies.select
+      .mockReturnValueOnce(scrapDraft) // adjustment lookup
+      .mockReturnValueOnce(baseStockLevel) // stock level for insufficient check
+      .mockReturnValueOnce(baseStockLevel) // stock level for update
+      .mockReturnValueOnce(baseItemValuation); // valuation lookup
+    spies.insert.mockReturnValue({
+      id: "movement-new",
+      movementType: "GOODS_ISSUE",
+      status: "DONE",
+    });
+    spies.update.mockReturnValue(confirmed);
+
+    await run(db, { id: "adjustment-1" }, ctx);
+
+    expect(spies.values).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ movementType: "GOODS_ISSUE" }),
+    );
+  });
+
+  it("SCRAP updates lot stock when applicable", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const scrapWithLot = {
+      ...baseDraftAdjustment,
+      adjustmentType: "SCRAP" as const,
+      quantityDelta: -3,
+      reasonCode: "expired",
+      lotId: "lot-1",
+    };
+    const confirmed = { ...scrapWithLot, status: "CONFIRMED" };
+    spies.select
+      .mockReturnValueOnce(scrapWithLot) // adjustment lookup
+      .mockReturnValueOnce(baseStockLevel) // stock level for insufficient check
+      .mockReturnValueOnce(baseLotStockLevel) // lot stock level lookup
+      .mockReturnValueOnce(baseStockLevel) // stock level for update
+      .mockReturnValueOnce(baseItemValuation); // valuation lookup
+    spies.insert.mockReturnValue({
+      id: "movement-new",
+      movementType: "GOODS_ISSUE",
+      status: "DONE",
+    });
+    spies.update.mockReturnValue(confirmed);
+
+    await run(db, { id: "adjustment-1" }, ctx);
+
+    // update calls: lot stock level, stock level, valuation, adjustment status
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("SCRAP transitions serial to SCRAPPED when applicable", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const scrapWithSerial = {
+      ...baseDraftAdjustment,
+      adjustmentType: "SCRAP" as const,
+      quantityDelta: -1,
+      reasonCode: "defective",
+      serialNumberId: "serial-1",
+    };
+    const confirmed = { ...scrapWithSerial, status: "CONFIRMED" };
+    spies.select
+      .mockReturnValueOnce(scrapWithSerial) // adjustment lookup
+      .mockReturnValueOnce(baseStockLevel) // stock level for insufficient check
+      .mockReturnValueOnce(baseStockLevel) // stock level for update
+      .mockReturnValueOnce(baseItemValuation); // valuation lookup
+    spies.insert.mockReturnValue({
+      id: "movement-new",
+      movementType: "GOODS_ISSUE",
+      status: "DONE",
+    });
+    spies.update.mockReturnValue(confirmed);
+
+    await run(db, { id: "adjustment-1" }, ctx);
+
+    // One of the update set calls should contain status: "SCRAPPED"
+    expect(spies.set).toHaveBeenCalledWith(expect.objectContaining({ status: "SCRAPPED" }));
+  });
+
+  it("updates on-hand quantity", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const confirmed = { ...baseDraftAdjustment, status: "CONFIRMED" };
+    spies.select
+      .mockReturnValueOnce(baseDraftAdjustment) // adjustment lookup (quantityDelta: -5)
+      .mockReturnValueOnce(baseStockLevel) // stock level for insufficient check (onHand: 100)
+      .mockReturnValueOnce(baseStockLevel) // stock level for update
+      .mockReturnValueOnce(baseItemValuation); // valuation lookup
+    spies.insert.mockReturnValue({
+      id: "movement-new",
+      movementType: "ADJUSTMENT",
+      status: "DONE",
+    });
+    spies.update.mockReturnValue(confirmed);
+
+    await run(db, { id: "adjustment-1" }, ctx);
+
+    // Stock level update should set onHand to 100 + (-5) = 95
+    expect(spies.set).toHaveBeenCalledWith(expect.objectContaining({ onHand: 95 }));
+  });
+
+  it("updates inventory valuation", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const confirmed = { ...baseDraftAdjustment, status: "CONFIRMED" };
+    spies.select
+      .mockReturnValueOnce(baseDraftAdjustment) // adjustment lookup (quantityDelta: -5)
+      .mockReturnValueOnce(baseStockLevel) // stock level for insufficient check
+      .mockReturnValueOnce(baseStockLevel) // stock level for update
+      .mockReturnValueOnce(baseItemValuation); // valuation lookup (totalQuantity: 100, costPerUnit: 10)
+    spies.insert.mockReturnValue({
+      id: "movement-new",
+      movementType: "ADJUSTMENT",
+      status: "DONE",
+    });
+    spies.update.mockReturnValue(confirmed);
+
+    await run(db, { id: "adjustment-1" }, ctx);
+
+    // Valuation update should set totalQuantity to 100 + (-5) = 95, totalValue to 95 * 10 = 950
+    expect(spies.set).toHaveBeenCalledWith(
+      expect.objectContaining({ totalQuantity: 95, totalValue: 950 }),
+    );
+  });
+});

package/src/modules/inventory/command/confirmInventoryAdjustment.ts

@@ -0,0 +1,194 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  AdjustmentNotFoundError,
+  AdjustmentInvalidStatusError,
+  InsufficientOnHandError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface ConfirmInventoryAdjustmentInput {
+  id: string;
+}
+
+/**
+ * Function: confirmInventoryAdjustment
+ *
+ * Confirms an inventory adjustment, generating a stock movement and updating on-hand quantities
+ * and valuation. Can be called from DRAFT (bypassing approval) or APPROVED status.
+ *
+ * CORRECTION: generates stock movement to/from virtual adjustment location.
+ * SCRAP: generates stock movement to virtual scrap location, updates lot stock and serial state.
+ */
+export async function run(
+  db: Transaction,
+  input: ConfirmInventoryAdjustmentInput,
+  _ctx: CommandContext,
+) {
+  const { id } = input;
+
+  // 1. Fetch adjustment
+  const adjustment = await db
+    .selectFrom("InventoryAdjustment")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!adjustment) {
+    return err(new AdjustmentNotFoundError(id));
+  }
+
+  // 2. Validate status is DRAFT or APPROVED
+  if (adjustment.status !== "DRAFT" && adjustment.status !== "APPROVED") {
+    return err(new AdjustmentInvalidStatusError(id));
+  }
+
+  // 3. Check on-hand for negative adjustments
+  if (adjustment.quantityDelta < 0) {
+    const stockLevel = await db
+      .selectFrom("StockLevel")
+      .selectAll()
+      .where("itemId", "=", adjustment.itemId)
+      .where("storageLocationId", "=", adjustment.storageLocationId)
+      .forUpdate()
+      .executeTakeFirst();
+
+    const onHand = stockLevel?.onHand ?? 0;
+    if (onHand + adjustment.quantityDelta < 0) {
+      return err(new InsufficientOnHandError(id));
+    }
+  }
+
+  // 4. Generate stock movement
+  const movementType =
+    adjustment.adjustmentType === "SCRAP" ? ("GOODS_ISSUE" as const) : ("GOODS_RECEIPT" as const);
+  const stockMovement = await db
+    .insertInto("StockMovement")
+    .values({
+      movementType,
+      reasonCode: adjustment.reasonCode,
+      status: "DONE",
+      executedAt: new Date(),
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  // 5. Create stock move line
+  await db
+    .insertInto("StockMoveLine")
+    .values({
+      stockMovementId: stockMovement!.id,
+      itemId: adjustment.itemId,
+      quantity: Math.abs(adjustment.quantityDelta),
+      sourceLocationId: adjustment.quantityDelta < 0 ? adjustment.storageLocationId : null,
+      destinationLocationId: adjustment.quantityDelta >= 0 ? adjustment.storageLocationId : null,
+      lotId: adjustment.lotId,
+      serialNumberId: adjustment.serialNumberId,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  // 6. SCRAP-specific: update lot stock levels if lot specified
+  if (adjustment.adjustmentType === "SCRAP" && adjustment.lotId) {
+    const lotStock = await db
+      .selectFrom("LotStockLevel")
+      .selectAll()
+      .where("lotId", "=", adjustment.lotId)
+      .where("storageLocationId", "=", adjustment.storageLocationId)
+      .forUpdate()
+      .executeTakeFirst();
+
+    if (lotStock) {
+      await db
+        .updateTable("LotStockLevel")
+        .set({
+          onHand: lotStock.onHand + adjustment.quantityDelta,
+          updatedAt: new Date(),
+        })
+        .where("id", "=", lotStock.id)
+        .execute();
+    }
+  }
+
+  // 7. SCRAP-specific: transition serial to SCRAPPED if serial specified
+  if (adjustment.adjustmentType === "SCRAP" && adjustment.serialNumberId) {
+    await db
+      .updateTable("SerialNumber")
+      .set({ status: "SCRAPPED", updatedAt: new Date() })
+      .where("id", "=", adjustment.serialNumberId)
+      .execute();
+  }
+
+  // 8. Update on-hand quantity on StockLevel
+  const existingStockLevel = await db
+    .selectFrom("StockLevel")
+    .selectAll()
+    .where("itemId", "=", adjustment.itemId)
+    .where("storageLocationId", "=", adjustment.storageLocationId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (existingStockLevel) {
+    await db
+      .updateTable("StockLevel")
+      .set({
+        onHand: existingStockLevel.onHand + adjustment.quantityDelta,
+        updatedAt: new Date(),
+      })
+      .where("id", "=", existingStockLevel.id)
+      .execute();
+  } else {
+    await db
+      .insertInto("StockLevel")
+      .values({
+        itemId: adjustment.itemId,
+        storageLocationId: adjustment.storageLocationId,
+        onHand: adjustment.quantityDelta,
+        reserved: 0,
+        incoming: 0,
+        blocked: 0,
+        createdAt: new Date(),
+        updatedAt: null,
+      })
+      .execute();
+  }
+
+  // 9. Update inventory valuation
+  const valuation = await db
+    .selectFrom("ItemValuation")
+    .selectAll()
+    .where("itemId", "=", adjustment.itemId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (valuation) {
+    const newTotalQuantity = valuation.totalQuantity + adjustment.quantityDelta;
+    const newTotalValue =
+      valuation.costPerUnit != null
+        ? newTotalQuantity * valuation.costPerUnit
+        : valuation.totalValue;
+    await db
+      .updateTable("ItemValuation")
+      .set({
+        totalQuantity: newTotalQuantity,
+        totalValue: newTotalValue,
+        updatedAt: new Date(),
+      })
+      .where("id", "=", valuation.id)
+      .execute();
+  }
+
+  // 10. Update status to CONFIRMED
+  const confirmed = await db
+    .updateTable("InventoryAdjustment")
+    .set({ status: "CONFIRMED", updatedAt: new Date() })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ adjustment: confirmed! });
+}

package/src/modules/inventory/command/confirmStockMovement.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./confirmStockMovement";
+import { defineCommand } from "@tailor-platform/erp-kit/module";
+
+export const confirmStockMovement = defineCommand(permissions.confirmStockMovement, run);