@tailor-platform/erp-kit 0.4.1 → 0.5.0

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

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { InvalidSalespriceruleStatusError } from "../lib/errors.generated";
+import { basePriceRule, draftPriceRule } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./deactivateSalesPriceRule";
+
+describe("deactivateSalesPriceRule", () => {
+  it("deactivates an active SalesPriceRule", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePriceRule);
+    spies.update.mockReturnValueOnce({
+      ...basePriceRule,
+      status: "INACTIVE",
+      updatedAt: new Date(),
+    });
+
+    const result = await run(db, { salesPriceRuleId: basePriceRule.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.salesPriceRule.status).toBe("INACTIVE");
+  });
+
+  it("throws when SalesPriceRule is not active", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(draftPriceRule);
+
+    const result = await run(db, { salesPriceRuleId: draftPriceRule.id }, commandCtx);
+
+    expectErr(result, InvalidSalespriceruleStatusError);
+  });
+});

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

@@ -0,0 +1,37 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  InvalidSalespriceruleStatusError,
+  SalespriceruleNotFoundError,
+} from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface DeactivateSalesPriceRuleInput {
+  salesPriceRuleId: string;
+}
+
+export async function run(
+  db: Transaction,
+  input: DeactivateSalesPriceRuleInput,
+  ctx: CommandContext,
+) {
+  void ctx;
+  const salesPriceRule = await db
+    .selectFrom("SalesPriceRule")
+    .selectAll()
+    .where("id", "=", input.salesPriceRuleId)
+    .forUpdate()
+    .executeTakeFirst();
+  if (!salesPriceRule) {
+    return err(new SalespriceruleNotFoundError(input.salesPriceRuleId));
+  }
+  if (salesPriceRule.status !== "ACTIVE") {
+    return err(new InvalidSalespriceruleStatusError(input.salesPriceRuleId));
+  }
+  const updated = await db
+    .updateTable("SalesPriceRule")
+    .set({ status: "INACTIVE", updatedAt: new Date() })
+    .where("id", "=", input.salesPriceRuleId)
+    .returningAll()
+    .executeTakeFirst();
+  return ok({ salesPriceRule: updated! });
+}

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

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

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

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { CreditLimitExceededError, InvalidCreditNoteStatusError } from "../lib/errors.generated";
+import {
+  baseCreditNote,
+  baseCreditNoteLine,
+  baseSalesInvoiceLine,
+  issuedCreditNote,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./issueSalesCreditNote";
+
+describe("issueSalesCreditNote", () => {
+  it("issues a credit note within the original invoice baseline", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const invoiceLine = { ...baseSalesInvoiceLine, salesInvoiceId: baseCreditNote.salesInvoiceId };
+    spies.select
+      .mockReturnValueOnce(baseCreditNote)
+      .mockReturnValueOnce([baseCreditNoteLine])
+      .mockReturnValueOnce(invoiceLine)
+      .mockReturnValueOnce([issuedCreditNote])
+      .mockReturnValueOnce([]);
+    spies.update.mockReturnValueOnce({
+      ...baseCreditNote,
+      status: "ISSUED",
+      creditNoteNumber: `CN-${baseCreditNote.id}`,
+      correctionSnapshot: JSON.stringify({ issuedAt: new Date().toISOString() }),
+    });
+
+    const result = await run(db, { salesCreditNoteId: baseCreditNote.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.salesCreditNote.status).toBe("ISSUED");
+  });
+
+  it("throws when credit quantity exceeds original billed quantity", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const invoiceLine = { ...baseSalesInvoiceLine, salesInvoiceId: baseCreditNote.salesInvoiceId };
+    spies.select
+      .mockReturnValueOnce(baseCreditNote)
+      .mockReturnValueOnce([{ ...baseCreditNoteLine, quantity: 4 }])
+      .mockReturnValueOnce(invoiceLine)
+      .mockReturnValueOnce([issuedCreditNote])
+      .mockReturnValueOnce([
+        { ...baseCreditNoteLine, salesCreditNoteId: issuedCreditNote.id, quantity: 2 },
+      ]);
+
+    const result = await run(db, { salesCreditNoteId: baseCreditNote.id }, commandCtx);
+
+    expectErr(result, CreditLimitExceededError);
+  });
+
+  it("throws when credit note is not in DRAFT status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(issuedCreditNote);
+
+    const result = await run(db, { salesCreditNoteId: issuedCreditNote.id }, commandCtx);
+
+    expectErr(result, InvalidCreditNoteStatusError);
+  });
+});

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

@@ -0,0 +1,71 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CreditLimitExceededError,
+  InvalidCreditNoteStatusError,
+  SalesCreditNoteNotFoundError,
+} from "../lib/errors.generated";
+import { encodeJson } from "../lib/domain";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface IssueSalesCreditNoteInput {
+  salesCreditNoteId: string;
+}
+
+export async function run(db: Transaction, input: IssueSalesCreditNoteInput, ctx: CommandContext) {
+  void ctx;
+  const salesCreditNote = await db
+    .selectFrom("SalesCreditNote")
+    .selectAll()
+    .where("id", "=", input.salesCreditNoteId)
+    .forUpdate()
+    .executeTakeFirst();
+  if (!salesCreditNote) {
+    return err(new SalesCreditNoteNotFoundError(input.salesCreditNoteId));
+  }
+  if (salesCreditNote.status !== "DRAFT") {
+    return err(new InvalidCreditNoteStatusError(input.salesCreditNoteId));
+  }
+  const lines = await db
+    .selectFrom("SalesCreditNoteLine")
+    .selectAll()
+    .where("salesCreditNoteId", "=", input.salesCreditNoteId)
+    .execute();
+  for (const line of lines) {
+    const invoiceLine = await db
+      .selectFrom("SalesInvoiceLine")
+      .selectAll()
+      .where("id", "=", line.salesInvoiceLineId)
+      .executeTakeFirst();
+    const issuedCreditNotes = await db
+      .selectFrom("SalesCreditNote")
+      .selectAll()
+      .where("salesInvoiceId", "=", salesCreditNote.salesInvoiceId)
+      .execute();
+    const issuedIds = new Set(
+      issuedCreditNotes.filter((note) => note.status === "ISSUED").map((note) => note.id),
+    );
+    const priorLines = await db.selectFrom("SalesCreditNoteLine").selectAll().execute();
+    const priorQuantity = priorLines
+      .filter(
+        (item) =>
+          issuedIds.has(item.salesCreditNoteId) &&
+          item.salesInvoiceLineId === line.salesInvoiceLineId,
+      )
+      .reduce((sum, item) => sum + (item.quantity ?? 0), 0);
+    if ((line.quantity ?? 0) + priorQuantity > (invoiceLine?.quantity ?? 0)) {
+      return err(new CreditLimitExceededError(line.salesInvoiceLineId));
+    }
+  }
+  const updated = await db
+    .updateTable("SalesCreditNote")
+    .set({
+      status: "ISSUED",
+      creditNoteNumber: salesCreditNote.creditNoteNumber ?? `CN-${salesCreditNote.id}`,
+      correctionSnapshot: encodeJson({ issuedAt: new Date().toISOString() }),
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.salesCreditNoteId)
+    .returningAll()
+    .executeTakeFirst();
+  return ok({ salesCreditNote: updated! });
+}

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

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

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

@@ -0,0 +1,88 @@
+import { describe, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  BillingPolicyViolationError,
+  DueScheduleNotComputableError,
+} from "../lib/errors.generated";
+import {
+  basePaymentTerm,
+  baseSalesInvoice,
+  baseSalesInvoiceLine,
+  baseSalesOrderLine,
+  baseShipmentLine,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./issueSalesInvoice";
+
+describe("issueSalesInvoice", () => {
+  it("issues an order-based invoice when quantities and prices are valid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const invoice = { ...baseSalesInvoice, billingPolicy: "ORDER" as const };
+    spies.select
+      .mockReturnValueOnce(invoice)
+      .mockReturnValueOnce([baseSalesInvoiceLine])
+      .mockReturnValueOnce(baseSalesOrderLine)
+      .mockReturnValueOnce(basePaymentTerm)
+      .mockReturnValueOnce(baseSalesOrderLine);
+    spies.update
+      .mockReturnValueOnce({ ...baseSalesOrderLine, invoicedQuantity: 5 })
+      .mockReturnValueOnce({
+        ...invoice,
+        status: "ISSUED" as const,
+      });
+
+    const result = await run(db, { salesInvoiceId: invoice.id }, commandCtx);
+
+    expectOk(result);
+  });
+
+  it("issues a shipment-gated invoice when posted shipment evidence exists", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const shipmentInvoiceLine = {
+      ...baseSalesInvoiceLine,
+      shipmentLineId: baseShipmentLine.id,
+      billingPolicy: "SHIPMENT" as const,
+      quantity: baseShipmentLine.quantity,
+    };
+    const invoice = { ...baseSalesInvoice, billingPolicy: "SHIPMENT" as const };
+    spies.select
+      .mockReturnValueOnce(invoice)
+      .mockReturnValueOnce([shipmentInvoiceLine])
+      .mockReturnValueOnce(baseSalesOrderLine)
+      .mockReturnValueOnce(baseShipmentLine)
+      .mockReturnValueOnce(basePaymentTerm)
+      .mockReturnValueOnce(baseSalesOrderLine);
+    spies.update
+      .mockReturnValueOnce({ ...baseSalesOrderLine, invoicedQuantity: 4 })
+      .mockReturnValueOnce({
+        ...invoice,
+        status: "ISSUED" as const,
+      });
+
+    const result = await run(db, { salesInvoiceId: invoice.id }, commandCtx);
+
+    expectOk(result);
+  });
+
+  it("throws when draft invoice exceeds allowed billed quantity", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseSalesInvoice)
+      .mockReturnValueOnce([{ ...baseSalesInvoiceLine, quantity: 11 }])
+      .mockReturnValueOnce(baseSalesOrderLine);
+
+    const result = await run(db, { salesInvoiceId: baseSalesInvoice.id }, commandCtx);
+
+    expectErr(result, BillingPolicyViolationError);
+  });
+
+  it("throws when due schedule cannot be computed", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce({ ...baseSalesInvoice, paymentTermId: null });
+
+    const result = await run(db, { salesInvoiceId: baseSalesInvoice.id }, commandCtx);
+
+    expectErr(result, DueScheduleNotComputableError);
+  });
+});

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

@@ -0,0 +1,115 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  BillingPolicyViolationError,
+  DueScheduleNotComputableError,
+  InvalidInvoiceStatusError,
+  SalesInvoiceNotFoundError,
+} from "../lib/errors.generated";
+import {
+  buildPaymentTermSnapshot,
+  calculateDueSchedule,
+  decodeJson,
+  encodeJson,
+  type PaymentTermScheduleLineInput,
+} from "../lib/domain";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface IssueSalesInvoiceInput {
+  salesInvoiceId: string;
+}
+
+export async function run(db: Transaction, input: IssueSalesInvoiceInput, ctx: CommandContext) {
+  void ctx;
+  const salesInvoice = await db
+    .selectFrom("SalesInvoice")
+    .selectAll()
+    .where("id", "=", input.salesInvoiceId)
+    .forUpdate()
+    .executeTakeFirst();
+  if (!salesInvoice) {
+    return err(new SalesInvoiceNotFoundError(input.salesInvoiceId));
+  }
+  if (salesInvoice.status !== "DRAFT") {
+    return err(new InvalidInvoiceStatusError(input.salesInvoiceId));
+  }
+  if (!salesInvoice.paymentTermId) {
+    return err(new DueScheduleNotComputableError(input.salesInvoiceId));
+  }
+  const lines = await db
+    .selectFrom("SalesInvoiceLine")
+    .selectAll()
+    .where("salesInvoiceId", "=", input.salesInvoiceId)
+    .execute();
+  for (const line of lines) {
+    const orderLine = await db
+      .selectFrom("SalesOrderLine")
+      .selectAll()
+      .where("id", "=", line.salesOrderLineId)
+      .forUpdate()
+      .executeTakeFirst();
+    if (!orderLine) {
+      return err(new BillingPolicyViolationError(line.salesOrderLineId));
+    }
+    if (line.shipmentLineId || line.billingPolicy === "SHIPMENT") {
+      if (!line.shipmentLineId) {
+        return err(new BillingPolicyViolationError(line.salesOrderLineId));
+      }
+      const shipmentLine = await db
+        .selectFrom("ShipmentLine")
+        .selectAll()
+        .where("id", "=", line.shipmentLineId)
+        .executeTakeFirst();
+      if (!shipmentLine || line.quantity > shipmentLine.quantity) {
+        return err(new BillingPolicyViolationError(line.salesOrderLineId));
+      }
+    } else if (line.quantity > orderLine.quantity - orderLine.invoicedQuantity) {
+      return err(new BillingPolicyViolationError(line.salesOrderLineId));
+    }
+    if (line.unitPrice !== orderLine.unitPrice) {
+      return err(new BillingPolicyViolationError(line.salesOrderLineId));
+    }
+  }
+  const paymentTerm = await db
+    .selectFrom("SalesPaymentTerm")
+    .selectAll()
+    .where("id", "=", salesInvoice.paymentTermId)
+    .executeTakeFirst();
+  if (!paymentTerm) {
+    return err(new DueScheduleNotComputableError(input.salesInvoiceId));
+  }
+  const paymentTermSnapshot = encodeJson(buildPaymentTermSnapshot(paymentTerm));
+  const dueSchedule =
+    calculateDueSchedule(
+      decodeJson<PaymentTermScheduleLineInput[]>(paymentTerm.scheduleLines, []),
+      salesInvoice.invoiceDate,
+      lines.reduce((sum, line) => sum + line.quantity * line.unitPrice, 0),
+    ) ?? [];
+  if (!dueSchedule.length) {
+    return err(new DueScheduleNotComputableError(input.salesInvoiceId));
+  }
+  for (const line of lines) {
+    const orderLine = await db
+      .selectFrom("SalesOrderLine")
+      .selectAll()
+      .where("id", "=", line.salesOrderLineId)
+      .executeTakeFirst();
+    await db
+      .updateTable("SalesOrderLine")
+      .set({ invoicedQuantity: orderLine!.invoicedQuantity + line.quantity, updatedAt: new Date() })
+      .where("id", "=", line.salesOrderLineId)
+      .executeTakeFirst();
+  }
+  const updated = await db
+    .updateTable("SalesInvoice")
+    .set({
+      status: "ISSUED",
+      invoiceNumber: salesInvoice.invoiceNumber ?? `INV-${salesInvoice.id}`,
+      paymentTermSnapshot,
+      dueSchedule: encodeJson(dueSchedule),
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.salesInvoiceId)
+    .returningAll()
+    .executeTakeFirst();
+  return ok({ salesInvoice: updated! });
+}

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

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

package/src/modules/sales/command/markChannelOrderException.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 {
+  ExceptionContextRequiredError,
+  InvalidChannelOrderStatusError,
+} from "../lib/errors.generated";
+import { baseChannelOrder } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./markChannelOrderException";
+
+describe("markChannelOrderException", () => {
+  it("marks a pending channel order as exception with retry context", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseChannelOrder);
+    spies.update.mockReturnValueOnce({
+      ...baseChannelOrder,
+      status: "EXCEPTION",
+      retryContext: JSON.stringify({ attempt: 2 }),
+      updatedAt: new Date(),
+    });
+
+    const result = await run(
+      db,
+      { channelOrderId: baseChannelOrder.id, retryContext: { attempt: 2 } },
+      commandCtx,
+    );
+
+    expectOk(result);
+    expect(spies.set).toHaveBeenCalledWith(
+      expect.objectContaining({
+        status: "EXCEPTION",
+        retryContext: JSON.stringify({ attempt: 2 }),
+      }),
+    );
+  });
+
+  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, errorSummary: "Mapping failed" },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidChannelOrderStatusError);
+  });
+
+  it("throws when exception context is empty", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseChannelOrder);
+
+    const result = await run(db, { channelOrderId: baseChannelOrder.id }, commandCtx);
+
+    expectErr(result, ExceptionContextRequiredError);
+  });
+});

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

@@ -0,0 +1,49 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ChannelOrderNotFoundError,
+  ExceptionContextRequiredError,
+  InvalidChannelOrderStatusError,
+} from "../lib/errors.generated";
+import { encodeJson } from "../lib/domain";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface MarkChannelOrderExceptionInput {
+  channelOrderId: string;
+  errorSummary?: string;
+  retryContext?: Record<string, unknown> | null;
+}
+
+export async function run(
+  db: Transaction,
+  input: MarkChannelOrderExceptionInput,
+  ctx: CommandContext,
+) {
+  void ctx;
+  const channelOrder = await db
+    .selectFrom("ChannelOrder")
+    .selectAll()
+    .where("id", "=", input.channelOrderId)
+    .forUpdate()
+    .executeTakeFirst();
+  if (!channelOrder) {
+    return err(new ChannelOrderNotFoundError(input.channelOrderId));
+  }
+  if (channelOrder.status !== "PENDING_CONVERSION") {
+    return err(new InvalidChannelOrderStatusError(input.channelOrderId));
+  }
+  if (!input.errorSummary && !input.retryContext) {
+    return err(new ExceptionContextRequiredError(input.channelOrderId));
+  }
+  const updated = await db
+    .updateTable("ChannelOrder")
+    .set({
+      status: "EXCEPTION",
+      errorSummary: input.errorSummary ?? channelOrder.errorSummary,
+      retryContext: input.retryContext ? encodeJson(input.retryContext) : channelOrder.retryContext,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.channelOrderId)
+    .returningAll()
+    .executeTakeFirst();
+  return ok({ channelOrder: updated! });
+}

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

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

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

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { InvalidListingStatusError } from "../lib/errors.generated";
+import { baseListing, draftListing, pausedListing } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./pauseListing";
+
+describe("pauseListing", () => {
+  it("pauses an active listing", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseListing);
+    spies.update.mockReturnValueOnce(pausedListing);
+
+    const result = await run(db, { listingId: baseListing.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.listing.status).toBe("PAUSED");
+  });
+
+  it("preserves identifiers when listing is paused", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseListing);
+    spies.update.mockReturnValueOnce(pausedListing);
+
+    const result = await run(db, { listingId: baseListing.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.listing.externalIdentifier).toBe(baseListing.externalIdentifier);
+  });
+
+  it("throws when listing is not active", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(draftListing);
+
+    const result = await run(db, { listingId: draftListing.id }, commandCtx);
+
+    expectErr(result, InvalidListingStatusError);
+  });
+});

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

@@ -0,0 +1,30 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { InvalidListingStatusError, ListingNotFoundError } from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface PauseListingInput {
+  listingId: string;
+}
+
+export async function run(db: Transaction, input: PauseListingInput, ctx: CommandContext) {
+  void ctx;
+  const listing = await db
+    .selectFrom("Listing")
+    .selectAll()
+    .where("id", "=", input.listingId)
+    .forUpdate()
+    .executeTakeFirst();
+  if (!listing) {
+    return err(new ListingNotFoundError(input.listingId));
+  }
+  if (listing.status !== "ACTIVE") {
+    return err(new InvalidListingStatusError(input.listingId));
+  }
+  const updated = await db
+    .updateTable("Listing")
+    .set({ status: "PAUSED", updatedAt: new Date() })
+    .where("id", "=", input.listingId)
+    .returningAll()
+    .executeTakeFirst();
+  return ok({ listing: updated! });
+}

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

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