@tailor-platform/erp-kit 0.2.1 → 0.3.0

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

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../testing/index";
+import { createMockDb } from "../../../testing/index";
 import type { DB } from "../generated/kysely-tailordb";
 import { baseRootNode, baseChildNode, baseLeafNode } from "../testing/fixtures";
 import { run } from "./calculateNodeDepth";
@@ -11,7 +11,10 @@ describe("calculateNodeDepth", () => {
 
     const result = await run(db, { nodeId: "node-1" });
 
-    expect(result.depth).toBe(1);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.depth).toBe(1);
+    }
   });
 
   it("returns depth 2 for child of root", async () => {
@@ -20,7 +23,10 @@ describe("calculateNodeDepth", () => {
 
     const result = await run(db, { nodeId: "node-2" });
 
-    expect(result.depth).toBe(2);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.depth).toBe(2);
+    }
   });
 
   it("returns depth 3 for grandchild of root", async () => {
@@ -32,7 +38,10 @@ describe("calculateNodeDepth", () => {
 
     const result = await run(db, { nodeId: "node-3" });
 
-    expect(result.depth).toBe(3);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.depth).toBe(3);
+    }
   });
 
   it("returns depth 1 when node not found", async () => {
@@ -41,7 +50,10 @@ describe("calculateNodeDepth", () => {
 
     const result = await run(db, { nodeId: "nonexistent" });
 
-    expect(result.depth).toBe(1);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.depth).toBe(1);
+    }
   });
 
   it("handles broken ancestor chain gracefully", async () => {
@@ -51,6 +63,9 @@ describe("calculateNodeDepth", () => {
 
     const result = await run(db, { nodeId: "node-2" });
 
-    expect(result.depth).toBe(2);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.depth).toBe(2);
+    }
   });
 });

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

@@ -1,4 +1,4 @@
-import type { ReadonlyDB } from "../../shared/internal";
+import { ok, type ReadonlyDB } from "../../../shared";
 import type { DB } from "../generated/kysely-tailordb";
 
 export interface CalculateNodeDepthInput {
@@ -24,5 +24,5 @@ export async function run(db: ReadonlyDB<DB>, input: CalculateNodeDepthInput) {
     currentId = node.parentId;
   }
 
-  return { depth };
+  return ok({ depth });
 }

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

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

package/src/modules/item-management/query/calculateSubtreeDepth.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../testing/index";
+import { createMockDb } from "../../../testing/index";
 import type { DB } from "../generated/kysely-tailordb";
 import { baseChildNode, baseLeafNode } from "../testing/fixtures";
 import { run } from "./calculateSubtreeDepth";
@@ -11,7 +11,10 @@ describe("calculateSubtreeDepth", () => {
 
     const result = await run(db, { nodeId: "node-3" });
 
-    expect(result.depth).toBe(1);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.depth).toBe(1);
+    }
   });
 
   it("returns 2 for node with one level of children", async () => {
@@ -20,7 +23,10 @@ describe("calculateSubtreeDepth", () => {
 
     const result = await run(db, { nodeId: "node-1" });
 
-    expect(result.depth).toBe(2);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.depth).toBe(2);
+    }
   });
 
   it("returns 3 for node with two levels of children", async () => {
@@ -32,7 +38,10 @@ describe("calculateSubtreeDepth", () => {
 
     const result = await run(db, { nodeId: "node-1" });
 
-    expect(result.depth).toBe(3);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.depth).toBe(3);
+    }
   });
 
   it("returns max depth for node with multiple branches", async () => {
@@ -70,6 +79,9 @@ describe("calculateSubtreeDepth", () => {
 
     const result = await run(db, { nodeId: "node-1" });
 
-    expect(result.depth).toBe(3);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.depth).toBe(3);
+    }
   });
 });

package/src/modules/item-management/query/calculateSubtreeDepth.ts

@@ -1,4 +1,4 @@
-import type { ReadonlyDB } from "../../shared/internal";
+import { ok, type ReadonlyDB } from "../../../shared";
 import type { DB } from "../generated/kysely-tailordb";
 
 export interface CalculateSubtreeDepthInput {
@@ -25,5 +25,5 @@ async function getSubtreeDepth(db: ReadonlyDB<DB>, nodeId: string): Promise<numb
 
 export async function run(db: ReadonlyDB<DB>, input: CalculateSubtreeDepthInput) {
   const depth = await getSubtreeDepth(db, input.nodeId);
-  return { depth };
+  return ok({ depth });
 }

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

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

package/src/modules/item-management/query/detectCircularReference.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../testing/index";
+import { createMockDb } from "../../../testing/index";
 import type { DB } from "../generated/kysely-tailordb";
 import { baseRootNode, baseChildNode, baseLeafNode } from "../testing/fixtures";
 import { run } from "./detectCircularReference";
@@ -10,7 +10,10 @@ describe("detectCircularReference", () => {
 
     const result = await run(db, { nodeId: "node-1", newParentId: "node-1" });
 
-    expect(result.isCircular).toBe(true);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.isCircular).toBe(true);
+    }
   });
 
   it("detects moving node under its child as circular", async () => {
@@ -19,7 +22,10 @@ describe("detectCircularReference", () => {
 
     const result = await run(db, { nodeId: "node-1", newParentId: "node-2" });
 
-    expect(result.isCircular).toBe(true);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.isCircular).toBe(true);
+    }
   });
 
   it("detects moving node under its grandchild as circular", async () => {
@@ -28,7 +34,10 @@ describe("detectCircularReference", () => {
 
     const result = await run(db, { nodeId: "node-1", newParentId: "node-3" });
 
-    expect(result.isCircular).toBe(true);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.isCircular).toBe(true);
+    }
   });
 
   it("returns not circular for valid move", async () => {
@@ -38,7 +47,10 @@ describe("detectCircularReference", () => {
 
     const result = await run(db, { nodeId: "node-3", newParentId: "node-4" });
 
-    expect(result.isCircular).toBe(false);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.isCircular).toBe(false);
+    }
   });
 
   it("returns not circular when new parent is root", async () => {
@@ -47,7 +59,10 @@ describe("detectCircularReference", () => {
 
     const result = await run(db, { nodeId: "node-2", newParentId: "node-1" });
 
-    expect(result.isCircular).toBe(false);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.isCircular).toBe(false);
+    }
   });
 
   it("handles broken ancestor chain gracefully (not circular)", async () => {
@@ -56,6 +71,9 @@ describe("detectCircularReference", () => {
 
     const result = await run(db, { nodeId: "node-1", newParentId: "missing-node" });
 
-    expect(result.isCircular).toBe(false);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.isCircular).toBe(false);
+    }
   });
 });

package/src/modules/item-management/query/detectCircularReference.ts

@@ -1,4 +1,4 @@
-import type { ReadonlyDB } from "../../shared/internal";
+import { ok, type ReadonlyDB } from "../../../shared";
 import type { DB } from "../generated/kysely-tailordb";
 
 export interface DetectCircularReferenceInput {
@@ -8,7 +8,7 @@ export interface DetectCircularReferenceInput {
 
 export async function run(db: ReadonlyDB<DB>, input: DetectCircularReferenceInput) {
   if (input.newParentId === input.nodeId) {
-    return { isCircular: true };
+    return ok({ isCircular: true });
   }
 
   // Walk up from new parent to root, checking if the moved node appears
@@ -24,9 +24,9 @@ export async function run(db: ReadonlyDB<DB>, input: DetectCircularReferenceInpu
 
     ancestorId = ancestor.parentId;
     if (ancestorId === input.nodeId) {
-      return { isCircular: true };
+      return ok({ isCircular: true });
     }
   }
 
-  return { isCircular: false };
+  return ok({ isCircular: false });
 }

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

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