@tailor-platform/erp-kit 0.4.1 → 0.5.1

package/src/modules/sales/command/createSalesInvoice.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { CrossCompanyReferenceError, InvalidInvoiceLineError } from "../lib/errors.generated";
+import {
+  baseInvoiceLineInput,
+  baseSalesInvoice,
+  baseSalesInvoiceLine,
+  baseSalesOrderLine,
+  confirmedSalesOrder,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./createSalesInvoice";
+
+describe("createSalesInvoice", () => {
+  it("creates a draft invoice for a valid order", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const orderLine = { ...baseSalesOrderLine, salesOrderId: confirmedSalesOrder.id };
+    spies.select
+      .mockReturnValueOnce(confirmedSalesOrder)
+      .mockReturnValueOnce(orderLine)
+      .mockReturnValueOnce(orderLine);
+    spies.insert.mockReturnValueOnce(baseSalesInvoice).mockReturnValueOnce(baseSalesInvoiceLine);
+
+    const result = await run(
+      db,
+      {
+        companyId: confirmedSalesOrder.companyId,
+        salesOrderId: confirmedSalesOrder.id,
+        lines: [baseInvoiceLineInput],
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.salesInvoice.status).toBe("DRAFT");
+  });
+
+  it("throws when no invoice lines are provided", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(confirmedSalesOrder);
+
+    const result = await run(
+      db,
+      { companyId: confirmedSalesOrder.companyId, salesOrderId: confirmedSalesOrder.id, lines: [] },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidInvoiceLineError);
+  });
+
+  it("throws when invoice line references an unknown sales-order line", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(confirmedSalesOrder).mockReturnValueOnce(undefined);
+
+    const result = await run(
+      db,
+      {
+        companyId: confirmedSalesOrder.companyId,
+        salesOrderId: confirmedSalesOrder.id,
+        lines: [baseInvoiceLineInput],
+      },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidInvoiceLineError);
+  });
+
+  it("throws when order belongs to another company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce({ ...confirmedSalesOrder, companyId: "company-2" });
+
+    const result = await run(
+      db,
+      {
+        companyId: confirmedSalesOrder.companyId,
+        salesOrderId: confirmedSalesOrder.id,
+        lines: [baseInvoiceLineInput],
+      },
+      commandCtx,
+    );
+
+    expectErr(result, CrossCompanyReferenceError);
+  });
+});

package/src/modules/sales/command/createSalesInvoice.ts

@@ -0,0 +1,94 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CrossCompanyReferenceError,
+  InvalidInvoiceLineError,
+  SalesOrderNotFoundError,
+} from "../lib/errors.generated";
+import { encodeJson, type SalesInvoiceLineInput } from "../lib/domain";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface CreateSalesInvoiceInput {
+  companyId: string;
+  salesOrderId: string;
+  shipmentId?: string | null;
+  invoiceDate?: Date;
+  lines: SalesInvoiceLineInput[];
+  notes?: string;
+}
+
+export async function run(db: Transaction, input: CreateSalesInvoiceInput, ctx: CommandContext) {
+  void ctx;
+  const salesOrder = await db
+    .selectFrom("SalesOrder")
+    .selectAll()
+    .where("id", "=", input.salesOrderId)
+    .executeTakeFirst();
+  if (!salesOrder) {
+    return err(new SalesOrderNotFoundError(input.salesOrderId));
+  }
+  if (salesOrder.companyId !== input.companyId) {
+    return err(new CrossCompanyReferenceError(input.salesOrderId));
+  }
+  if (!input.lines.length) {
+    return err(new InvalidInvoiceLineError(input.salesOrderId));
+  }
+  for (const line of input.lines) {
+    const orderLine = await db
+      .selectFrom("SalesOrderLine")
+      .selectAll()
+      .where("id", "=", line.salesOrderLineId)
+      .executeTakeFirst();
+    if (orderLine?.salesOrderId !== input.salesOrderId || line.quantity <= 0) {
+      return err(new InvalidInvoiceLineError(line.salesOrderLineId));
+    }
+  }
+  const salesInvoice = await db
+    .insertInto("SalesInvoice")
+    .values({
+      companyId: input.companyId,
+      customerId: salesOrder.customerId,
+      salesOrderId: input.salesOrderId,
+      paymentTermId: salesOrder.paymentTermId,
+      shipmentId: input.shipmentId ?? null,
+      status: "DRAFT",
+      invoiceNumber: null,
+      invoiceDate: input.invoiceDate ?? new Date(),
+      billingPolicy: null,
+      paymentTermSnapshot: salesOrder.paymentTermSnapshot,
+      dueSchedule: null,
+      taxIdentitySnapshot: null,
+      deliveryMetadata: null,
+      arHandoffAccepted: false,
+      notes: input.notes ?? null,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+  for (const line of input.lines) {
+    const orderLine = await db
+      .selectFrom("SalesOrderLine")
+      .selectAll()
+      .where("id", "=", line.salesOrderLineId)
+      .executeTakeFirst();
+    await db
+      .insertInto("SalesInvoiceLine")
+      .values({
+        salesInvoiceId: salesInvoice!.id,
+        salesOrderLineId: line.salesOrderLineId,
+        shipmentLineId: line.shipmentLineId ?? null,
+        quantity: line.quantity,
+        unitPrice: line.unitPrice ?? orderLine!.unitPrice,
+        taxCode: line.taxCode ?? null,
+        taxableAmount: line.taxableAmount ?? null,
+        taxAmount: line.taxAmount ?? null,
+        billingPolicy:
+          line.billingPolicy ?? (line.shipmentLineId ? "SHIPMENT" : orderLine!.billingPolicy),
+        orderPriceSnapshot: encodeJson({ unitPrice: orderLine!.unitPrice }),
+        createdAt: new Date(),
+        updatedAt: null,
+      })
+      .executeTakeFirst();
+  }
+  return ok({ salesInvoice: salesInvoice! });
+}

package/src/modules/sales/command/createSalesOrder.generated.ts

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

package/src/modules/sales/command/createSalesOrder.test.ts

@@ -0,0 +1,134 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CrossCompanyReferenceError,
+  CustomerNotActiveError,
+  CustomerNotFoundError,
+  InvalidOrderLineError,
+  ItemNotActiveError,
+} from "../lib/errors.generated";
+import {
+  baseChannel,
+  baseCompany,
+  baseCustomer,
+  baseCustomerRole,
+  baseOrderLineInput,
+  baseSalesOrder,
+  baseSalesOrderLine,
+  inactiveCustomer,
+  inactiveItem,
+  otherCompanyItem,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./createSalesOrder";
+
+describe("createSalesOrder", () => {
+  it("creates a draft sales order with valid customer and lines", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCustomer)
+      .mockReturnValueOnce([baseCustomerRole])
+      .mockReturnValueOnce({
+        ...otherCompanyItem,
+        id: baseOrderLineInput.itemId,
+        companyId: baseCompany.id,
+        status: "ACTIVE",
+      })
+      .mockReturnValueOnce(baseChannel);
+    spies.insert.mockReturnValueOnce(baseSalesOrder).mockReturnValueOnce(baseSalesOrderLine);
+
+    const result = await run(
+      db,
+      {
+        companyId: baseCompany.id,
+        customerId: baseCustomer.id,
+        channelId: baseChannel.id,
+        lines: [baseOrderLineInput],
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.salesOrder.status).toBe("DRAFT");
+    expect(spies.values).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ companyId: baseCompany.id, customerId: baseCustomer.id }),
+    );
+  });
+
+  it("throws when customer does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(
+      db,
+      { companyId: baseCompany.id, customerId: baseCustomer.id, lines: [baseOrderLineInput] },
+      commandCtx,
+    );
+
+    expectErr(result, CustomerNotFoundError);
+  });
+
+  it("throws when customer is inactive or lacks CUSTOMER role", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(inactiveCustomer);
+
+    const result = await run(
+      db,
+      { companyId: baseCompany.id, customerId: inactiveCustomer.id, lines: [baseOrderLineInput] },
+      commandCtx,
+    );
+
+    expectErr(result, CustomerNotActiveError);
+  });
+
+  it("throws when an order line references an inactive item", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCustomer)
+      .mockReturnValueOnce([baseCustomerRole])
+      .mockReturnValueOnce(inactiveItem);
+
+    const result = await run(
+      db,
+      { companyId: baseCompany.id, customerId: baseCustomer.id, lines: [baseOrderLineInput] },
+      commandCtx,
+    );
+
+    expectErr(result, ItemNotActiveError);
+  });
+
+  it("throws when line quantity is zero or unit price is negative", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCustomer).mockReturnValueOnce([baseCustomerRole]);
+
+    const result = await run(
+      db,
+      {
+        companyId: baseCompany.id,
+        customerId: baseCustomer.id,
+        lines: [{ ...baseOrderLineInput, quantity: 0, unitPrice: -1 }],
+      },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidOrderLineError);
+  });
+
+  it("throws when references cross company boundaries", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCustomer)
+      .mockReturnValueOnce([baseCustomerRole])
+      .mockReturnValueOnce(otherCompanyItem);
+
+    const result = await run(
+      db,
+      { companyId: baseCompany.id, customerId: baseCustomer.id, lines: [baseOrderLineInput] },
+      commandCtx,
+    );
+
+    expectErr(result, CrossCompanyReferenceError);
+  });
+});

package/src/modules/sales/command/createSalesOrder.ts

@@ -0,0 +1,140 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CrossCompanyReferenceError,
+  CustomerNotActiveError,
+  CustomerNotFoundError,
+  CustomerRoleRequiredError,
+  InvalidOrderLineError,
+  ItemNotActiveError,
+  ItemNotFoundError,
+} from "../lib/errors.generated";
+import { encodeJson, type SalesOrderLineInput } from "../lib/domain";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface CreateSalesOrderInput {
+  companyId: string;
+  customerId: string;
+  channelId?: string | null;
+  paymentTermId?: string | null;
+  orderDate?: Date;
+  requestedShipDate?: Date | null;
+  shippingAddressSnapshot?: Record<string, unknown> | null;
+  billingAddressSnapshot?: Record<string, unknown> | null;
+  lines: SalesOrderLineInput[];
+}
+
+export async function run(db: Transaction, input: CreateSalesOrderInput, ctx: CommandContext) {
+  void ctx;
+  const customer = await db
+    .selectFrom("BusinessPartner")
+    .selectAll()
+    .where("id", "=", input.customerId)
+    .executeTakeFirst();
+  if (!customer) {
+    return err(new CustomerNotFoundError(input.customerId));
+  }
+  if (customer.status !== "ACTIVE") {
+    return err(new CustomerNotActiveError(input.customerId));
+  }
+  if (customer.companyId !== input.companyId) {
+    return err(new CrossCompanyReferenceError(input.customerId));
+  }
+
+  const customerRoles = await db
+    .selectFrom("PartnerRole")
+    .selectAll()
+    .where("partnerId", "=", input.customerId)
+    .execute();
+  if (!customerRoles.some((role) => role.role === "CUSTOMER")) {
+    return err(new CustomerRoleRequiredError(input.customerId));
+  }
+  if (!input.lines.length) {
+    return err(new InvalidOrderLineError(input.customerId));
+  }
+
+  for (const line of input.lines) {
+    if (!line.itemId || line.quantity <= 0 || line.unitPrice < 0 || !line.currencyId) {
+      return err(new InvalidOrderLineError(line.itemId || input.customerId));
+    }
+    const item = await db
+      .selectFrom("Item")
+      .selectAll()
+      .where("id", "=", line.itemId)
+      .executeTakeFirst();
+    if (!item) {
+      return err(new ItemNotFoundError(line.itemId));
+    }
+    if (item.status !== "ACTIVE") {
+      return err(new ItemNotActiveError(line.itemId));
+    }
+    if (item.companyId && item.companyId !== input.companyId) {
+      return err(new CrossCompanyReferenceError(line.itemId));
+    }
+  }
+
+  if (input.channelId) {
+    const channel = await db
+      .selectFrom("Channel")
+      .selectAll()
+      .where("id", "=", input.channelId)
+      .executeTakeFirst();
+    if (channel && channel.companyId !== input.companyId) {
+      return err(new CrossCompanyReferenceError(input.channelId));
+    }
+  }
+
+  const salesOrder = await db
+    .insertInto("SalesOrder")
+    .values({
+      companyId: input.companyId,
+      customerId: input.customerId,
+      channelId: input.channelId ?? null,
+      paymentTermId: input.paymentTermId ?? null,
+      status: "DRAFT",
+      orderDate: input.orderDate ?? new Date(),
+      requestedShipDate: input.requestedShipDate ?? null,
+      shippingAddressSnapshot: input.shippingAddressSnapshot
+        ? encodeJson(input.shippingAddressSnapshot)
+        : null,
+      billingAddressSnapshot: input.billingAddressSnapshot
+        ? encodeJson(input.billingAddressSnapshot)
+        : null,
+      paymentTermSnapshot: null,
+      rejectionReason: null,
+      holdReason: null,
+      closeReason: null,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  const insertedLines = [];
+  for (const line of input.lines) {
+    const inserted = await db
+      .insertInto("SalesOrderLine")
+      .values({
+        salesOrderId: salesOrder!.id,
+        itemId: line.itemId,
+        description: line.description ?? null,
+        quantity: line.quantity,
+        unitPrice: line.unitPrice,
+        currencyId: line.currencyId,
+        unitId: line.unitId ?? null,
+        matchedPriceRuleId: line.matchedPriceRuleId ?? null,
+        billingPolicy: line.billingPolicy ?? "ORDER",
+        requestedShipDate: line.requestedShipDate ?? null,
+        requiresPhysicalFulfillment: line.requiresPhysicalFulfillment ?? true,
+        priceSnapshot: line.priceSnapshot ? encodeJson(line.priceSnapshot) : null,
+        shippedQuantity: line.shippedQuantity ?? 0,
+        invoicedQuantity: line.invoicedQuantity ?? 0,
+        createdAt: new Date(),
+        updatedAt: null,
+      })
+      .returningAll()
+      .executeTakeFirst();
+    insertedLines.push(inserted);
+  }
+
+  return ok({ salesOrder: salesOrder!, lines: insertedLines });
+}

package/src/modules/sales/command/createSalesPaymentTerm.generated.ts

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

package/src/modules/sales/command/createSalesPaymentTerm.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { InvalidPaymentScheduleError } from "../lib/errors.generated";
+import {
+  baseCompany,
+  basePaymentTerm,
+  baseScheduleLines,
+  draftPaymentTerm,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./createSalesPaymentTerm";
+
+describe("createSalesPaymentTerm", () => {
+  it("creates a payment term with valid schedule lines", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany);
+    spies.insert.mockReturnValueOnce(draftPaymentTerm);
+
+    const result = await run(
+      db,
+      { companyId: baseCompany.id, name: basePaymentTerm.name, scheduleLines: baseScheduleLines },
+      commandCtx,
+    );
+
+    expectOk(result);
+    expect(spies.values).toHaveBeenCalledWith(
+      expect.objectContaining({ status: "DRAFT", companyId: baseCompany.id }),
+    );
+  });
+
+  it("throws when required SalesPaymentTerm fields are missing", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany);
+
+    const result = await run(
+      db,
+      { companyId: baseCompany.id, name: basePaymentTerm.name, scheduleLines: [] },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidPaymentScheduleError);
+  });
+
+  it("creates the SalesPaymentTerm in DRAFT status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany);
+    spies.insert.mockReturnValueOnce(draftPaymentTerm);
+
+    const result = await run(
+      db,
+      { companyId: baseCompany.id, name: basePaymentTerm.name, scheduleLines: baseScheduleLines },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.salesPaymentTerm.status).toBe("DRAFT");
+  });
+});

package/src/modules/sales/command/createSalesPaymentTerm.ts

@@ -0,0 +1,50 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { CompanyNotFoundError, InvalidPaymentScheduleError } from "../lib/errors.generated";
+import {
+  encodeJson,
+  validateScheduleLines,
+  type PaymentTermScheduleLineInput,
+} from "../lib/domain";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface CreateSalesPaymentTermInput {
+  companyId: string;
+  name: string;
+  code?: string;
+  scheduleLines: PaymentTermScheduleLineInput[];
+  notes?: string;
+}
+
+export async function run(
+  db: Transaction,
+  input: CreateSalesPaymentTermInput,
+  ctx: CommandContext,
+) {
+  void ctx;
+  const company = await db
+    .selectFrom("Company")
+    .selectAll()
+    .where("id", "=", input.companyId)
+    .executeTakeFirst();
+  if (!company) {
+    return err(new CompanyNotFoundError(input.companyId));
+  }
+  if (validateScheduleLines(input.scheduleLines)) {
+    return err(new InvalidPaymentScheduleError(input.companyId));
+  }
+  const salesPaymentTerm = await db
+    .insertInto("SalesPaymentTerm")
+    .values({
+      companyId: input.companyId,
+      name: input.name,
+      code: input.code ?? null,
+      status: "DRAFT",
+      scheduleLines: encodeJson(input.scheduleLines),
+      notes: input.notes ?? null,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+  return ok({ salesPaymentTerm: salesPaymentTerm! });
+}

package/src/modules/sales/command/createSalesPriceList.generated.ts

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

package/src/modules/sales/command/createSalesPriceList.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { CompanyNotFoundError, IdentifierRequiredError } from "../lib/errors.generated";
+import { baseCompany, basePriceList } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./createSalesPriceList";
+
+describe("createSalesPriceList", () => {
+  it("creates a draft price list for a valid company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const created = { ...basePriceList, id: "price-list-9", status: "DRAFT" as const };
+    spies.select.mockReturnValueOnce(baseCompany);
+    spies.insert.mockReturnValueOnce(created);
+
+    const result = await run(
+      db,
+      { companyId: baseCompany.id, name: "Promo Prices", code: "PROMO" },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.salesPriceList).toEqual(created);
+  });
+
+  it("throws when required SalesPriceList fields are missing", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany);
+
+    const result = await run(db, { companyId: baseCompany.id, name: "" }, commandCtx);
+
+    expectErr(result, IdentifierRequiredError);
+  });
+
+  it("creates the SalesPriceList in DRAFT status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany);
+    spies.insert.mockReturnValueOnce({ ...basePriceList, status: "DRAFT" as const });
+
+    const result = await run(
+      db,
+      { companyId: baseCompany.id, name: basePriceList.name, priority: basePriceList.priority },
+      commandCtx,
+    );
+
+    expectOk(result);
+    expect(spies.values).toHaveBeenCalledWith(
+      expect.objectContaining({
+        companyId: baseCompany.id,
+        status: "DRAFT",
+      }),
+    );
+  });
+
+  it("throws when the company does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(
+      db,
+      { companyId: baseCompany.id, name: basePriceList.name },
+      commandCtx,
+    );
+
+    expectErr(result, CompanyNotFoundError);
+  });
+});