@tailor-platform/erp-kit 0.1.1 → 0.2.0

package/src/modules/item-management/command/createItem.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import { type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import {
+  DuplicateBarcodeError,
+  DuplicateSkuError,
+  UnitNotFoundError,
+} from "../lib/errors.generated";
+import { baseActiveItem, baseDraftItem } from "../testing/fixtures";
+import { getUnit } from "../../primitives";
+import { run } from "./createItem";
+
+describe("createItem", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["item-management:createItem"],
+  };
+
+  it("returns error when SKU already exists", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseDraftItem); // SKU lookup finds existing
+
+    const result = await run(db, { sku: "SKU-001", name: "Widget", unitId: "unit-kg" }, ctx, {
+      getUnit,
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateSkuError);
+    }
+  });
+
+  it("returns error when barcode already exists", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(undefined) // SKU unique
+      .mockReturnValueOnce(baseActiveItem); // Barcode lookup finds existing
+
+    const result = await run(
+      db,
+      { sku: "SKU-NEW", name: "Widget", barcode: "BAR-002", unitId: "unit-kg" },
+      ctx,
+      { getUnit },
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateBarcodeError);
+    }
+  });
+
+  it("returns error when UoM does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(undefined) // SKU unique
+      .mockReturnValueOnce(undefined); // UoM lookup fails
+
+    const result = await run(
+      db,
+      { sku: "SKU-NEW", name: "Widget", unitId: "nonexistent-unit" },
+      ctx,
+      { getUnit },
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(UnitNotFoundError);
+    }
+  });
+
+  it("creates item in DRAFT status by default", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const activeUnit = { id: "unit-kg", isActive: true };
+    const createdItem = { ...baseDraftItem, id: "new-item-id", sku: "SKU-NEW" };
+
+    spies.select
+      .mockReturnValueOnce(undefined) // SKU unique
+      .mockReturnValueOnce(activeUnit); // UoM valid
+    spies.insert.mockReturnValue(createdItem);
+
+    const result = await run(db, { sku: "SKU-NEW", name: "Widget", unitId: "unit-kg" }, ctx, {
+      getUnit,
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.item.sku).toBe("SKU-NEW");
+      expect(result.value.item.status).toBe("DRAFT");
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("creates item in ACTIVE status", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const activeUnit = { id: "unit-kg", isActive: true };
+    const createdItem = { ...baseActiveItem, id: "new-item-id", sku: "SKU-NEW" };
+
+    spies.select
+      .mockReturnValueOnce(undefined) // SKU unique
+      .mockReturnValueOnce(activeUnit); // UoM valid
+    spies.insert.mockReturnValue(createdItem);
+
+    const result = await run(
+      db,
+      { sku: "SKU-NEW", name: "New Widget", unitId: "unit-kg", status: "ACTIVE" },
+      ctx,
+      { getUnit },
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.item.status).toBe("ACTIVE");
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("skips barcode uniqueness check when barcode is not provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const activeUnit = { id: "unit-kg", isActive: true };
+    const createdItem = { ...baseDraftItem, id: "new-item-id" };
+
+    spies.select
+      .mockReturnValueOnce(undefined) // SKU unique
+      .mockReturnValueOnce(activeUnit); // UoM valid (no barcode check)
+    spies.insert.mockReturnValue(createdItem);
+
+    const result = await run(db, { sku: "SKU-001", name: "Widget", unitId: "unit-kg" }, ctx, {
+      getUnit,
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.item).toBeDefined();
+    }
+    expect(spies.select).toHaveBeenCalledTimes(2); // Only SKU + UoM checks
+  });
+
+  it("passes custom fields through to insert", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const activeUnit = { id: "unit-kg", isActive: true };
+    const createdItem = { ...baseDraftItem, id: "new-item-id", priority: 5 };
+
+    spies.select
+      .mockReturnValueOnce(undefined) // SKU unique
+      .mockReturnValueOnce(activeUnit); // UoM valid
+    spies.insert.mockReturnValue(createdItem);
+
+    await run(db, { sku: "SKU-NEW", name: "Widget", unitId: "unit-kg", priority: 5 }, ctx, {
+      getUnit,
+    });
+
+    expect(spies.values).toHaveBeenNthCalledWith(1, expect.objectContaining({ priority: 5 }));
+  });
+});

package/src/modules/item-management/command/createItem.ts

@@ -0,0 +1,72 @@
+import { ok, err, type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import {
+  DuplicateBarcodeError,
+  DuplicateSkuError,
+  UnitNotFoundError,
+} from "../lib/errors.generated";
+import { getItem } from "../query/getItem.generated";
+import { type PrimitivesQueries } from "../module";
+
+export interface CreateItemInput {
+  sku: string;
+  name: string;
+  barcode?: string;
+  unitId: string;
+  status?: "DRAFT" | "ACTIVE";
+}
+/**
+ * Function: createItem
+ *
+ * Creates a new item with a unique SKU in DRAFT or ACTIVE status.
+ * DRAFT items allow review before activation; ACTIVE items are immediately available.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: DB,
+  input: CreateItemInput & CF,
+  ctx: CommandContext,
+  primitivesQueries?: Pick<PrimitivesQueries, "getUnit">,
+) {
+  const { sku, name, barcode, unitId, status = "DRAFT", ...customFields } = input;
+
+  // 1. Check SKU uniqueness
+  const { item: existingSku } = await getItem(db, { sku }, ctx);
+
+  if (existingSku) {
+    return err(new DuplicateSkuError(sku));
+  }
+
+  // 2. Check barcode uniqueness (when provided)
+  if (barcode) {
+    const { item: existingBarcode } = await getItem(db, { barcode }, ctx);
+
+    if (existingBarcode) {
+      return err(new DuplicateBarcodeError(barcode));
+    }
+  }
+
+  // 3. Validate UoM exists and is active
+  const { unit } = await primitivesQueries!.getUnit(db, { id: unitId }, ctx);
+
+  if (!unit?.isActive) {
+    return err(new UnitNotFoundError(unitId));
+  }
+
+  // 4. Create item
+  const item = await db
+    .insertInto("Item")
+    .values({
+      ...(customFields as Record<string, unknown>),
+      sku,
+      name,
+      barcode: barcode ?? null,
+      unitId,
+      status,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ item: item! });
+}

package/src/modules/item-management/command/createTaxonomyNode.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { defineCommand } from "../../shared/internal";
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./createTaxonomyNode";
+
+export const createTaxonomyNode = defineCommand(permissions.createTaxonomyNode, run);

package/src/modules/item-management/command/createTaxonomyNode.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import { type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import {
+  DuplicateNodeCodeError,
+  MaxDepthExceededError,
+  ParentNodeNotFoundError,
+} from "../lib/errors.generated";
+import { baseChildNode, baseLeafNode, baseRootNode } from "../testing/fixtures";
+import { run } from "./createTaxonomyNode";
+
+describe("createTaxonomyNode", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["item-management:createTaxonomyNode"],
+  };
+
+  it("returns error when code already exists", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseRootNode); // Code lookup finds existing
+
+    const result = await run(db, { code: "ELECTRONICS", name: "Electronics" }, ctx, {
+      maxDepth: 10,
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateNodeCodeError);
+    }
+  });
+
+  it("returns error when parent does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(undefined) // Code unique
+      .mockReturnValueOnce(undefined); // Parent not found
+
+    const result = await run(
+      db,
+      { code: "LAPTOPS", name: "Laptops", parentId: "nonexistent" },
+      ctx,
+      { maxDepth: 10 },
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ParentNodeNotFoundError);
+    }
+  });
+
+  it("returns error when max depth would be exceeded", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(undefined) // getTaxonomyNode: code unique
+      .mockReturnValueOnce(baseLeafNode) // getTaxonomyNode: parent exists (node-3)
+      .mockReturnValueOnce(baseLeafNode) // calculateNodeDepth: lookup node-3 (parentId=node-2)
+      .mockReturnValueOnce(baseChildNode) // calculateNodeDepth: lookup node-2 (parentId=node-1)
+      .mockReturnValueOnce(baseRootNode); // calculateNodeDepth: lookup node-1 (parentId=null, stop)
+
+    // parentDepth=3, new node depth=4 > maxDepth=3
+    const result = await run(
+      db,
+      { code: "DEEP", name: "Too Deep", parentId: baseLeafNode.id },
+      ctx,
+      { maxDepth: 3 },
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MaxDepthExceededError);
+    }
+  });
+
+  it("creates a root node", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const createdNode = { ...baseRootNode, id: "new-node-id", code: "CLOTHING" };
+    spies.select.mockReturnValueOnce(undefined); // Code unique
+    spies.insert.mockReturnValue(createdNode);
+
+    const result = await run(db, { code: "CLOTHING", name: "Clothing" }, ctx, { maxDepth: 10 });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.node.code).toBe("CLOTHING");
+      expect(result.value.node.parentId).toBeNull();
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("creates a child node under existing parent", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const createdNode = {
+      ...baseChildNode,
+      id: "new-node-id",
+      code: "TABLETS",
+      parentId: baseRootNode.id,
+    };
+    spies.select
+      .mockReturnValueOnce(undefined) // getTaxonomyNode: code unique
+      .mockReturnValueOnce(baseRootNode) // getTaxonomyNode: parent exists (root)
+      .mockReturnValueOnce(baseRootNode); // calculateNodeDepth: lookup root (parentId=null, depth=1)
+    spies.insert.mockReturnValue(createdNode);
+
+    const result = await run(
+      db,
+      { code: "TABLETS", name: "Tablets", parentId: baseRootNode.id },
+      ctx,
+      { maxDepth: 10 },
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.node.code).toBe("TABLETS");
+      expect(result.value.node.parentId).toBe(baseRootNode.id);
+    }
+  });
+
+  it("passes custom fields through to insert", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const createdNode = { ...baseRootNode, id: "new-node-id", sortOrder: 1 };
+    spies.select.mockReturnValueOnce(undefined); // Code unique
+    spies.insert.mockReturnValue(createdNode);
+
+    await run(db, { code: "SORTED", name: "Sorted Node", sortOrder: 1 }, ctx, { maxDepth: 10 });
+
+    expect(spies.values).toHaveBeenNthCalledWith(1, expect.objectContaining({ sortOrder: 1 }));
+  });
+});

package/src/modules/item-management/command/createTaxonomyNode.ts

@@ -0,0 +1,70 @@
+import { ok, err, type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import {
+  DuplicateNodeCodeError,
+  MaxDepthExceededError,
+  ParentNodeNotFoundError,
+} from "../lib/errors.generated";
+import { getTaxonomyNode } from "../query/getTaxonomyNode.generated";
+import { calculateNodeDepth } from "../query/calculateNodeDepth.generated";
+
+export interface CreateTaxonomyNodeInput {
+  code: string;
+  name: string;
+  parentId?: string;
+}
+
+/**
+ * Function: createTaxonomyNode
+ *
+ * Creates a new root or child taxonomy node with a unique code.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: DB,
+  input: CreateTaxonomyNodeInput & CF,
+  ctx: CommandContext,
+  deps?: { maxDepth: number },
+) {
+  const { maxDepth } = deps!;
+  const { code, name, parentId, ...customFields } = input;
+
+  // 1. Check code uniqueness
+  const { node: existingCode } = await getTaxonomyNode(db, { code }, ctx);
+
+  if (existingCode) {
+    return err(new DuplicateNodeCodeError(code));
+  }
+
+  // 2. If parent specified, check it exists and validate depth
+  if (parentId) {
+    const { node: parent } = await getTaxonomyNode(db, { id: parentId }, ctx);
+
+    if (!parent) {
+      return err(new ParentNodeNotFoundError(parentId));
+    }
+
+    // Calculate depth: parent depth + 1 for new node
+    const { depth: parentDepth } = await calculateNodeDepth(db, { nodeId: parentId }, ctx);
+    const depth = parentDepth + 1;
+
+    if (depth > maxDepth) {
+      return err(new MaxDepthExceededError(`${depth} exceeds ${maxDepth}`));
+    }
+  }
+
+  // 3. Create node
+  const node = await db
+    .insertInto("TaxonomyNode")
+    .values({
+      ...(customFields as Record<string, unknown>),
+      code,
+      name,
+      parentId: parentId ?? null,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ node: node });
+}

package/src/modules/item-management/command/deactivateItem.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { defineCommand } from "../../shared/internal";
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./deactivateItem";
+
+export const deactivateItem = defineCommand(permissions.deactivateItem, run);

package/src/modules/item-management/command/deactivateItem.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import { type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import { InvalidStateTransitionError, ItemNotFoundError } from "../lib/errors.generated";
+import { baseActiveItem, baseDraftItem, baseInactiveItem } from "../testing/fixtures";
+import { run } from "./deactivateItem";
+
+describe("deactivateItem", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["item-management:deactivateItem"],
+  };
+
+  it("returns error when item does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { id: "nonexistent" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ItemNotFoundError);
+    }
+  });
+
+  it("returns error when item is not ACTIVE", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseDraftItem);
+
+    const result = await run(db, { id: baseDraftItem.id }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateTransitionError);
+    }
+  });
+
+  it("returns error when item is already INACTIVE", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseInactiveItem);
+
+    const result = await run(db, { id: baseInactiveItem.id }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateTransitionError);
+    }
+  });
+
+  it("deactivates an ACTIVE item", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const deactivatedItem = { ...baseActiveItem, status: "INACTIVE" };
+    spies.select.mockReturnValueOnce(baseActiveItem);
+    spies.update.mockReturnValue(deactivatedItem);
+
+    const result = await run(db, { id: baseActiveItem.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.item.status).toBe("INACTIVE");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("deactivates from custom status when from is overridden", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const deactivatedItem = { ...baseDraftItem, status: "INACTIVE" };
+    spies.select.mockReturnValueOnce(baseDraftItem);
+    spies.update.mockReturnValue(deactivatedItem);
+
+    const result = await run(db, { id: baseDraftItem.id, from: ["ACTIVE", "DRAFT"] }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.item.status).toBe("INACTIVE");
+    }
+  });
+});

package/src/modules/item-management/command/deactivateItem.ts

@@ -0,0 +1,42 @@
+import { ok, err, type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import { InvalidStateTransitionError, ItemNotFoundError } from "../lib/errors.generated";
+import { getItem } from "../query/getItem.generated";
+
+export interface DeactivateItemInput {
+  id: string;
+  from?: string[];
+}
+
+/**
+ * Function: deactivateItem
+ *
+ * Transitions an item from ACTIVE to INACTIVE status,
+ * preserving it for audit trails while preventing new transactions.
+ */
+export async function run(db: DB, input: DeactivateItemInput, ctx: CommandContext) {
+  const { id, from } = input;
+
+  // 1. Check item exists
+  const { item } = await getItem(db, { id }, ctx);
+
+  if (!item) {
+    return err(new ItemNotFoundError(id));
+  }
+
+  // 2. Check status is valid for deactivation
+  const validFromStatuses = from ?? ["ACTIVE"];
+  if (!validFromStatuses.includes(item.status)) {
+    return err(new InvalidStateTransitionError(`${item.status} to INACTIVE`));
+  }
+
+  // 3. Update status to INACTIVE
+  const deactivatedItem = await db
+    .updateTable("Item")
+    .set({ status: "INACTIVE", updatedAt: new Date() })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ item: deactivatedItem });
+}

package/src/modules/item-management/command/deleteItem.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { defineCommand } from "../../shared/internal";
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./deleteItem";
+
+export const deleteItem = defineCommand(permissions.deleteItem, run);

package/src/modules/item-management/command/deleteItem.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import { type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import { DeleteNonDraftError, ItemNotFoundError } from "../lib/errors.generated";
+import { baseActiveItem, baseDraftItem, baseInactiveItem } from "../testing/fixtures";
+import { run } from "./deleteItem";
+
+describe("deleteItem", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["item-management:deleteItem"],
+  };
+
+  it("returns error when item does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { id: "nonexistent" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ItemNotFoundError);
+    }
+  });
+
+  it("returns error when item is ACTIVE", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseActiveItem);
+
+    const result = await run(db, { id: baseActiveItem.id }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DeleteNonDraftError);
+    }
+  });
+
+  it("returns error when item is INACTIVE", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseInactiveItem);
+
+    const result = await run(db, { id: baseInactiveItem.id }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DeleteNonDraftError);
+    }
+  });
+
+  it("deletes a DRAFT item and removes taxonomy assignments", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseDraftItem);
+    spies.delete.mockReturnValue(undefined); // Assignments delete + item delete
+
+    const result = await run(db, { id: baseDraftItem.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.success).toBe(true);
+    }
+    expect(spies.delete).toHaveBeenCalled();
+  });
+});

package/src/modules/item-management/command/deleteItem.ts

@@ -0,0 +1,38 @@
+import { ok, err, type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import { DeleteNonDraftError, ItemNotFoundError } from "../lib/errors.generated";
+import { getItem } from "../query/getItem.generated";
+
+export interface DeleteItemInput {
+  id: string;
+}
+
+/**
+ * Function: deleteItem
+ *
+ * Permanently removes a DRAFT item from the system.
+ * Only DRAFT items can be deleted; ACTIVE and INACTIVE are preserved for audit trails.
+ */
+export async function run(db: DB, input: DeleteItemInput, ctx: CommandContext) {
+  const { id } = input;
+
+  // 1. Check item exists
+  const { item } = await getItem(db, { id }, ctx);
+
+  if (!item) {
+    return err(new ItemNotFoundError(id));
+  }
+
+  // 2. Check status is DRAFT
+  if (item.status !== "DRAFT") {
+    return err(new DeleteNonDraftError(`${id} (status: ${item.status})`));
+  }
+
+  // 3. Remove taxonomy assignments
+  await db.deleteFrom("ItemTaxonomyAssignment").where("itemId", "=", id).execute();
+
+  // 4. Delete item
+  await db.deleteFrom("Item").where("id", "=", id).execute();
+
+  return ok({ success: true as const });
+}

package/src/modules/item-management/command/deleteTaxonomyNode.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { defineCommand } from "../../shared/internal";
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./deleteTaxonomyNode";
+
+export const deleteTaxonomyNode = defineCommand(permissions.deleteTaxonomyNode, run);