@tailor-platform/erp-kit 0.4.1 → 0.5.1

package/src/modules/purchase/module.ts

@@ -0,0 +1,218 @@
+import type { TailorAnyDBField } from "@tailor-platform/sdk";
+import type { defineModule as defineBusinessPartnerModule } from "../business-partner";
+import type { defineModule as defineItemManagementModule } from "../item-management";
+import type { defineModule as defineOrganizationModule } from "../organization";
+import type { defineModule as definePrimitivesModule } from "../primitives";
+import { activatePurchasePaymentTerm } from "./command/activatePurchasePaymentTerm.generated";
+import { activatePurchasePriceList } from "./command/activatePurchasePriceList.generated";
+import { activatePurchasePriceRule } from "./command/activatePurchasePriceRule.generated";
+import { approvePurchaseOrder } from "./command/approvePurchaseOrder.generated";
+import { cancelGoodsReceipt } from "./command/cancelGoodsReceipt.generated";
+import { cancelPurchaseBill } from "./command/cancelPurchaseBill.generated";
+import { cancelPurchaseOrder } from "./command/cancelPurchaseOrder.generated";
+import { closePurchaseOrder } from "./command/closePurchaseOrder.generated";
+import { createGoodsReceipt } from "./command/createGoodsReceipt.generated";
+import { createPurchaseBill } from "./command/createPurchaseBill.generated";
+import { createPurchaseOrder } from "./command/createPurchaseOrder.generated";
+import { createPurchasePaymentTerm } from "./command/createPurchasePaymentTerm.generated";
+import { createPurchasePriceList } from "./command/createPurchasePriceList.generated";
+import { createPurchasePriceRule } from "./command/createPurchasePriceRule.generated";
+import { deactivatePurchasePaymentTerm } from "./command/deactivatePurchasePaymentTerm.generated";
+import { deactivatePurchasePriceList } from "./command/deactivatePurchasePriceList.generated";
+import { deactivatePurchasePriceRule } from "./command/deactivatePurchasePriceRule.generated";
+import { matchPurchaseBill } from "./command/matchPurchaseBill.generated";
+import { postGoodsReceipt } from "./command/postGoodsReceipt.generated";
+import { rejectPurchaseOrder } from "./command/rejectPurchaseOrder.generated";
+import { releasePurchaseBill } from "./command/releasePurchaseBill.generated";
+import { setSupplierDefaultPurchasePaymentTerm } from "./command/setSupplierDefaultPurchasePaymentTerm.generated";
+import { submitPurchaseOrder } from "./command/submitPurchaseOrder.generated";
+import { updateGoodsReceipt } from "./command/updateGoodsReceipt.generated";
+import { updatePurchaseBill } from "./command/updatePurchaseBill.generated";
+import { updatePurchaseOrder } from "./command/updatePurchaseOrder.generated";
+import { updatePurchasePaymentTerm } from "./command/updatePurchasePaymentTerm.generated";
+import { updatePurchasePriceList } from "./command/updatePurchasePriceList.generated";
+import { updatePurchasePriceRule } from "./command/updatePurchasePriceRule.generated";
+import { createGoodsReceiptType, type CreateGoodsReceiptTypeParams } from "./db/goodsReceipt";
+import { createPurchaseBillType, type CreatePurchaseBillTypeParams } from "./db/purchaseBill";
+import { createPurchaseOrderType, type CreatePurchaseOrderTypeParams } from "./db/purchaseOrder";
+import {
+  createPurchasePaymentTermType,
+  type CreatePurchasePaymentTermTypeParams,
+} from "./db/purchasePaymentTerm";
+import {
+  createPurchasePriceListType,
+  type CreatePurchasePriceListTypeParams,
+} from "./db/purchasePriceList";
+import {
+  createPurchasePriceRuleType,
+  type CreatePurchasePriceRuleTypeParams,
+} from "./db/purchasePriceRule";
+import {
+  createSupplierProfileType,
+  type CreateSupplierProfileTypeParams,
+} from "./db/supplierProfile";
+import { calculatePurchaseBillDueSchedule } from "./query/calculatePurchaseBillDueSchedule.generated";
+import { calculatePurchasePrice } from "./query/calculatePurchasePrice.generated";
+import { getGoodsReceipt } from "./query/getGoodsReceipt.generated";
+import { getPurchaseBill } from "./query/getPurchaseBill.generated";
+import { getPurchaseOrder } from "./query/getPurchaseOrder.generated";
+import { getPurchasePaymentTerm } from "./query/getPurchasePaymentTerm.generated";
+import { getPurchasePriceList } from "./query/getPurchasePriceList.generated";
+import { getSupplierProfile } from "./query/getSupplierProfile.generated";
+
+type OrganizationModule = ReturnType<typeof defineOrganizationModule>;
+type OrganizationDB = OrganizationModule["db"];
+type BusinessPartnerModule = ReturnType<typeof defineBusinessPartnerModule>;
+type BusinessPartnerDB = BusinessPartnerModule["db"];
+type ItemManagementModule = ReturnType<typeof defineItemManagementModule>;
+type ItemManagementDB = ItemManagementModule["db"];
+type PrimitivesModule = ReturnType<typeof definePrimitivesModule>;
+type PrimitivesDB = PrimitivesModule["db"];
+
+export interface DefineModuleParams<
+  SPF extends Record<string, TailorAnyDBField>,
+  PTF extends Record<string, TailorAnyDBField>,
+  PLF extends Record<string, TailorAnyDBField>,
+  PRF extends Record<string, TailorAnyDBField>,
+  POF extends Record<string, TailorAnyDBField>,
+  GRF extends Record<string, TailorAnyDBField>,
+  PBF extends Record<string, TailorAnyDBField>,
+> {
+  supplierProfile?: CreateSupplierProfileTypeParams<SPF>;
+  purchasePaymentTerm?: CreatePurchasePaymentTermTypeParams<PTF>;
+  purchasePriceList?: CreatePurchasePriceListTypeParams<PLF>;
+  purchasePriceRule?: CreatePurchasePriceRuleTypeParams<PRF>;
+  purchaseOrder?: CreatePurchaseOrderTypeParams<POF>;
+  goodsReceipt?: CreateGoodsReceiptTypeParams<GRF>;
+  purchaseBill?: CreatePurchaseBillTypeParams<PBF>;
+  organization: {
+    db: {
+      company: OrganizationDB["company"];
+      site: OrganizationDB["site"];
+    };
+  };
+  businessPartner: {
+    db: {
+      businessPartner: BusinessPartnerDB["businessPartner"];
+      partnerRole: BusinessPartnerDB["partnerRole"];
+      partnerIdentification: BusinessPartnerDB["partnerIdentification"];
+    };
+  };
+  itemManagement: {
+    db: {
+      item: ItemManagementDB["item"];
+    };
+  };
+  primitives: {
+    db: {
+      currency: PrimitivesDB["currency"];
+      unit: PrimitivesDB["unit"];
+    };
+  };
+}
+
+export const defineModule = <
+  const SPF extends Record<string, TailorAnyDBField> = Record<never, never>,
+  const PTF extends Record<string, TailorAnyDBField> = Record<never, never>,
+  const PLF extends Record<string, TailorAnyDBField> = Record<never, never>,
+  const PRF extends Record<string, TailorAnyDBField> = Record<never, never>,
+  const POF extends Record<string, TailorAnyDBField> = Record<never, never>,
+  const GRF extends Record<string, TailorAnyDBField> = Record<never, never>,
+  const PBF extends Record<string, TailorAnyDBField> = Record<never, never>,
+>(
+  params: DefineModuleParams<SPF, PTF, PLF, PRF, POF, GRF, PBF>,
+) => {
+  const purchasePaymentTermDb = createPurchasePaymentTermType({
+    ...params.purchasePaymentTerm,
+    companyType: params.organization.db.company,
+  });
+  const supplierProfileDb = createSupplierProfileType({
+    ...params.supplierProfile,
+    companyType: params.organization.db.company,
+    supplierType: params.businessPartner.db.businessPartner,
+    paymentTermType: purchasePaymentTermDb,
+  });
+  const purchasePriceListDb = createPurchasePriceListType({
+    ...params.purchasePriceList,
+    companyType: params.organization.db.company,
+    supplierType: params.businessPartner.db.businessPartner,
+  });
+  const purchasePriceRuleDb = createPurchasePriceRuleType({
+    ...params.purchasePriceRule,
+    priceListType: purchasePriceListDb,
+    itemType: params.itemManagement.db.item,
+    currencyType: params.primitives.db.currency,
+    unitType: params.primitives.db.unit,
+  });
+  const purchaseOrderDb = createPurchaseOrderType({
+    ...params.purchaseOrder,
+    companyType: params.organization.db.company,
+    supplierType: params.businessPartner.db.businessPartner,
+    siteType: params.organization.db.site,
+    paymentTermType: purchasePaymentTermDb,
+  });
+  const goodsReceiptDb = createGoodsReceiptType({
+    ...params.goodsReceipt,
+    companyType: params.organization.db.company,
+    supplierType: params.businessPartner.db.businessPartner,
+    purchaseOrderType: purchaseOrderDb,
+  });
+  const purchaseBillDb = createPurchaseBillType({
+    ...params.purchaseBill,
+    companyType: params.organization.db.company,
+    supplierType: params.businessPartner.db.businessPartner,
+  });
+
+  return {
+    db: {
+      supplierProfile: supplierProfileDb,
+      purchasePaymentTerm: purchasePaymentTermDb,
+      purchasePriceList: purchasePriceListDb,
+      purchasePriceRule: purchasePriceRuleDb,
+      purchaseOrder: purchaseOrderDb,
+      goodsReceipt: goodsReceiptDb,
+      purchaseBill: purchaseBillDb,
+    },
+    commands: {
+      activatePurchasePaymentTerm: activatePurchasePaymentTerm(),
+      activatePurchasePriceList: activatePurchasePriceList(),
+      activatePurchasePriceRule: activatePurchasePriceRule(),
+      approvePurchaseOrder: approvePurchaseOrder(),
+      cancelGoodsReceipt: cancelGoodsReceipt(),
+      cancelPurchaseBill: cancelPurchaseBill(),
+      cancelPurchaseOrder: cancelPurchaseOrder(),
+      closePurchaseOrder: closePurchaseOrder(),
+      createGoodsReceipt: createGoodsReceipt(),
+      createPurchaseBill: createPurchaseBill(),
+      createPurchaseOrder: createPurchaseOrder(),
+      createPurchasePaymentTerm: createPurchasePaymentTerm(),
+      createPurchasePriceList: createPurchasePriceList(),
+      createPurchasePriceRule: createPurchasePriceRule(),
+      deactivatePurchasePaymentTerm: deactivatePurchasePaymentTerm(),
+      deactivatePurchasePriceList: deactivatePurchasePriceList(),
+      deactivatePurchasePriceRule: deactivatePurchasePriceRule(),
+      matchPurchaseBill: matchPurchaseBill(),
+      postGoodsReceipt: postGoodsReceipt(),
+      rejectPurchaseOrder: rejectPurchaseOrder(),
+      releasePurchaseBill: releasePurchaseBill(),
+      setSupplierDefaultPurchasePaymentTerm: setSupplierDefaultPurchasePaymentTerm(),
+      submitPurchaseOrder: submitPurchaseOrder(),
+      updateGoodsReceipt: updateGoodsReceipt(),
+      updatePurchaseBill: updatePurchaseBill(),
+      updatePurchaseOrder: updatePurchaseOrder(),
+      updatePurchasePaymentTerm: updatePurchasePaymentTerm(),
+      updatePurchasePriceList: updatePurchasePriceList(),
+      updatePurchasePriceRule: updatePurchasePriceRule(),
+    },
+    queries: {
+      calculatePurchaseBillDueSchedule,
+      calculatePurchasePrice,
+      getGoodsReceipt,
+      getPurchaseBill,
+      getPurchaseOrder,
+      getPurchasePaymentTerm,
+      getPurchasePriceList,
+      getSupplierProfile,
+    },
+  };
+};

package/src/modules/purchase/permissions.ts

@@ -0,0 +1 @@
+export { permissions, own, all } from "./lib/permissions.generated";

package/src/modules/purchase/query/calculatePurchaseBillDueSchedule.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./calculatePurchaseBillDueSchedule";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const calculatePurchaseBillDueSchedule = defineQuery(run);

package/src/modules/purchase/query/calculatePurchaseBillDueSchedule.test.ts

@@ -0,0 +1,183 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  InvalidPaymentTermConfigurationError,
+  PaymentTermNotFoundError,
+} from "../lib/errors.generated";
+import { encodeJson, type DueScheduleLine, type PaymentTermScheduleLineInput } from "../lib/domain";
+import {
+  basePaymentTerm,
+  discountScheduleLines,
+  installmentScheduleLines,
+} from "../testing/fixtures";
+import { expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./calculatePurchaseBillDueSchedule";
+
+const billDate = new Date("2024-02-15T00:00:00.000Z");
+
+describe("calculatePurchaseBillDueSchedule", () => {
+  it("calculates a single due date for net-30 terms", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(basePaymentTerm);
+
+    const result = await run(db, {
+      purchasePaymentTermId: basePaymentTerm.id,
+      billDate,
+      billAmount: 1000,
+    });
+    const { dueSchedule } = expectOk<{ dueSchedule: DueScheduleLine[] }>(result);
+
+    expect(dueSchedule).toHaveLength(1);
+    expect(dueSchedule[0]).toMatchObject({
+      amount: 1000,
+      dueDate: new Date("2024-03-16T00:00:00.000Z"),
+    });
+  });
+
+  it("calculates discount window and final due date for 2/10 net 30", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const discountTerm = {
+      ...basePaymentTerm,
+      id: "payment-term-discount",
+      scheduleLines: encodeJson(discountScheduleLines),
+    };
+    spies.select.mockReturnValueOnce(discountTerm);
+
+    const result = await run(db, {
+      purchasePaymentTermId: discountTerm.id,
+      billDate,
+      billAmount: 1000,
+    });
+    const { dueSchedule } = expectOk<{ dueSchedule: DueScheduleLine[] }>(result);
+
+    expect(dueSchedule).toHaveLength(1);
+    expect(dueSchedule[0]).toMatchObject({
+      amount: 1000,
+      // bill date + 30 days
+      dueDate: new Date("2024-03-16T00:00:00.000Z"),
+      // bill date + 10 days
+      discountDueDate: new Date("2024-02-25T00:00:00.000Z"),
+      // 2% of 1000
+      discountAmount: 20,
+    });
+  });
+
+  it("calculates multiple due-schedule lines for installment terms", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const installmentTerm = {
+      ...basePaymentTerm,
+      id: "payment-term-installment",
+      scheduleLines: encodeJson(installmentScheduleLines),
+    };
+    spies.select.mockReturnValueOnce(installmentTerm);
+
+    const result = await run(db, {
+      purchasePaymentTermId: installmentTerm.id,
+      billDate,
+      billAmount: 1000,
+    });
+    const { dueSchedule } = expectOk<{ dueSchedule: DueScheduleLine[] }>(result);
+
+    expect(dueSchedule).toHaveLength(2);
+    expect(dueSchedule[0]).toMatchObject({
+      amount: 500,
+      dueDate: new Date("2024-03-01T00:00:00.000Z"),
+    });
+    expect(dueSchedule[1]).toMatchObject({
+      amount: 500,
+      dueDate: new Date("2024-03-16T00:00:00.000Z"),
+    });
+  });
+
+  it("applies end-of-month logic correctly", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const eomLines: PaymentTermScheduleLineInput[] = [{ kind: "END_OF_MONTH" }];
+    const eomTerm = {
+      ...basePaymentTerm,
+      id: "payment-term-eom",
+      scheduleLines: encodeJson(eomLines),
+    };
+    spies.select.mockReturnValueOnce(eomTerm);
+
+    const result = await run(db, {
+      purchasePaymentTermId: eomTerm.id,
+      billDate,
+      billAmount: 500,
+    });
+    const { dueSchedule } = expectOk<{ dueSchedule: DueScheduleLine[] }>(result);
+
+    expect(dueSchedule).toHaveLength(1);
+    // End of February 2024 (leap year) → Feb 29
+    expect(dueSchedule[0]).toMatchObject({
+      amount: 500,
+      dueDate: new Date("2024-02-29T00:00:00.000Z"),
+    });
+  });
+
+  it("assigns rounding residual to the final schedule line", async () => {
+    const { db, spies } = createMockDb<DB>();
+    // 33.33 + 33.33 + 33.34 = 100, but per-line rounding on an odd amount creates residual
+    const threeWayLines: PaymentTermScheduleLineInput[] = [
+      { kind: "INSTALLMENT", days: 10, percentage: 33.33 },
+      { kind: "INSTALLMENT", days: 20, percentage: 33.33 },
+      { kind: "INSTALLMENT", days: 30, percentage: 33.34 },
+    ];
+    const threeWayTerm = {
+      ...basePaymentTerm,
+      id: "payment-term-3way",
+      scheduleLines: encodeJson(threeWayLines),
+    };
+    spies.select.mockReturnValueOnce(threeWayTerm);
+
+    // Use an amount that causes actual rounding residual: 999
+    // 33.33% of 999 = 333.0367 → 333.04, 33.33% of 999 = 333.04, 33.34% of 999 = 333.0666 → 333.07
+    // Sum = 333.04 + 333.04 + 333.07 = 999.15, residual = 999 - 999.15 = -0.15
+    // Final line absorbs residual: 333.07 + (-0.15) = 332.92
+    const result = await run(db, {
+      purchasePaymentTermId: threeWayTerm.id,
+      billDate,
+      billAmount: 999,
+    });
+    const { dueSchedule } = expectOk<{ dueSchedule: DueScheduleLine[] }>(result);
+
+    expect(dueSchedule).toHaveLength(3);
+    const total = dueSchedule.reduce((sum, line) => sum + line.amount, 0);
+    expect(total).toBeCloseTo(999, 2);
+  });
+
+  it("returns error when payment term does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, {
+      purchasePaymentTermId: "nonexistent-term",
+      billDate,
+      billAmount: 1000,
+    });
+
+    expectErr(result, PaymentTermNotFoundError);
+  });
+
+  it("returns error when payment term configuration is invalid", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const invalidLines: PaymentTermScheduleLineInput[] = [
+      { kind: "INSTALLMENT", days: 15, percentage: 40 },
+      { kind: "INSTALLMENT", days: 30, percentage: 40 },
+    ];
+    const invalidTerm = {
+      ...basePaymentTerm,
+      id: "payment-term-invalid",
+      scheduleLines: encodeJson(invalidLines),
+    };
+    spies.select.mockReturnValueOnce(invalidTerm);
+
+    const result = await run(db, {
+      purchasePaymentTermId: invalidTerm.id,
+      billDate,
+      billAmount: 1000,
+    });
+
+    expectErr(result, InvalidPaymentTermConfigurationError);
+  });
+});

package/src/modules/purchase/query/calculatePurchaseBillDueSchedule.ts

@@ -0,0 +1,41 @@
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  InvalidBillAmountError,
+  InvalidPaymentTermConfigurationError,
+  PaymentTermNotFoundError,
+} from "../lib/errors.generated";
+import { buildPaymentTermSnapshot, calculateDueSchedule } from "../lib/domain";
+import { err, ok, type ReadonlyDB, type QueryContext } from "@tailor-platform/erp-kit/module";
+
+export interface CalculatePurchaseBillDueScheduleInput {
+  purchasePaymentTermId: string;
+  billDate: Date;
+  billAmount: number;
+}
+
+export async function run(
+  db: ReadonlyDB<DB>,
+  input: CalculatePurchaseBillDueScheduleInput,
+  ctx?: QueryContext,
+) {
+  void ctx;
+  const paymentTerm = await db
+    .selectFrom("PurchasePaymentTerm")
+    .selectAll()
+    .where("id", "=", input.purchasePaymentTermId)
+    .executeTakeFirst();
+  if (!paymentTerm) {
+    return err(new PaymentTermNotFoundError(input.purchasePaymentTermId));
+  }
+
+  const snapshot = buildPaymentTermSnapshot(paymentTerm);
+  const result = calculateDueSchedule(snapshot.lines, input.billDate, input.billAmount);
+  if ("error" in result) {
+    if (result.error === "INVALID_BILL_AMOUNT") {
+      return err(new InvalidBillAmountError(String(input.billAmount)));
+    }
+    return err(new InvalidPaymentTermConfigurationError(input.purchasePaymentTermId));
+  }
+
+  return ok({ dueSchedule: result.schedule, paymentTerm });
+}

package/src/modules/purchase/query/calculatePurchasePrice.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./calculatePurchasePrice";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const calculatePurchasePrice = defineQuery(run);

package/src/modules/purchase/query/calculatePurchasePrice.test.ts

@@ -0,0 +1,143 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  IncompatibleUnitsError,
+  ItemNotActiveError,
+  ItemNotFoundError,
+} from "../lib/errors.generated";
+import {
+  baseCompany,
+  baseCurrency,
+  baseItem,
+  basePriceList,
+  basePriceRule,
+  baseSupplier,
+  baseUnit,
+  higherBreakPriceRule,
+  inactiveItem,
+  inactivePriceList,
+  inactivePriceRule,
+  incompatibleUnit,
+} from "../testing/fixtures";
+import { expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./calculatePurchasePrice";
+
+const defaultInput = {
+  companyId: baseCompany.id,
+  supplierId: baseSupplier.id,
+  itemId: baseItem.id,
+  unitId: baseUnit.id,
+  currencyId: baseCurrency.id,
+  quantity: 5,
+  pricingDate: new Date("2024-06-01T00:00:00.000Z"),
+};
+
+describe("calculatePurchasePrice", () => {
+  it("returns the best matching rule for a valid supplier item context", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseItem);
+    spies.select.mockReturnValueOnce(baseUnit);
+    spies.select.mockReturnValueOnce(baseCurrency);
+    spies.select.mockReturnValueOnce(baseUnit);
+    spies.select.mockReturnValueOnce([basePriceRule]);
+    spies.select.mockReturnValueOnce([basePriceList]);
+
+    const result = await run(db, defaultInput);
+    const { priceSuggestion, matchedRule } = expectOk<{
+      priceSuggestion: { ruleId: string; priceListId: string; unitPrice: number } | null;
+      matchedRule: unknown;
+    }>(result as never);
+
+    expect(priceSuggestion).not.toBeNull();
+    expect(priceSuggestion!.ruleId).toBe(basePriceRule.id);
+    expect(priceSuggestion!.priceListId).toBe(basePriceList.id);
+    expect(priceSuggestion!.unitPrice).toBe(100);
+    expect(matchedRule).not.toBeNull();
+  });
+
+  it("picks the higher quantity-break rule when ordered quantity qualifies", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseItem);
+    spies.select.mockReturnValueOnce(baseUnit);
+    spies.select.mockReturnValueOnce(baseCurrency);
+    spies.select.mockReturnValueOnce(baseUnit);
+    spies.select.mockReturnValueOnce([basePriceRule, higherBreakPriceRule]);
+    spies.select.mockReturnValueOnce([basePriceList]);
+
+    const result = await run(db, { ...defaultInput, quantity: 15 });
+    const { priceSuggestion } = expectOk<{
+      priceSuggestion: { ruleId: string; unitPrice: number } | null;
+    }>(result as never);
+
+    expect(priceSuggestion).not.toBeNull();
+    expect(priceSuggestion!.ruleId).toBe(higherBreakPriceRule.id);
+    expect(priceSuggestion!.unitPrice).toBe(90);
+  });
+
+  it("ignores inactive price lists and inactive rules", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseItem);
+    spies.select.mockReturnValueOnce(baseUnit);
+    spies.select.mockReturnValueOnce(baseCurrency);
+    spies.select.mockReturnValueOnce(baseUnit);
+    spies.select.mockReturnValueOnce([inactivePriceRule]);
+    spies.select.mockReturnValueOnce([inactivePriceList]);
+
+    const result = await run(db, defaultInput);
+    const { priceSuggestion } = expectOk<{
+      priceSuggestion: null;
+    }>(result as never);
+
+    expect(priceSuggestion).toBeNull();
+  });
+
+  it("returns null when no active rule matches", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseItem);
+    spies.select.mockReturnValueOnce(baseUnit);
+    spies.select.mockReturnValueOnce(baseCurrency);
+    spies.select.mockReturnValueOnce(baseUnit);
+    spies.select.mockReturnValueOnce([]);
+    spies.select.mockReturnValueOnce([basePriceList]);
+
+    const result = await run(db, defaultInput);
+    const { priceSuggestion, matchedRule } = expectOk<{
+      priceSuggestion: null;
+      matchedRule: null;
+    }>(result as never);
+
+    expect(priceSuggestion).toBeNull();
+    expect(matchedRule).toBeNull();
+  });
+
+  it("returns error when item does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, defaultInput);
+
+    expectErr(result, ItemNotFoundError);
+  });
+
+  it("returns error when item is inactive", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(inactiveItem);
+
+    const result = await run(db, defaultInput);
+
+    expectErr(result, ItemNotActiveError);
+  });
+
+  it("returns error when units are incompatible for quantity-break comparison", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseItem);
+    spies.select.mockReturnValueOnce(incompatibleUnit);
+    spies.select.mockReturnValueOnce(baseCurrency);
+    spies.select.mockReturnValueOnce(baseUnit);
+
+    const result = await run(db, { ...defaultInput, unitId: incompatibleUnit.id });
+
+    expectErr(result, IncompatibleUnitsError);
+  });
+});