@tailor-platform/erp-kit 0.2.1 → 0.2.2

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

@@ -1,11 +1,10 @@
-import { ok, err, type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { ok, err, type CommandContext } from "../../../shared";
+import { Transaction } 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 {
@@ -22,7 +21,7 @@ export interface CreateItemInput {
  * DRAFT items allow review before activation; ACTIVE items are immediately available.
  */
 export async function run<CF extends Record<string, unknown>>(
-  db: DB,
+  db: Transaction,
   input: CreateItemInput & CF,
   ctx: CommandContext,
   primitivesQueries?: Pick<PrimitivesQueries, "getUnit">,
@@ -30,7 +29,12 @@ export async function run<CF extends Record<string, unknown>>(
   const { sku, name, barcode, unitId, status = "DRAFT", ...customFields } = input;
 
   // 1. Check SKU uniqueness
-  const { item: existingSku } = await getItem(db, { sku }, ctx);
+  const existingSku = await db
+    .selectFrom("Item")
+    .selectAll()
+    .where("sku", "=", sku)
+    .forUpdate()
+    .executeTakeFirst();
 
   if (existingSku) {
     return err(new DuplicateSkuError(sku));
@@ -38,7 +42,12 @@ export async function run<CF extends Record<string, unknown>>(
 
   // 2. Check barcode uniqueness (when provided)
   if (barcode) {
-    const { item: existingBarcode } = await getItem(db, { barcode }, ctx);
+    const existingBarcode = await db
+      .selectFrom("Item")
+      .selectAll()
+      .where("barcode", "=", barcode)
+      .forUpdate()
+      .executeTakeFirst();
 
     if (existingBarcode) {
       return err(new DuplicateBarcodeError(barcode));
@@ -46,7 +55,7 @@ export async function run<CF extends Record<string, unknown>>(
   }
 
   // 3. Validate UoM exists and is active
-  const { unit } = await primitivesQueries!.getUnit(db, { id: unitId }, ctx);
+  const { unit } = (await primitivesQueries!.getUnit(db, { id: unitId }, ctx)).value;
 
   if (!unit?.isActive) {
     return err(new UnitNotFoundError(unitId));

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

@@ -1,5 +1,5 @@
 // @generated — do not edit
-import { defineCommand } from "../../shared/internal";
+import { defineCommand } from "../../../shared";
 import { permissions } from "../lib/permissions.generated";
 import { run } from "./createTaxonomyNode";
 

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

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../testing/index";
-import { type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { createMockDb } from "../../../testing/index";
+import { type CommandContext } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
 import {
   DuplicateNodeCodeError,
   MaxDepthExceededError,
@@ -17,7 +17,7 @@ describe("createTaxonomyNode", () => {
   };
 
   it("returns error when code already exists", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(baseRootNode); // Code lookup finds existing
 
     const result = await run(db, { code: "ELECTRONICS", name: "Electronics" }, ctx, {
@@ -30,7 +30,7 @@ describe("createTaxonomyNode", () => {
   });
 
   it("returns error when parent does not exist", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select
       .mockReturnValueOnce(undefined) // Code unique
       .mockReturnValueOnce(undefined); // Parent not found
@@ -48,7 +48,7 @@ describe("createTaxonomyNode", () => {
   });
 
   it("returns error when max depth would be exceeded", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select
       .mockReturnValueOnce(undefined) // getTaxonomyNode: code unique
       .mockReturnValueOnce(baseLeafNode) // getTaxonomyNode: parent exists (node-3)
@@ -70,7 +70,7 @@ describe("createTaxonomyNode", () => {
   });
 
   it("creates a root node", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const createdNode = { ...baseRootNode, id: "new-node-id", code: "CLOTHING" };
     spies.select.mockReturnValueOnce(undefined); // Code unique
     spies.insert.mockReturnValue(createdNode);
@@ -86,7 +86,7 @@ describe("createTaxonomyNode", () => {
   });
 
   it("creates a child node under existing parent", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const createdNode = {
       ...baseChildNode,
       id: "new-node-id",
@@ -114,7 +114,7 @@ describe("createTaxonomyNode", () => {
   });
 
   it("passes custom fields through to insert", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const createdNode = { ...baseRootNode, id: "new-node-id", sortOrder: 1 };
     spies.select.mockReturnValueOnce(undefined); // Code unique
     spies.insert.mockReturnValue(createdNode);

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

@@ -1,12 +1,10 @@
-import { ok, err, type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { ok, err, type CommandContext } from "../../../shared";
+import { Transaction } 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;
@@ -20,16 +18,21 @@ export interface CreateTaxonomyNodeInput {
  * Creates a new root or child taxonomy node with a unique code.
  */
 export async function run<CF extends Record<string, unknown>>(
-  db: DB,
+  db: Transaction,
   input: CreateTaxonomyNodeInput & CF,
-  ctx: CommandContext,
+  _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);
+  // 1. Check code uniqueness (uniqueness before insert — lock)
+  const existingCode = await db
+    .selectFrom("TaxonomyNode")
+    .selectAll()
+    .where("code", "=", code)
+    .forUpdate()
+    .executeTakeFirst();
 
   if (existingCode) {
     return err(new DuplicateNodeCodeError(code));
@@ -37,18 +40,34 @@ export async function run<CF extends Record<string, unknown>>(
 
   // 2. If parent specified, check it exists and validate depth
   if (parentId) {
-    const { node: parent } = await getTaxonomyNode(db, { id: parentId }, ctx);
+    const parent = await db
+      .selectFrom("TaxonomyNode")
+      .selectAll()
+      .where("id", "=", parentId)
+      .executeTakeFirst();
 
     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;
+    // Calculate depth: walk up from parent to root
+    let depth = 1;
+    let currentId: string | null = parentId;
+    while (currentId) {
+      const node = await db
+        .selectFrom("TaxonomyNode")
+        .selectAll()
+        .where("id", "=", currentId)
+        .executeTakeFirst();
+      if (!node?.parentId) break;
+      depth++;
+      currentId = node.parentId;
+    }
+    // Add 1 for the new node
+    const newNodeDepth = depth + 1;
 
-    if (depth > maxDepth) {
-      return err(new MaxDepthExceededError(`${depth} exceeds ${maxDepth}`));
+    if (newNodeDepth > maxDepth) {
+      return err(new MaxDepthExceededError(`${newNodeDepth} exceeds ${maxDepth}`));
     }
   }
 

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

@@ -1,5 +1,5 @@
 // @generated — do not edit
-import { defineCommand } from "../../shared/internal";
+import { defineCommand } from "../../../shared";
 import { permissions } from "../lib/permissions.generated";
 import { run } from "./deactivateItem";
 

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

@@ -1,22 +1,16 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../testing/index";
-import { type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { createMockDb } from "../../../testing/index";
+import { Transaction } 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>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(undefined);
 
-    const result = await run(db, { id: "nonexistent" }, ctx);
+    const result = await run(db, { id: "nonexistent" });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(ItemNotFoundError);
@@ -24,10 +18,10 @@ describe("deactivateItem", () => {
   });
 
   it("returns error when item is not ACTIVE", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(baseDraftItem);
 
-    const result = await run(db, { id: baseDraftItem.id }, ctx);
+    const result = await run(db, { id: baseDraftItem.id });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(InvalidStateTransitionError);
@@ -35,10 +29,10 @@ describe("deactivateItem", () => {
   });
 
   it("returns error when item is already INACTIVE", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(baseInactiveItem);
 
-    const result = await run(db, { id: baseInactiveItem.id }, ctx);
+    const result = await run(db, { id: baseInactiveItem.id });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(InvalidStateTransitionError);
@@ -46,12 +40,12 @@ describe("deactivateItem", () => {
   });
 
   it("deactivates an ACTIVE item", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const deactivatedItem = { ...baseActiveItem, status: "INACTIVE" };
     spies.select.mockReturnValueOnce(baseActiveItem);
     spies.update.mockReturnValue(deactivatedItem);
 
-    const result = await run(db, { id: baseActiveItem.id }, ctx);
+    const result = await run(db, { id: baseActiveItem.id });
 
     expect(result.ok).toBe(true);
     if (result.ok) {
@@ -61,12 +55,12 @@ describe("deactivateItem", () => {
   });
 
   it("deactivates from custom status when from is overridden", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     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);
+    const result = await run(db, { id: baseDraftItem.id, from: ["ACTIVE", "DRAFT"] });
 
     expect(result.ok).toBe(true);
     if (result.ok) {

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

@@ -1,7 +1,6 @@
-import { ok, err, type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { ok, err } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
 import { InvalidStateTransitionError, ItemNotFoundError } from "../lib/errors.generated";
-import { getItem } from "../query/getItem.generated";
 
 export interface DeactivateItemInput {
   id: string;
@@ -14,11 +13,16 @@ export interface DeactivateItemInput {
  * 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) {
+export async function run(db: Transaction, input: DeactivateItemInput) {
   const { id, from } = input;
 
   // 1. Check item exists
-  const { item } = await getItem(db, { id }, ctx);
+  const item = await db
+    .selectFrom("Item")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
 
   if (!item) {
     return err(new ItemNotFoundError(id));

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

@@ -1,5 +1,5 @@
 // @generated — do not edit
-import { defineCommand } from "../../shared/internal";
+import { defineCommand } from "../../../shared";
 import { permissions } from "../lib/permissions.generated";
 import { run } from "./deleteItem";
 

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

@@ -1,22 +1,16 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../testing/index";
-import { type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { createMockDb } from "../../../testing/index";
+import { Transaction } 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>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(undefined);
 
-    const result = await run(db, { id: "nonexistent" }, ctx);
+    const result = await run(db, { id: "nonexistent" });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(ItemNotFoundError);
@@ -24,10 +18,10 @@ describe("deleteItem", () => {
   });
 
   it("returns error when item is ACTIVE", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(baseActiveItem);
 
-    const result = await run(db, { id: baseActiveItem.id }, ctx);
+    const result = await run(db, { id: baseActiveItem.id });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(DeleteNonDraftError);
@@ -35,10 +29,10 @@ describe("deleteItem", () => {
   });
 
   it("returns error when item is INACTIVE", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(baseInactiveItem);
 
-    const result = await run(db, { id: baseInactiveItem.id }, ctx);
+    const result = await run(db, { id: baseInactiveItem.id });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(DeleteNonDraftError);
@@ -46,11 +40,11 @@ describe("deleteItem", () => {
   });
 
   it("deletes a DRAFT item and removes taxonomy assignments", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(baseDraftItem);
     spies.delete.mockReturnValue(undefined); // Assignments delete + item delete
 
-    const result = await run(db, { id: baseDraftItem.id }, ctx);
+    const result = await run(db, { id: baseDraftItem.id });
 
     expect(result.ok).toBe(true);
     if (result.ok) {

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

@@ -1,7 +1,6 @@
-import { ok, err, type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { ok, err } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
 import { DeleteNonDraftError, ItemNotFoundError } from "../lib/errors.generated";
-import { getItem } from "../query/getItem.generated";
 
 export interface DeleteItemInput {
   id: string;
@@ -13,11 +12,16 @@ export interface DeleteItemInput {
  * 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) {
+export async function run(db: Transaction, input: DeleteItemInput) {
   const { id } = input;
 
   // 1. Check item exists
-  const { item } = await getItem(db, { id }, ctx);
+  const item = await db
+    .selectFrom("Item")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
 
   if (!item) {
     return err(new ItemNotFoundError(id));

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

@@ -1,5 +1,5 @@
 // @generated — do not edit
-import { defineCommand } from "../../shared/internal";
+import { defineCommand } from "../../../shared";
 import { permissions } from "../lib/permissions.generated";
 import { run } from "./deleteTaxonomyNode";
 

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

@@ -1,7 +1,6 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../testing/index";
-import { type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { createMockDb } from "../../../testing/index";
+import { Transaction } from "../generated/kysely-tailordb";
 import {
   NodeHasAssignmentsError,
   NodeHasChildrenError,
@@ -11,16 +10,11 @@ import { baseAssignment, baseChildNode, baseLeafNode, baseRootNode } from "../te
 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>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(undefined);
 
-    const result = await run(db, { id: "nonexistent" }, ctx);
+    const result = await run(db, { id: "nonexistent" });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(NodeNotFoundError);
@@ -28,12 +22,12 @@ describe("deleteTaxonomyNode", () => {
   });
 
   it("returns error when node has children", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select
       .mockReturnValueOnce(baseRootNode) // getTaxonomyNode
       .mockReturnValueOnce([baseChildNode]); // getTaxonomyNodeChildren (execute returns array)
 
-    const result = await run(db, { id: baseRootNode.id }, ctx);
+    const result = await run(db, { id: baseRootNode.id });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(NodeHasChildrenError);
@@ -41,13 +35,13 @@ describe("deleteTaxonomyNode", () => {
   });
 
   it("returns error when node has item assignments", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select
       .mockReturnValueOnce(baseLeafNode) // getTaxonomyNode
       .mockReturnValueOnce([]) // getTaxonomyNodeChildren (no children)
       .mockReturnValueOnce([baseAssignment]); // getTaxonomyNodeAssignments (has assignment)
 
-    const result = await run(db, { id: baseLeafNode.id }, ctx);
+    const result = await run(db, { id: baseLeafNode.id });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(NodeHasAssignmentsError);
@@ -55,14 +49,14 @@ describe("deleteTaxonomyNode", () => {
   });
 
   it("deletes a leaf node with no assignments", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     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);
+    const result = await run(db, { id: baseLeafNode.id });
 
     expect(result.ok).toBe(true);
     if (result.ok) {

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

@@ -1,13 +1,10 @@
-import { ok, err, type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { ok, err } from "../../../shared";
+import { Transaction } 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;
@@ -19,25 +16,38 @@ export interface DeleteTaxonomyNodeInput {
  * 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) {
+export async function run(db: Transaction, input: DeleteTaxonomyNodeInput) {
   const { id } = input;
 
-  // 1. Check node exists
-  const { node } = await getTaxonomyNode(db, { id }, ctx);
+  // 1. Check node exists (read-then-delete — lock)
+  const node = await db
+    .selectFrom("TaxonomyNode")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
 
   if (!node) {
     return err(new NodeNotFoundError(id));
   }
 
-  // 2. Check no children
-  const { children } = await getTaxonomyNodeChildren(db, { parentId: id }, ctx);
+  // 2. Check no children (validation only — no lock)
+  const children = await db
+    .selectFrom("TaxonomyNode")
+    .selectAll()
+    .where("parentId", "=", id)
+    .execute();
 
   if (children.length > 0) {
     return err(new NodeHasChildrenError(id));
   }
 
-  // 3. Check no item assignments
-  const { assignments } = await getTaxonomyNodeAssignments(db, { taxonomyNodeId: id }, ctx);
+  // 3. Check no item assignments (validation only — no lock)
+  const assignments = await db
+    .selectFrom("ItemTaxonomyAssignment")
+    .selectAll()
+    .where("taxonomyNodeId", "=", id)
+    .execute();
 
   if (assignments.length > 0) {
     return err(new NodeHasAssignmentsError(id));

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

@@ -1,5 +1,5 @@
 // @generated — do not edit
-import { defineCommand } from "../../shared/internal";
+import { defineCommand } from "../../../shared";
 import { permissions } from "../lib/permissions.generated";
 import { run } from "./moveTaxonomyNode";