@tailor-platform/erp-kit 0.2.0 → 0.2.2

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

@@ -0,0 +1,100 @@
+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": {
+    Product: {
+      id: Generated<string>;
+      code: string;
+      name: string;
+      description: string | null;
+      unitId: string;
+      status: "DRAFT" | "ACTIVE" | "ARCHIVED";
+      createdAt: Generated<Timestamp>;
+      updatedAt: Timestamp | null;
+    }
+
+    ProductAttribute: {
+      id: Generated<string>;
+      code: string;
+      name: string;
+      createdAt: Generated<Timestamp>;
+      updatedAt: Timestamp | null;
+    }
+
+    ProductAttributeAssignment: {
+      id: Generated<string>;
+      productId: string;
+      attributeId: string;
+      valueId: string;
+      createdAt: Generated<Timestamp>;
+      updatedAt: Timestamp | null;
+    }
+
+    ProductAttributeValue: {
+      id: Generated<string>;
+      attributeId: string;
+      label: string;
+      createdAt: Generated<Timestamp>;
+      updatedAt: Timestamp | null;
+    }
+
+    ProductCategory: {
+      id: Generated<string>;
+      code: string;
+      name: string;
+      parentId: string | null;
+      createdAt: Generated<Timestamp>;
+      updatedAt: Timestamp | null;
+    }
+
+    ProductCategoryAssignment: {
+      id: Generated<string>;
+      productId: string;
+      categoryId: string;
+      createdAt: Generated<Timestamp>;
+      updatedAt: Timestamp | null;
+    }
+
+    ProductVariant: {
+      id: Generated<string>;
+      productId: string;
+      axisValueKey: string;
+      itemId: string;
+      createdAt: Generated<Timestamp>;
+      updatedAt: Timestamp | null;
+    }
+
+    Item: {
+      id: Generated<string>;
+    }
+
+    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/product-management/index.ts

@@ -0,0 +1,2 @@
+export { defineModule } from "./module";
+export { permissions, own, all } from "./lib/permissions.generated";

package/src/modules/product-management/lib/_db_deps.ts

@@ -0,0 +1,17 @@
+// Stub types for cross-module dependencies — used only for codegen.
+// At runtime, actual types are injected via defineModule() params.
+import {
+  db,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+
+export const unit = db
+  .type("Unit", {})
+  .permission(unsafeAllowAllTypePermission)
+  .gqlPermission(unsafeAllowAllGqlPermission);
+
+export const item = db
+  .type("Item", {})
+  .permission(unsafeAllowAllTypePermission)
+  .gqlPermission(unsafeAllowAllGqlPermission);

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

@@ -0,0 +1,152 @@
+// @generated — do not edit
+import { createDomainError } from "../../../shared";
+
+export const ProductNotFoundError = createDomainError(
+  "ProductNotFoundError", "PRODUCT_MANAGEMENT_PRODUCT_NOT_FOUND",
+  (identifier: string) => `Specified product ID does not exist: ${identifier}`,
+);
+
+export const InvalidStateTransitionError = createDomainError(
+  "InvalidStateTransitionError", "PRODUCT_MANAGEMENT_INVALID_STATE_TRANSITION",
+  (identifier: string) => `Product is not in DRAFT status: ${identifier}`,
+);
+
+export const CategoryNotFoundError = createDomainError(
+  "CategoryNotFoundError", "PRODUCT_MANAGEMENT_CATEGORY_NOT_FOUND",
+  (identifier: string) => `Specified category ID does not exist: ${identifier}`,
+);
+
+export const DuplicateCodeError = createDomainError(
+  "DuplicateCodeError", "PRODUCT_MANAGEMENT_DUPLICATE_CODE",
+  (identifier: string) => `A product with the same code already exists: ${identifier}`,
+);
+
+export const MissingRequiredFieldError = createDomainError(
+  "MissingRequiredFieldError", "PRODUCT_MANAGEMENT_MISSING_REQUIRED_FIELD",
+  (identifier: string) => `Code, name, or UoM not provided: ${identifier}`,
+);
+
+export const InvalidUomError = createDomainError(
+  "InvalidUomError", "PRODUCT_MANAGEMENT_INVALID_UOM",
+  (identifier: string) => `Referenced unit does not exist or is inactive: ${identifier}`,
+);
+
+export const AttributeNotFoundError = createDomainError(
+  "AttributeNotFoundError", "PRODUCT_MANAGEMENT_ATTRIBUTE_NOT_FOUND",
+  (identifier: string) => `Specified attribute ID does not exist: ${identifier}`,
+);
+
+export const InvalidLabelError = createDomainError(
+  "InvalidLabelError", "PRODUCT_MANAGEMENT_INVALID_LABEL",
+  (identifier: string) => `Label is empty or blank: ${identifier}`,
+);
+
+export const DuplicateValueError = createDomainError(
+  "DuplicateValueError", "PRODUCT_MANAGEMENT_DUPLICATE_VALUE",
+  (identifier: string) => `A value with the same label already exists for this attribute: ${identifier}`,
+);
+
+export const ParentNotFoundError = createDomainError(
+  "ParentNotFoundError", "PRODUCT_MANAGEMENT_PARENT_NOT_FOUND",
+  (identifier: string) => `Specified parent category ID does not exist: ${identifier}`,
+);
+
+export const MaxDepthExceededError = createDomainError(
+  "MaxDepthExceededError", "PRODUCT_MANAGEMENT_MAX_DEPTH_EXCEEDED",
+  (identifier: string) => `Adding this child would exceed the configurable maximum tree depth: ${identifier}`,
+);
+
+export const DeleteNotAllowedError = createDomainError(
+  "DeleteNotAllowedError", "PRODUCT_MANAGEMENT_DELETE_NOT_ALLOWED",
+  (identifier: string) => `Product is not in DRAFT status and cannot be deleted: ${identifier}`,
+);
+
+export const AttributeInUseError = createDomainError(
+  "AttributeInUseError", "PRODUCT_MANAGEMENT_ATTRIBUTE_IN_USE",
+  (identifier: string) => `Attribute is assigned to one or more products and cannot be deleted: ${identifier}`,
+);
+
+export const ValueNotFoundError = createDomainError(
+  "ValueNotFoundError", "PRODUCT_MANAGEMENT_VALUE_NOT_FOUND",
+  (identifier: string) => `Specified attribute value ID does not exist: ${identifier}`,
+);
+
+export const ValueInUseError = createDomainError(
+  "ValueInUseError", "PRODUCT_MANAGEMENT_VALUE_IN_USE",
+  (identifier: string) => `Value is in use on one or more ACTIVE products: ${identifier}`,
+);
+
+export const HasChildrenError = createDomainError(
+  "HasChildrenError", "PRODUCT_MANAGEMENT_HAS_CHILDREN",
+  (identifier: string) => `Category has child categories and cannot be deleted: ${identifier}`,
+);
+
+export const HasAssignmentsError = createDomainError(
+  "HasAssignmentsError", "PRODUCT_MANAGEMENT_HAS_ASSIGNMENTS",
+  (identifier: string) => `Category has product assignments and cannot be deleted: ${identifier}`,
+);
+
+export const InvalidProductStatusError = createDomainError(
+  "InvalidProductStatusError", "PRODUCT_MANAGEMENT_INVALID_PRODUCT_STATUS",
+  (identifier: string) => `Product is not in ACTIVE status (DRAFT or ARCHIVED): ${identifier}`,
+);
+
+export const NoVariantAxesError = createDomainError(
+  "NoVariantAxesError", "PRODUCT_MANAGEMENT_NO_VARIANT_AXES",
+  (identifier: string) => `Product has no attributes with assigned values: ${identifier}`,
+);
+
+export const AttributeValueNotFoundError = createDomainError(
+  "AttributeValueNotFoundError", "PRODUCT_MANAGEMENT_ATTRIBUTE_VALUE_NOT_FOUND",
+  (identifier: string) => `Referenced attribute value no longer exists (data integrity check): ${identifier}`,
+);
+
+export const ItemCreationFailedError = createDomainError(
+  "ItemCreationFailedError", "PRODUCT_MANAGEMENT_ITEM_CREATION_FAILED",
+  (identifier: string) => `Item creation in item-management failed (e.g., duplicate SKU) — entire generation is rolled back: ${identifier}`,
+);
+
+export const CircularReferenceError = createDomainError(
+  "CircularReferenceError", "PRODUCT_MANAGEMENT_CIRCULAR_REFERENCE",
+  (identifier: string) => `Moving the category would create a circular reference (new parent is a descendant): ${identifier}`,
+);
+
+export const AssignmentNotFoundError = createDomainError(
+  "AssignmentNotFoundError", "PRODUCT_MANAGEMENT_ASSIGNMENT_NOT_FOUND",
+  (identifier: string) => `No assignment exists for the specified product and category combination: ${identifier}`,
+);
+
+export const ProductArchivedError = createDomainError(
+  "ProductArchivedError", "PRODUCT_MANAGEMENT_PRODUCT_ARCHIVED",
+  (identifier: string) => `Archived products do not allow any assignment changes: ${identifier}`,
+);
+
+export const AxisStructureLockedError = createDomainError(
+  "AxisStructureLockedError", "PRODUCT_MANAGEMENT_AXIS_STRUCTURE_LOCKED",
+  (identifier: string) => `A new attribute cannot be assigned to an ACTIVE product — the set of attributes is fixed once activated: ${identifier}`,
+);
+
+export const InvalidValueError = createDomainError(
+  "InvalidValueError", "PRODUCT_MANAGEMENT_INVALID_VALUE",
+  (identifier: string) => `Value does not reference a valid ProductAttributeValue for the attribute: ${identifier}`,
+);
+
+export const CodeImmutableError = createDomainError(
+  "CodeImmutableError", "PRODUCT_MANAGEMENT_CODE_IMMUTABLE",
+  (identifier: string) => `Attempt to change the product code: ${identifier}`,
+);
+
+export const NoFieldsToUpdateError = createDomainError(
+  "NoFieldsToUpdateError", "PRODUCT_MANAGEMENT_NO_FIELDS_TO_UPDATE",
+  (identifier: string) => `No updatable fields were provided in the request: ${identifier}`,
+);
+
+export const UomLockedError = createDomainError(
+  "UomLockedError", "PRODUCT_MANAGEMENT_UOM_LOCKED",
+  (identifier: string) => `UoM cannot be changed after product has been activated: ${identifier}`,
+);
+
+export const VariantNotFoundError = createDomainError(
+  "VariantNotFoundError", "PRODUCT_MANAGEMENT_VARIANT_NOT_FOUND",
+  (identifier: string) => `No variant matches the given criteria — caller receives null: ${identifier}`,
+);

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

@@ -0,0 +1,25 @@
+// @generated — do not edit
+import { definePermissions } from "../../../shared";
+
+export const { permissions, own, all } = definePermissions("product-management", [
+  "activateProduct",
+  "assignProductToCategory",
+  "createProduct",
+  "createProductAttribute",
+  "createProductAttributeValue",
+  "createProductCategory",
+  "deactivateProduct",
+  "deleteProduct",
+  "deleteProductAttribute",
+  "deleteProductAttributeValue",
+  "deleteProductCategory",
+  "generateVariants",
+  "moveProductCategory",
+  "reactivateProduct",
+  "removeProductFromCategory",
+  "setProductAttributeAssignment",
+  "updateProduct",
+  "updateProductAttribute",
+  "updateProductAttributeValue",
+  "updateProductCategory",
+] as const);

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

@@ -0,0 +1,51 @@
+import type { InferSchema, Selectable, Insertable, Updateable } from "../../../shared";
+import type { DB } from "../generated/kysely-tailordb";
+
+export type Schema = InferSchema<DB>;
+
+export type Product<T extends { Product: object }> = Selectable<T["Product"]>;
+export type ProductCreate<T extends { Product: object }> = Insertable<T["Product"]>;
+export type ProductUpdate<T extends { Product: object }> = Updateable<T["Product"]>;
+
+export type ProductAttribute<T extends { ProductAttribute: object }> = Selectable<
+  T["ProductAttribute"]
+>;
+export type ProductAttributeCreate<T extends { ProductAttribute: object }> = Insertable<
+  T["ProductAttribute"]
+>;
+export type ProductAttributeUpdate<T extends { ProductAttribute: object }> = Updateable<
+  T["ProductAttribute"]
+>;
+
+export type ProductAttributeValue<T extends { ProductAttributeValue: object }> = Selectable<
+  T["ProductAttributeValue"]
+>;
+export type ProductAttributeValueCreate<T extends { ProductAttributeValue: object }> = Insertable<
+  T["ProductAttributeValue"]
+>;
+
+export type ProductAttributeAssignment<T extends { ProductAttributeAssignment: object }> =
+  Selectable<T["ProductAttributeAssignment"]>;
+export type ProductAttributeAssignmentCreate<T extends { ProductAttributeAssignment: object }> =
+  Insertable<T["ProductAttributeAssignment"]>;
+
+export type ProductCategory<T extends { ProductCategory: object }> = Selectable<
+  T["ProductCategory"]
+>;
+export type ProductCategoryCreate<T extends { ProductCategory: object }> = Insertable<
+  T["ProductCategory"]
+>;
+export type ProductCategoryUpdate<T extends { ProductCategory: object }> = Updateable<
+  T["ProductCategory"]
+>;
+
+export type ProductCategoryAssignment<T extends { ProductCategoryAssignment: object }> = Selectable<
+  T["ProductCategoryAssignment"]
+>;
+export type ProductCategoryAssignmentCreate<T extends { ProductCategoryAssignment: object }> =
+  Insertable<T["ProductCategoryAssignment"]>;
+
+export type ProductVariant<T extends { ProductVariant: object }> = Selectable<T["ProductVariant"]>;
+export type ProductVariantCreate<T extends { ProductVariant: object }> = Insertable<
+  T["ProductVariant"]
+>;

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

@@ -0,0 +1,201 @@
+import { type TailorAnyDBField } from "@tailor-platform/sdk";
+import { type EmptyFields, type FieldsToInsertable } from "../../shared";
+import type { defineModule as definePrimitivesModule } from "../primitives";
+import type { defineModule as defineItemManagementModule } from "../item-management";
+import { createProduct } from "./command/createProduct.generated";
+import { updateProduct } from "./command/updateProduct.generated";
+import { activateProduct } from "./command/activateProduct.generated";
+import { deactivateProduct } from "./command/deactivateProduct.generated";
+import { reactivateProduct } from "./command/reactivateProduct.generated";
+import { deleteProduct } from "./command/deleteProduct.generated";
+import { createProductAttribute } from "./command/createProductAttribute.generated";
+import { updateProductAttribute } from "./command/updateProductAttribute.generated";
+import { deleteProductAttribute } from "./command/deleteProductAttribute.generated";
+import { createProductAttributeValue } from "./command/createProductAttributeValue.generated";
+import { updateProductAttributeValue } from "./command/updateProductAttributeValue.generated";
+import { deleteProductAttributeValue } from "./command/deleteProductAttributeValue.generated";
+import { createProductCategory } from "./command/createProductCategory.generated";
+import { updateProductCategory } from "./command/updateProductCategory.generated";
+import { moveProductCategory } from "./command/moveProductCategory.generated";
+import { deleteProductCategory } from "./command/deleteProductCategory.generated";
+import { assignProductToCategory } from "./command/assignProductToCategory.generated";
+import { removeProductFromCategory } from "./command/removeProductFromCategory.generated";
+import { setProductAttributeAssignment } from "./command/setProductAttributeAssignment.generated";
+import { generateVariants } from "./command/generateVariants.generated";
+import { getProduct } from "./query/getProduct.generated";
+import { getProductAttribute } from "./query/getProductAttribute.generated";
+import { getProductAttributeValue } from "./query/getProductAttributeValue.generated";
+import { getProductAttributeAssignment } from "./query/getProductAttributeAssignment.generated";
+import { getProductCategory } from "./query/getProductCategory.generated";
+import { getProductCategoryAssignment } from "./query/getProductCategoryAssignment.generated";
+import { listProductAttributeAssignments } from "./query/listProductAttributeAssignments.generated";
+import { listAttributeAssignmentsByAttribute } from "./query/listAttributeAssignmentsByAttribute.generated";
+import { listProductCategoryAssignments } from "./query/listProductCategoryAssignments.generated";
+import { listProductCategoryChildren } from "./query/listProductCategoryChildren.generated";
+import { listProductVariants } from "./query/listProductVariants.generated";
+import { getProductVariant } from "./query/getProductVariant.generated";
+import { listCategoryAssignmentsByProduct } from "./query/listCategoryAssignmentsByProduct.generated";
+import { listProductAttributeValues } from "./query/listProductAttributeValues.generated";
+import { calculateCategoryDepth } from "./query/calculateCategoryDepth.generated";
+import { detectCategoryCircularReference } from "./query/detectCategoryCircularReference.generated";
+import { createProductType, type CreateProductTypeParams } from "./db/product";
+import {
+  createProductAttributeType,
+  type CreateProductAttributeTypeParams,
+} from "./db/productAttribute";
+import {
+  createProductAttributeValueType,
+  type CreateProductAttributeValueTypeParams,
+} from "./db/productAttributeValue";
+import {
+  createProductAttributeAssignmentType,
+  type CreateProductAttributeAssignmentTypeParams,
+} from "./db/productAttributeAssignment";
+import {
+  createProductCategoryType,
+  type CreateProductCategoryTypeParams,
+} from "./db/productCategory";
+import {
+  createProductCategoryAssignmentType,
+  type CreateProductCategoryAssignmentTypeParams,
+} from "./db/productCategoryAssignment";
+import { createProductVariantType, type CreateProductVariantTypeParams } from "./db/productVariant";
+
+type PrimitivesModule = ReturnType<typeof definePrimitivesModule>;
+type PrimitivesDB = PrimitivesModule["db"];
+export type PrimitivesQueries = PrimitivesModule["queries"];
+
+type ItemManagementModule = ReturnType<typeof defineItemManagementModule>;
+type ItemManagementDB = ItemManagementModule["db"];
+export type ItemManagementCommands = ItemManagementModule["commands"];
+
+export type SkuStrategy = (
+  productCode: string,
+  axisValues: string[],
+  currentVariantCount: number,
+) => string;
+
+const DEFAULT_MAX_DEPTH = 10;
+
+const defaultSkuStrategy: SkuStrategy = (productCode, _axisValues, currentVariantCount) => {
+  const seq = String(currentVariantCount + 1).padStart(3, "0");
+  return `${productCode}-${seq}`;
+};
+
+export interface DefineModuleParams<
+  PF extends Record<string, TailorAnyDBField>,
+  PAF extends Record<string, TailorAnyDBField>,
+  PAVF extends Record<string, TailorAnyDBField>,
+  PAAF extends Record<string, TailorAnyDBField>,
+  PCF extends Record<string, TailorAnyDBField>,
+  PCAF extends Record<string, TailorAnyDBField>,
+  PVF extends Record<string, TailorAnyDBField>,
+> {
+  product?: Omit<CreateProductTypeParams<PF>, "unitType">;
+  productAttribute?: CreateProductAttributeTypeParams<PAF>;
+  productAttributeValue?: CreateProductAttributeValueTypeParams<PAVF>;
+  productAttributeAssignment?: CreateProductAttributeAssignmentTypeParams<PAAF>;
+  productCategory?: CreateProductCategoryTypeParams<PCF>;
+  productCategoryAssignment?: CreateProductCategoryAssignmentTypeParams<PCAF>;
+  productVariant?: Omit<CreateProductVariantTypeParams<PVF>, "itemType">;
+  categoryTree?: { maxDepth?: number };
+  skuStrategy?: SkuStrategy;
+  primitives: {
+    db: { unit: PrimitivesDB["unit"] };
+    queries: { getUnit: PrimitivesQueries["getUnit"] };
+  };
+  itemManagement: {
+    db: { item: ItemManagementDB["item"] };
+    commands: { createItem: ItemManagementCommands["createItem"] };
+  };
+}
+
+export const defineModule = <
+  const PF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const PAF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const PAVF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const PAAF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const PCF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const PCAF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const PVF extends Record<string, TailorAnyDBField> = EmptyFields,
+>(
+  params: DefineModuleParams<PF, PAF, PAVF, PAAF, PCF, PCAF, PVF>,
+) => {
+  const product = createProductType({
+    ...params.product,
+    unitType: params.primitives.db.unit,
+  });
+  const productAttributeDb = createProductAttributeType(params.productAttribute ?? {});
+  const productAttributeValueDb = createProductAttributeValueType(
+    params.productAttributeValue ?? {},
+  );
+  const productAttributeAssignmentDb = createProductAttributeAssignmentType(
+    params.productAttributeAssignment ?? {},
+  );
+  const productCategoryDb = createProductCategoryType(params.productCategory ?? {});
+  const productCategoryAssignmentDb = createProductCategoryAssignmentType(
+    params.productCategoryAssignment ?? {},
+  );
+  const productVariantDb = createProductVariantType({
+    ...params.productVariant,
+    itemType: params.itemManagement.db.item,
+  });
+
+  const maxDepth = params.categoryTree?.maxDepth ?? DEFAULT_MAX_DEPTH;
+  const skuStrategy = params.skuStrategy ?? defaultSkuStrategy;
+
+  return {
+    db: {
+      product,
+      productAttribute: productAttributeDb,
+      productAttributeValue: productAttributeValueDb,
+      productAttributeAssignment: productAttributeAssignmentDb,
+      productCategory: productCategoryDb,
+      productCategoryAssignment: productCategoryAssignmentDb,
+      productVariant: productVariantDb,
+    },
+    queries: {
+      getProduct,
+      getProductAttribute,
+      getProductAttributeValue,
+      getProductAttributeAssignment,
+      getProductCategory,
+      getProductCategoryAssignment,
+      listProductAttributeAssignments,
+      listAttributeAssignmentsByAttribute,
+      listProductCategoryAssignments,
+      listProductCategoryChildren,
+      listProductVariants,
+      getProductVariant,
+      listCategoryAssignmentsByProduct,
+      listProductAttributeValues,
+      calculateCategoryDepth,
+      detectCategoryCircularReference,
+    },
+    commands: {
+      createProduct: createProduct<FieldsToInsertable<PF>>(params.primitives.queries),
+      updateProduct: updateProduct<FieldsToInsertable<PF>>(params.primitives.queries),
+      activateProduct: activateProduct(),
+      deactivateProduct: deactivateProduct(),
+      reactivateProduct: reactivateProduct(),
+      deleteProduct: deleteProduct(),
+      createProductAttribute: createProductAttribute<FieldsToInsertable<PAF>>(),
+      updateProductAttribute: updateProductAttribute<FieldsToInsertable<PAF>>(),
+      deleteProductAttribute: deleteProductAttribute(),
+      createProductAttributeValue: createProductAttributeValue(),
+      updateProductAttributeValue: updateProductAttributeValue(),
+      deleteProductAttributeValue: deleteProductAttributeValue(),
+      createProductCategory: createProductCategory<FieldsToInsertable<PCF>>({ maxDepth }),
+      updateProductCategory: updateProductCategory<FieldsToInsertable<PCF>>(),
+      moveProductCategory: moveProductCategory({ maxDepth }),
+      deleteProductCategory: deleteProductCategory(),
+      assignProductToCategory: assignProductToCategory(),
+      removeProductFromCategory: removeProductFromCategory(),
+      setProductAttributeAssignment: setProductAttributeAssignment(),
+      generateVariants: generateVariants({
+        itemManagement: params.itemManagement.commands,
+        skuStrategy,
+      }),
+    },
+  };
+};

package/src/modules/product-management/query/calculateCategoryDepth.generated.ts

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

package/src/modules/product-management/query/calculateCategoryDepth.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { CategoryNotFoundError } from "../lib/errors.generated";
+import { run } from "./calculateCategoryDepth";
+
+describe("calculateCategoryDepth", () => {
+  it("returns depth 1 for root category", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce({ parentId: null });
+
+    const result = await run(db, { categoryId: "category-1" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.depth).toBe(1);
+    }
+  });
+
+  it("returns depth 2 for child of root", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce({ parentId: "category-1" })
+      .mockReturnValueOnce({ parentId: null });
+
+    const result = await run(db, { categoryId: "category-2" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.depth).toBe(2);
+    }
+  });
+
+  it("returns depth 3 for grandchild of root", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce({ parentId: "category-2" })
+      .mockReturnValueOnce({ parentId: "category-1" })
+      .mockReturnValueOnce({ parentId: null });
+
+    const result = await run(db, { categoryId: "category-3" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.depth).toBe(3);
+    }
+  });
+
+  it("returns CategoryNotFoundError when category does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { categoryId: "nonexistent" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CategoryNotFoundError);
+    }
+  });
+
+  it("returns partial depth when ancestor in chain is not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce({ parentId: "category-1" }).mockReturnValueOnce(undefined);
+
+    const result = await run(db, { categoryId: "category-2" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.depth).toBe(1);
+    }
+  });
+});

package/src/modules/product-management/query/calculateCategoryDepth.ts

@@ -0,0 +1,37 @@
+import { ok, err, type ReadonlyDB } from "../../../shared";
+import type { DB } from "../generated/kysely-tailordb";
+import { CategoryNotFoundError } from "../lib/errors.generated";
+
+export interface CalculateCategoryDepthInput {
+  categoryId: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: CalculateCategoryDepthInput) {
+  const category = await db
+    .selectFrom("ProductCategory")
+    .select("parentId")
+    .where("id", "=", input.categoryId)
+    .executeTakeFirst();
+
+  if (!category) {
+    return err(new CategoryNotFoundError(input.categoryId));
+  }
+
+  let depth = 1;
+  let currentId: string | null = category.parentId ?? null;
+
+  while (currentId) {
+    const node = await db
+      .selectFrom("ProductCategory")
+      .select("parentId")
+      .where("id", "=", currentId)
+      .executeTakeFirst();
+
+    if (!node) break;
+
+    depth++;
+    currentId = node.parentId ?? null;
+  }
+
+  return ok({ depth });
+}

package/src/modules/product-management/query/detectCategoryCircularReference.generated.ts

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