@tailor-platform/erp-kit 0.1.2 → 0.2.0

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);

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

@@ -0,0 +1,73 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import { type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import {
+  NodeHasAssignmentsError,
+  NodeHasChildrenError,
+  NodeNotFoundError,
+} from "../lib/errors.generated";
+import { baseAssignment, baseChildNode, baseLeafNode, baseRootNode } from "../testing/fixtures";
+import { run } from "./deleteTaxonomyNode";
+
+describe("deleteTaxonomyNode", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["item-management:deleteTaxonomyNode"],
+  };
+
+  it("returns error when node 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(NodeNotFoundError);
+    }
+  });
+
+  it("returns error when node has children", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseRootNode) // getTaxonomyNode
+      .mockReturnValueOnce([baseChildNode]); // getTaxonomyNodeChildren (execute returns array)
+
+    const result = await run(db, { id: baseRootNode.id }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(NodeHasChildrenError);
+    }
+  });
+
+  it("returns error when node has item assignments", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseLeafNode) // getTaxonomyNode
+      .mockReturnValueOnce([]) // getTaxonomyNodeChildren (no children)
+      .mockReturnValueOnce([baseAssignment]); // getTaxonomyNodeAssignments (has assignment)
+
+    const result = await run(db, { id: baseLeafNode.id }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(NodeHasAssignmentsError);
+    }
+  });
+
+  it("deletes a leaf node with no assignments", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseLeafNode) // getTaxonomyNode
+      .mockReturnValueOnce([]) // getTaxonomyNodeChildren (no children)
+      .mockReturnValueOnce([]); // getTaxonomyNodeAssignments (no assignments)
+    spies.delete.mockReturnValue(undefined);
+
+    const result = await run(db, { id: baseLeafNode.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/deleteTaxonomyNode.ts

@@ -0,0 +1,50 @@
+import { ok, err, type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import {
+  NodeHasAssignmentsError,
+  NodeHasChildrenError,
+  NodeNotFoundError,
+} from "../lib/errors.generated";
+import { getTaxonomyNode } from "../query/getTaxonomyNode.generated";
+import { getTaxonomyNodeChildren } from "../query/getTaxonomyNodeChildren.generated";
+import { getTaxonomyNodeAssignments } from "../query/getTaxonomyNodeAssignments.generated";
+
+export interface DeleteTaxonomyNodeInput {
+  id: string;
+}
+
+/**
+ * Function: deleteTaxonomyNode
+ *
+ * Permanently removes a leaf taxonomy node with no item assignments.
+ * The node's code becomes available for reuse.
+ */
+export async function run(db: DB, input: DeleteTaxonomyNodeInput, ctx: CommandContext) {
+  const { id } = input;
+
+  // 1. Check node exists
+  const { node } = await getTaxonomyNode(db, { id }, ctx);
+
+  if (!node) {
+    return err(new NodeNotFoundError(id));
+  }
+
+  // 2. Check no children
+  const { children } = await getTaxonomyNodeChildren(db, { parentId: id }, ctx);
+
+  if (children.length > 0) {
+    return err(new NodeHasChildrenError(id));
+  }
+
+  // 3. Check no item assignments
+  const { assignments } = await getTaxonomyNodeAssignments(db, { taxonomyNodeId: id }, ctx);
+
+  if (assignments.length > 0) {
+    return err(new NodeHasAssignmentsError(id));
+  }
+
+  // 4. Delete node
+  await db.deleteFrom("TaxonomyNode").where("id", "=", id).execute();
+
+  return ok({ success: true as const });
+}

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

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

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

@@ -0,0 +1,136 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import { type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import {
+  CircularReferenceError,
+  MaxDepthExceededError,
+  NodeNotFoundError,
+  ParentNodeNotFoundError,
+} from "../lib/errors.generated";
+import { baseChildNode, baseLeafNode, baseRootNode, secondRootNode } from "../testing/fixtures";
+import { run } from "./moveTaxonomyNode";
+
+describe("moveTaxonomyNode", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["item-management:moveTaxonomyNode"],
+  };
+
+  it("returns error when node does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { id: "nonexistent", newParentId: null }, ctx, { maxDepth: 10 });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(NodeNotFoundError);
+    }
+  });
+
+  it("returns error when new parent does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseChildNode) // getTaxonomyNode for node
+      .mockReturnValueOnce(undefined); // getTaxonomyNode for new parent
+
+    const result = await run(db, { id: baseChildNode.id, newParentId: "nonexistent" }, ctx, {
+      maxDepth: 10,
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ParentNodeNotFoundError);
+    }
+  });
+
+  it("returns error when moving node under itself", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseRootNode) // getTaxonomyNode for node
+      .mockReturnValueOnce(baseRootNode); // getTaxonomyNode for new parent
+
+    const result = await run(db, { id: baseRootNode.id, newParentId: baseRootNode.id }, ctx, {
+      maxDepth: 10,
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CircularReferenceError);
+    }
+  });
+
+  it("returns error when moving node under its descendant", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseRootNode) // getTaxonomyNode for node (node-1)
+      .mockReturnValueOnce(baseLeafNode) // getTaxonomyNode for new parent (node-3)
+      .mockReturnValueOnce(baseLeafNode) // detectCircularReference: lookup node-3
+      .mockReturnValueOnce(baseChildNode); // detectCircularReference: lookup node-2 → parentId=node-1=nodeId → circular!
+
+    const result = await run(db, { id: baseRootNode.id, newParentId: baseLeafNode.id }, ctx, {
+      maxDepth: 10,
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CircularReferenceError);
+    }
+  });
+
+  it("promotes node to root by setting parent to null", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const movedNode = { ...baseChildNode, parentId: null };
+    spies.select.mockReturnValueOnce(baseChildNode); // getTaxonomyNode for node
+    spies.update.mockReturnValue(movedNode);
+
+    const result = await run(db, { id: baseChildNode.id, newParentId: null }, ctx, {
+      maxDepth: 10,
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.node.parentId).toBeNull();
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("moves node to different parent", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const movedNode = { ...baseChildNode, parentId: secondRootNode.id };
+    spies.select
+      .mockReturnValueOnce(baseChildNode) // getTaxonomyNode for node (node-2)
+      .mockReturnValueOnce(secondRootNode) // getTaxonomyNode for new parent (node-4)
+      .mockReturnValueOnce(secondRootNode) // detectCircularReference: lookup node-4 → parentId=null → not circular
+      .mockReturnValueOnce(secondRootNode) // calculateNodeDepth: lookup node-4 → parentId=null → depth=1
+      .mockReturnValueOnce([baseLeafNode]) // calculateSubtreeDepth: children of node-2
+      .mockReturnValueOnce([]); // calculateSubtreeDepth: children of node-3 (leaf, no children)
+    spies.update.mockReturnValue(movedNode);
+
+    const result = await run(db, { id: baseChildNode.id, newParentId: secondRootNode.id }, ctx, {
+      maxDepth: 10,
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.node.parentId).toBe(secondRootNode.id);
+    }
+  });
+
+  it("returns error when subtree depth + new parent depth exceeds maxDepth", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseChildNode) // getTaxonomyNode for node (node-2)
+      .mockReturnValueOnce(secondRootNode) // getTaxonomyNode for new parent (node-4)
+      .mockReturnValueOnce(secondRootNode) // detectCircularReference: lookup node-4 → not circular
+      .mockReturnValueOnce(secondRootNode) // calculateNodeDepth: lookup node-4 → depth=1
+      .mockReturnValueOnce([baseLeafNode]) // calculateSubtreeDepth: children of node-2
+      .mockReturnValueOnce([]); // calculateSubtreeDepth: children of node-3 (leaf)
+
+    // newParentDepth=1 (root), subtreeDepth=2 (child+leaf), totalDepth=3 > maxDepth=2
+    const result = await run(db, { id: baseChildNode.id, newParentId: secondRootNode.id }, ctx, {
+      maxDepth: 2,
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MaxDepthExceededError);
+    }
+  });
+});

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

@@ -0,0 +1,85 @@
+import { ok, err, type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import {
+  CircularReferenceError,
+  MaxDepthExceededError,
+  NodeNotFoundError,
+  ParentNodeNotFoundError,
+} from "../lib/errors.generated";
+import { getTaxonomyNode } from "../query/getTaxonomyNode.generated";
+import { detectCircularReference } from "../query/detectCircularReference.generated";
+import { calculateNodeDepth } from "../query/calculateNodeDepth.generated";
+import { calculateSubtreeDepth } from "../query/calculateSubtreeDepth.generated";
+
+export interface MoveTaxonomyNodeInput {
+  id: string;
+  newParentId: string | null;
+}
+
+/**
+ * Function: moveTaxonomyNode
+ *
+ * Reparents a taxonomy node. Moving to null promotes to root.
+ * Validates circular references and depth limits.
+ */
+export async function run(
+  db: DB,
+  input: MoveTaxonomyNodeInput,
+  ctx: CommandContext,
+  config?: { maxDepth: number },
+) {
+  const { maxDepth } = config!;
+  const { id, newParentId } = input;
+
+  // 1. Check node exists
+  const { node } = await getTaxonomyNode(db, { id }, ctx);
+
+  if (!node) {
+    return err(new NodeNotFoundError(id));
+  }
+
+  // 2. If promoting to root, just update
+  if (newParentId === null) {
+    const movedNode = await db
+      .updateTable("TaxonomyNode")
+      .set({ parentId: null, updatedAt: new Date() })
+      .where("id", "=", id)
+      .returningAll()
+      .executeTakeFirst();
+
+    return ok({ node: movedNode! });
+  }
+
+  // 3. Check new parent exists
+  const { node: newParent } = await getTaxonomyNode(db, { id: newParentId }, ctx);
+
+  if (!newParent) {
+    return err(new ParentNodeNotFoundError(newParentId));
+  }
+
+  // 4. Check circular reference
+  const { isCircular } = await detectCircularReference(db, { nodeId: id, newParentId }, ctx);
+
+  if (isCircular) {
+    return err(new CircularReferenceError(`${id} -> ${newParentId}`));
+  }
+
+  // 5. Check depth limit: new parent depth + subtree depth of moved node
+  const { depth: newParentDepth } = await calculateNodeDepth(db, { nodeId: newParentId }, ctx);
+  const { depth: subtreeDepth } = await calculateSubtreeDepth(db, { nodeId: id }, ctx);
+  const totalDepth = newParentDepth + subtreeDepth;
+
+  if (totalDepth > maxDepth) {
+    return err(new MaxDepthExceededError(`${totalDepth} exceeds ${maxDepth}`));
+  }
+
+  // 6. Update parent
+  const movedNode = await db
+    .updateTable("TaxonomyNode")
+    .set({ parentId: newParentId, updatedAt: new Date() })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ node: movedNode! });
+}

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

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