@tailor-platform/erp-kit 0.1.1 → 0.2.0

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

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

@@ -0,0 +1,117 @@
+// @generated — do not edit
+import { createDomainError } from "../../shared/internal";
+
+export const ItemNotFoundError = createDomainError(
+  "ItemNotFoundError", "ITEM_NOT_FOUND",
+  (identifier: string) => `Specified item ID does not exist: ${identifier}`,
+);
+
+export const InvalidStateTransitionError = createDomainError(
+  "InvalidStateTransitionError", "INVALID_STATE_TRANSITION",
+  (identifier: string) => `Item is not in DRAFT status: ${identifier}`,
+);
+
+export const NodeNotFoundError = createDomainError(
+  "NodeNotFoundError", "NODE_NOT_FOUND",
+  (identifier: string) => `Specified taxonomy node ID does not exist: ${identifier}`,
+);
+
+export const DuplicateAssignmentError = createDomainError(
+  "DuplicateAssignmentError", "DUPLICATE_ASSIGNMENT",
+  (identifier: string) => `Item is already assigned to this taxonomy node: ${identifier}`,
+);
+
+export const DuplicateSkuError = createDomainError(
+  "DuplicateSkuError", "DUPLICATE_SKU",
+  (identifier: string) => `An item with the same SKU already exists: ${identifier}`,
+);
+
+export const DuplicateBarcodeError = createDomainError(
+  "DuplicateBarcodeError", "DUPLICATE_BARCODE",
+  (identifier: string) => `An item with the same barcode already exists: ${identifier}`,
+);
+
+export const UnitNotFoundError = createDomainError(
+  "UnitNotFoundError", "UNIT_NOT_FOUND",
+  (identifier: string) => `Referenced unit does not exist or is inactive: ${identifier}`,
+);
+
+export const DuplicateNodeCodeError = createDomainError(
+  "DuplicateNodeCodeError", "DUPLICATE_NODE_CODE",
+  (identifier: string) => `A node with the same code already exists: ${identifier}`,
+);
+
+export const ParentNodeNotFoundError = createDomainError(
+  "ParentNodeNotFoundError", "PARENT_NODE_NOT_FOUND",
+  (identifier: string) => `Specified parent node ID does not exist: ${identifier}`,
+);
+
+export const MaxDepthExceededError = createDomainError(
+  "MaxDepthExceededError", "MAX_DEPTH_EXCEEDED",
+  (identifier: string) => `Adding this child would exceed the configurable tree depth limit: ${identifier}`,
+);
+
+export const DeleteNonDraftError = createDomainError(
+  "DeleteNonDraftError", "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",
+  (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",
+  (identifier: string) => `Node has one or more item assignments — assignments must be removed first: ${identifier}`,
+);
+
+export const CircularReferenceError = createDomainError(
+  "CircularReferenceError", "CIRCULAR_REFERENCE",
+  (identifier: string) => `New parent is the node itself or one of its descendants: ${identifier}`,
+);
+
+export const AssignmentNotFoundError = createDomainError(
+  "AssignmentNotFoundError", "ASSIGNMENT_NOT_FOUND",
+  (identifier: string) => `No assignment exists for the specified item and taxonomy node combination: ${identifier}`,
+);
+
+export const SkuImmutableError = createDomainError(
+  "SkuImmutableError", "SKU_IMMUTABLE",
+  (identifier: string) => `Attempt to change the SKU field: ${identifier}`,
+);
+
+export const UomLockedError = createDomainError(
+  "UomLockedError", "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",
+  (identifier: string) => `No updatable fields were provided in the request: ${identifier}`,
+);
+
+export const CodeImmutableError = createDomainError(
+  "CodeImmutableError", "CODE_IMMUTABLE",
+  (identifier: string) => `Attempt to change the node code: ${identifier}`,
+);
+
+export const MissingRequiredFieldsError = createDomainError(
+  "MissingRequiredFieldsError", "MISSING_REQUIRED_FIELDS",
+  (identifier: string) => `Name not provided or empty: ${identifier}`,
+);
+
+export const SelfReferenceError = createDomainError(
+  "SelfReferenceError", "SELF_REFERENCE",
+  (identifier: string) => `Node is moved to itself as parent — returns isCircular: true: ${identifier}`,
+);
+
+export const NoAssignmentsError = createDomainError(
+  "NoAssignmentsError", "NO_ASSIGNMENTS",
+  (identifier: string) => `No item assignments exist for the given node — caller receives empty array: ${identifier}`,
+);
+
+export const NoChildrenError = createDomainError(
+  "NoChildrenError", "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

@@ -0,0 +1,17 @@
+// @generated — do not edit
+import { definePermissions } from "../../shared/internal";
+
+export const { permissions, own, all } = definePermissions("item-management", [
+  "activateItem",
+  "assignItemToTaxonomy",
+  "createItem",
+  "createTaxonomyNode",
+  "deactivateItem",
+  "deleteItem",
+  "deleteTaxonomyNode",
+  "moveTaxonomyNode",
+  "reactivateItem",
+  "removeItemFromTaxonomy",
+  "updateItem",
+  "updateTaxonomyNode",
+] as const);

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

@@ -0,0 +1,19 @@
+import type { InferSchema, Selectable, Insertable, Updateable } from "../../shared/internal";
+import type { DB } from "../generated/kysely-tailordb";
+
+export type Schema = InferSchema<DB>;
+
+export type Item<T extends { Item: object }> = Selectable<T["Item"]>;
+export type ItemCreate<T extends { Item: object }> = Insertable<T["Item"]>;
+export type ItemUpdate<T extends { Item: object }> = Updateable<T["Item"]>;
+
+export type TaxonomyNode<T extends { TaxonomyNode: object }> = Selectable<T["TaxonomyNode"]>;
+export type TaxonomyNodeCreate<T extends { TaxonomyNode: object }> = Insertable<T["TaxonomyNode"]>;
+export type TaxonomyNodeUpdate<T extends { TaxonomyNode: object }> = Updateable<T["TaxonomyNode"]>;
+
+export type ItemTaxonomyAssignment<T extends { ItemTaxonomyAssignment: object }> = Selectable<
+  T["ItemTaxonomyAssignment"]
+>;
+export type ItemTaxonomyAssignmentCreate<T extends { ItemTaxonomyAssignment: object }> = Insertable<
+  T["ItemTaxonomyAssignment"]
+>;

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

@@ -0,0 +1,97 @@
+import { type TailorAnyDBField } from "@tailor-platform/sdk";
+import { type EmptyFields, type FieldsToInsertable } from "../shared/internal";
+import type { defineModule as definePrimitivesModule } from "../primitives";
+import { createItem } from "./command/createItem.generated";
+import { updateItem } from "./command/updateItem.generated";
+import { activateItem } from "./command/activateItem.generated";
+import { deactivateItem } from "./command/deactivateItem.generated";
+import { reactivateItem } from "./command/reactivateItem.generated";
+import { deleteItem } from "./command/deleteItem.generated";
+import { createTaxonomyNode } from "./command/createTaxonomyNode.generated";
+import { updateTaxonomyNode } from "./command/updateTaxonomyNode.generated";
+import { moveTaxonomyNode } from "./command/moveTaxonomyNode.generated";
+import { deleteTaxonomyNode } from "./command/deleteTaxonomyNode.generated";
+import { assignItemToTaxonomy } from "./command/assignItemToTaxonomy.generated";
+import { removeItemFromTaxonomy } from "./command/removeItemFromTaxonomy.generated";
+import { getItem } from "./query/getItem.generated";
+import { getTaxonomyNode } from "./query/getTaxonomyNode.generated";
+import { getTaxonomyNodeChildren } from "./query/getTaxonomyNodeChildren.generated";
+import { getItemTaxonomyAssignment } from "./query/getItemTaxonomyAssignment.generated";
+import { getTaxonomyNodeAssignments } from "./query/getTaxonomyNodeAssignments.generated";
+import { calculateNodeDepth } from "./query/calculateNodeDepth.generated";
+import { calculateSubtreeDepth } from "./query/calculateSubtreeDepth.generated";
+import { detectCircularReference } from "./query/detectCircularReference.generated";
+import { createItemType, type CreateItemTypeParams } from "./db/item";
+import { createTaxonomyNodeType, type CreateTaxonomyNodeTypeParams } from "./db/taxonomyNode";
+import {
+  createItemTaxonomyAssignmentType,
+  type CreateItemTaxonomyAssignmentTypeParams,
+} from "./db/itemTaxonomyAssignment";
+
+type PrimitivesModule = ReturnType<typeof definePrimitivesModule>;
+type PrimitivesDB = PrimitivesModule["db"];
+export type PrimitivesQueries = PrimitivesModule["queries"];
+
+const DEFAULT_MAX_DEPTH = 10;
+
+export interface DefineModuleParams<
+  IF extends Record<string, TailorAnyDBField>,
+  TNF extends Record<string, TailorAnyDBField>,
+  ITAF extends Record<string, TailorAnyDBField>,
+> {
+  item?: CreateItemTypeParams<IF>;
+  taxonomyNode?: CreateTaxonomyNodeTypeParams<TNF>;
+  itemTaxonomyAssignment?: CreateItemTaxonomyAssignmentTypeParams<ITAF>;
+  taxonomy?: { maxDepth?: number };
+  primitives: {
+    db: { unit: PrimitivesDB["unit"] };
+    queries: { getUnit: PrimitivesQueries["getUnit"] };
+  };
+}
+
+export const defineModule = <
+  const IF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const TNF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const ITAF extends Record<string, TailorAnyDBField> = EmptyFields,
+>(
+  params: DefineModuleParams<IF, TNF, ITAF>,
+) => {
+  const item = createItemType({
+    ...params.item,
+    unitType: params.primitives.db.unit,
+  });
+  const taxonomyNode = createTaxonomyNodeType(params.taxonomyNode ?? {});
+  const itemTaxonomyAssignment = createItemTaxonomyAssignmentType(
+    params.itemTaxonomyAssignment ?? {},
+  );
+
+  const maxDepth = params.taxonomy?.maxDepth ?? DEFAULT_MAX_DEPTH;
+
+  return {
+    db: { item, taxonomyNode, itemTaxonomyAssignment },
+    queries: {
+      getItem,
+      getTaxonomyNode,
+      getTaxonomyNodeChildren,
+      getItemTaxonomyAssignment,
+      getTaxonomyNodeAssignments,
+      calculateNodeDepth,
+      calculateSubtreeDepth,
+      detectCircularReference,
+    },
+    commands: {
+      createItem: createItem<FieldsToInsertable<IF>>(params.primitives.queries),
+      updateItem: updateItem<FieldsToInsertable<IF>>(params.primitives.queries),
+      activateItem: activateItem(),
+      deactivateItem: deactivateItem(),
+      reactivateItem: reactivateItem(),
+      deleteItem: deleteItem(),
+      createTaxonomyNode: createTaxonomyNode<FieldsToInsertable<TNF>>({ maxDepth }),
+      updateTaxonomyNode: updateTaxonomyNode<FieldsToInsertable<TNF>>(),
+      moveTaxonomyNode: moveTaxonomyNode({ maxDepth }),
+      deleteTaxonomyNode: deleteTaxonomyNode(),
+      assignItemToTaxonomy: assignItemToTaxonomy(),
+      removeItemFromTaxonomy: removeItemFromTaxonomy(),
+    },
+  };
+};

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

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