@tailor-platform/erp-kit 0.4.0 → 0.5.0

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

@@ -0,0 +1,45 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { CompanyNotFoundError, IdentifierRequiredError } from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface CreateSalesPriceListInput {
+  companyId: string;
+  customerId?: string | null;
+  channelId?: string | null;
+  name: string;
+  code?: string;
+  priority?: number;
+  notes?: string;
+}
+
+export async function run(db: Transaction, input: CreateSalesPriceListInput, 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 (!input.name) {
+    return err(new IdentifierRequiredError("sales-price-list.name"));
+  }
+  const salesPriceList = await db
+    .insertInto("SalesPriceList")
+    .values({
+      companyId: input.companyId,
+      customerId: input.customerId ?? null,
+      channelId: input.channelId ?? null,
+      name: input.name,
+      code: input.code ?? null,
+      priority: input.priority ?? 0,
+      status: "DRAFT",
+      notes: input.notes ?? null,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+  return ok({ salesPriceList: salesPriceList! });
+}

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

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

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

@@ -0,0 +1,137 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  IdentifierRequiredError,
+  InvalidEffectiveRangeError,
+  InvalidUnitPriceError,
+  PriceListNotFoundError,
+} from "../lib/errors.generated";
+import { basePriceList, basePriceRule } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./createSalesPriceRule";
+
+describe("createSalesPriceRule", () => {
+  it("creates a draft price rule with item, currency, and UoM context", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const created = { ...basePriceRule, id: "price-rule-9", status: "DRAFT" as const };
+    spies.select.mockReturnValueOnce(basePriceList);
+    spies.insert.mockReturnValueOnce(created);
+
+    const result = await run(
+      db,
+      {
+        salesPriceListId: basePriceList.id,
+        itemId: basePriceRule.itemId,
+        currencyId: basePriceRule.currencyId,
+        unitId: basePriceRule.unitId,
+        minimumQuantity: 1,
+        unitPrice: 120,
+        effectiveFrom: basePriceRule.effectiveFrom,
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.salesPriceRule).toEqual(created);
+  });
+
+  it("throws when required SalesPriceRule fields are missing", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePriceList);
+
+    const result = await run(
+      db,
+      {
+        salesPriceListId: basePriceList.id,
+        itemId: "",
+        currencyId: basePriceRule.currencyId,
+        unitId: basePriceRule.unitId,
+        unitPrice: 120,
+      },
+      commandCtx,
+    );
+
+    expectErr(result, IdentifierRequiredError);
+  });
+
+  it("creates the SalesPriceRule in DRAFT status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePriceList);
+    spies.insert.mockReturnValueOnce({ ...basePriceRule, status: "DRAFT" as const });
+
+    const result = await run(
+      db,
+      {
+        salesPriceListId: basePriceList.id,
+        itemId: basePriceRule.itemId,
+        currencyId: basePriceRule.currencyId,
+        unitId: basePriceRule.unitId,
+        unitPrice: 120,
+      },
+      commandCtx,
+    );
+
+    expectOk(result);
+    expect(spies.values).toHaveBeenCalledWith(expect.objectContaining({ status: "DRAFT" }));
+  });
+
+  it("throws when the parent price list does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(
+      db,
+      {
+        salesPriceListId: basePriceList.id,
+        itemId: basePriceRule.itemId,
+        currencyId: basePriceRule.currencyId,
+        unitId: basePriceRule.unitId,
+        unitPrice: 120,
+      },
+      commandCtx,
+    );
+
+    expectErr(result, PriceListNotFoundError);
+  });
+
+  it("throws on invalid unit price", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePriceList);
+
+    const result = await run(
+      db,
+      {
+        salesPriceListId: basePriceList.id,
+        itemId: basePriceRule.itemId,
+        currencyId: basePriceRule.currencyId,
+        unitId: basePriceRule.unitId,
+        unitPrice: 0,
+      },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidUnitPriceError);
+  });
+
+  it("throws on invalid effective date range", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePriceList);
+
+    const result = await run(
+      db,
+      {
+        salesPriceListId: basePriceList.id,
+        itemId: basePriceRule.itemId,
+        currencyId: basePriceRule.currencyId,
+        unitId: basePriceRule.unitId,
+        unitPrice: 120,
+        effectiveFrom: new Date("2024-02-01T00:00:00.000Z"),
+        effectiveTo: new Date("2024-01-01T00:00:00.000Z"),
+      },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidEffectiveRangeError);
+  });
+});

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

@@ -0,0 +1,66 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  IdentifierRequiredError,
+  InvalidEffectiveRangeError,
+  InvalidUnitPriceError,
+  PriceListNotFoundError,
+} from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface CreateSalesPriceRuleInput {
+  salesPriceListId: string;
+  itemId: string;
+  customerId?: string | null;
+  channelId?: string | null;
+  currencyId: string;
+  unitId: string;
+  minimumQuantity?: number;
+  unitPrice: number;
+  effectiveFrom?: Date | null;
+  effectiveTo?: Date | null;
+  priority?: number;
+  notes?: string;
+}
+
+export async function run(db: Transaction, input: CreateSalesPriceRuleInput, ctx: CommandContext) {
+  void ctx;
+  const salesPriceList = await db
+    .selectFrom("SalesPriceList")
+    .selectAll()
+    .where("id", "=", input.salesPriceListId)
+    .executeTakeFirst();
+  if (!salesPriceList) {
+    return err(new PriceListNotFoundError(input.salesPriceListId));
+  }
+  if (!input.itemId || !input.currencyId || !input.unitId) {
+    return err(new IdentifierRequiredError("sales-price-rule.scope"));
+  }
+  if (input.unitPrice <= 0 || (input.minimumQuantity ?? 0) < 0) {
+    return err(new InvalidUnitPriceError(input.itemId));
+  }
+  if (input.effectiveFrom && input.effectiveTo && input.effectiveTo < input.effectiveFrom) {
+    return err(new InvalidEffectiveRangeError(input.itemId));
+  }
+  const salesPriceRule = await db
+    .insertInto("SalesPriceRule")
+    .values({
+      salesPriceListId: input.salesPriceListId,
+      itemId: input.itemId,
+      customerId: input.customerId ?? null,
+      channelId: input.channelId ?? null,
+      currencyId: input.currencyId,
+      unitId: input.unitId,
+      minimumQuantity: input.minimumQuantity ?? 0,
+      unitPrice: input.unitPrice,
+      effectiveFrom: input.effectiveFrom ?? null,
+      effectiveTo: input.effectiveTo ?? null,
+      priority: input.priority ?? 0,
+      status: "DRAFT",
+      notes: input.notes ?? null,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+  return ok({ salesPriceRule: salesPriceRule! });
+}

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

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

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

@@ -0,0 +1,75 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { InvalidShipmentLineError, OrderNotShippableError } from "../lib/errors.generated";
+import {
+  baseShipment,
+  baseShipmentLine,
+  baseShipmentLineInput,
+  confirmedSalesOrder,
+  baseSalesOrderLine,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./createShipment";
+
+describe("createShipment", () => {
+  it("creates a draft shipment against a confirmed order", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const orderLine = { ...baseSalesOrderLine, salesOrderId: confirmedSalesOrder.id };
+    spies.select.mockReturnValueOnce(confirmedSalesOrder).mockReturnValueOnce(orderLine);
+    spies.insert.mockReturnValueOnce(baseShipment).mockReturnValueOnce(baseShipmentLine);
+
+    const result = await run(
+      db,
+      {
+        companyId: confirmedSalesOrder.companyId,
+        salesOrderId: confirmedSalesOrder.id,
+        lines: [baseShipmentLineInput],
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.shipment.status).toBe("DRAFT");
+  });
+
+  it("throws when order has no open shippable quantity", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const orderLine = {
+      ...baseSalesOrderLine,
+      salesOrderId: confirmedSalesOrder.id,
+      shippedQuantity: baseSalesOrderLine.quantity,
+    };
+    spies.select.mockReturnValueOnce(confirmedSalesOrder).mockReturnValueOnce(orderLine);
+
+    const result = await run(
+      db,
+      {
+        companyId: confirmedSalesOrder.companyId,
+        salesOrderId: confirmedSalesOrder.id,
+        lines: [baseShipmentLineInput],
+      },
+      commandCtx,
+    );
+
+    expectErr(result, OrderNotShippableError);
+  });
+
+  it("throws when shipment line quantity is not positive", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const orderLine = { ...baseSalesOrderLine, salesOrderId: confirmedSalesOrder.id };
+    spies.select.mockReturnValueOnce(confirmedSalesOrder).mockReturnValueOnce(orderLine);
+
+    const result = await run(
+      db,
+      {
+        companyId: confirmedSalesOrder.companyId,
+        salesOrderId: confirmedSalesOrder.id,
+        lines: [{ ...baseShipmentLineInput, quantity: 0 }],
+      },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidShipmentLineError);
+  });
+});

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

@@ -0,0 +1,86 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  InvalidShipmentLineError,
+  OrderNotShippableError,
+  SalesOrderNotFoundError,
+} from "../lib/errors.generated";
+import { encodeJson, type ShipmentLineInput } from "../lib/domain";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface CreateShipmentInput {
+  companyId: string;
+  salesOrderId: string;
+  shipFromSiteId?: string | null;
+  shipmentDate?: Date;
+  trackingNumber?: string | null;
+  shippingAddressSnapshot?: Record<string, unknown> | null;
+  lines: ShipmentLineInput[];
+}
+
+export async function run(db: Transaction, input: CreateShipmentInput, 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 (
+    !["CONFIRMED", "PARTIALLY_SHIPPED", "PARTIALLY_INVOICED", "SHIPPED"].includes(salesOrder.status)
+  ) {
+    return err(new OrderNotShippableError(input.salesOrderId));
+  }
+  if (!input.lines.length) {
+    return err(new InvalidShipmentLineError(input.salesOrderId));
+  }
+  for (const line of input.lines) {
+    const orderLine = await db
+      .selectFrom("SalesOrderLine")
+      .selectAll()
+      .where("id", "=", line.salesOrderLineId)
+      .executeTakeFirst();
+    if (!orderLine || line.quantity <= 0 || orderLine.salesOrderId !== input.salesOrderId) {
+      return err(new InvalidShipmentLineError(line.salesOrderLineId));
+    }
+    if (orderLine.quantity - orderLine.shippedQuantity < line.quantity) {
+      return err(new OrderNotShippableError(line.salesOrderLineId));
+    }
+  }
+  const shipment = await db
+    .insertInto("Shipment")
+    .values({
+      companyId: input.companyId,
+      salesOrderId: input.salesOrderId,
+      customerId: salesOrder.customerId,
+      shipFromSiteId: input.shipFromSiteId ?? null,
+      shipmentDate: input.shipmentDate ?? new Date(),
+      status: "DRAFT",
+      trackingNumber: input.trackingNumber ?? null,
+      shippingAddressSnapshot: input.shippingAddressSnapshot
+        ? encodeJson(input.shippingAddressSnapshot)
+        : salesOrder.shippingAddressSnapshot,
+      inventoryHandoff: null,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+  for (const line of input.lines) {
+    await db
+      .insertInto("ShipmentLine")
+      .values({
+        shipmentId: shipment!.id,
+        salesOrderLineId: line.salesOrderLineId,
+        quantity: line.quantity,
+        unitId: line.unitId ?? null,
+        trackingReference: line.trackingReference ?? null,
+        requiresInventoryHandoff: line.requiresInventoryHandoff ?? true,
+        createdAt: new Date(),
+        updatedAt: null,
+      })
+      .executeTakeFirst();
+  }
+  return ok({ shipment: shipment! });
+}

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

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

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

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { InvalidChannelStatusError } from "../lib/errors.generated";
+import { baseChannel, inactiveChannel } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./deactivateChannel";
+
+describe("deactivateChannel", () => {
+  it("deactivates an active Channel", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseChannel);
+    spies.update.mockReturnValueOnce(inactiveChannel);
+
+    const result = await run(db, { channelId: baseChannel.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.channel.status).toBe("INACTIVE");
+  });
+
+  it("throws when Channel is not active", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(inactiveChannel);
+
+    const result = await run(db, { channelId: inactiveChannel.id }, commandCtx);
+
+    expectErr(result, InvalidChannelStatusError);
+  });
+});

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

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

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

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

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

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { InvalidSalespaymenttermStatusError } from "../lib/errors.generated";
+import { basePaymentTerm, inactivePaymentTerm } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./deactivateSalesPaymentTerm";
+
+describe("deactivateSalesPaymentTerm", () => {
+  it("deactivates an active SalesPaymentTerm", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePaymentTerm);
+    spies.update.mockReturnValueOnce(inactivePaymentTerm);
+
+    const result = await run(db, { salesPaymentTermId: basePaymentTerm.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.salesPaymentTerm.status).toBe("INACTIVE");
+  });
+
+  it("throws when SalesPaymentTerm is not active", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(inactivePaymentTerm);
+
+    const result = await run(db, { salesPaymentTermId: inactivePaymentTerm.id }, commandCtx);
+
+    expectErr(result, InvalidSalespaymenttermStatusError);
+  });
+});

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

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

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

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

package/src/modules/sales/command/deactivateSalesPriceList.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 { InvalidSalespricelistStatusError } from "../lib/errors.generated";
+import { basePriceList, draftPriceList } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./deactivateSalesPriceList";
+
+describe("deactivateSalesPriceList", () => {
+  it("deactivates an active SalesPriceList", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePriceList);
+    spies.update.mockReturnValueOnce({
+      ...basePriceList,
+      status: "INACTIVE",
+      updatedAt: new Date(),
+    });
+
+    const result = await run(db, { salesPriceListId: basePriceList.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.salesPriceList.status).toBe("INACTIVE");
+  });
+
+  it("throws when SalesPriceList is not active", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(draftPriceList);
+
+    const result = await run(db, { salesPriceListId: draftPriceList.id }, commandCtx);
+
+    expectErr(result, InvalidSalespricelistStatusError);
+  });
+});

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

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

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

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