@tailor-platform/erp-kit 0.4.1 → 0.5.1

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,
+    );
+  });
+});

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

@@ -0,0 +1,143 @@
+/* eslint-disable @typescript-eslint/array-type */
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  GoodsReceiptNotDraftError,
+  GoodsReceiptNotFoundError,
+  InactiveExecutionReferenceError,
+  InventoryHandoffFailedError,
+  NoOpenReceiptQuantityError,
+  OverReceiptToleranceExceededError,
+  PurchaseOrderNotReceivableError,
+} from "../lib/errors.generated";
+import {
+  decodeJson,
+  derivePurchaseOrderStatus,
+  encodeJson,
+  isActiveStatus,
+  updateOrderLineQuantities,
+  type GoodsReceiptLineInput,
+  type PurchaseOrderLineInput,
+} from "../lib/domain";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface PostGoodsReceiptInput {
+  id: string;
+  inventoryHandoffSucceeded?: boolean;
+}
+
+export async function run(db: Transaction, input: PostGoodsReceiptInput, ctx: CommandContext) {
+  void ctx;
+  const goodsReceipt = await db
+    .selectFrom("GoodsReceipt")
+    .selectAll()
+    .where("id", "=", input.id)
+    .forUpdate()
+    .executeTakeFirst();
+  if (!goodsReceipt) {
+    return err(new GoodsReceiptNotFoundError(input.id));
+  }
+  if (goodsReceipt.status !== "DRAFT") {
+    return err(new GoodsReceiptNotDraftError(input.id));
+  }
+
+  const purchaseOrder = await db
+    .selectFrom("PurchaseOrder")
+    .selectAll()
+    .where("id", "=", goodsReceipt.purchaseOrderId)
+    .forUpdate()
+    .executeTakeFirst();
+  if (!purchaseOrder || ["CANCELLED", "CLOSED"].includes(purchaseOrder.status)) {
+    return err(new PurchaseOrderNotReceivableError(goodsReceipt.purchaseOrderId));
+  }
+
+  const supplier = await db
+    .selectFrom("BusinessPartner")
+    .selectAll()
+    .where("id", "=", goodsReceipt.supplierId)
+    .executeTakeFirst();
+  if (!supplier || !isActiveStatus(supplier.status)) {
+    return err(new InactiveExecutionReferenceError(goodsReceipt.supplierId));
+  }
+
+  const orderLines = decodeJson<PurchaseOrderLineInput[]>(purchaseOrder.lines, []);
+  const receiptLines = decodeJson<GoodsReceiptLineInput[]>(goodsReceipt.lines, []);
+  const receivedQuantities = new Map<string, number>();
+  const handoffPayload: Array<Record<string, unknown>> = [];
+
+  for (const receiptLine of receiptLines) {
+    const orderLine = orderLines.find(
+      (candidate) => candidate.id === receiptLine.purchaseOrderLineId,
+    );
+    if (!orderLine) {
+      return err(new NoOpenReceiptQuantityError(receiptLine.purchaseOrderLineId));
+    }
+    const item = await db
+      .selectFrom("Item")
+      .selectAll()
+      .where("id", "=", orderLine.itemId)
+      .executeTakeFirst();
+    if (!item || !isActiveStatus(item.status)) {
+      return err(new InactiveExecutionReferenceError(orderLine.itemId));
+    }
+    const openQuantity = orderLine.quantity - (orderLine.receivedQuantity ?? 0);
+    if (openQuantity <= 0) {
+      return err(new NoOpenReceiptQuantityError(receiptLine.purchaseOrderLineId));
+    }
+    if (receiptLine.quantity > openQuantity * 1.05) {
+      return err(new OverReceiptToleranceExceededError(receiptLine.purchaseOrderLineId));
+    }
+
+    receivedQuantities.set(
+      receiptLine.purchaseOrderLineId,
+      (receivedQuantities.get(receiptLine.purchaseOrderLineId) ?? 0) + receiptLine.quantity,
+    );
+
+    if (receiptLine.requiresInventoryHandoff) {
+      handoffPayload.push({
+        purchaseOrderId: purchaseOrder.id,
+        purchaseOrderLineId: receiptLine.purchaseOrderLineId,
+        goodsReceiptId: goodsReceipt.id,
+        quantity: receiptLine.quantity,
+        unitId: receiptLine.unitId ?? orderLine.unitId ?? null,
+        receiptDate: goodsReceipt.receiptDate,
+        destinationSite: receiptLine.destinationSite ?? orderLine.receivingSiteId ?? null,
+        destinationStorageLocation: receiptLine.destinationStorageLocation ?? null,
+      });
+    }
+  }
+
+  if (input.inventoryHandoffSucceeded === false && handoffPayload.length > 0) {
+    return err(new InventoryHandoffFailedError(input.id));
+  }
+
+  const nextOrderLines = updateOrderLineQuantities(
+    orderLines,
+    receivedQuantities,
+    "receivedQuantity",
+  );
+  const nextOrderStatus = derivePurchaseOrderStatus(purchaseOrder.status, nextOrderLines);
+
+  await db
+    .updateTable("PurchaseOrder")
+    .set({
+      lines: encodeJson(nextOrderLines),
+      status: nextOrderStatus,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", purchaseOrder.id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  const posted = await db
+    .updateTable("GoodsReceipt")
+    .set({
+      status: "POSTED",
+      inventoryHandoff: handoffPayload.length > 0 ? encodeJson(handoffPayload) : null,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ goodsReceipt: posted });
+}

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

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

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

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  PurchaseOrderNotFoundError,
+  PurchaseOrderNotSubmittedError,
+  RejectionReasonRequiredError,
+} from "../lib/errors.generated";
+import { basePurchaseOrder, submittedPurchaseOrder } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./rejectPurchaseOrder";
+
+describe("rejectPurchaseOrder", () => {
+  it("rejects a submitted purchase order back to draft", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(submittedPurchaseOrder);
+    spies.update.mockReturnValueOnce({
+      ...submittedPurchaseOrder,
+      status: "DRAFT",
+      rejectionReason: "Supplier cannot fulfill",
+    });
+
+    const result = await run(
+      db,
+      { id: submittedPurchaseOrder.id, reason: "Supplier cannot fulfill" },
+      commandCtx,
+    );
+
+    expect(expectOk(result).purchaseOrder.status).toBe("DRAFT");
+  });
+
+  it("records the rejection reason for audit", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(submittedPurchaseOrder);
+    spies.update.mockReturnValueOnce({
+      ...submittedPurchaseOrder,
+      status: "DRAFT",
+      rejectionReason: "Budget rejected",
+    });
+
+    const result = await run(
+      db,
+      { id: submittedPurchaseOrder.id, reason: "Budget rejected" },
+      commandCtx,
+    );
+
+    expect(expectOk(result).purchaseOrder.rejectionReason).toBe("Budget rejected");
+    expect(spies.set).toHaveBeenCalledWith(
+      expect.objectContaining({ rejectionReason: "Budget rejected" }),
+    );
+  });
+
+  it("returns error when purchase order does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "missing-order", reason: "No match" }, commandCtx);
+
+    expectErr(result, PurchaseOrderNotFoundError);
+  });
+
+  it("returns error when purchase order is not submitted", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePurchaseOrder);
+
+    const result = await run(db, { id: basePurchaseOrder.id, reason: "No match" }, commandCtx);
+
+    expectErr(result, PurchaseOrderNotSubmittedError);
+  });
+
+  it("returns error when rejection reason is missing", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(submittedPurchaseOrder);
+
+    const result = await run(db, { id: submittedPurchaseOrder.id, reason: "   " }, commandCtx);
+
+    expectErr(result, RejectionReasonRequiredError);
+  });
+});

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

@@ -0,0 +1,41 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access */
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  PurchaseOrderNotFoundError,
+  PurchaseOrderNotSubmittedError,
+  RejectionReasonRequiredError,
+} from "../lib/errors.generated";
+import { selectOne } from "../lib/domain";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface RejectPurchaseOrderInput {
+  id: string;
+  reason: string;
+}
+
+export async function run(db: Transaction, input: RejectPurchaseOrderInput, ctx: CommandContext) {
+  void ctx;
+  const purchaseOrder = await selectOne(db, "PurchaseOrder", "id", input.id, true);
+  if (!purchaseOrder) {
+    return err(new PurchaseOrderNotFoundError(input.id));
+  }
+  if (purchaseOrder.status !== "SUBMITTED") {
+    return err(new PurchaseOrderNotSubmittedError(input.id));
+  }
+  if (!input.reason.trim()) {
+    return err(new RejectionReasonRequiredError(input.id));
+  }
+
+  const rejected = await db
+    .updateTable("PurchaseOrder")
+    .set({
+      status: "DRAFT",
+      rejectionReason: input.reason,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ purchaseOrder: rejected });
+}

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

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