@tailor-platform/erp-kit 0.4.0 → 0.5.0

package/src/modules/purchase/command/deactivatePurchasePriceRule.generated.ts

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

package/src/modules/purchase/command/deactivatePurchasePriceRule.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { PriceRuleNotFoundError } from "../lib/errors.generated";
+import { basePriceRule, inactivePriceRule } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./deactivatePurchasePriceRule";
+
+describe("deactivatePurchasePriceRule", () => {
+  it("deactivates an active price rule", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePriceRule);
+    spies.update.mockReturnValueOnce({ ...basePriceRule, status: "INACTIVE" });
+
+    const result = await run(db, { id: basePriceRule.id }, commandCtx);
+    const value = expectOk<{ purchasePriceRule: typeof basePriceRule }>(result);
+
+    expect(value.purchasePriceRule.status).toBe("INACTIVE");
+  });
+
+  it("returns success when the rule is already inactive", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(inactivePriceRule);
+
+    const result = await run(db, { id: inactivePriceRule.id }, commandCtx);
+    const value = expectOk<{ purchasePriceRule: typeof inactivePriceRule }>(result);
+
+    expect(value.purchasePriceRule).toEqual(inactivePriceRule);
+  });
+
+  it("preserves historical purchase-order snapshots after deactivation", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePriceRule);
+    spies.update.mockReturnValueOnce({ ...basePriceRule, status: "INACTIVE" });
+
+    await run(db, { id: basePriceRule.id }, commandCtx);
+
+    const firstSetCall = spies.set.mock.calls[0]?.[0] as Record<string, unknown>;
+    expect(firstSetCall).not.toHaveProperty("matchedPriceRuleId");
+  });
+
+  it("returns error when rule does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "missing-rule" }, commandCtx);
+
+    expectErr(result, PriceRuleNotFoundError);
+  });
+});

package/src/modules/purchase/command/deactivatePurchasePriceRule.ts

@@ -0,0 +1,32 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unused-vars */
+import type { Transaction } from "../generated/kysely-tailordb";
+import { PriceRuleNotFoundError } from "../lib/errors.generated";
+import { selectOne } from "../lib/domain";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface DeactivatePurchasePriceRuleInput {
+  id: string;
+}
+
+export async function run(
+  db: Transaction,
+  input: DeactivatePurchasePriceRuleInput,
+  ctx: CommandContext,
+) {
+  const purchasePriceRule = await selectOne(db, "PurchasePriceRule", "id", input.id, true);
+  if (!purchasePriceRule) {
+    return err(new PriceRuleNotFoundError(input.id));
+  }
+  if (purchasePriceRule.status === "INACTIVE") {
+    return ok({ purchasePriceRule });
+  }
+
+  const deactivated = await db
+    .updateTable("PurchasePriceRule")
+    .set({ status: "INACTIVE", updatedAt: new Date() })
+    .where("id", "=", input.id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ purchasePriceRule: deactivated });
+}

package/src/modules/purchase/command/matchPurchaseBill.generated.ts

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

package/src/modules/purchase/command/matchPurchaseBill.test.ts

@@ -0,0 +1,188 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  MatchModeRequiredError,
+  PaymentScheduleCalculationFailedError,
+  PurchaseBillNotDraftError,
+  PurchaseBillNotFoundError,
+  PurchaseOrderCancelledError,
+} from "../lib/errors.generated";
+import {
+  baseGoodsReceiptLines,
+  basePurchaseBill,
+  basePurchaseBillLines,
+  matchedPurchaseBill,
+  orderedPurchaseOrder,
+  postedGoodsReceipt,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./matchPurchaseBill";
+
+describe("matchPurchaseBill", () => {
+  it("matches a valid 2-way purchase bill", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(basePurchaseBill)
+      .mockReturnValueOnce([orderedPurchaseOrder])
+      .mockReturnValueOnce([]);
+    spies.update
+      .mockReturnValueOnce({ ...orderedPurchaseOrder, status: "PARTIALLY_BILLED" })
+      .mockReturnValueOnce({ ...matchedPurchaseBill, matchingMode: "TWO_WAY" });
+
+    const result = await run(db, { id: basePurchaseBill.id, matchingMode: "TWO_WAY" }, commandCtx);
+
+    expect(expectOk(result).purchaseBill.status).toBe("MATCHED");
+  });
+
+  it("matches a valid 3-way purchase bill when posted receipt quantity is sufficient", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(basePurchaseBill)
+      .mockReturnValueOnce([orderedPurchaseOrder])
+      .mockReturnValueOnce([postedGoodsReceipt]);
+    spies.update
+      .mockReturnValueOnce({ ...orderedPurchaseOrder, status: "PARTIALLY_BILLED" })
+      .mockReturnValueOnce({ ...matchedPurchaseBill, matchingMode: "THREE_WAY" });
+
+    const result = await run(
+      db,
+      { id: basePurchaseBill.id, matchingMode: "THREE_WAY" },
+      commandCtx,
+    );
+
+    expect(expectOk(result).purchaseBill.matchingMode).toBe("THREE_WAY");
+  });
+
+  it("blocks a bill when 3-way quantity exceeds posted receipt quantity", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const partialReceipt = {
+      ...postedGoodsReceipt,
+      lines: JSON.stringify([{ ...baseGoodsReceiptLines[0], quantity: 3 }]),
+    };
+    spies.select
+      .mockReturnValueOnce(basePurchaseBill)
+      .mockReturnValueOnce([orderedPurchaseOrder])
+      .mockReturnValueOnce([partialReceipt]);
+    spies.update.mockReturnValueOnce({
+      ...basePurchaseBill,
+      status: "BLOCKED",
+      varianceReason: "RECEIPT_QUANTITY_EXCEEDED",
+    });
+
+    const result = await run(
+      db,
+      { id: basePurchaseBill.id, matchingMode: "THREE_WAY" },
+      commandCtx,
+    );
+
+    expect(expectOk(result).purchaseBill.status).toBe("BLOCKED");
+  });
+
+  it("blocks a bill when price variance exceeds tolerance", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const highVarianceBill = {
+      ...basePurchaseBill,
+      lines: JSON.stringify([{ ...basePurchaseBillLines[0], billedUnitPrice: 120 }]),
+    };
+    spies.select
+      .mockReturnValueOnce(highVarianceBill)
+      .mockReturnValueOnce([orderedPurchaseOrder])
+      .mockReturnValueOnce([]);
+    spies.update.mockReturnValueOnce({
+      ...highVarianceBill,
+      status: "BLOCKED",
+      varianceReason: "PRICE_VARIANCE_EXCEEDED",
+    });
+
+    const result = await run(db, { id: highVarianceBill.id, matchingMode: "TWO_WAY" }, commandCtx);
+
+    expect(expectOk(result).purchaseBill.status).toBe("BLOCKED");
+  });
+
+  it("records matching mode on the bill", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(basePurchaseBill)
+      .mockReturnValueOnce([orderedPurchaseOrder])
+      .mockReturnValueOnce([]);
+    spies.update
+      .mockReturnValueOnce({ ...orderedPurchaseOrder, status: "PARTIALLY_BILLED" })
+      .mockReturnValueOnce({ ...matchedPurchaseBill, matchingMode: "TWO_WAY" });
+
+    const result = await run(db, { id: basePurchaseBill.id, matchingMode: "TWO_WAY" }, commandCtx);
+
+    expect(expectOk(result).purchaseBill.matchingMode).toBe("TWO_WAY");
+  });
+
+  it("increases purchase-order billed quantity when the bill is matched", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(basePurchaseBill)
+      .mockReturnValueOnce([orderedPurchaseOrder])
+      .mockReturnValueOnce([]);
+    spies.update
+      .mockReturnValueOnce({ ...orderedPurchaseOrder, status: "PARTIALLY_BILLED" })
+      .mockReturnValueOnce({ ...matchedPurchaseBill, matchingMode: "TWO_WAY" });
+
+    await run(db, { id: basePurchaseBill.id, matchingMode: "TWO_WAY" }, commandCtx);
+
+    const setCall = spies.set.mock.calls[0]?.[0] as { lines?: string };
+    expect(setCall.lines).toContain('"billedQuantity":4');
+  });
+
+  it("returns error when purchase bill does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+    expectErr(
+      await run(db, { id: "missing-bill", matchingMode: "TWO_WAY" }, commandCtx),
+      PurchaseBillNotFoundError,
+    );
+  });
+
+  it("returns error when purchase bill is not draft", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(matchedPurchaseBill);
+    expectErr(
+      await run(db, { id: matchedPurchaseBill.id, matchingMode: "TWO_WAY" }, commandCtx),
+      PurchaseBillNotDraftError,
+    );
+  });
+
+  it("returns error when matching mode is missing", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePurchaseBill);
+    expectErr(
+      await run(db, { id: basePurchaseBill.id, matchingMode: undefined as never }, commandCtx),
+      MatchModeRequiredError,
+    );
+  });
+
+  it("returns error when a referenced purchase order is cancelled", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(basePurchaseBill)
+      .mockReturnValueOnce([{ ...orderedPurchaseOrder, status: "CANCELLED" }])
+      .mockReturnValueOnce([]);
+    expectErr(
+      await run(db, { id: basePurchaseBill.id, matchingMode: "TWO_WAY" }, commandCtx),
+      PurchaseOrderCancelledError,
+    );
+  });
+
+  it("returns error when payment schedule calculation fails", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const invalidScheduleBill = {
+      ...basePurchaseBill,
+      paymentTermSnapshot: JSON.stringify({ lines: [] }),
+    };
+    spies.select
+      .mockReturnValueOnce(invalidScheduleBill)
+      .mockReturnValueOnce([orderedPurchaseOrder])
+      .mockReturnValueOnce([]);
+    expectErr(
+      await run(db, { id: invalidScheduleBill.id, matchingMode: "TWO_WAY" }, commandCtx),
+      PaymentScheduleCalculationFailedError,
+    );
+  });
+});

package/src/modules/purchase/command/matchPurchaseBill.ts

@@ -0,0 +1,146 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  MatchModeRequiredError,
+  PaymentScheduleCalculationFailedError,
+  PurchaseBillNotDraftError,
+  PurchaseBillNotFoundError,
+  PurchaseOrderCancelledError,
+} from "../lib/errors.generated";
+import {
+  calculateDueSchedule,
+  decodeJson,
+  derivePurchaseOrderStatus,
+  encodeJson,
+  findOrderLine,
+  priceVarianceExceeded,
+  totalReceiptQuantityForOrderLine,
+  updateOrderLineQuantities,
+  type PaymentTermScheduleLineInput,
+  type PurchaseBillLineInput,
+  type PurchaseOrderLineInput,
+} from "../lib/domain";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface MatchPurchaseBillInput {
+  id: string;
+  matchingMode: "TWO_WAY" | "THREE_WAY";
+}
+
+export async function run(db: Transaction, input: MatchPurchaseBillInput, ctx: CommandContext) {
+  void ctx;
+  const purchaseBill = await db
+    .selectFrom("PurchaseBill")
+    .selectAll()
+    .where("id", "=", input.id)
+    .forUpdate()
+    .executeTakeFirst();
+  if (!purchaseBill) {
+    return err(new PurchaseBillNotFoundError(input.id));
+  }
+  if (purchaseBill.status !== "DRAFT") {
+    return err(new PurchaseBillNotDraftError(input.id));
+  }
+  if (!input.matchingMode) {
+    return err(new MatchModeRequiredError(input.id));
+  }
+
+  const purchaseOrders = await db.selectFrom("PurchaseOrder").selectAll().execute();
+  const postedReceipts = await db
+    .selectFrom("GoodsReceipt")
+    .selectAll()
+    .where("status", "=", "POSTED")
+    .execute();
+  const billLines = decodeJson<PurchaseBillLineInput[]>(purchaseBill.lines, []);
+  const billedQuantitiesByOrderId = new Map<string, Map<string, number>>();
+  let varianceReason: string | null = null;
+
+  for (const billLine of billLines) {
+    const match = findOrderLine(purchaseOrders, billLine.purchaseOrderLineId);
+    if (!match) continue;
+    if (match.order.status === "CANCELLED") {
+      return err(new PurchaseOrderCancelledError(String(match.order.id)));
+    }
+
+    if (
+      input.matchingMode === "THREE_WAY" &&
+      billLine.quantity >
+        totalReceiptQuantityForOrderLine(postedReceipts, billLine.purchaseOrderLineId) * 1.05
+    ) {
+      varianceReason = "RECEIPT_QUANTITY_EXCEEDED";
+    }
+    if (
+      billLine.billedUnitPrice !== undefined &&
+      priceVarianceExceeded(billLine.billedUnitPrice, match.line.unitPrice)
+    ) {
+      varianceReason = "PRICE_VARIANCE_EXCEEDED";
+    }
+
+    const perOrder =
+      billedQuantitiesByOrderId.get(String(match.order.id)) ?? new Map<string, number>();
+    perOrder.set(
+      billLine.purchaseOrderLineId,
+      (perOrder.get(billLine.purchaseOrderLineId) ?? 0) + billLine.quantity,
+    );
+    billedQuantitiesByOrderId.set(String(match.order.id), perOrder);
+  }
+
+  const snapshot = decodeJson<{ lines: PaymentTermScheduleLineInput[] }>(
+    purchaseBill.paymentTermSnapshot,
+    { lines: [] },
+  );
+  const billAmount = billLines.reduce(
+    (sum, line) => sum + line.quantity * (line.billedUnitPrice ?? 0),
+    0,
+  );
+  const dueSchedule = calculateDueSchedule(
+    snapshot.lines,
+    new Date(purchaseBill.invoiceDate),
+    billAmount,
+  );
+  if ("error" in dueSchedule) {
+    return err(new PaymentScheduleCalculationFailedError(input.id));
+  }
+
+  if (!varianceReason) {
+    for (const [orderId, quantities] of billedQuantitiesByOrderId) {
+      const order = purchaseOrders.find((candidate) => candidate.id === orderId);
+      if (!order) continue;
+      const lines = decodeJson<PurchaseOrderLineInput[]>(order.lines, []);
+      const nextLines = updateOrderLineQuantities(lines, quantities, "billedQuantity");
+      await db
+        .updateTable("PurchaseOrder")
+        .set({
+          lines: encodeJson(nextLines),
+          status: derivePurchaseOrderStatus(order.status, nextLines),
+          updatedAt: new Date(),
+        })
+        .where("id", "=", orderId)
+        .returningAll()
+        .executeTakeFirstOrThrow();
+    }
+  }
+
+  const status = varianceReason ? "BLOCKED" : "MATCHED";
+  const matched = await db
+    .updateTable("PurchaseBill")
+    .set({
+      status,
+      matchingMode: input.matchingMode,
+      varianceReason,
+      dueSchedule: varianceReason ? null : encodeJson(dueSchedule.schedule),
+      comparisonEvidence: encodeJson({ matchingMode: input.matchingMode, varianceReason }),
+      billReadyHandoff: varianceReason
+        ? null
+        : encodeJson({
+            invoiceNumber: purchaseBill.invoiceNumber,
+            matchingMode: input.matchingMode,
+            dueSchedule: dueSchedule.schedule,
+          }),
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ purchaseBill: matched });
+}

package/src/modules/purchase/command/postGoodsReceipt.generated.ts

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

package/src/modules/purchase/command/postGoodsReceipt.test.ts

@@ -0,0 +1,210 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  GoodsReceiptNotDraftError,
+  GoodsReceiptNotFoundError,
+  InactiveExecutionReferenceError,
+  InventoryHandoffFailedError,
+  NoOpenReceiptQuantityError,
+  OverReceiptToleranceExceededError,
+  PurchaseOrderNotReceivableError,
+} from "../lib/errors.generated";
+import {
+  baseGoodsReceipt,
+  baseGoodsReceiptLines,
+  baseItem,
+  basePurchaseOrderLines,
+  orderedPurchaseOrder,
+  postedGoodsReceipt,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./postGoodsReceipt";
+
+describe("postGoodsReceipt", () => {
+  it("posts a valid goods receipt and increases purchase-order received quantity", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseGoodsReceipt)
+      .mockReturnValueOnce(orderedPurchaseOrder)
+      .mockReturnValueOnce({ id: baseGoodsReceipt.supplierId, status: "ACTIVE" })
+      .mockReturnValueOnce(baseItem);
+    spies.update
+      .mockReturnValueOnce({ ...orderedPurchaseOrder, status: "PARTIALLY_RECEIVED" })
+      .mockReturnValueOnce({ ...baseGoodsReceipt, status: "POSTED" });
+
+    const result = await run(db, { id: baseGoodsReceipt.id }, commandCtx);
+
+    expect(expectOk(result).goodsReceipt.status).toBe("POSTED");
+    const orderUpdate = spies.set.mock.calls[0]?.[0] as { lines?: string };
+    expect(orderUpdate.lines).toContain('"receivedQuantity":4');
+  });
+
+  it("transitions purchase order to partially received when open quantity remains", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseGoodsReceipt)
+      .mockReturnValueOnce(orderedPurchaseOrder)
+      .mockReturnValueOnce({ id: baseGoodsReceipt.supplierId, status: "ACTIVE" })
+      .mockReturnValueOnce(baseItem);
+    spies.update
+      .mockReturnValueOnce({ ...orderedPurchaseOrder, status: "PARTIALLY_RECEIVED" })
+      .mockReturnValueOnce({ ...baseGoodsReceipt, status: "POSTED" });
+
+    await run(db, { id: baseGoodsReceipt.id }, commandCtx);
+
+    expect(spies.set).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ status: "PARTIALLY_RECEIVED" }),
+    );
+  });
+
+  it("transitions purchase order to received when all quantity is posted", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const receipt = {
+      ...baseGoodsReceipt,
+      lines: JSON.stringify([{ ...baseGoodsReceiptLines[0], quantity: 10 }]),
+    };
+    const order = {
+      ...orderedPurchaseOrder,
+      lines: JSON.stringify([{ ...basePurchaseOrderLines[0], quantity: 10, receivedQuantity: 0 }]),
+    };
+    spies.select
+      .mockReturnValueOnce(receipt)
+      .mockReturnValueOnce(order)
+      .mockReturnValueOnce({ id: receipt.supplierId, status: "ACTIVE" })
+      .mockReturnValueOnce(baseItem);
+    spies.update
+      .mockReturnValueOnce({ ...order, status: "RECEIVED" })
+      .mockReturnValueOnce({ ...receipt, status: "POSTED" });
+
+    await run(db, { id: receipt.id }, commandCtx);
+
+    expect(spies.set).toHaveBeenNthCalledWith(1, expect.objectContaining({ status: "RECEIVED" }));
+  });
+
+  it("emits inventory handoff once for a stock-item receipt", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseGoodsReceipt)
+      .mockReturnValueOnce(orderedPurchaseOrder)
+      .mockReturnValueOnce({ id: baseGoodsReceipt.supplierId, status: "ACTIVE" })
+      .mockReturnValueOnce(baseItem);
+    spies.update
+      .mockReturnValueOnce({ ...orderedPurchaseOrder, status: "PARTIALLY_RECEIVED" })
+      .mockReturnValueOnce({ ...baseGoodsReceipt, status: "POSTED" });
+
+    await run(db, { id: baseGoodsReceipt.id }, commandCtx);
+
+    const receiptUpdate = spies.set.mock.calls[1]?.[0] as { inventoryHandoff?: string | null };
+    expect(receiptUpdate.inventoryHandoff).toContain(baseGoodsReceipt.id);
+  });
+
+  it("skips inventory handoff for a service receipt", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const serviceReceipt = {
+      ...baseGoodsReceipt,
+      lines: JSON.stringify([{ ...baseGoodsReceiptLines[0], requiresInventoryHandoff: false }]),
+    };
+    spies.select
+      .mockReturnValueOnce(serviceReceipt)
+      .mockReturnValueOnce(orderedPurchaseOrder)
+      .mockReturnValueOnce({ id: serviceReceipt.supplierId, status: "ACTIVE" })
+      .mockReturnValueOnce(baseItem);
+    spies.update
+      .mockReturnValueOnce({ ...orderedPurchaseOrder, status: "PARTIALLY_RECEIVED" })
+      .mockReturnValueOnce({ ...serviceReceipt, status: "POSTED" });
+
+    await run(db, { id: serviceReceipt.id }, commandCtx);
+
+    expect(spies.set).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({ inventoryHandoff: null }),
+    );
+  });
+
+  it("returns error when goods receipt does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+    expectErr(await run(db, { id: "missing-receipt" }, commandCtx), GoodsReceiptNotFoundError);
+  });
+
+  it("returns error when goods receipt is not draft", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(postedGoodsReceipt);
+    expectErr(await run(db, { id: postedGoodsReceipt.id }, commandCtx), GoodsReceiptNotDraftError);
+  });
+
+  it("returns error when posting exceeds tolerance", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const receipt = {
+      ...baseGoodsReceipt,
+      lines: JSON.stringify([{ ...baseGoodsReceiptLines[0], quantity: 11 }]),
+    };
+    const order = {
+      ...orderedPurchaseOrder,
+      lines: JSON.stringify([{ ...basePurchaseOrderLines[0], quantity: 10, receivedQuantity: 0 }]),
+    };
+    spies.select
+      .mockReturnValueOnce(receipt)
+      .mockReturnValueOnce(order)
+      .mockReturnValueOnce({ id: receipt.supplierId, status: "ACTIVE" })
+      .mockReturnValueOnce(baseItem);
+    expectErr(await run(db, { id: receipt.id }, commandCtx), OverReceiptToleranceExceededError);
+  });
+
+  it("returns error when posting a receipt line with no open quantity remaining", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const order = {
+      ...orderedPurchaseOrder,
+      lines: JSON.stringify([{ ...basePurchaseOrderLines[0], quantity: 10, receivedQuantity: 10 }]),
+    };
+    const receipt = {
+      ...baseGoodsReceipt,
+      lines: JSON.stringify([{ ...baseGoodsReceiptLines[0], quantity: 1 }]),
+    };
+    spies.select
+      .mockReturnValueOnce(receipt)
+      .mockReturnValueOnce(order)
+      .mockReturnValueOnce({ id: receipt.supplierId, status: "ACTIVE" })
+      .mockReturnValueOnce(baseItem);
+
+    expectErr(await run(db, { id: receipt.id }, commandCtx), NoOpenReceiptQuantityError);
+  });
+
+  it("returns error when inventory handoff fails", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseGoodsReceipt)
+      .mockReturnValueOnce(orderedPurchaseOrder)
+      .mockReturnValueOnce({ id: baseGoodsReceipt.supplierId, status: "ACTIVE" })
+      .mockReturnValueOnce(baseItem);
+    expectErr(
+      await run(db, { id: baseGoodsReceipt.id, inventoryHandoffSucceeded: false }, commandCtx),
+      InventoryHandoffFailedError,
+    );
+  });
+
+  it("returns error when purchase order is no longer receivable", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseGoodsReceipt)
+      .mockReturnValueOnce({ ...orderedPurchaseOrder, status: "CANCELLED" });
+    expectErr(
+      await run(db, { id: baseGoodsReceipt.id }, commandCtx),
+      PurchaseOrderNotReceivableError,
+    );
+  });
+
+  it("returns error when execution references are inactive", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseGoodsReceipt)
+      .mockReturnValueOnce(orderedPurchaseOrder)
+      .mockReturnValueOnce({ id: baseGoodsReceipt.supplierId, status: "INACTIVE" });
+    expectErr(
+      await run(db, { id: baseGoodsReceipt.id }, commandCtx),
+      InactiveExecutionReferenceError,
+    );
+  });
+});