@tailor-platform/erp-kit 0.4.1 → 0.5.1

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

@@ -0,0 +1,115 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  GoodsReceiptNotDraftError,
+  GoodsReceiptNotFoundError,
+  InvalidReceivedQuantityError,
+  NoOpenReceiptQuantityError,
+  PurchaseOrderLineNotFoundError,
+} from "../lib/errors.generated";
+import {
+  baseGoodsReceipt,
+  baseGoodsReceiptLines,
+  basePurchaseOrderLines,
+  orderedPurchaseOrder,
+  postedGoodsReceipt,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./updateGoodsReceipt";
+
+describe("updateGoodsReceipt", () => {
+  it("updates quantities on a draft goods receipt", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updated = {
+      ...baseGoodsReceipt,
+      lines: JSON.stringify([{ ...baseGoodsReceiptLines[0], quantity: 2 }]),
+    };
+    spies.select.mockReturnValueOnce(baseGoodsReceipt).mockReturnValueOnce(orderedPurchaseOrder);
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { id: baseGoodsReceipt.id, lines: [{ ...baseGoodsReceiptLines[0], quantity: 2 }] },
+      commandCtx,
+    );
+
+    expect(expectOk(result).goodsReceipt.lines).toContain('"quantity":2');
+  });
+
+  it("updates receipt date on a draft goods receipt", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updated = { ...baseGoodsReceipt, receiptDate: new Date("2024-02-01T00:00:00.000Z") };
+    spies.select.mockReturnValueOnce(baseGoodsReceipt).mockReturnValueOnce(orderedPurchaseOrder);
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { id: baseGoodsReceipt.id, receiptDate: updated.receiptDate },
+      commandCtx,
+    );
+
+    expect(expectOk(result).goodsReceipt.receiptDate).toEqual(updated.receiptDate);
+  });
+
+  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 updated line data is invalid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseGoodsReceipt).mockReturnValueOnce(orderedPurchaseOrder);
+    expectErr(
+      await run(
+        db,
+        {
+          id: baseGoodsReceipt.id,
+          lines: [{ ...baseGoodsReceiptLines[0], purchaseOrderLineId: "missing-line" }],
+        },
+        commandCtx,
+      ),
+      PurchaseOrderLineNotFoundError,
+    );
+  });
+
+  it("returns error when an updated receipt quantity is not positive", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseGoodsReceipt).mockReturnValueOnce(orderedPurchaseOrder);
+
+    expectErr(
+      await run(
+        db,
+        { id: baseGoodsReceipt.id, lines: [{ ...baseGoodsReceiptLines[0], quantity: 0 }] },
+        commandCtx,
+      ),
+      InvalidReceivedQuantityError,
+    );
+  });
+
+  it("returns error when an updated receipt line has no open quantity remaining", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseGoodsReceipt).mockReturnValueOnce({
+      ...orderedPurchaseOrder,
+      lines: JSON.stringify([
+        { ...basePurchaseOrderLines[0], receivedQuantity: basePurchaseOrderLines[0].quantity },
+      ]),
+    });
+
+    expectErr(
+      await run(
+        db,
+        { id: baseGoodsReceipt.id, lines: [{ ...baseGoodsReceiptLines[0], quantity: 1 }] },
+        commandCtx,
+      ),
+      NoOpenReceiptQuantityError,
+    );
+  });
+});

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

@@ -0,0 +1,73 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access */
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  GoodsReceiptNotDraftError,
+  GoodsReceiptNotFoundError,
+  InvalidReceivedQuantityError,
+  NoOpenReceiptQuantityError,
+  PurchaseOrderLineNotFoundError,
+} from "../lib/errors.generated";
+import {
+  decodeJson,
+  encodeJson,
+  normalizeReceiptLines,
+  selectOne,
+  type GoodsReceiptLineInput,
+  type PurchaseOrderLineInput,
+} from "../lib/domain";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface UpdateGoodsReceiptInput {
+  id: string;
+  receiptDate?: Date;
+  lines?: GoodsReceiptLineInput[];
+}
+
+export async function run(db: Transaction, input: UpdateGoodsReceiptInput, ctx: CommandContext) {
+  void ctx;
+  const goodsReceipt = await selectOne(db, "GoodsReceipt", "id", input.id, true);
+  if (!goodsReceipt) {
+    return err(new GoodsReceiptNotFoundError(input.id));
+  }
+  if (goodsReceipt.status !== "DRAFT") {
+    return err(new GoodsReceiptNotDraftError(input.id));
+  }
+
+  const purchaseOrder = await selectOne(
+    db,
+    "PurchaseOrder",
+    "id",
+    goodsReceipt.purchaseOrderId as string,
+  );
+  const orderLines = decodeJson<PurchaseOrderLineInput[]>(purchaseOrder?.lines, []);
+  const lines = normalizeReceiptLines(
+    input.lines ?? decodeJson<GoodsReceiptLineInput[]>(goodsReceipt.lines, []),
+  );
+
+  for (const line of lines) {
+    const orderLine = orderLines.find((candidate) => candidate.id === line.purchaseOrderLineId);
+    if (!orderLine) {
+      return err(new PurchaseOrderLineNotFoundError(line.purchaseOrderLineId));
+    }
+    if (line.quantity <= 0) {
+      return err(new InvalidReceivedQuantityError(line.purchaseOrderLineId));
+    }
+    const openQuantity = orderLine.quantity - (orderLine.receivedQuantity ?? 0);
+    if (openQuantity <= 0) {
+      return err(new NoOpenReceiptQuantityError(line.purchaseOrderLineId));
+    }
+  }
+
+  const updated = await db
+    .updateTable("GoodsReceipt")
+    .set({
+      receiptDate: input.receiptDate ?? goodsReceipt.receiptDate,
+      lines: encodeJson(lines),
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ goodsReceipt: updated });
+}

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

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

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

@@ -0,0 +1,137 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  DuplicateSupplierInvoiceNumberError,
+  InvalidBilledQuantityError,
+  PurchaseBillNotDraftError,
+  PurchaseBillNotFoundError,
+  PurchaseOrderCancelledError,
+  PurchaseOrderLineNotFoundError,
+} from "../lib/errors.generated";
+import {
+  basePurchaseBill,
+  basePurchaseBillLines,
+  basePurchaseOrder,
+  blockedPurchaseBill,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./updatePurchaseBill";
+
+describe("updatePurchaseBill", () => {
+  it("updates invoice metadata on a draft purchase bill", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updated = { ...basePurchaseBill, invoiceNumber: "INV-UPDATED" };
+    spies.select
+      .mockReturnValueOnce(basePurchaseBill)
+      .mockReturnValueOnce(undefined)
+      .mockReturnValueOnce([basePurchaseOrder]);
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { id: basePurchaseBill.id, invoiceNumber: "INV-UPDATED" },
+      commandCtx,
+    );
+
+    expect(expectOk(result).purchaseBill.invoiceNumber).toBe("INV-UPDATED");
+    expect(spies.set).toHaveBeenCalledWith(
+      expect.objectContaining({ invoiceNumber: "INV-UPDATED" }),
+    );
+  });
+
+  it("updates bill lines on a draft purchase bill", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updated = {
+      ...basePurchaseBill,
+      lines: JSON.stringify([{ ...basePurchaseBillLines[0], quantity: 5 }]),
+    };
+    spies.select.mockReturnValueOnce(basePurchaseBill).mockReturnValueOnce([basePurchaseOrder]);
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { id: basePurchaseBill.id, lines: [{ ...basePurchaseBillLines[0], quantity: 5 }] },
+      commandCtx,
+    );
+
+    expect(expectOk(result).purchaseBill.lines).toBe(updated.lines);
+    const setCall = spies.set.mock.calls[0]?.[0] as { lines?: string };
+    expect(setCall.lines).toContain('"quantity":5');
+  });
+
+  it("returns error when purchase bill does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "missing-bill" }, commandCtx);
+
+    expectErr(result, PurchaseBillNotFoundError);
+  });
+
+  it("returns error when purchase bill is not draft", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(blockedPurchaseBill);
+
+    const result = await run(db, { id: blockedPurchaseBill.id }, commandCtx);
+
+    expectErr(result, PurchaseBillNotDraftError);
+  });
+
+  it("returns error when updated invoice number is duplicated", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePurchaseBill).mockReturnValueOnce({ id: "existing-bill" });
+
+    const result = await run(
+      db,
+      { id: basePurchaseBill.id, invoiceNumber: "INV-DUPLICATE" },
+      commandCtx,
+    );
+
+    expectErr(result, DuplicateSupplierInvoiceNumberError);
+  });
+
+  it("returns error when updated line data is invalid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePurchaseBill).mockReturnValueOnce([basePurchaseOrder]);
+
+    const result = await run(
+      db,
+      {
+        id: basePurchaseBill.id,
+        lines: [{ ...basePurchaseBillLines[0], purchaseOrderLineId: "missing-line" }],
+      },
+      commandCtx,
+    );
+
+    expectErr(result, PurchaseOrderLineNotFoundError);
+  });
+
+  it("returns error when updated billed quantity is zero or negative", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePurchaseBill).mockReturnValueOnce([basePurchaseOrder]);
+
+    const result = await run(
+      db,
+      { id: basePurchaseBill.id, lines: [{ ...basePurchaseBillLines[0], quantity: 0 }] },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidBilledQuantityError);
+  });
+
+  it("returns error when updated bill references a cancelled purchase order", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(basePurchaseBill)
+      .mockReturnValueOnce([{ ...basePurchaseOrder, status: "CANCELLED" }]);
+
+    const result = await run(
+      db,
+      { id: basePurchaseBill.id, lines: basePurchaseBillLines },
+      commandCtx,
+    );
+
+    expectErr(result, PurchaseOrderCancelledError);
+  });
+});

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

@@ -0,0 +1,89 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  DuplicateSupplierInvoiceNumberError,
+  InvalidBilledQuantityError,
+  PurchaseBillNotDraftError,
+  PurchaseBillNotFoundError,
+  PurchaseOrderCancelledError,
+  PurchaseOrderLineNotFoundError,
+} from "../lib/errors.generated";
+import {
+  decodeJson,
+  encodeJson,
+  findOrderLine,
+  findPurchaseBillDuplicate,
+  normalizeBillLines,
+  type PurchaseBillLineInput,
+} from "../lib/domain";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface UpdatePurchaseBillInput {
+  id: string;
+  invoiceNumber?: string;
+  invoiceDate?: Date;
+  lines?: PurchaseBillLineInput[];
+}
+
+export async function run(db: Transaction, input: UpdatePurchaseBillInput, 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));
+  }
+
+  const invoiceNumber = input.invoiceNumber ?? purchaseBill.invoiceNumber;
+  if (
+    invoiceNumber !== purchaseBill.invoiceNumber &&
+    (await findPurchaseBillDuplicate(
+      db,
+      purchaseBill.companyId,
+      purchaseBill.supplierId,
+      invoiceNumber,
+    ))
+  ) {
+    return err(new DuplicateSupplierInvoiceNumberError(invoiceNumber));
+  }
+
+  const purchaseOrders = await db.selectFrom("PurchaseOrder").selectAll().execute();
+  const lines: ReturnType<typeof normalizeBillLines> = [];
+  for (const line of normalizeBillLines(
+    input.lines ?? decodeJson<PurchaseBillLineInput[]>(purchaseBill.lines, []),
+  )) {
+    const match = findOrderLine(purchaseOrders, line.purchaseOrderLineId);
+    if (!match) {
+      return err(new PurchaseOrderLineNotFoundError(line.purchaseOrderLineId));
+    }
+    if (line.quantity <= 0) {
+      return err(new InvalidBilledQuantityError(line.purchaseOrderLineId));
+    }
+    if (match.order.status === "CANCELLED") {
+      return err(new PurchaseOrderCancelledError(String(match.order.id)));
+    }
+    lines.push({
+      ...line,
+      billedUnitPrice: line.billedUnitPrice ?? match.line.unitPrice,
+    });
+  }
+
+  const updated = await db
+    .updateTable("PurchaseBill")
+    .set({
+      invoiceNumber,
+      invoiceDate: input.invoiceDate ?? purchaseBill.invoiceDate,
+      lines: encodeJson(lines),
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ purchaseBill: updated });
+}

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

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

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

@@ -0,0 +1,195 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ItemNotActiveError,
+  ItemNotFoundError,
+  InvalidQuantityError,
+  InvalidUnitPriceError,
+  PaymentTermInactiveError,
+  PurchaseOrderNotDraftError,
+  PurchaseOrderNotFoundError,
+  ReceivingSiteNotFoundError,
+  ReceivingSiteRequiredError,
+} from "../lib/errors.generated";
+import {
+  baseItem,
+  basePaymentTerm,
+  basePurchaseOrder,
+  basePurchaseOrderLines,
+  baseReceivingSite,
+  inactivePaymentTerm,
+  inactiveItem,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./updatePurchaseOrder";
+
+describe("updatePurchaseOrder", () => {
+  it("updates supplier-facing data on a draft purchase order", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updated = { ...basePurchaseOrder, externalSupplierOrderReference: "PO-EXT-2" };
+    spies.select
+      .mockReturnValueOnce(basePurchaseOrder)
+      .mockReturnValueOnce(baseItem)
+      .mockReturnValueOnce(baseReceivingSite)
+      .mockReturnValueOnce(basePaymentTerm);
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { id: basePurchaseOrder.id, externalSupplierOrderReference: "PO-EXT-2" },
+      commandCtx,
+    );
+
+    expect(expectOk(result).purchaseOrder.externalSupplierOrderReference).toBe("PO-EXT-2");
+  });
+
+  it("updates line pricing while preserving matched price-rule reference", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(basePurchaseOrder)
+      .mockReturnValueOnce(baseItem)
+      .mockReturnValueOnce(baseReceivingSite)
+      .mockReturnValueOnce(basePaymentTerm);
+    spies.update.mockReturnValueOnce(basePurchaseOrder);
+
+    await run(
+      db,
+      { id: basePurchaseOrder.id, lines: [{ ...basePurchaseOrderLines[0], unitPrice: 110 }] },
+      commandCtx,
+    );
+
+    const setCall = spies.set.mock.calls[0]?.[0] as { lines?: string };
+    expect(setCall.lines).toContain('"matchedPriceRuleId":"price-rule-1"');
+  });
+
+  it("returns error when purchase order does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+    expectErr(await run(db, { id: "missing-order" }, commandCtx), PurchaseOrderNotFoundError);
+  });
+
+  it("returns error when purchase order is not in draft", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce({ ...basePurchaseOrder, status: "SUBMITTED" });
+    expectErr(await run(db, { id: basePurchaseOrder.id }, commandCtx), PurchaseOrderNotDraftError);
+  });
+
+  it("returns error when updated line data is invalid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePurchaseOrder).mockReturnValueOnce(undefined);
+    expectErr(
+      await run(
+        db,
+        {
+          id: basePurchaseOrder.id,
+          lines: [{ ...basePurchaseOrderLines[0], itemId: "missing-item" }],
+        },
+        commandCtx,
+      ),
+      ItemNotFoundError,
+    );
+  });
+
+  it("returns error when an updated line item is inactive", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePurchaseOrder).mockReturnValueOnce(inactiveItem);
+
+    expectErr(
+      await run(
+        db,
+        {
+          id: basePurchaseOrder.id,
+          lines: [{ ...basePurchaseOrderLines[0], itemId: inactiveItem.id }],
+        },
+        commandCtx,
+      ),
+      ItemNotActiveError,
+    );
+  });
+
+  it("returns error when an updated line quantity is not positive", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePurchaseOrder).mockReturnValueOnce(baseItem);
+
+    expectErr(
+      await run(
+        db,
+        { id: basePurchaseOrder.id, lines: [{ ...basePurchaseOrderLines[0], quantity: 0 }] },
+        commandCtx,
+      ),
+      InvalidQuantityError,
+    );
+  });
+
+  it("returns error when an updated line unit price is negative", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePurchaseOrder).mockReturnValueOnce(baseItem);
+
+    expectErr(
+      await run(
+        db,
+        { id: basePurchaseOrder.id, lines: [{ ...basePurchaseOrderLines[0], unitPrice: -1 }] },
+        commandCtx,
+      ),
+      InvalidUnitPriceError,
+    );
+  });
+
+  it("returns error when an updated receiving site does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(basePurchaseOrder)
+      .mockReturnValueOnce(baseItem)
+      .mockReturnValueOnce(undefined);
+
+    expectErr(
+      await run(
+        db,
+        {
+          id: basePurchaseOrder.id,
+          lines: [{ ...basePurchaseOrderLines[0], receivingSiteId: "missing-site" }],
+        },
+        commandCtx,
+      ),
+      ReceivingSiteNotFoundError,
+    );
+  });
+
+  it("returns error when a physical-receipt line has no receiving site", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce({
+        ...basePurchaseOrder,
+        documentReceivingSiteId: null,
+        lines: JSON.stringify([{ ...basePurchaseOrderLines[0], receivingSiteId: null }]),
+      })
+      .mockReturnValueOnce(baseItem);
+
+    expectErr(
+      await run(
+        db,
+        {
+          id: basePurchaseOrder.id,
+          documentReceivingSiteId: null,
+          lines: [{ ...basePurchaseOrderLines[0], receivingSiteId: null }],
+        },
+        commandCtx,
+      ),
+      ReceivingSiteRequiredError,
+    );
+  });
+
+  it("returns error when selected payment term is inactive", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(basePurchaseOrder)
+      .mockReturnValueOnce(baseItem)
+      .mockReturnValueOnce(baseReceivingSite)
+      .mockReturnValueOnce(inactivePaymentTerm);
+    expectErr(
+      await run(db, { id: basePurchaseOrder.id, paymentTermId: basePaymentTerm.id }, commandCtx),
+      PaymentTermInactiveError,
+    );
+  });
+});