@tailor-platform/erp-kit 0.1.2 → 0.2.0

package/src/modules/item-management/docs/features/item-taxonomy.md

@@ -0,0 +1,65 @@
+# Item Taxonomy
+
+## Overview
+
+Item Taxonomy organizes items using a structured, hierarchical classification system. Taxonomy nodes form a tree where each node can have a parent, creating multi-level classification (e.g., "Electronics > Computers > Laptops"). Items are linked to taxonomy nodes through a many-to-many relationship, allowing a single item to belong to multiple classification branches simultaneously (e.g., both "Electronics > Smartphones" and "Gift Ideas > Tech Gifts").
+
+## Business Purpose
+
+As item catalogs grow, a single flat category structure is insufficient. Item Taxonomy addresses this by:
+
+- Enabling multi-dimensional item classification — an item can belong to multiple taxonomy branches
+- Supporting hierarchical browsing and filtering of large item catalogs
+- Enabling consistent item grouping for operations and reporting
+- Organizing items for different audiences (internal operations, eCommerce, procurement)
+- Providing a flexible foundation for future classification needs without restructuring existing data
+- Stable node identification via globally unique code for API references and integrations
+
+## Process Flow
+
+```mermaid
+flowchart TD
+    A[Create Root Taxonomy Node] --> B[Create Child Node]
+    B --> C{More Levels?}
+    C -->|Yes| B
+    C -->|No| D[Assign Items to Taxonomy Nodes]
+    D --> E{Move Node?}
+    E -->|Yes| F[Validate No Circular Reference]
+    F --> G[Update Parent]
+    G --> H[Children Move With Parent]
+    E -->|No| I{Delete Node?}
+    I -->|Yes| J{Has Children or Item Assignments?}
+    J -->|Yes| K[Block Deletion]
+    J -->|No| L[Delete Node]
+    I -->|No| M[Node Active]
+```
+
+## Scenario Patterns
+
+- **Initial Taxonomy Setup**: Administrator creates root nodes with unique codes (e.g., "electronics", "clothing") and populates child nodes for each classification branch
+- **Deep Hierarchy**: "Clothing > Men > Outerwear > Jackets > Winter Jackets" — five levels deep for detailed classification
+- **Multi-Classification**: A "Bluetooth Headset" item is assigned to both "Electronics > Audio" and "Accessories > Travel" taxonomy nodes simultaneously
+- **Node Reparenting**: "Accessories" node moved from under "Clothing" to a root-level node, all child nodes and item assignments preserved
+- **Taxonomy Standards**: "Electronics" node groups items such as laptops, monitors, and accessories under a common branch for operational consistency
+- **Node Rename**: Administrator renames "Accessories" to "Travel Accessories" to better reflect the node's contents — child nodes and item assignments are unaffected
+- **Node Merge**: Two similar nodes consolidated by moving item assignments from one to the other, then deleting the empty node
+- **Reporting by Taxonomy**: Sales report grouped by top-level taxonomy node shows revenue breakdown across item groups (cross-module dependency: reporting/analytics module consumes taxonomy hierarchy)
+
+## Test Cases
+
+- Node code must be globally unique across all taxonomy nodes
+- Node code is immutable after creation; only the display name can be updated
+- Moving a node under its own descendant should fail (circular reference prevention)
+- Deleting a node with child nodes should be blocked
+- Deleting a node with assigned items should be blocked
+- Root nodes have no parent (null parent reference)
+- An item can be assigned to multiple taxonomy nodes
+- Removing an item-taxonomy assignment does not affect the item or other assignments
+- Duplicate item-taxonomy assignments (same item + same node) should be rejected
+- Node tree depth should have a configurable maximum to prevent excessively deep hierarchies
+
+## Reference Links
+
+- [Akeneo Product Classification](https://docs.akeneo.com/serenity-2025-02/articles/manage-your-categories.html)
+- [Salsify Taxonomy Management](https://www.salsify.com/resources/content/product-taxonomy-management)
+- [Odoo Product Categories](https://www.odoo.com/documentation/19.0/applications/inventory_and_mrp/inventory/product_management.html)

package/src/modules/item-management/docs/models/ItemTaxonomyAssignment.md

@@ -0,0 +1,36 @@
+# ItemTaxonomyAssignment
+
+## Description
+
+ItemTaxonomyAssignment is a join entity that links an Item to a TaxonomyNode, enabling many-to-many classification. A single item can belong to multiple taxonomy branches simultaneously (e.g., both "Electronics > Smartphones" and "Gift Ideas > Tech Gifts"), and a single taxonomy node can have multiple items assigned.
+
+## Domain Model Definitions
+
+### Model type
+
+Standard
+
+### Command Definitions
+
+- [assignItemToTaxonomy](../commands/AssignItemToTaxonomy.md) - Link an item to a taxonomy node
+- [removeItemFromTaxonomy](../commands/RemoveItemFromTaxonomy.md) - Remove a link between an item and a taxonomy node
+
+### Query Definitions
+
+- [GetItemTaxonomyAssignment](../queries/GetItemTaxonomyAssignment.md) - Retrieve an assignment by itemId and taxonomyNodeId
+- [GetTaxonomyNodeAssignments](../queries/GetTaxonomyNodeAssignments.md) - Retrieve item assignments for a given taxonomy node
+
+### Models
+
+- ItemTaxonomyAssignment
+
+### Invariants
+
+- The combination of item and taxonomy node must be unique (no duplicate assignments)
+- The referenced item must exist
+- The referenced taxonomy node must exist
+
+### Relationships
+
+- **References Item**: Each assignment references exactly one Item
+- **References TaxonomyNode**: Each assignment references exactly one TaxonomyNode

package/src/modules/item-management/docs/models/TaxonomyNode.md

@@ -0,0 +1,47 @@
+# TaxonomyNode
+
+## Description
+
+TaxonomyNode represents a single node in a hierarchical classification tree used to organize items. Each node has a globally unique code, a display name, and an optional parent reference that defines its position in the tree. Root nodes have no parent. Nodes can be reparented to restructure the tree, and children move with their parent.
+
+Examples: "electronics", "electronics > computers", "electronics > computers > laptops".
+
+## Domain Model Definitions
+
+### Model type
+
+Standard
+
+### Command Definitions
+
+- [createTaxonomyNode](../commands/CreateTaxonomyNode.md) - Create a new root or child taxonomy node
+- [updateTaxonomyNode](../commands/UpdateTaxonomyNode.md) - Update the display name of an existing node
+- [moveTaxonomyNode](../commands/MoveTaxonomyNode.md) - Reparent a node within the tree
+- [deleteTaxonomyNode](../commands/DeleteTaxonomyNode.md) - Delete a leaf node with no item assignments
+
+### Query Definitions
+
+- [GetTaxonomyNode](../queries/GetTaxonomyNode.md) - Retrieve a taxonomy node by id or code
+- [GetTaxonomyNodeChildren](../queries/GetTaxonomyNodeChildren.md) - Retrieve direct child nodes of a given node
+- [CalculateNodeDepth](../queries/CalculateNodeDepth.md) - Calculate the depth of a node from root by walking the ancestor chain
+- [CalculateSubtreeDepth](../queries/CalculateSubtreeDepth.md) - Recursively calculate the maximum depth of a node's subtree
+- [DetectCircularReference](../queries/DetectCircularReference.md) - Validate that reparenting would not create a cycle
+
+### Models
+
+- TaxonomyNode
+
+### Invariants
+
+- Node code must be globally unique across all taxonomy nodes
+- Node code is immutable after creation — it cannot be changed once assigned
+- Root nodes have a null parent reference
+- A node cannot be moved under its own descendant (circular reference prevention)
+- Node tree depth has a configurable maximum (default 10) to prevent excessively deep hierarchies
+- A node with child nodes cannot be deleted
+- A node with assigned items cannot be deleted
+
+### Relationships
+
+- **Self-Referential Parent-Child**: Each node optionally references another TaxonomyNode as its parent, forming a tree
+- **Referenced By Item Assignments**: TaxonomyNodes are linked to Items via ItemTaxonomyAssignment (many-to-many)

package/src/modules/item-management/docs/models/item.md

@@ -0,0 +1,59 @@
+# item
+
+## Description
+
+Item is the fundamental SKU-level entity in the ERP system — the sellable, purchasable, and trackable unit referenced by all downstream modules (Sales, Purchasing, Inventory, Manufacturing). Each item has a lifecycle state machine (DRAFT → ACTIVE ↔ INACTIVE), a globally unique SKU identifier, an optional barcode, and an assigned unit of measure.
+
+Items can be created in either DRAFT or ACTIVE status. DRAFT items require explicit activation before participating in transactions.
+
+## Domain Model Definitions
+
+### Model type
+
+Stateful
+
+#### State Transitions
+
+```mermaid
+stateDiagram-v2
+    [*] --> Draft: createItem (draft)
+    [*] --> Active: createItem (active)
+    Draft --> Active: activateItem
+    Active --> Inactive: deactivateItem
+    Inactive --> Active: reactivateItem
+    Draft --> [*]: deleteItem
+```
+
+### Command Definitions
+
+- [createItem](../commands/CreateItem.md) - Create a new item in DRAFT or ACTIVE status
+- [updateItem](../commands/UpdateItem.md) - Update mutable fields (name, barcode, UoM) of an existing item
+- [activateItem](../commands/ActivateItem.md) - Transition item from DRAFT to ACTIVE
+- [deactivateItem](../commands/DeactivateItem.md) - Transition item from ACTIVE to INACTIVE
+- [reactivateItem](../commands/ReactivateItem.md) - Transition item from INACTIVE to ACTIVE
+- [deleteItem](../commands/DeleteItem.md) - Permanently delete a DRAFT item
+
+### Query Definitions
+
+- [GetItem](../queries/GetItem.md) - Retrieve an item by id, sku, or barcode
+
+### Models
+
+- Item
+
+### Invariants
+
+- SKU is required and must be globally unique across all items regardless of status
+- SKU is immutable after assignment (cannot be changed once set)
+- Barcode must be unique across all items when provided
+- Barcode can be updated after creation
+- Only DRAFT items can be deleted; ACTIVE and INACTIVE items are preserved for audit trails
+- Only ACTIVE items can be referenced in new transactions (sales orders, purchase orders)
+- Name is required at creation time
+- UoM can be updated only in DRAFT status — once activated, UoM is locked to preserve transaction consistency
+
+### Relationships
+
+- **References Unit**: Each item references a Unit from the primitives module as its unit of measure
+- **Referenced By Taxonomy Assignments**: Items are linked to TaxonomyNodes via ItemTaxonomyAssignment (many-to-many)
+- **Referenced By Downstream Modules**: Items are referenced by Sales, Purchasing, Inventory, and Manufacturing modules

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

@@ -0,0 +1,36 @@
+# CalculateNodeDepth
+
+## Overview
+
+CalculateNodeDepth determines the depth of a taxonomy node in the tree hierarchy by walking up the ancestor chain from a given node to the root. Depth is defined as the number of nodes in the path from root to the target node (root = depth 1). This is essential for enforcing maximum depth constraints when creating or moving taxonomy nodes.
+
+## Business Rules
+
+- Depth is calculated by traversing parentId references from the target node up to the root
+- Root nodes (parentId = null) have depth 1
+- Each additional ancestor increments the depth by 1
+- The traversal stops when a node with parentId = null is reached or a parent is not found
+- Used together with maxDepth parameter (default: 10) to enforce tree depth limits
+
+## Process Flow
+
+```mermaid
+flowchart TD
+    A[Receive nodeId] --> B[Initialize depth = 1, currentId = nodeId]
+    B --> C[SELECT node where id = currentId]
+    C --> D{Node found?}
+    D -->|No| E[Return current depth]
+    D -->|Yes| F{parentId is null?}
+    F -->|Yes| E
+    F -->|No| G[Increment depth]
+    G --> H[Set currentId = parentId]
+    H --> C
+```
+
+## External Dependencies
+
+- None
+
+## Error Scenarios
+
+- **NODE_NOT_FOUND**: The starting node or an ancestor in the chain is not found — traversal stops and returns partial depth

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

@@ -0,0 +1,40 @@
+# CalculateSubtreeDepth
+
+## Overview
+
+CalculateSubtreeDepth recursively calculates the maximum depth of a node's subtree, including the node itself. This is used in conjunction with CalculateNodeDepth to determine the total tree depth after a move operation, ensuring the combined depth does not exceed the maximum allowed depth.
+
+## Business Rules
+
+- A leaf node (no children) has subtree depth of 1
+- For nodes with children, subtree depth = 1 + max(child subtree depths)
+- All children are fetched by querying parentId = nodeId
+- Recursion continues until leaf nodes are reached
+- The calculation is exhaustive — it traverses the entire subtree
+
+## Process Flow
+
+```mermaid
+flowchart TD
+    A[Receive nodeId] --> B[SELECT all children where parentId = nodeId]
+    B --> C{Has children?}
+    C -->|No| D[Return 1]
+    C -->|Yes| E[Initialize maxChildDepth = 0]
+    E --> F[For each child]
+    F --> G[Recursively calculate child subtree depth]
+    G --> H{childDepth > maxChildDepth?}
+    H -->|Yes| I[Update maxChildDepth = childDepth]
+    H -->|No| J[Continue to next child]
+    I --> J
+    J --> K{More children?}
+    K -->|Yes| F
+    K -->|No| L[Return 1 + maxChildDepth]
+```
+
+## External Dependencies
+
+- None
+
+## Error Scenarios
+
+- **MAX_DEPTH_EXCEEDED**: Combined new parent depth + subtree depth exceeds maxDepth — enforced by the calling command, not this query directly

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

@@ -0,0 +1,41 @@
+# DetectCircularReference
+
+## Overview
+
+DetectCircularReference validates that reparenting a taxonomy node would not create a circular reference in the tree hierarchy. It walks up the ancestor chain from the proposed new parent, checking whether the node being moved appears as an ancestor. If the moved node is found in the ancestor chain, the move would create a cycle.
+
+## Business Rules
+
+- A node cannot be moved to become a descendant of itself
+- Self-referencing is explicitly rejected: newParentId === nodeId
+- Ancestor chain is traversed from the new parent upward to the root
+- If the moved node's ID is found in the ancestor chain, the move is circular
+- Traversal stops at root (parentId = null) or broken chain (parent not found)
+- Only relevant when newParentId is non-null (promoting to root cannot create a cycle)
+
+## Process Flow
+
+```mermaid
+flowchart TD
+    A[Receive nodeId + newParentId] --> B{newParentId === nodeId?}
+    B -->|Yes| C[Return isCircular: true]
+    B -->|No| D[Set ancestorId = newParentId]
+    D --> E[SELECT ancestor where id = ancestorId]
+    E --> F{Ancestor found?}
+    F -->|No| G[Return isCircular: false]
+    F -->|Yes| H[Set ancestorId = ancestor.parentId]
+    H --> I{ancestorId === nodeId?}
+    I -->|Yes| C
+    I -->|No| J{ancestorId is null?}
+    J -->|Yes| G
+    J -->|No| E
+```
+
+## External Dependencies
+
+- None
+
+## Error Scenarios
+
+- **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

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

@@ -0,0 +1,38 @@
+# GetItem
+
+## Overview
+
+GetItem retrieves a single item record by id, sku, or barcode. The input is a union type — callers specify exactly one lookup field. This serves as the core item lookup for existence checks, uniqueness validation, and all item lifecycle commands.
+
+## Business Rules
+
+- Accepts one of three lookup variants:
+  - `{ id }` — retrieves by unique identifier (most common, used for existence/state checks)
+  - `{ sku }` — retrieves by SKU code (used for uniqueness validation during creation; SKU is immutable after creation)
+  - `{ barcode }` — retrieves by barcode (used for uniqueness validation)
+- Returns the full item record including all fields (id, sku, name, barcode, unitId, status, timestamps)
+- Returns null if no matching item is found
+- All comparisons are exact (case-sensitive)
+
+## Process Flow
+
+```mermaid
+flowchart TD
+    A[Receive input] --> B{Which field?}
+    B -->|id| C[SELECT from Item where id = input.id]
+    B -->|sku| D[SELECT from Item where sku = input.sku]
+    B -->|barcode| E[SELECT from Item where barcode = input.barcode]
+    C --> H{Item found?}
+    D --> H
+    E --> H
+    H -->|Yes| I[Return item record]
+    H -->|No| J[Return null]
+```
+
+## External Dependencies
+
+- None
+
+## Error Scenarios
+
+- **ITEM_NOT_FOUND**: No item matches the given criteria — caller receives null

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

@@ -0,0 +1,29 @@
+# GetItemTaxonomyAssignment
+
+## Overview
+
+GetItemTaxonomyAssignment retrieves a specific item-to-taxonomy-node assignment by the composite key of itemId and taxonomyNodeId. Used for duplicate detection during assignment creation and existence verification before removal.
+
+## Business Rules
+
+- Searches ItemTaxonomyAssignment table using both itemId AND taxonomyNodeId as a composite filter
+- Returns the full assignment record if found (id, itemId, taxonomyNodeId, timestamps)
+- Returns null if no assignment exists for the given pair
+
+## Process Flow
+
+```mermaid
+flowchart TD
+    A[Receive itemId + taxonomyNodeId] --> B[SELECT from ItemTaxonomyAssignment where itemId = input AND taxonomyNodeId = input]
+    B --> C{Assignment found?}
+    C -->|Yes| D[Return assignment record]
+    C -->|No| E[Return null]
+```
+
+## External Dependencies
+
+- None
+
+## Error Scenarios
+
+- **ASSIGNMENT_NOT_FOUND**: No assignment exists for the item-node pair — caller receives null

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

@@ -0,0 +1,35 @@
+# GetTaxonomyNode
+
+## Overview
+
+GetTaxonomyNode retrieves a single taxonomy node by id or code. The input is a union type — callers specify exactly one lookup field. This serves as the core taxonomy node lookup for existence checks, uniqueness validation, and as the starting point for tree traversal operations.
+
+## Business Rules
+
+- Accepts one of two lookup variants:
+  - `{ id }` — retrieves by unique identifier (used for existence checks and tree operations)
+  - `{ code }` — retrieves by code (used for uniqueness validation during creation; code is immutable after creation)
+- Returns the full taxonomy node record (id, code, name, parentId, timestamps)
+- Returns null if no matching node is found
+- All comparisons are exact (case-sensitive)
+
+## Process Flow
+
+```mermaid
+flowchart TD
+    A[Receive input] --> B{Which field?}
+    B -->|id| C[SELECT from TaxonomyNode where id = input.id]
+    B -->|code| D[SELECT from TaxonomyNode where code = input.code]
+    C --> E{Node found?}
+    D --> E
+    E -->|Yes| F[Return node record]
+    E -->|No| G[Return null]
+```
+
+## External Dependencies
+
+- None
+
+## Error Scenarios
+
+- **NODE_NOT_FOUND**: No taxonomy node matches the given criteria — caller receives null

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

@@ -0,0 +1,29 @@
+# GetTaxonomyNodeAssignments
+
+## Overview
+
+GetTaxonomyNodeAssignments retrieves item assignments for a given taxonomy node. Used as a guard check before node deletion to ensure no items are classified under the node being removed.
+
+## Business Rules
+
+- Searches ItemTaxonomyAssignment table for records with taxonomyNodeId matching the given node ID
+- Returns all matching assignment records as an array
+- Returns an empty array if the node has no item assignments
+
+## Process Flow
+
+```mermaid
+flowchart TD
+    A[Receive taxonomyNodeId] --> B[SELECT from ItemTaxonomyAssignment where taxonomyNodeId = input]
+    B --> C{Assignments found?}
+    C -->|Yes| D[Return assignment records]
+    C -->|No| E[Return empty array]
+```
+
+## External Dependencies
+
+- None
+
+## Error Scenarios
+
+- **NO_ASSIGNMENTS**: No item assignments exist for the given node — caller receives empty array

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

@@ -0,0 +1,29 @@
+# GetTaxonomyNodeChildren
+
+## Overview
+
+GetTaxonomyNodeChildren retrieves the direct child nodes of a given taxonomy node. Used as a guard check before node deletion to enforce the constraint that only leaf nodes can be deleted.
+
+## Business Rules
+
+- Searches TaxonomyNode table for records with parentId matching the given node ID
+- Returns all matching child node records as an array
+- Returns an empty array if the node has no children (is a leaf node)
+
+## Process Flow
+
+```mermaid
+flowchart TD
+    A[Receive parentId] --> B[SELECT from TaxonomyNode where parentId = input]
+    B --> C{Children found?}
+    C -->|Yes| D[Return child records]
+    C -->|No| E[Return empty array]
+```
+
+## External Dependencies
+
+- None
+
+## Error Scenarios
+
+- **NO_CHILDREN**: No child nodes exist for the given parent — caller receives empty array

package/src/modules/item-management/generated/enums.ts

@@ -0,0 +1,9 @@
+/**
+ * Lifecycle status: DRAFT, ACTIVE, INACTIVE
+ */
+export const ItemStatus = {
+  "DRAFT": "DRAFT",
+  "ACTIVE": "ACTIVE",
+  "INACTIVE": "INACTIVE"
+} as const;
+export type ItemStatus = (typeof ItemStatus)[keyof typeof ItemStatus];

package/src/modules/item-management/generated/kysely-tailordb.ts

@@ -0,0 +1,62 @@
+import {
+  createGetDB,
+  type Generated,
+  type Timestamp,
+  type NamespaceDB,
+  type NamespaceInsertable,
+  type NamespaceSelectable,
+  type NamespaceTable,
+  type NamespaceTableName,
+  type NamespaceTransaction,
+  type NamespaceUpdateable,
+} from "@tailor-platform/sdk/kysely";
+
+export interface Namespace {
+  "main-db": {
+    Item: {
+      id: Generated<string>;
+      sku: string;
+      name: string;
+      barcode: string | null;
+      unitId: string;
+      status: "DRAFT" | "ACTIVE" | "INACTIVE";
+      createdAt: Generated<Timestamp>;
+      updatedAt: Timestamp | null;
+    }
+
+    ItemTaxonomyAssignment: {
+      id: Generated<string>;
+      itemId: string;
+      taxonomyNodeId: string;
+      createdAt: Generated<Timestamp>;
+      updatedAt: Timestamp | null;
+    }
+
+    TaxonomyNode: {
+      id: Generated<string>;
+      code: string;
+      name: string;
+      parentId: string | null;
+      createdAt: Generated<Timestamp>;
+      updatedAt: Timestamp | null;
+    }
+
+    Unit: {
+      id: Generated<string>;
+    }
+  }
+}
+
+export const getDB = createGetDB<Namespace>();
+
+export type DB<N extends keyof Namespace = keyof Namespace> = NamespaceDB<Namespace, N>;
+
+export type Transaction<K extends keyof Namespace | DB = keyof Namespace> =
+  NamespaceTransaction<Namespace, K>;
+
+type TableName = NamespaceTableName<Namespace>;
+export type Table<T extends TableName> = NamespaceTable<Namespace, T>;
+
+export type Insertable<T extends TableName> = NamespaceInsertable<Namespace, T>;
+export type Selectable<T extends TableName> = NamespaceSelectable<Namespace, T>;
+export type Updateable<T extends TableName> = NamespaceUpdateable<Namespace, T>;

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

@@ -0,0 +1,53 @@
+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/_db_deps.ts

@@ -0,0 +1,13 @@
+// Stub types for cross-module dependencies — used only for codegen.
+// At runtime, actual types are injected via defineModule() params.
+// TODO: Replace with SDK-level externalTypes support when available.
+import {
+  db,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+
+export const unit = db
+  .type("Unit", {})
+  .permission(unsafeAllowAllTypePermission)
+  .gqlPermission(unsafeAllowAllGqlPermission);