@tailor-platform/erp-kit 0.2.1 → 0.2.2

package/src/modules/item-management/command/updateTaxonomyNode.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 {
   CodeImmutableError,
   MissingRequiredFieldsError,
@@ -11,16 +10,11 @@ import { baseRootNode } from "../testing/fixtures";
 import { run } from "./updateTaxonomyNode";
 
 describe("updateTaxonomyNode", () => {
-  const ctx: CommandContext = {
-    actorId: "test-actor",
-    permissions: ["item-management:updateTaxonomyNode"],
-  };
-
   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", name: "New Name" }, ctx);
+    const result = await run(db, { id: "nonexistent", name: "New Name" });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(NodeNotFoundError);
@@ -28,10 +22,10 @@ describe("updateTaxonomyNode", () => {
   });
 
   it("returns error when attempting to change code", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(baseRootNode);
 
-    const result = await run(db, { id: baseRootNode.id, code: "NEW-CODE" }, ctx);
+    const result = await run(db, { id: baseRootNode.id, code: "NEW-CODE" });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(CodeImmutableError);
@@ -39,10 +33,10 @@ describe("updateTaxonomyNode", () => {
   });
 
   it("returns error when name is empty", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(baseRootNode);
 
-    const result = await run(db, { id: baseRootNode.id, name: "" }, ctx);
+    const result = await run(db, { id: baseRootNode.id, name: "" });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(MissingRequiredFieldsError);
@@ -50,10 +44,10 @@ describe("updateTaxonomyNode", () => {
   });
 
   it("returns error when name is not provided", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(baseRootNode);
 
-    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(MissingRequiredFieldsError);
@@ -61,12 +55,12 @@ describe("updateTaxonomyNode", () => {
   });
 
   it("updates node name", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const updatedNode = { ...baseRootNode, name: "Consumer Electronics" };
     spies.select.mockReturnValueOnce(baseRootNode);
     spies.update.mockReturnValue(updatedNode);
 
-    const result = await run(db, { id: baseRootNode.id, name: "Consumer Electronics" }, ctx);
+    const result = await run(db, { id: baseRootNode.id, name: "Consumer Electronics" });
 
     expect(result.ok).toBe(true);
     if (result.ok) {
@@ -76,12 +70,12 @@ describe("updateTaxonomyNode", () => {
   });
 
   it("passes custom fields through to set", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const updatedNode = { ...baseRootNode, sortOrder: 5 };
     spies.select.mockReturnValueOnce(baseRootNode);
     spies.update.mockReturnValue(updatedNode);
 
-    await run(db, { id: baseRootNode.id, name: "Electronics", sortOrder: 5 }, ctx);
+    await run(db, { id: baseRootNode.id, name: "Electronics", sortOrder: 5 });
 
     expect(spies.set).toHaveBeenNthCalledWith(1, expect.objectContaining({ sortOrder: 5 }));
   });

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

@@ -1,11 +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 {
   CodeImmutableError,
   MissingRequiredFieldsError,
   NodeNotFoundError,
 } from "../lib/errors.generated";
-import { getTaxonomyNode } from "../query/getTaxonomyNode.generated";
 
 export interface UpdateTaxonomyNodeInput {
   id: string;
@@ -20,14 +19,18 @@ export interface UpdateTaxonomyNodeInput {
  * Node code is immutable.
  */
 export async function run<CF extends Record<string, unknown>>(
-  db: DB,
+  db: Transaction,
   input: UpdateTaxonomyNodeInput & Partial<CF>,
-  ctx: CommandContext,
 ) {
   const { id, code, name, ...customFields } = input;
 
   // 1. Check node exists
-  const { node } = await getTaxonomyNode(db, { id }, ctx);
+  const node = await db
+    .selectFrom("TaxonomyNode")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
 
   if (!node) {
     return err(new NodeNotFoundError(id));

package/src/modules/item-management/docs/commands/ActivateItem.md

@@ -30,3 +30,11 @@ flowchart TD
 
 - **ITEM_NOT_FOUND**: Specified item ID does not exist
 - **INVALID_STATE_TRANSITION**: Item is not in DRAFT status
+
+## Test Cases
+
+- returns error when item does not exist
+- returns error when item is not DRAFT
+- returns error when item is INACTIVE
+- activates a DRAFT item
+- activates from custom status when from is overridden

package/src/modules/item-management/docs/commands/AssignItemToTaxonomy.md

@@ -36,3 +36,10 @@ flowchart TD
 - **ITEM_NOT_FOUND**: Specified item ID does not exist
 - **NODE_NOT_FOUND**: Specified taxonomy node ID does not exist
 - **DUPLICATE_ASSIGNMENT**: Item is already assigned to this taxonomy node
+
+## Test Cases
+
+- returns error when item does not exist
+- returns error when node does not exist
+- returns error when assignment already exists
+- creates assignment successfully

package/src/modules/item-management/docs/commands/CreateItem.md

@@ -42,3 +42,13 @@ flowchart TD
 - **DUPLICATE_SKU**: An item with the same SKU already exists
 - **DUPLICATE_BARCODE**: An item with the same barcode already exists
 - **UNIT_NOT_FOUND**: Referenced unit does not exist or is inactive
+
+## Test Cases
+
+- returns error when SKU already exists
+- returns error when barcode already exists
+- returns error when UoM does not exist
+- creates item in DRAFT status by default
+- creates item in ACTIVE status
+- skips barcode uniqueness check when barcode is not provided
+- passes custom fields through to insert

package/src/modules/item-management/docs/commands/CreateTaxonomyNode.md

@@ -42,3 +42,12 @@ flowchart TD
 - **DUPLICATE_NODE_CODE**: A node with the same code already exists
 - **PARENT_NODE_NOT_FOUND**: Specified parent node ID does not exist
 - **MAX_DEPTH_EXCEEDED**: Adding this child would exceed the configurable tree depth limit
+
+## Test Cases
+
+- returns error when code already exists
+- returns error when parent does not exist
+- returns error when max depth would be exceeded
+- creates a root node
+- creates a child node under existing parent
+- passes custom fields through to insert

package/src/modules/item-management/docs/commands/DeactivateItem.md

@@ -32,3 +32,11 @@ flowchart TD
 
 - **ITEM_NOT_FOUND**: Specified item ID does not exist
 - **INVALID_STATE_TRANSITION**: Item is not in ACTIVE status
+
+## Test Cases
+
+- returns error when item does not exist
+- returns error when item is not ACTIVE
+- returns error when item is already INACTIVE
+- deactivates an ACTIVE item
+- deactivates from custom status when from is overridden

package/src/modules/item-management/docs/commands/DeleteItem.md

@@ -33,3 +33,10 @@ flowchart TD
 
 - **ITEM_NOT_FOUND**: Specified item ID does not exist
 - **DELETE_NON_DRAFT**: Item is in ACTIVE or INACTIVE status — only DRAFT items can be deleted
+
+## Test Cases
+
+- returns error when item does not exist
+- returns error when item is ACTIVE
+- returns error when item is INACTIVE
+- deletes a DRAFT item and removes taxonomy assignments

package/src/modules/item-management/docs/commands/DeleteTaxonomyNode.md

@@ -37,3 +37,10 @@ flowchart TD
 - **NODE_NOT_FOUND**: Specified node ID does not exist
 - **NODE_HAS_CHILDREN**: Node has one or more child nodes — children must be moved or deleted first
 - **NODE_HAS_ASSIGNMENTS**: Node has one or more item assignments — assignments must be removed first
+
+## Test Cases
+
+- returns error when node does not exist
+- returns error when node has children
+- returns error when node has item assignments
+- deletes a leaf node with no assignments

package/src/modules/item-management/docs/commands/MoveTaxonomyNode.md

@@ -43,3 +43,13 @@ flowchart TD
 - **PARENT_NODE_NOT_FOUND**: Specified new parent node ID does not exist
 - **CIRCULAR_REFERENCE**: New parent is the node itself or one of its descendants
 - **MAX_DEPTH_EXCEEDED**: Moving this subtree would exceed the configurable tree depth limit
+
+## Test Cases
+
+- returns error when node does not exist
+- returns error when new parent does not exist
+- returns error when moving node under itself
+- returns error when moving node under its descendant
+- promotes node to root by setting parent to null
+- moves node to different parent
+- returns error when subtree depth + new parent depth exceeds maxDepth

package/src/modules/item-management/docs/commands/ReactivateItem.md

@@ -32,3 +32,11 @@ flowchart TD
 
 - **ITEM_NOT_FOUND**: Specified item ID does not exist
 - **INVALID_STATE_TRANSITION**: Item is not in INACTIVE status
+
+## Test Cases
+
+- returns error when item does not exist
+- returns error when item is not INACTIVE
+- returns error when item is DRAFT
+- reactivates an INACTIVE item
+- reactivates from custom status when from is overridden

package/src/modules/item-management/docs/commands/RemoveItemFromTaxonomy.md

@@ -28,3 +28,8 @@ flowchart TD
 ## Error Scenarios
 
 - **ASSIGNMENT_NOT_FOUND**: No assignment exists for the specified item and taxonomy node combination
+
+## Test Cases
+
+- returns error when assignment does not exist
+- removes assignment successfully

package/src/modules/item-management/docs/commands/UpdateItem.md

@@ -53,3 +53,18 @@ flowchart TD
 - **UNIT_NOT_FOUND**: Referenced unit does not exist or is inactive
 - **UOM_LOCKED**: UoM cannot be changed after item has been activated (status is ACTIVE or INACTIVE)
 - **NO_FIELDS_TO_UPDATE**: No updatable fields were provided in the request
+
+## Test Cases
+
+- returns error when item does not exist
+- returns error when attempting to change SKU
+- returns error when no fields to update
+- returns error when barcode is duplicate
+- returns error when changing UoM on non-DRAFT item
+- returns error when changing UoM on INACTIVE item
+- returns error when new UoM does not exist
+- updates name in any status
+- updates barcode in any status
+- clears barcode by setting to null
+- updates UoM in DRAFT status
+- passes custom fields through to set

package/src/modules/item-management/docs/commands/UpdateTaxonomyNode.md

@@ -34,3 +34,12 @@ flowchart TD
 - **NODE_NOT_FOUND**: Specified node ID does not exist
 - **CODE_IMMUTABLE**: Attempt to change the node code
 - **MISSING_REQUIRED_FIELDS**: Name not provided or empty
+
+## Test Cases
+
+- returns error when node does not exist
+- returns error when attempting to change code
+- returns error when name is empty
+- returns error when name is not provided
+- updates node name
+- passes custom fields through to set

package/src/modules/item-management/docs/queries/CalculateNodeDepth.md

@@ -34,3 +34,11 @@ flowchart TD
 ## Error Scenarios
 
 - **NODE_NOT_FOUND**: The starting node or an ancestor in the chain is not found — traversal stops and returns partial depth
+
+## Test Cases
+
+- returns depth 1 for root node
+- returns depth 2 for child of root
+- returns depth 3 for grandchild of root
+- returns depth 1 when node not found
+- handles broken ancestor chain gracefully

package/src/modules/item-management/docs/queries/CalculateSubtreeDepth.md

@@ -38,3 +38,10 @@ flowchart TD
 ## Error Scenarios
 
 - **MAX_DEPTH_EXCEEDED**: Combined new parent depth + subtree depth exceeds maxDepth — enforced by the calling command, not this query directly
+
+## Test Cases
+
+- returns 1 for leaf node (no children)
+- returns 2 for node with one level of children
+- returns 3 for node with two levels of children
+- returns max depth for node with multiple branches

package/src/modules/item-management/docs/queries/DetectCircularReference.md

@@ -39,3 +39,12 @@ flowchart TD
 
 - **CIRCULAR_REFERENCE**: The moved node appears in the ancestor chain of the new parent — returns isCircular: true
 - **SELF_REFERENCE**: Node is moved to itself as parent — returns isCircular: true
+
+## Test Cases
+
+- detects self-reference as circular
+- detects moving node under its child as circular
+- detects moving node under its grandchild as circular
+- returns not circular for valid move
+- returns not circular when new parent is root
+- handles broken ancestor chain gracefully (not circular)

package/src/modules/item-management/docs/queries/GetItem.md

@@ -36,3 +36,12 @@ flowchart TD
 ## Error Scenarios
 
 - **ITEM_NOT_FOUND**: No item matches the given criteria — caller receives null
+
+## Test Cases
+
+- returns item when found
+- returns null when item not found
+- returns item when found
+- returns null when item not found
+- returns item when found
+- returns null when item not found

package/src/modules/item-management/docs/queries/GetItemTaxonomyAssignment.md

@@ -27,3 +27,8 @@ flowchart TD
 ## Error Scenarios
 
 - **ASSIGNMENT_NOT_FOUND**: No assignment exists for the item-node pair — caller receives null
+
+## Test Cases
+
+- returns assignment when found
+- returns null when assignment not found

package/src/modules/item-management/docs/queries/GetTaxonomyNode.md

@@ -33,3 +33,10 @@ flowchart TD
 ## Error Scenarios
 
 - **NODE_NOT_FOUND**: No taxonomy node matches the given criteria — caller receives null
+
+## Test Cases
+
+- returns node when found
+- returns null when node not found
+- returns node when found
+- returns null when node not found

package/src/modules/item-management/docs/queries/GetTaxonomyNodeAssignments.md

@@ -27,3 +27,8 @@ flowchart TD
 ## Error Scenarios
 
 - **NO_ASSIGNMENTS**: No item assignments exist for the given node — caller receives empty array
+
+## Test Cases
+
+- returns assignments when found
+- returns empty array when no assignments

package/src/modules/item-management/docs/queries/GetTaxonomyNodeChildren.md

@@ -27,3 +27,9 @@ flowchart TD
 ## Error Scenarios
 
 - **NO_CHILDREN**: No child nodes exist for the given parent — caller receives empty array
+
+## Test Cases
+
+- returns children when found
+- returns multiple children
+- returns empty array when no children

package/src/modules/item-management/index.ts

@@ -1,53 +1,2 @@
 export { defineModule } from "./module";
 export { permissions, own, all } from "./lib/permissions.generated";
-
-// generated types
-export { ItemStatus } from "./generated/enums";
-
-// errors
-export {
-  ItemNotFoundError,
-  DuplicateSkuError,
-  DuplicateBarcodeError,
-  UnitNotFoundError,
-  SkuImmutableError,
-  UomLockedError,
-  NoFieldsToUpdateError,
-  InvalidStateTransitionError,
-  DeleteNonDraftError,
-  NodeNotFoundError,
-  DuplicateNodeCodeError,
-  ParentNodeNotFoundError,
-  MaxDepthExceededError,
-  CodeImmutableError,
-  MissingRequiredFieldsError,
-  CircularReferenceError,
-  NodeHasChildrenError,
-  NodeHasAssignmentsError,
-  DuplicateAssignmentError,
-  AssignmentNotFoundError,
-} from "./lib/errors.generated";
-
-// query input types
-export { type GetItemInput } from "./query/getItem";
-export { type GetTaxonomyNodeInput } from "./query/getTaxonomyNode";
-export { type GetTaxonomyNodeChildrenInput } from "./query/getTaxonomyNodeChildren";
-export { type GetItemTaxonomyAssignmentInput } from "./query/getItemTaxonomyAssignment";
-export { type GetTaxonomyNodeAssignmentsInput } from "./query/getTaxonomyNodeAssignments";
-export { type CalculateNodeDepthInput } from "./query/calculateNodeDepth";
-export { type CalculateSubtreeDepthInput } from "./query/calculateSubtreeDepth";
-export { type DetectCircularReferenceInput } from "./query/detectCircularReference";
-
-// command input types
-export { type CreateItemInput } from "./command/createItem";
-export { type UpdateItemInput } from "./command/updateItem";
-export { type ActivateItemInput } from "./command/activateItem";
-export { type DeactivateItemInput } from "./command/deactivateItem";
-export { type ReactivateItemInput } from "./command/reactivateItem";
-export { type DeleteItemInput } from "./command/deleteItem";
-export { type CreateTaxonomyNodeInput } from "./command/createTaxonomyNode";
-export { type UpdateTaxonomyNodeInput } from "./command/updateTaxonomyNode";
-export { type MoveTaxonomyNodeInput } from "./command/moveTaxonomyNode";
-export { type DeleteTaxonomyNodeInput } from "./command/deleteTaxonomyNode";
-export { type AssignItemToTaxonomyInput } from "./command/assignItemToTaxonomy";
-export { type RemoveItemFromTaxonomyInput } from "./command/removeItemFromTaxonomy";

package/src/modules/item-management/lib/errors.generated.ts

@@ -1,117 +1,117 @@
 // @generated — do not edit
-import { createDomainError } from "../../shared/internal";
+import { createDomainError } from "../../../shared";
 
 export const ItemNotFoundError = createDomainError(
-  "ItemNotFoundError", "ITEM_NOT_FOUND",
+  "ItemNotFoundError", "ITEM_MANAGEMENT_ITEM_NOT_FOUND",
   (identifier: string) => `Specified item ID does not exist: ${identifier}`,
 );
 
 export const InvalidStateTransitionError = createDomainError(
-  "InvalidStateTransitionError", "INVALID_STATE_TRANSITION",
+  "InvalidStateTransitionError", "ITEM_MANAGEMENT_INVALID_STATE_TRANSITION",
   (identifier: string) => `Item is not in DRAFT status: ${identifier}`,
 );
 
 export const NodeNotFoundError = createDomainError(
-  "NodeNotFoundError", "NODE_NOT_FOUND",
+  "NodeNotFoundError", "ITEM_MANAGEMENT_NODE_NOT_FOUND",
   (identifier: string) => `Specified taxonomy node ID does not exist: ${identifier}`,
 );
 
 export const DuplicateAssignmentError = createDomainError(
-  "DuplicateAssignmentError", "DUPLICATE_ASSIGNMENT",
+  "DuplicateAssignmentError", "ITEM_MANAGEMENT_DUPLICATE_ASSIGNMENT",
   (identifier: string) => `Item is already assigned to this taxonomy node: ${identifier}`,
 );
 
 export const DuplicateSkuError = createDomainError(
-  "DuplicateSkuError", "DUPLICATE_SKU",
+  "DuplicateSkuError", "ITEM_MANAGEMENT_DUPLICATE_SKU",
   (identifier: string) => `An item with the same SKU already exists: ${identifier}`,
 );
 
 export const DuplicateBarcodeError = createDomainError(
-  "DuplicateBarcodeError", "DUPLICATE_BARCODE",
+  "DuplicateBarcodeError", "ITEM_MANAGEMENT_DUPLICATE_BARCODE",
   (identifier: string) => `An item with the same barcode already exists: ${identifier}`,
 );
 
 export const UnitNotFoundError = createDomainError(
-  "UnitNotFoundError", "UNIT_NOT_FOUND",
+  "UnitNotFoundError", "ITEM_MANAGEMENT_UNIT_NOT_FOUND",
   (identifier: string) => `Referenced unit does not exist or is inactive: ${identifier}`,
 );
 
 export const DuplicateNodeCodeError = createDomainError(
-  "DuplicateNodeCodeError", "DUPLICATE_NODE_CODE",
+  "DuplicateNodeCodeError", "ITEM_MANAGEMENT_DUPLICATE_NODE_CODE",
   (identifier: string) => `A node with the same code already exists: ${identifier}`,
 );
 
 export const ParentNodeNotFoundError = createDomainError(
-  "ParentNodeNotFoundError", "PARENT_NODE_NOT_FOUND",
+  "ParentNodeNotFoundError", "ITEM_MANAGEMENT_PARENT_NODE_NOT_FOUND",
   (identifier: string) => `Specified parent node ID does not exist: ${identifier}`,
 );
 
 export const MaxDepthExceededError = createDomainError(
-  "MaxDepthExceededError", "MAX_DEPTH_EXCEEDED",
+  "MaxDepthExceededError", "ITEM_MANAGEMENT_MAX_DEPTH_EXCEEDED",
   (identifier: string) => `Adding this child would exceed the configurable tree depth limit: ${identifier}`,
 );
 
 export const DeleteNonDraftError = createDomainError(
-  "DeleteNonDraftError", "DELETE_NON_DRAFT",
+  "DeleteNonDraftError", "ITEM_MANAGEMENT_DELETE_NON_DRAFT",
   (identifier: string) => `Item is in ACTIVE or INACTIVE status — only DRAFT items can be deleted: ${identifier}`,
 );
 
 export const NodeHasChildrenError = createDomainError(
-  "NodeHasChildrenError", "NODE_HAS_CHILDREN",
+  "NodeHasChildrenError", "ITEM_MANAGEMENT_NODE_HAS_CHILDREN",
   (identifier: string) => `Node has one or more child nodes — children must be moved or deleted first: ${identifier}`,
 );
 
 export const NodeHasAssignmentsError = createDomainError(
-  "NodeHasAssignmentsError", "NODE_HAS_ASSIGNMENTS",
+  "NodeHasAssignmentsError", "ITEM_MANAGEMENT_NODE_HAS_ASSIGNMENTS",
   (identifier: string) => `Node has one or more item assignments — assignments must be removed first: ${identifier}`,
 );
 
 export const CircularReferenceError = createDomainError(
-  "CircularReferenceError", "CIRCULAR_REFERENCE",
+  "CircularReferenceError", "ITEM_MANAGEMENT_CIRCULAR_REFERENCE",
   (identifier: string) => `New parent is the node itself or one of its descendants: ${identifier}`,
 );
 
 export const AssignmentNotFoundError = createDomainError(
-  "AssignmentNotFoundError", "ASSIGNMENT_NOT_FOUND",
+  "AssignmentNotFoundError", "ITEM_MANAGEMENT_ASSIGNMENT_NOT_FOUND",
   (identifier: string) => `No assignment exists for the specified item and taxonomy node combination: ${identifier}`,
 );
 
 export const SkuImmutableError = createDomainError(
-  "SkuImmutableError", "SKU_IMMUTABLE",
+  "SkuImmutableError", "ITEM_MANAGEMENT_SKU_IMMUTABLE",
   (identifier: string) => `Attempt to change the SKU field: ${identifier}`,
 );
 
 export const UomLockedError = createDomainError(
-  "UomLockedError", "UOM_LOCKED",
+  "UomLockedError", "ITEM_MANAGEMENT_UOM_LOCKED",
   (identifier: string) => `UoM cannot be changed after item has been activated (status is ACTIVE or INACTIVE): ${identifier}`,
 );
 
 export const NoFieldsToUpdateError = createDomainError(
-  "NoFieldsToUpdateError", "NO_FIELDS_TO_UPDATE",
+  "NoFieldsToUpdateError", "ITEM_MANAGEMENT_NO_FIELDS_TO_UPDATE",
   (identifier: string) => `No updatable fields were provided in the request: ${identifier}`,
 );
 
 export const CodeImmutableError = createDomainError(
-  "CodeImmutableError", "CODE_IMMUTABLE",
+  "CodeImmutableError", "ITEM_MANAGEMENT_CODE_IMMUTABLE",
   (identifier: string) => `Attempt to change the node code: ${identifier}`,
 );
 
 export const MissingRequiredFieldsError = createDomainError(
-  "MissingRequiredFieldsError", "MISSING_REQUIRED_FIELDS",
+  "MissingRequiredFieldsError", "ITEM_MANAGEMENT_MISSING_REQUIRED_FIELDS",
   (identifier: string) => `Name not provided or empty: ${identifier}`,
 );
 
 export const SelfReferenceError = createDomainError(
-  "SelfReferenceError", "SELF_REFERENCE",
+  "SelfReferenceError", "ITEM_MANAGEMENT_SELF_REFERENCE",
   (identifier: string) => `Node is moved to itself as parent — returns isCircular: true: ${identifier}`,
 );
 
 export const NoAssignmentsError = createDomainError(
-  "NoAssignmentsError", "NO_ASSIGNMENTS",
+  "NoAssignmentsError", "ITEM_MANAGEMENT_NO_ASSIGNMENTS",
   (identifier: string) => `No item assignments exist for the given node — caller receives empty array: ${identifier}`,
 );
 
 export const NoChildrenError = createDomainError(
-  "NoChildrenError", "NO_CHILDREN",
+  "NoChildrenError", "ITEM_MANAGEMENT_NO_CHILDREN",
   (identifier: string) => `No child nodes exist for the given parent — caller receives empty array: ${identifier}`,
 );

package/src/modules/item-management/lib/permissions.generated.ts

@@ -1,5 +1,5 @@
 // @generated — do not edit
-import { definePermissions } from "../../shared/internal";
+import { definePermissions } from "../../../shared";
 
 export const { permissions, own, all } = definePermissions("item-management", [
   "activateItem",

package/src/modules/item-management/lib/types.ts

@@ -1,4 +1,4 @@
-import type { InferSchema, Selectable, Insertable, Updateable } from "../../shared/internal";
+import type { InferSchema, Selectable, Insertable, Updateable } from "../../../shared";
 import type { DB } from "../generated/kysely-tailordb";
 
 export type Schema = InferSchema<DB>;

package/src/modules/item-management/module.ts

@@ -1,5 +1,5 @@
 import { type TailorAnyDBField } from "@tailor-platform/sdk";
-import { type EmptyFields, type FieldsToInsertable } from "../shared/internal";
+import { type EmptyFields, type FieldsToInsertable } from "../../shared";
 import type { defineModule as definePrimitivesModule } from "../primitives";
 import { createItem } from "./command/createItem.generated";
 import { updateItem } from "./command/updateItem.generated";

package/src/modules/item-management/query/calculateNodeDepth.generated.ts

@@ -1,5 +1,5 @@
 // @generated — do not edit
-import { defineQuery } from "../../shared/internal";
+import { defineQuery } from "../../../shared";
 import { run } from "./calculateNodeDepth";
 
 export const calculateNodeDepth = defineQuery(run);