@tailor-platform/erp-kit 0.4.1 → 0.5.1

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

@@ -0,0 +1,113 @@
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  CurrencyNotFoundError,
+  IncompatibleUnitsError,
+  ItemNotActiveError,
+  ItemNotFoundError,
+  UnitNotFoundError,
+} from "../lib/errors.generated";
+import { effectiveDateInRange, isActiveStatus } from "../lib/domain";
+import { err, ok, type ReadonlyDB, type QueryContext } from "@tailor-platform/erp-kit/module";
+
+export interface CalculatePurchasePriceInput {
+  companyId: string;
+  supplierId: string;
+  itemId: string;
+  unitId: string;
+  currencyId: string;
+  quantity: number;
+  pricingDate?: Date;
+}
+
+export async function run(
+  db: ReadonlyDB<DB>,
+  input: CalculatePurchasePriceInput,
+  ctx?: QueryContext,
+) {
+  void ctx;
+  const item = await db
+    .selectFrom("Item")
+    .selectAll()
+    .where("id", "=", input.itemId)
+    .executeTakeFirst();
+  if (!item) {
+    return err(new ItemNotFoundError(input.itemId));
+  }
+  if (!isActiveStatus(item.status)) {
+    return err(new ItemNotActiveError(input.itemId));
+  }
+
+  const requestedUnit = await db
+    .selectFrom("Unit")
+    .selectAll()
+    .where("id", "=", input.unitId)
+    .executeTakeFirst();
+  if (!requestedUnit) {
+    return err(new UnitNotFoundError(input.unitId));
+  }
+  const currency = await db
+    .selectFrom("Currency")
+    .selectAll()
+    .where("id", "=", input.currencyId)
+    .executeTakeFirst();
+  if (!currency) {
+    return err(new CurrencyNotFoundError(input.currencyId));
+  }
+
+  let baseUnit = requestedUnit;
+  if (item.unitId) {
+    const itemUnit = await db
+      .selectFrom("Unit")
+      .selectAll()
+      .where("id", "=", item.unitId)
+      .executeTakeFirst();
+    if (itemUnit) {
+      baseUnit = itemUnit;
+    }
+  }
+  if (baseUnit.categoryId !== requestedUnit.categoryId) {
+    return err(new IncompatibleUnitsError(`${item.unitId ?? "unknown"}:${input.unitId}`));
+  }
+
+  const rules = await db
+    .selectFrom("PurchasePriceRule")
+    .selectAll()
+    .where("itemId", "=", input.itemId)
+    .execute();
+  const lists = await db
+    .selectFrom("PurchasePriceList")
+    .selectAll()
+    .where("companyId", "=", input.companyId)
+    .where("supplierId", "=", input.supplierId)
+    .execute();
+
+  const activeListIds = new Set(
+    lists.filter((list) => list.status === "ACTIVE").map((list) => list.id),
+  );
+  const pricingDate = input.pricingDate ?? new Date();
+
+  const matchingRules = rules
+    .filter((rule) => rule.status === "ACTIVE")
+    .filter((rule) => activeListIds.has(rule.priceListId))
+    .filter((rule) => rule.currencyId === input.currencyId)
+    .filter((rule) => rule.unitId === input.unitId)
+    .filter((rule) => input.quantity >= rule.minimumQuantity)
+    .filter((rule) => effectiveDateInRange(pricingDate, rule.effectiveFrom, rule.effectiveTo))
+    .sort((left, right) => {
+      if (left.minimumQuantity !== right.minimumQuantity) {
+        return right.minimumQuantity - left.minimumQuantity;
+      }
+      return right.priority - left.priority;
+    });
+
+  const matchedRule = matchingRules[0] ?? null;
+  const priceSuggestion = matchedRule
+    ? {
+        ruleId: matchedRule.id,
+        priceListId: matchedRule.priceListId,
+        unitPrice: matchedRule.unitPrice,
+      }
+    : null;
+
+  return ok({ priceSuggestion, matchedRule });
+}

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

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

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

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseGoodsReceipt, baseGoodsReceiptLines } from "../testing/fixtures";
+import { expectOk } from "../testing/commandTestUtils";
+import { run } from "./getGoodsReceipt";
+
+describe("getGoodsReceipt", () => {
+  it("returns goods receipt when found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseGoodsReceipt);
+
+    const result = await run(db, { id: baseGoodsReceipt.id });
+    const { goodsReceipt } = expectOk<{ goodsReceipt: unknown }>(result as never);
+
+    expect(goodsReceipt).not.toBeNull();
+    expect(goodsReceipt).toMatchObject({ id: baseGoodsReceipt.id });
+  });
+
+  it("returns receipt lines and handoff metadata with the receipt", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseGoodsReceipt);
+
+    const result = await run(db, { id: baseGoodsReceipt.id });
+    const { goodsReceipt } = expectOk<{
+      goodsReceipt: { lines: unknown[]; inventoryHandoff: unknown };
+    }>(result as never);
+
+    expect(goodsReceipt.lines).toEqual(baseGoodsReceiptLines);
+    expect(goodsReceipt.inventoryHandoff).toBeNull();
+  });
+
+  it("returns null when goods receipt does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent-id" });
+    const { goodsReceipt } = expectOk<{ goodsReceipt: unknown }>(result as never);
+
+    expect(goodsReceipt).toBeNull();
+  });
+});

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

@@ -0,0 +1,27 @@
+/* eslint-disable @typescript-eslint/array-type */
+import type { DB } from "../generated/kysely-tailordb";
+import { decodeJson } from "../lib/domain";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetGoodsReceiptInput {
+  id: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetGoodsReceiptInput) {
+  const goodsReceipt = await db
+    .selectFrom("GoodsReceipt")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+  if (!goodsReceipt) {
+    return ok({ goodsReceipt: null });
+  }
+
+  return ok({
+    goodsReceipt: {
+      ...goodsReceipt,
+      lines: decodeJson(goodsReceipt.lines, [] as Array<Record<string, unknown>>),
+      inventoryHandoff: decodeJson(goodsReceipt.inventoryHandoff, null),
+    },
+  });
+}

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

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

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

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { basePurchaseBill, basePurchaseBillLines, matchedPurchaseBill } from "../testing/fixtures";
+import { expectOk } from "../testing/commandTestUtils";
+import { run } from "./getPurchaseBill";
+
+describe("getPurchaseBill", () => {
+  it("returns purchase bill when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(basePurchaseBill);
+
+    const result = await run(db, { id: basePurchaseBill.id });
+    const { purchaseBill } = expectOk<{ purchaseBill: unknown }>(result as never);
+
+    expect(purchaseBill).not.toBeNull();
+    expect(purchaseBill).toMatchObject({
+      id: basePurchaseBill.id,
+      lines: basePurchaseBillLines,
+    });
+  });
+
+  it("returns purchase bill when found by supplier invoice identity", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(basePurchaseBill);
+
+    const result = await run(db, {
+      companyId: basePurchaseBill.companyId,
+      supplierId: basePurchaseBill.supplierId,
+      invoiceNumber: basePurchaseBill.invoiceNumber,
+    });
+    const { purchaseBill } = expectOk<{ purchaseBill: unknown }>(result as never);
+
+    expect(purchaseBill).not.toBeNull();
+    expect(purchaseBill).toMatchObject({
+      id: basePurchaseBill.id,
+      companyId: basePurchaseBill.companyId,
+      supplierId: basePurchaseBill.supplierId,
+      invoiceNumber: basePurchaseBill.invoiceNumber,
+    });
+  });
+
+  it("returns matching outcome and due schedule with the bill", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(matchedPurchaseBill);
+
+    const result = await run(db, { id: matchedPurchaseBill.id });
+    const { purchaseBill } = expectOk<{
+      purchaseBill: {
+        matchingMode: string;
+        dueSchedule: { dueDate: Date; amount: number }[];
+      };
+    }>(result as never);
+
+    expect(purchaseBill.matchingMode).toBe("TWO_WAY");
+    expect(purchaseBill.dueSchedule).toHaveLength(1);
+    expect(purchaseBill.dueSchedule[0]).toMatchObject({ amount: 440 });
+  });
+
+  it("returns null when purchase bill is not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent-id" });
+    const { purchaseBill } = expectOk<{ purchaseBill: null }>(result as never);
+
+    expect(purchaseBill).toBeNull();
+  });
+});

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

@@ -0,0 +1,35 @@
+/* eslint-disable @typescript-eslint/array-type */
+import type { DB } from "../generated/kysely-tailordb";
+import { decodeJson } from "../lib/domain";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export type GetPurchaseBillInput =
+  | { id: string }
+  | { companyId: string; supplierId: string; invoiceNumber: string };
+
+export async function run(db: ReadonlyDB<DB>, input: GetPurchaseBillInput) {
+  let query = db.selectFrom("PurchaseBill").selectAll();
+  if ("id" in input) {
+    query = query.where("id", "=", input.id);
+  } else {
+    query = query
+      .where("companyId", "=", input.companyId)
+      .where("supplierId", "=", input.supplierId)
+      .where("invoiceNumber", "=", input.invoiceNumber);
+  }
+
+  const purchaseBill = await query.executeTakeFirst();
+  if (!purchaseBill) {
+    return ok({ purchaseBill: null });
+  }
+
+  return ok({
+    purchaseBill: {
+      ...purchaseBill,
+      lines: decodeJson(purchaseBill.lines, [] as Array<Record<string, unknown>>),
+      paymentTermSnapshot: decodeJson(purchaseBill.paymentTermSnapshot, null),
+      dueSchedule: decodeJson(purchaseBill.dueSchedule, null),
+      comparisonEvidence: decodeJson(purchaseBill.comparisonEvidence, null),
+    },
+  });
+}

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

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

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

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { basePurchaseOrder, basePurchaseOrderLines } from "../testing/fixtures";
+import { expectOk } from "../testing/commandTestUtils";
+import { run } from "./getPurchaseOrder";
+
+describe("getPurchaseOrder", () => {
+  it("returns purchase order when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(basePurchaseOrder);
+
+    const result = await run(db, { id: basePurchaseOrder.id });
+    const { purchaseOrder } = expectOk<{ purchaseOrder: unknown }>(result as never);
+
+    expect(purchaseOrder).not.toBeNull();
+    expect(purchaseOrder).toMatchObject({ id: basePurchaseOrder.id });
+  });
+
+  it("returns purchase order when found by company and external supplier order reference", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(basePurchaseOrder);
+
+    const result = await run(db, {
+      companyId: basePurchaseOrder.companyId,
+      externalSupplierOrderReference: basePurchaseOrder.externalSupplierOrderReference,
+    });
+    const { purchaseOrder } = expectOk<{ purchaseOrder: unknown }>(result as never);
+
+    expect(purchaseOrder).not.toBeNull();
+    expect(purchaseOrder).toMatchObject({ id: basePurchaseOrder.id });
+  });
+
+  it("returns lines and fulfillment totals with the order", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(basePurchaseOrder);
+
+    const result = await run(db, { id: basePurchaseOrder.id });
+    const { purchaseOrder } = expectOk<{
+      purchaseOrder: {
+        lines: unknown[];
+        paymentTermSnapshot: unknown;
+        fulfillmentTotals: { totalOrdered: number; totalReceived: number; totalBilled: number };
+      };
+    }>(result as never);
+
+    expect(purchaseOrder.lines).toEqual(basePurchaseOrderLines);
+    expect(purchaseOrder.paymentTermSnapshot).not.toBeNull();
+    expect(purchaseOrder.fulfillmentTotals).toEqual({
+      totalOrdered: 10,
+      totalReceived: 0,
+      totalBilled: 0,
+    });
+  });
+
+  it("returns null when purchase order is not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "non-existent-id" });
+    const { purchaseOrder } = expectOk<{ purchaseOrder: null }>(result as never);
+
+    expect(purchaseOrder).toBeNull();
+  });
+});

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

@@ -0,0 +1,33 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { decodeJson, summarizeOrderProgress, type PurchaseOrderLineInput } from "../lib/domain";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export type GetPurchaseOrderInput =
+  | { id: string }
+  | { companyId: string; externalSupplierOrderReference: string };
+
+export async function run(db: ReadonlyDB<DB>, input: GetPurchaseOrderInput) {
+  let query = db.selectFrom("PurchaseOrder").selectAll();
+  if ("id" in input) {
+    query = query.where("id", "=", input.id);
+  } else {
+    query = query
+      .where("companyId", "=", input.companyId)
+      .where("externalSupplierOrderReference", "=", input.externalSupplierOrderReference);
+  }
+
+  const purchaseOrder = await query.executeTakeFirst();
+  if (!purchaseOrder) {
+    return ok({ purchaseOrder: null });
+  }
+
+  const lines = decodeJson<PurchaseOrderLineInput[]>(purchaseOrder.lines, []);
+  return ok({
+    purchaseOrder: {
+      ...purchaseOrder,
+      lines,
+      paymentTermSnapshot: decodeJson(purchaseOrder.paymentTermSnapshot, null),
+      fulfillmentTotals: summarizeOrderProgress(lines),
+    },
+  });
+}

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

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

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

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { basePaymentTerm, baseScheduleLines } from "../testing/fixtures";
+import { expectOk } from "../testing/commandTestUtils";
+import { run } from "./getPurchasePaymentTerm";
+
+describe("getPurchasePaymentTerm", () => {
+  it("returns purchase payment term when found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(basePaymentTerm);
+
+    const result = await run(db, { id: basePaymentTerm.id });
+    const { purchasePaymentTerm } = expectOk<{ purchasePaymentTerm: unknown }>(result as never);
+
+    expect(purchasePaymentTerm).not.toBeNull();
+    expect(purchasePaymentTerm).toMatchObject({
+      id: basePaymentTerm.id,
+      name: basePaymentTerm.name,
+    });
+  });
+
+  it("returns schedule lines with the term", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(basePaymentTerm);
+
+    const result = await run(db, { id: basePaymentTerm.id });
+    const { purchasePaymentTerm } = expectOk<{
+      purchasePaymentTerm: { scheduleLines: unknown[] };
+    }>(result as never);
+
+    expect(purchasePaymentTerm.scheduleLines).toEqual(baseScheduleLines);
+  });
+
+  it("returns null when purchase payment term does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent-id" });
+    const { purchasePaymentTerm } = expectOk<{ purchasePaymentTerm: unknown }>(result as never);
+
+    expect(purchasePaymentTerm).toBeNull();
+  });
+});

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

@@ -0,0 +1,30 @@
+/* eslint-disable @typescript-eslint/array-type */
+import type { DB } from "../generated/kysely-tailordb";
+import { decodeJson } from "../lib/domain";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetPurchasePaymentTermInput {
+  id: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetPurchasePaymentTermInput) {
+  const purchasePaymentTerm = await db
+    .selectFrom("PurchasePaymentTerm")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  if (!purchasePaymentTerm) {
+    return ok({ purchasePaymentTerm: null });
+  }
+
+  return ok({
+    purchasePaymentTerm: {
+      ...purchasePaymentTerm,
+      scheduleLines: decodeJson(
+        purchasePaymentTerm.scheduleLines,
+        [] as Array<Record<string, unknown>>,
+      ),
+    },
+  });
+}

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

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

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

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { basePriceList, basePriceRule, higherBreakPriceRule } from "../testing/fixtures";
+import { expectOk } from "../testing/commandTestUtils";
+import { run } from "./getPurchasePriceList";
+
+describe("getPurchasePriceList", () => {
+  it("returns purchase price list when found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(basePriceList);
+    spies.select.mockReturnValueOnce([basePriceRule]);
+
+    const result = await run(db, { id: basePriceList.id });
+    const { purchasePriceList } = expectOk<{ purchasePriceList: unknown }>(result as never);
+
+    expect(purchasePriceList).not.toBeNull();
+    expect(purchasePriceList).toMatchObject({
+      id: basePriceList.id,
+      name: basePriceList.name,
+    });
+  });
+
+  it("returns embedded purchase price rules with the list", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(basePriceList);
+    spies.select.mockReturnValueOnce([basePriceRule, higherBreakPriceRule]);
+
+    const result = await run(db, { id: basePriceList.id });
+    const { purchasePriceList } = expectOk<{
+      purchasePriceList: { rules: unknown[] };
+    }>(result as never);
+
+    expect(purchasePriceList.rules).toHaveLength(2);
+    expect(purchasePriceList.rules).toContainEqual(basePriceRule);
+    expect(purchasePriceList.rules).toContainEqual(higherBreakPriceRule);
+  });
+
+  it("returns null when purchase price list does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent-id" });
+    const { purchasePriceList } = expectOk<{ purchasePriceList: null }>(result as never);
+
+    expect(purchasePriceList).toBeNull();
+  });
+});

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

@@ -0,0 +1,30 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetPurchasePriceListInput {
+  id: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetPurchasePriceListInput) {
+  const purchasePriceList = await db
+    .selectFrom("PurchasePriceList")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+  if (!purchasePriceList) {
+    return ok({ purchasePriceList: null });
+  }
+
+  const rules = await db
+    .selectFrom("PurchasePriceRule")
+    .selectAll()
+    .where("priceListId", "=", input.id)
+    .execute();
+
+  return ok({
+    purchasePriceList: {
+      ...purchasePriceList,
+      rules,
+    },
+  });
+}

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

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

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

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseCompany, baseSupplier, baseSupplierProfile } from "../testing/fixtures";
+import { expectOk } from "../testing/commandTestUtils";
+import { run } from "./getSupplierProfile";
+
+describe("getSupplierProfile", () => {
+  it("returns supplier profile when found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseSupplierProfile);
+
+    const result = await run(db, {
+      companyId: baseCompany.id,
+      supplierId: baseSupplier.id,
+    });
+    const { supplierProfile } = expectOk<{ supplierProfile: unknown }>(result as never);
+
+    expect(supplierProfile).not.toBeNull();
+    expect(supplierProfile).toMatchObject({ id: baseSupplierProfile.id });
+  });
+
+  it("returns default payment term reference when configured", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseSupplierProfile);
+
+    const result = await run(db, {
+      companyId: baseCompany.id,
+      supplierId: baseSupplier.id,
+    });
+    const { supplierProfile } = expectOk<{
+      supplierProfile: { defaultPurchasePaymentTermId: string };
+    }>(result as never);
+
+    expect(supplierProfile.defaultPurchasePaymentTermId).toBe("payment-term-1");
+  });
+
+  it("returns null when supplier profile does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, {
+      companyId: baseCompany.id,
+      supplierId: "nonexistent-supplier",
+    });
+    const { supplierProfile } = expectOk<{ supplierProfile: unknown }>(result as never);
+
+    expect(supplierProfile).toBeNull();
+  });
+});

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

@@ -0,0 +1,18 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetSupplierProfileInput {
+  companyId: string;
+  supplierId: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetSupplierProfileInput) {
+  const supplierProfile = await db
+    .selectFrom("SupplierProfile")
+    .selectAll()
+    .where("companyId", "=", input.companyId)
+    .where("supplierId", "=", input.supplierId)
+    .executeTakeFirst();
+
+  return ok({ supplierProfile: supplierProfile ?? null });
+}

package/src/modules/purchase/tailor.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig, definePlugins } from "@tailor-platform/sdk";
+import { kyselyTypePlugin } from "@tailor-platform/sdk/plugin/kysely-type";
+import { enumConstantsPlugin } from "@tailor-platform/sdk/plugin/enum-constants";
+
+export default defineConfig({
+  name: "purchase",
+  db: { "main-db": { files: [`./db/*.ts`, `./lib/_db_deps.ts`] } },
+});
+
+export const plugins = definePlugins(
+  kyselyTypePlugin({ distPath: `./generated/kysely-tailordb.ts` }),
+  enumConstantsPlugin({ distPath: "./generated/enums.ts" }),
+);