@tailor-platform/erp-kit 0.2.1 → 0.2.2

package/src/modules/product-management/command/moveProductCategory.test.ts

@@ -0,0 +1,170 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { baseRootCategory, baseChildCategory, baseLeafCategory } from "../testing/fixtures";
+import {
+  CategoryNotFoundError,
+  ParentNotFoundError,
+  CircularReferenceError,
+  MaxDepthExceededError,
+} from "../lib/errors.generated";
+import type { MoveProductCategoryInput } from "./moveProductCategory";
+import { run } from "./moveProductCategory";
+
+describe("moveProductCategory", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["product-management:moveProductCategory"],
+  };
+
+  const config = { maxDepth: 3 };
+
+  it("should return CategoryNotFoundError when category does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // getProductCategory(id) -> null
+    spies.select.mockReturnValueOnce(undefined);
+    const input: MoveProductCategoryInput = {
+      id: "non-existent",
+      newParentId: baseRootCategory.id,
+    };
+    const result = await run(db, input, ctx, config);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CategoryNotFoundError);
+    }
+  });
+
+  it("should return ParentNotFoundError when new parent does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // 1. getProductCategory(id) -> found
+    spies.select.mockReturnValueOnce(baseChildCategory);
+    // 2. getProductCategory(newParentId) -> null
+    spies.select.mockReturnValueOnce(undefined);
+    const input: MoveProductCategoryInput = {
+      id: baseChildCategory.id,
+      newParentId: "non-existent",
+    };
+    const result = await run(db, input, ctx, config);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ParentNotFoundError);
+    }
+  });
+
+  it("should return CircularReferenceError when move would create a cycle", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // 1. getProductCategory(id=category-1) -> found (root)
+    spies.select.mockReturnValueOnce(baseRootCategory);
+    // 2. getProductCategory(newParentId=category-3) -> found (leaf, child of child of root)
+    spies.select.mockReturnValueOnce(baseLeafCategory);
+    // 3. detectCategoryCircularReference walks parent chain from newParentId:
+    //    input.newParentId !== input.categoryId so enters while loop
+    //    1st iteration: select parentId where id=category-3 -> { parentId: "category-2" }
+    spies.select.mockReturnValueOnce({ parentId: "category-2" });
+    //    currentId=category-2, not equal to category-1, continue
+    //    2nd iteration: select parentId where id=category-2 -> { parentId: "category-1" }
+    spies.select.mockReturnValueOnce({ parentId: "category-1" });
+    //    currentId=category-1, equals categoryId -> isCircular: true
+
+    const input: MoveProductCategoryInput = {
+      id: baseRootCategory.id,
+      newParentId: baseLeafCategory.id,
+    };
+    const result = await run(db, input, ctx, config);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CircularReferenceError);
+    }
+  });
+
+  it("should return MaxDepthExceededError when move would exceed max depth", async () => {
+    // Use a scenario: move leaf (category-3) under a deep parent
+    const { db: db2, spies: spies2 } = createMockDb<Transaction>();
+    // 1. getProductCategory(id=category-3) -> leaf node
+    spies2.select.mockReturnValueOnce(baseLeafCategory);
+    // 2. getProductCategory(newParentId=category-2) -> child node
+    spies2.select.mockReturnValueOnce(baseChildCategory);
+    // 3. detectCategoryCircularReference: walk from category-2
+    //    1st: id=category-2 -> { parentId: "category-1" }
+    spies2.select.mockReturnValueOnce({ parentId: "category-1" });
+    //    category-1 !== category-3, continue
+    //    2nd: id=category-1 -> { parentId: null }
+    spies2.select.mockReturnValueOnce({ parentId: null });
+    //    currentId=null -> break -> isCircular: false
+    // 4. calculateCategoryDepth for newParentId=category-2
+    //    1st: id=category-2 -> { parentId: "category-1" }
+    spies2.select.mockReturnValueOnce({ parentId: "category-1" });
+    //    2nd: id=category-1 -> { parentId: null }
+    spies2.select.mockReturnValueOnce({ parentId: null });
+    //    depth=2
+    // 5. calculateSubtreeDepth for category-3: no children
+    spies2.select.mockReturnValueOnce([]); // execute() returns array for children query
+    //    subtreeDepth=1, totalDepth=2+1=3, maxDepth=2 -> exceed
+
+    const input: MoveProductCategoryInput = {
+      id: baseLeafCategory.id,
+      newParentId: baseChildCategory.id,
+    };
+    const result = await run(db2, input, ctx, { maxDepth: 2 });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MaxDepthExceededError);
+    }
+  });
+
+  it("should move category to new parent successfully", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // 1. getProductCategory(id=category-3) -> leaf
+    spies.select.mockReturnValueOnce(baseLeafCategory);
+    // 2. getProductCategory(newParentId=category-1) -> root
+    spies.select.mockReturnValueOnce(baseRootCategory);
+    // 3. detectCategoryCircularReference: walk from category-1
+    //    1st: id=category-1 -> { parentId: null }
+    spies.select.mockReturnValueOnce({ parentId: null });
+    //    currentId=null -> break -> isCircular: false
+    // 4. calculateCategoryDepth for category-1
+    //    1st: id=category-1 -> { parentId: null }
+    spies.select.mockReturnValueOnce({ parentId: null });
+    //    depth=1
+    // 5. calculateSubtreeDepth for category-3: no children
+    spies.select.mockReturnValueOnce([]); // children query -> empty
+    //    subtreeDepth=1, totalDepth=1+1=2, maxDepth=3 -> ok
+    // 6. update returns moved category
+    const movedCategory = {
+      ...baseLeafCategory,
+      parentId: baseRootCategory.id,
+      updatedAt: new Date(),
+    };
+    spies.update.mockReturnValueOnce(movedCategory);
+
+    const input: MoveProductCategoryInput = {
+      id: baseLeafCategory.id,
+      newParentId: baseRootCategory.id,
+    };
+    const result = await run(db, input, ctx, config);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.category.parentId).toBe(baseRootCategory.id);
+    }
+  });
+
+  it("should promote category to root when newParentId is null", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // 1. getProductCategory(id=category-2) -> child
+    spies.select.mockReturnValueOnce(baseChildCategory);
+    // newParentId=null -> promote to root, update directly
+    const movedCategory = { ...baseChildCategory, parentId: null, updatedAt: new Date() };
+    spies.update.mockReturnValueOnce(movedCategory);
+
+    const input: MoveProductCategoryInput = {
+      id: baseChildCategory.id,
+      newParentId: null,
+    };
+    const result = await run(db, input, ctx, config);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.category.parentId).toBeNull();
+    }
+  });
+});

package/src/modules/product-management/command/moveProductCategory.ts

@@ -0,0 +1,124 @@
+import { ok, err, type CommandContext } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
+import {
+  CategoryNotFoundError,
+  ParentNotFoundError,
+  CircularReferenceError,
+  MaxDepthExceededError,
+} from "../lib/errors.generated";
+import { calculateCategoryDepth } from "../query/calculateCategoryDepth.generated";
+
+export interface MoveProductCategoryInput {
+  id: string;
+  newParentId: string | null;
+}
+
+/**
+ * Function: moveProductCategory
+ *
+ * Reparents a category node. Moving to null promotes to root.
+ */
+export async function run(
+  db: Transaction,
+  input: MoveProductCategoryInput,
+  ctx: CommandContext,
+  config: { maxDepth: number },
+) {
+  const { maxDepth } = config;
+  const { id, newParentId } = input;
+
+  const category = await db
+    .selectFrom("ProductCategory")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+  if (!category) {
+    return err(new CategoryNotFoundError(id));
+  }
+
+  // Promote to root
+  if (newParentId === null) {
+    const moved = await db
+      .updateTable("ProductCategory")
+      .set({ parentId: null, updatedAt: new Date() })
+      .where("id", "=", id)
+      .returningAll()
+      .executeTakeFirst();
+    return ok({ category: moved! });
+  }
+
+  // Check new parent exists
+  const newParent = await db
+    .selectFrom("ProductCategory")
+    .select("id")
+    .where("id", "=", newParentId)
+    .executeTakeFirst();
+  if (!newParent) {
+    return err(new ParentNotFoundError(newParentId));
+  }
+
+  // Check circular reference
+  const isDescendant = await isAncestorOf(db, id, newParentId);
+  if (isDescendant) {
+    return err(new CircularReferenceError(`${id} -> ${newParentId}`));
+  }
+
+  // Check depth limit: need to calculate subtree depth of moved node
+  const depthResult = await calculateCategoryDepth(db, { categoryId: newParentId }, ctx);
+  if (!depthResult.ok) return err(new ParentNotFoundError(newParentId));
+  const newParentDepth = depthResult.value.depth;
+  // Calculate subtree depth of the node being moved
+  const subtreeDepth = await calculateSubtreeDepth(db, id);
+  const totalDepth = newParentDepth + subtreeDepth;
+
+  if (totalDepth > maxDepth) {
+    return err(new MaxDepthExceededError(`${totalDepth} exceeds ${maxDepth}`));
+  }
+
+  const moved = await db
+    .updateTable("ProductCategory")
+    .set({ parentId: newParentId, updatedAt: new Date() })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ category: moved! });
+}
+
+/** Checks if `ancestorId` is an ancestor of `descendantId` by walking up the tree. */
+async function isAncestorOf(
+  db: Transaction,
+  ancestorId: string,
+  descendantId: string,
+): Promise<boolean> {
+  let currentId: string | null = descendantId;
+  while (currentId) {
+    if (currentId === ancestorId) return true;
+    const parent = await db
+      .selectFrom("ProductCategory")
+      .select("parentId")
+      .where("id", "=", currentId)
+      .executeTakeFirst();
+    currentId = parent?.parentId ?? null;
+  }
+  return false;
+}
+
+async function calculateSubtreeDepth(db: Transaction, nodeId: string): Promise<number> {
+  const children = await db
+    .selectFrom("ProductCategory")
+    .select("id")
+    .where("parentId", "=", nodeId)
+    .execute();
+
+  if (children.length === 0) return 1;
+
+  let maxChildDepth = 0;
+  for (const child of children) {
+    const childDepth = await calculateSubtreeDepth(db, child.id);
+    if (childDepth > maxChildDepth) maxChildDepth = childDepth;
+  }
+
+  return 1 + maxChildDepth;
+}

package/src/modules/product-management/command/reactivateProduct.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { defineCommand } from "../../../shared";
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./reactivateProduct";
+
+export const reactivateProduct = defineCommand(permissions.reactivateProduct, run);

package/src/modules/product-management/command/reactivateProduct.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { InvalidStateTransitionError, ProductNotFoundError } from "../lib/errors.generated";
+import { baseActiveProduct, baseArchivedProduct } from "../testing/fixtures";
+import { run } from "./reactivateProduct";
+
+describe("reactivateProduct", () => {
+  it("returns error when product not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+    const result = await run(db, { id: "nonexistent" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ProductNotFoundError);
+    }
+  });
+
+  it("returns error when not in ARCHIVED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce({ ...baseActiveProduct });
+    const result = await run(db, { id: "product-2" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateTransitionError);
+    }
+  });
+
+  it("reactivates ARCHIVED product to ACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const reactivated = { ...baseArchivedProduct, status: "ACTIVE" };
+    spies.select.mockReturnValueOnce({ ...baseArchivedProduct });
+    spies.update.mockReturnValueOnce(reactivated);
+    const result = await run(db, { id: "product-3" });
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.product.status).toBe("ACTIVE");
+    }
+  });
+});

package/src/modules/product-management/command/reactivateProduct.ts

@@ -0,0 +1,42 @@
+import { ok, err } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
+import { ProductNotFoundError, InvalidStateTransitionError } from "../lib/errors.generated";
+
+export interface ReactivateProductInput {
+  id: string;
+  from?: string[];
+}
+
+/**
+ * Function: reactivateProduct
+ *
+ * Transitions a product from ARCHIVED to ACTIVE.
+ */
+export async function run(db: Transaction, input: ReactivateProductInput) {
+  const { id } = input;
+  const validFrom = input.from ?? ["ARCHIVED"];
+
+  const product = await db
+    .selectFrom("Product")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!product) {
+    return err(new ProductNotFoundError(id));
+  }
+
+  if (!validFrom.includes(product.status)) {
+    return err(new InvalidStateTransitionError(id));
+  }
+
+  const updated = await db
+    .updateTable("Product")
+    .set({ status: "ACTIVE", updatedAt: new Date() })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ product: updated! });
+}

package/src/modules/product-management/command/removeProductFromCategory.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { defineCommand } from "../../../shared";
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./removeProductFromCategory";
+
+export const removeProductFromCategory = defineCommand(permissions.removeProductFromCategory, run);

package/src/modules/product-management/command/removeProductFromCategory.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { baseCategoryAssignment } from "../testing/fixtures";
+import { AssignmentNotFoundError } from "../lib/errors.generated";
+import type { RemoveProductFromCategoryInput } from "./removeProductFromCategory";
+import { run } from "./removeProductFromCategory";
+
+describe("removeProductFromCategory", () => {
+  it("should return AssignmentNotFoundError when assignment does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // getProductCategoryAssignment -> null
+    spies.select.mockReturnValueOnce(undefined);
+    const input: RemoveProductFromCategoryInput = {
+      productId: "non-existent",
+      categoryId: "non-existent",
+    };
+    const result = await run(db, input);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AssignmentNotFoundError);
+    }
+  });
+
+  it("should remove assignment successfully", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // getProductCategoryAssignment -> found
+    spies.select.mockReturnValueOnce(baseCategoryAssignment);
+    // delete executes
+    spies.delete.mockReturnValueOnce(undefined);
+
+    const input: RemoveProductFromCategoryInput = {
+      productId: baseCategoryAssignment.productId,
+      categoryId: baseCategoryAssignment.categoryId,
+    };
+    const result = await run(db, input);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.id).toBe(baseCategoryAssignment.id);
+    }
+  });
+});

package/src/modules/product-management/command/removeProductFromCategory.ts

@@ -0,0 +1,32 @@
+import { ok, err } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
+import { AssignmentNotFoundError } from "../lib/errors.generated";
+
+export interface RemoveProductFromCategoryInput {
+  productId: string;
+  categoryId: string;
+}
+
+/**
+ * Function: removeProductFromCategory
+ *
+ * Removes a product-category assignment.
+ */
+export async function run(db: Transaction, input: RemoveProductFromCategoryInput) {
+  const { productId, categoryId } = input;
+
+  const assignment = await db
+    .selectFrom("ProductCategoryAssignment")
+    .selectAll()
+    .where("productId", "=", productId)
+    .where("categoryId", "=", categoryId)
+    .forUpdate()
+    .executeTakeFirst();
+  if (!assignment) {
+    return err(new AssignmentNotFoundError(`${productId}:${categoryId}`));
+  }
+
+  await db.deleteFrom("ProductCategoryAssignment").where("id", "=", assignment.id).execute();
+
+  return ok({ id: assignment.id });
+}

package/src/modules/product-management/command/setProductAttributeAssignment.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { defineCommand } from "../../../shared";
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./setProductAttributeAssignment";
+
+export const setProductAttributeAssignment = defineCommand(permissions.setProductAttributeAssignment, run);

package/src/modules/product-management/command/setProductAttributeAssignment.test.ts

@@ -0,0 +1,206 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import { Transaction } from "../generated/kysely-tailordb";
+import {
+  ProductNotFoundError,
+  AttributeNotFoundError,
+  ProductArchivedError,
+  AxisStructureLockedError,
+  InvalidValueError,
+} from "../lib/errors.generated";
+import {
+  baseDraftProduct,
+  baseActiveProduct,
+  baseArchivedProduct,
+  baseColorAttribute,
+  baseColorRed,
+  baseColorBlue,
+  baseAttributeAssignment,
+} from "../testing/fixtures";
+import { run } from "./setProductAttributeAssignment";
+
+describe("setProductAttributeAssignment", () => {
+  it("returns error when product not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // product not found
+
+    const result = await run(db, {
+      productId: "nonexistent",
+      attributeId: "attr-1",
+      valueId: "value-1",
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ProductNotFoundError);
+    }
+  });
+
+  it("returns error when attribute not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseDraftProduct) // product found
+      .mockReturnValueOnce(undefined); // attribute not found
+
+    const result = await run(db, {
+      productId: baseDraftProduct.id,
+      attributeId: "nonexistent",
+      valueId: "value-1",
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AttributeNotFoundError);
+    }
+  });
+
+  it("returns error when value not found for attribute", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseDraftProduct) // product found
+      .mockReturnValueOnce(baseColorAttribute) // attribute found
+      .mockReturnValueOnce(undefined); // value not found
+
+    const result = await run(db, {
+      productId: baseDraftProduct.id,
+      attributeId: baseColorAttribute.id,
+      valueId: "invalid-value-id",
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidValueError);
+    }
+  });
+
+  it("returns error when product is ARCHIVED", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseArchivedProduct) // product found (ARCHIVED)
+      .mockReturnValueOnce(baseColorAttribute) // attribute found
+      .mockReturnValueOnce(baseColorRed) // value found
+      .mockReturnValueOnce([]); // no existing assignments
+
+    const result = await run(db, {
+      productId: baseArchivedProduct.id,
+      attributeId: baseColorAttribute.id,
+      valueId: baseColorRed.id,
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ProductArchivedError);
+    }
+  });
+
+  it("returns existing assignment when exact triple already exists (idempotent no-op)", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const existingAssignment = {
+      ...baseAttributeAssignment,
+      productId: baseDraftProduct.id,
+      valueId: baseColorRed.id,
+    };
+    spies.select
+      .mockReturnValueOnce(baseDraftProduct) // product found
+      .mockReturnValueOnce(baseColorAttribute) // attribute found
+      .mockReturnValueOnce(baseColorRed) // value found
+      .mockReturnValueOnce([existingAssignment]); // existing assignments with matching valueId
+
+    const result = await run(db, {
+      productId: baseDraftProduct.id,
+      attributeId: baseColorAttribute.id,
+      valueId: baseColorRed.id,
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.assignment).toEqual(existingAssignment);
+    }
+    // Should not insert or update
+    expect(spies.insert).not.toHaveBeenCalled();
+    expect(spies.update).not.toHaveBeenCalled();
+  });
+
+  it("returns error when adding new attribute to ACTIVE product", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseActiveProduct) // product found (ACTIVE)
+      .mockReturnValueOnce(baseColorAttribute) // attribute found
+      .mockReturnValueOnce(baseColorRed) // value found
+      .mockReturnValueOnce([]); // no existing assignments for this attribute
+
+    const result = await run(db, {
+      productId: baseActiveProduct.id,
+      attributeId: baseColorAttribute.id,
+      valueId: baseColorRed.id,
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AxisStructureLockedError);
+    }
+  });
+
+  it("creates new assignment on DRAFT product", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const newAssignment = {
+      ...baseAttributeAssignment,
+      id: "new-assignment-id",
+      productId: baseDraftProduct.id,
+      valueId: baseColorRed.id,
+    };
+
+    spies.select
+      .mockReturnValueOnce(baseDraftProduct) // product found
+      .mockReturnValueOnce(baseColorAttribute) // attribute found
+      .mockReturnValueOnce(baseColorRed) // value found
+      .mockReturnValueOnce([]); // no existing assignments
+    spies.insert.mockReturnValue(newAssignment);
+
+    const result = await run(db, {
+      productId: baseDraftProduct.id,
+      attributeId: baseColorAttribute.id,
+      valueId: baseColorRed.id,
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.assignment.productId).toBe(baseDraftProduct.id);
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("adds new value to existing attribute on ACTIVE product (additive-only)", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const existingAssignment = {
+      ...baseAttributeAssignment,
+      productId: baseActiveProduct.id,
+      valueId: baseColorRed.id,
+    };
+    const newAssignment = {
+      ...baseAttributeAssignment,
+      id: "assignment-2",
+      productId: baseActiveProduct.id,
+      valueId: baseColorBlue.id,
+    };
+
+    spies.select
+      .mockReturnValueOnce(baseActiveProduct) // product found (ACTIVE)
+      .mockReturnValueOnce(baseColorAttribute) // attribute found
+      .mockReturnValueOnce(baseColorBlue) // value found (Blue)
+      .mockReturnValueOnce([existingAssignment]); // existing: Red already assigned
+    spies.insert.mockReturnValue(newAssignment);
+
+    const result = await run(db, {
+      productId: baseActiveProduct.id,
+      attributeId: baseColorAttribute.id,
+      valueId: baseColorBlue.id,
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.assignment.valueId).toBe(baseColorBlue.id);
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+});