@tailor-platform/erp-kit 0.4.0 → 0.5.0

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

@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { CancellationBlockedError } from "../lib/errors.generated";
+import {
+  baseSalesInvoice,
+  baseSalesOrder,
+  confirmedSalesOrder,
+  postedShipment,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./cancelSalesOrder";
+
+describe("cancelSalesOrder", () => {
+  it("cancels a draft order", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const cancelled = {
+      ...baseSalesOrder,
+      status: "CANCELLED",
+      updatedAt: new Date("2024-01-02T00:00:00.000Z"),
+    };
+    spies.select
+      .mockReturnValueOnce(baseSalesOrder)
+      .mockReturnValueOnce([])
+      .mockReturnValueOnce([]);
+    spies.update.mockReturnValueOnce(cancelled);
+
+    const result = await run(db, { salesOrderId: baseSalesOrder.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.salesOrder.status).toBe("CANCELLED");
+  });
+
+  it("cancels a confirmed order with no shipment or invoice evidence", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(confirmedSalesOrder)
+      .mockReturnValueOnce([])
+      .mockReturnValueOnce([]);
+    spies.update.mockReturnValueOnce({ ...confirmedSalesOrder, status: "CANCELLED" });
+
+    const result = await run(db, { salesOrderId: confirmedSalesOrder.id }, commandCtx);
+
+    expectOk(result);
+  });
+
+  it("throws when posted shipment evidence exists", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(confirmedSalesOrder)
+      .mockReturnValueOnce([postedShipment])
+      .mockReturnValueOnce([]);
+
+    const result = await run(db, { salesOrderId: confirmedSalesOrder.id }, commandCtx);
+
+    expectErr(result, CancellationBlockedError);
+  });
+
+  it("throws when issued invoice evidence exists", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(confirmedSalesOrder)
+      .mockReturnValueOnce([])
+      .mockReturnValueOnce([{ ...baseSalesInvoice, status: "ISSUED" }]);
+
+    const result = await run(db, { salesOrderId: confirmedSalesOrder.id }, commandCtx);
+
+    expectErr(result, CancellationBlockedError);
+  });
+});

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

@@ -0,0 +1,48 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CancellationBlockedError,
+  InvalidOrderStatusError,
+  SalesOrderNotFoundError,
+} from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface CancelSalesOrderInput {
+  salesOrderId: string;
+}
+
+export async function run(db: Transaction, input: CancelSalesOrderInput, ctx: CommandContext) {
+  void ctx;
+  const salesOrder = await db
+    .selectFrom("SalesOrder")
+    .selectAll()
+    .where("id", "=", input.salesOrderId)
+    .forUpdate()
+    .executeTakeFirst();
+  if (!salesOrder) {
+    return err(new SalesOrderNotFoundError(input.salesOrderId));
+  }
+  if (!["DRAFT", "SUBMITTED", "CONFIRMED", "CREDIT_HOLD"].includes(salesOrder.status)) {
+    return err(new InvalidOrderStatusError(input.salesOrderId));
+  }
+  const [shipments, invoices] = await Promise.all([
+    db.selectFrom("Shipment").selectAll().where("salesOrderId", "=", input.salesOrderId).execute(),
+    db
+      .selectFrom("SalesInvoice")
+      .selectAll()
+      .where("salesOrderId", "=", input.salesOrderId)
+      .execute(),
+  ]);
+  if (
+    shipments.some((shipment) => shipment.status === "POSTED") ||
+    invoices.some((invoice) => ["ISSUED", "SENT"].includes(invoice.status))
+  ) {
+    return err(new CancellationBlockedError(input.salesOrderId));
+  }
+  const updated = await db
+    .updateTable("SalesOrder")
+    .set({ status: "CANCELLED", updatedAt: new Date() })
+    .where("id", "=", input.salesOrderId)
+    .returningAll()
+    .executeTakeFirst();
+  return ok({ salesOrder: updated! });
+}

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

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

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

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { InvalidSyncJobStatusError } from "../lib/errors.generated";
+import { baseSyncJob, failedSyncJob } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./cancelSyncJob";
+
+describe("cancelSyncJob", () => {
+  it("cancels a running sync job", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseSyncJob);
+    spies.update.mockReturnValueOnce({
+      ...baseSyncJob,
+      status: "CANCELLED",
+      finishedAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    const result = await run(db, { syncJobId: baseSyncJob.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.syncJob.status).toBe("CANCELLED");
+  });
+
+  it("preserves existing counts and error context when cancelled", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const running = {
+      ...baseSyncJob,
+      processedCount: 10,
+      successCount: 8,
+      errorCount: 2,
+      errorSummary: "Timeout",
+    };
+    spies.select.mockReturnValueOnce(running);
+    spies.update.mockReturnValueOnce({
+      ...running,
+      status: "CANCELLED",
+      finishedAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    const result = await run(db, { syncJobId: running.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.syncJob.processedCount).toBe(10);
+    expect(value.syncJob.errorSummary).toBe("Timeout");
+  });
+
+  it("throws when sync job is not running", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(failedSyncJob);
+
+    const result = await run(db, { syncJobId: failedSyncJob.id }, commandCtx);
+
+    expectErr(result, InvalidSyncJobStatusError);
+  });
+});

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

@@ -0,0 +1,30 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { InvalidSyncJobStatusError, SyncJobNotFoundError } from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface CancelSyncJobInput {
+  syncJobId: string;
+}
+
+export async function run(db: Transaction, input: CancelSyncJobInput, ctx: CommandContext) {
+  void ctx;
+  const syncJob = await db
+    .selectFrom("SyncJob")
+    .selectAll()
+    .where("id", "=", input.syncJobId)
+    .forUpdate()
+    .executeTakeFirst();
+  if (!syncJob) {
+    return err(new SyncJobNotFoundError(input.syncJobId));
+  }
+  if (syncJob.status !== "RUNNING") {
+    return err(new InvalidSyncJobStatusError(input.syncJobId));
+  }
+  const updated = await db
+    .updateTable("SyncJob")
+    .set({ status: "CANCELLED", finishedAt: new Date(), updatedAt: new Date() })
+    .where("id", "=", input.syncJobId)
+    .returningAll()
+    .executeTakeFirst();
+  return ok({ syncJob: updated! });
+}

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

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

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

@@ -0,0 +1,41 @@
+import { describe, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { InvalidOrderStatusError, OrderNotClosableError } from "../lib/errors.generated";
+import { confirmedSalesOrder } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./closeSalesOrder";
+
+describe("closeSalesOrder", () => {
+  it("closes an order with no remaining open balance", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(confirmedSalesOrder)
+      .mockReturnValueOnce([{ quantity: 10, shippedQuantity: 10, invoicedQuantity: 10 }]);
+    spies.update.mockReturnValueOnce({ ...confirmedSalesOrder, status: "CLOSED" as const });
+
+    const result = await run(db, { salesOrderId: confirmedSalesOrder.id }, commandCtx);
+
+    expectOk(result);
+  });
+
+  it("throws when remaining quantity is still open", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(confirmedSalesOrder)
+      .mockReturnValueOnce([{ quantity: 10, shippedQuantity: 10, invoicedQuantity: 5 }]);
+
+    const result = await run(db, { salesOrderId: confirmedSalesOrder.id }, commandCtx);
+
+    expectErr(result, OrderNotClosableError);
+  });
+
+  it("throws when order status does not allow closure", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce({ ...confirmedSalesOrder, status: "DRAFT" });
+
+    const result = await run(db, { salesOrderId: confirmedSalesOrder.id }, commandCtx);
+
+    expectErr(result, InvalidOrderStatusError);
+  });
+});

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

@@ -0,0 +1,51 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  InvalidOrderStatusError,
+  OrderNotClosableError,
+  SalesOrderNotFoundError,
+} from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface CloseSalesOrderInput {
+  salesOrderId: string;
+  closeReason?: string;
+}
+
+export async function run(db: Transaction, input: CloseSalesOrderInput, ctx: CommandContext) {
+  void ctx;
+  const salesOrder = await db
+    .selectFrom("SalesOrder")
+    .selectAll()
+    .where("id", "=", input.salesOrderId)
+    .forUpdate()
+    .executeTakeFirst();
+  if (!salesOrder) {
+    return err(new SalesOrderNotFoundError(input.salesOrderId));
+  }
+  if (
+    !["SHIPPED", "INVOICED", "PARTIALLY_SHIPPED", "PARTIALLY_INVOICED", "CONFIRMED"].includes(
+      salesOrder.status,
+    )
+  ) {
+    return err(new InvalidOrderStatusError(input.salesOrderId));
+  }
+  const lines = await db
+    .selectFrom("SalesOrderLine")
+    .selectAll()
+    .where("salesOrderId", "=", input.salesOrderId)
+    .execute();
+  if (
+    lines.some(
+      (line) => line.shippedQuantity < line.quantity || line.invoicedQuantity < line.quantity,
+    )
+  ) {
+    return err(new OrderNotClosableError(input.salesOrderId));
+  }
+  const updated = await db
+    .updateTable("SalesOrder")
+    .set({ status: "CLOSED", closeReason: input.closeReason ?? null, updatedAt: new Date() })
+    .where("id", "=", input.salesOrderId)
+    .returningAll()
+    .executeTakeFirst();
+  return ok({ salesOrder: updated! });
+}

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

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

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

@@ -0,0 +1,68 @@
+import { describe, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CustomerNotActiveError,
+  InvalidOrderStatusError,
+  MissingFinalPriceError,
+} from "../lib/errors.generated";
+import {
+  baseCustomer,
+  basePaymentTerm,
+  baseSalesOrderLine,
+  inactiveCustomer,
+  submittedSalesOrder,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./confirmSalesOrder";
+
+describe("confirmSalesOrder", () => {
+  it("confirms a submitted order and snapshots commercial context", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updated = {
+      ...submittedSalesOrder,
+      status: "CONFIRMED" as const,
+      updatedAt: new Date("2024-01-02T00:00:00.000Z"),
+    };
+    spies.select
+      .mockReturnValueOnce(submittedSalesOrder)
+      .mockReturnValueOnce(baseCustomer)
+      .mockReturnValueOnce([baseSalesOrderLine])
+      .mockReturnValueOnce(basePaymentTerm);
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(db, { salesOrderId: submittedSalesOrder.id }, commandCtx);
+
+    expectOk(result);
+  });
+
+  it("throws when order is not submitted", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce({ ...submittedSalesOrder, status: "DRAFT" });
+
+    const result = await run(db, { salesOrderId: submittedSalesOrder.id }, commandCtx);
+
+    expectErr(result, InvalidOrderStatusError);
+  });
+
+  it("throws when customer became inactive before confirmation", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(submittedSalesOrder).mockReturnValueOnce(inactiveCustomer);
+
+    const result = await run(db, { salesOrderId: submittedSalesOrder.id }, commandCtx);
+
+    expectErr(result, CustomerNotActiveError);
+  });
+
+  it("throws when a line lacks final pricing data", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(submittedSalesOrder)
+      .mockReturnValueOnce(baseCustomer)
+      .mockReturnValueOnce([{ ...baseSalesOrderLine, unitPrice: 0 }]);
+
+    const result = await run(db, { salesOrderId: submittedSalesOrder.id }, commandCtx);
+
+    expectErr(result, MissingFinalPriceError);
+  });
+});

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

@@ -0,0 +1,67 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CustomerNotActiveError,
+  InvalidOrderStatusError,
+  MissingFinalPriceError,
+  SalesOrderNotFoundError,
+} from "../lib/errors.generated";
+import { buildPaymentTermSnapshot, encodeJson } from "../lib/domain";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface ConfirmSalesOrderInput {
+  salesOrderId: string;
+}
+
+export async function run(db: Transaction, input: ConfirmSalesOrderInput, ctx: CommandContext) {
+  void ctx;
+  const salesOrder = await db
+    .selectFrom("SalesOrder")
+    .selectAll()
+    .where("id", "=", input.salesOrderId)
+    .forUpdate()
+    .executeTakeFirst();
+  if (!salesOrder) {
+    return err(new SalesOrderNotFoundError(input.salesOrderId));
+  }
+  if (salesOrder.status !== "SUBMITTED") {
+    return err(new InvalidOrderStatusError(input.salesOrderId));
+  }
+  const customer = await db
+    .selectFrom("BusinessPartner")
+    .selectAll()
+    .where("id", "=", salesOrder.customerId)
+    .executeTakeFirst();
+  if (customer?.status !== "ACTIVE") {
+    return err(new CustomerNotActiveError(salesOrder.customerId));
+  }
+  const lines = await db
+    .selectFrom("SalesOrderLine")
+    .selectAll()
+    .where("salesOrderId", "=", input.salesOrderId)
+    .execute();
+  if (lines.some((line) => line.unitPrice <= 0 || !line.currencyId)) {
+    return err(new MissingFinalPriceError(input.salesOrderId));
+  }
+  let paymentTermSnapshot = salesOrder.paymentTermSnapshot;
+  if (salesOrder.paymentTermId) {
+    const paymentTerm = await db
+      .selectFrom("SalesPaymentTerm")
+      .selectAll()
+      .where("id", "=", salesOrder.paymentTermId)
+      .executeTakeFirst();
+    if (paymentTerm) {
+      paymentTermSnapshot = encodeJson(buildPaymentTermSnapshot(paymentTerm));
+    }
+  }
+  const updated = await db
+    .updateTable("SalesOrder")
+    .set({
+      status: "CONFIRMED",
+      paymentTermSnapshot,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.salesOrderId)
+    .returningAll()
+    .executeTakeFirst();
+  return ok({ salesOrder: updated! });
+}

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

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

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

@@ -0,0 +1,118 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ChannelOrderMappingFailedError,
+  InvalidChannelOrderStatusError,
+} from "../lib/errors.generated";
+import {
+  baseChannelOrder,
+  baseCurrency,
+  baseListing,
+  baseSalesOrder,
+  baseSalesOrderLine,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./convertChannelOrder";
+
+describe("convertChannelOrder", () => {
+  it("converts a pending channel order into a sales order", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const createdSalesOrder = { ...baseSalesOrder, id: "sales-order-converted" };
+    const convertedChannelOrder = {
+      ...baseChannelOrder,
+      salesOrderId: createdSalesOrder.id,
+      status: "CONVERTED",
+      updatedAt: new Date("2024-01-02T00:00:00.000Z"),
+    };
+    spies.select
+      .mockReturnValueOnce(baseChannelOrder)
+      .mockReturnValueOnce(baseCurrency)
+      .mockReturnValueOnce(baseCurrency)
+      .mockReturnValueOnce(baseListing);
+    spies.insert
+      .mockReturnValueOnce(createdSalesOrder)
+      .mockReturnValueOnce({ ...baseSalesOrderLine, salesOrderId: createdSalesOrder.id });
+    spies.update.mockReturnValueOnce(convertedChannelOrder);
+
+    const result = await run(db, { channelOrderId: baseChannelOrder.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.salesOrder.id).toBe(createdSalesOrder.id);
+    expect(spies.values).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        companyId: baseChannelOrder.companyId,
+        customerId: baseChannelOrder.customerId,
+      }),
+    );
+  });
+
+  it("stores linked sales order reference after conversion", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const createdSalesOrder = { ...baseSalesOrder, id: "sales-order-converted" };
+    const convertedChannelOrder = {
+      ...baseChannelOrder,
+      salesOrderId: createdSalesOrder.id,
+      status: "CONVERTED",
+      updatedAt: new Date("2024-01-02T00:00:00.000Z"),
+    };
+    spies.select
+      .mockReturnValueOnce(baseChannelOrder)
+      .mockReturnValueOnce(baseCurrency)
+      .mockReturnValueOnce(baseCurrency)
+      .mockReturnValueOnce(baseListing);
+    spies.insert
+      .mockReturnValueOnce(createdSalesOrder)
+      .mockReturnValueOnce({ ...baseSalesOrderLine, salesOrderId: createdSalesOrder.id });
+    spies.update.mockReturnValueOnce(convertedChannelOrder);
+
+    const result = await run(db, { channelOrderId: baseChannelOrder.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.channelOrder.salesOrderId).toBe(createdSalesOrder.id);
+    expect(spies.set).toHaveBeenCalledWith(
+      expect.objectContaining({
+        salesOrderId: createdSalesOrder.id,
+        status: "CONVERTED",
+      }),
+    );
+  });
+
+  it("throws when channel order is not pending conversion", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce({ ...baseChannelOrder, status: "EXCEPTION" });
+
+    const result = await run(db, { channelOrderId: baseChannelOrder.id }, commandCtx);
+
+    expectErr(result, InvalidChannelOrderStatusError);
+  });
+
+  it("throws when required mappings are missing", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const channelOrder = {
+      ...baseChannelOrder,
+      normalizedPayload: JSON.stringify({
+        customerId: baseChannelOrder.customerId,
+        lines: [
+          {
+            itemId: baseListing.itemId,
+            listingId: "missing-listing",
+            quantity: 1,
+            unitPrice: 100,
+            currencyId: baseCurrency.id,
+          },
+        ],
+      }),
+    };
+    spies.select
+      .mockReturnValueOnce(channelOrder)
+      .mockReturnValueOnce(baseCurrency)
+      .mockReturnValueOnce(baseCurrency)
+      .mockReturnValueOnce(undefined);
+
+    const result = await run(db, { channelOrderId: baseChannelOrder.id }, commandCtx);
+
+    expectErr(result, ChannelOrderMappingFailedError);
+  });
+});