@tailor-platform/erp-kit 0.7.0 → 0.9.0

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

@@ -114,7 +114,7 @@ describe("setProductAttributeAssignment", () => {
 
     expect(result.ok).toBe(true);
     if (result.ok) {
-      expect(result.value.assignment).toEqual(existingAssignment);
+      expect(result.value.productAttributeAssignment).toEqual(existingAssignment);
     }
     // Should not insert or update
     expect(spies.insert).not.toHaveBeenCalled();
@@ -165,7 +165,7 @@ describe("setProductAttributeAssignment", () => {
 
     expect(result.ok).toBe(true);
     if (result.ok) {
-      expect(result.value.assignment.productId).toBe(baseDraftProduct.id);
+      expect(result.value.productAttributeAssignment.productId).toBe(baseDraftProduct.id);
     }
     expect(spies.insert).toHaveBeenCalled();
   });
@@ -199,7 +199,7 @@ describe("setProductAttributeAssignment", () => {
 
     expect(result.ok).toBe(true);
     if (result.ok) {
-      expect(result.value.assignment.valueId).toBe(baseColorBlue.id);
+      expect(result.value.productAttributeAssignment.valueId).toBe(baseColorBlue.id);
     }
     expect(spies.insert).toHaveBeenCalled();
   });

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

@@ -68,7 +68,7 @@ export async function run(db: Transaction, input: SetProductAttributeAssignmentI
   // Idempotent no-op: if exact triple already exists, return existing
   const exactMatch = existingAssignments.find((a) => a.valueId === valueId);
   if (exactMatch) {
-    return ok({ assignment: exactMatch });
+    return ok({ productAttributeAssignment: exactMatch });
   }
 
   // Status-based rules
@@ -98,5 +98,5 @@ export async function run(db: Transaction, input: SetProductAttributeAssignmentI
     .returningAll()
     .executeTakeFirstOrThrow();
 
-  return ok({ assignment });
+  return ok({ productAttributeAssignment: assignment });
 }

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

@@ -3,7 +3,6 @@ import { createMockDb } from "../../../testing/index";
 import type { GetUnitInput } from "../../primitives/query/getUnit";
 import type { Transaction } from "../generated/kysely-tailordb";
 import {
-  CodeImmutableError,
   InvalidUomError,
   MissingRequiredFieldError,
   NoFieldsToUpdateError,
@@ -51,16 +50,6 @@ describe("updateProduct", () => {
     }
   });
 
-  it("returns error when code change attempted", async () => {
-    const { db, spies } = createMockDb<Transaction>();
-    spies.select.mockReturnValueOnce({ ...baseDraftProduct });
-    const result = await run(db, { id: "product-1", code: "NEW-CODE" }, ctx, primitivesQueries);
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error).toBeInstanceOf(CodeImmutableError);
-    }
-  });
-
   it("returns error when no fields provided", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce({ ...baseDraftProduct });
@@ -147,6 +136,23 @@ describe("updateProduct", () => {
     }
   });
 
+  it("looks up product by code and updates name", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updated = { ...baseDraftProduct, name: "Updated Name" };
+    spies.select.mockReturnValueOnce({ ...baseDraftProduct });
+    spies.update.mockReturnValueOnce(updated);
+    const result = await run(
+      db,
+      { code: baseDraftProduct.code, name: "Updated Name" },
+      ctx,
+      primitivesQueries,
+    );
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.product.name).toBe("Updated Name");
+    }
+  });
+
   it("passes custom fields through", async () => {
     const { db, spies } = createMockDb<Transaction>();
     const updated = { ...baseDraftProduct, customField1: "value1" };

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

@@ -1,7 +1,6 @@
 import { Transaction } from "../generated/kysely-tailordb";
 import {
   ProductNotFoundError,
-  CodeImmutableError,
   NoFieldsToUpdateError,
   UomLockedError,
   InvalidUomError,
@@ -10,63 +9,81 @@ import {
 import type { PrimitivesQueries } from "../module";
 import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
 
-export interface UpdateProductInput {
-  id: string;
-  code?: string;
+export type UpdateProductInput = (
+  | {
+      id: string;
+    }
+  | {
+      code: string;
+    }
+) & {
   name?: string;
   description?: string;
   unitId?: string;
-}
+};
 
 /**
  * Function: updateProduct
  *
  * Updates mutable fields of an existing product.
+ * The product can be looked up by id or code. UoM can only be changed in DRAFT status.
  */
 export async function run<CF extends Record<string, unknown>>(
   db: Transaction,
-  input: UpdateProductInput & CF,
+  input: UpdateProductInput & Omit<Partial<CF>, "status">,
   ctx: CommandContext,
   primitivesQueries: Pick<PrimitivesQueries, "getUnit">,
 ) {
-  const { id, code, name, description, unitId, ...customFields } = input;
-
-  // Check product exists (with lock)
-  const product = await db
-    .selectFrom("Product")
-    .selectAll()
-    .where("id", "=", id)
-    .forUpdate()
-    .executeTakeFirst();
+  const { name, description, unitId } = input;
 
-  if (!product) {
-    return err(new ProductNotFoundError(id));
+  const KNOWN_KEYS = new Set(["id", "code", "name", "description", "unitId"]);
+  const customFields: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(input as Record<string, unknown>)) {
+    if (!KNOWN_KEYS.has(key)) {
+      customFields[key] = value;
+    }
   }
 
-  // Code is immutable
-  if (code !== undefined) {
-    return err(new CodeImmutableError(id));
+  // 1. Check product exists (lookup by id or code)
+  const product =
+    "id" in input
+      ? await db
+          .selectFrom("Product")
+          .selectAll()
+          .where("id", "=", (input as { id: string }).id)
+          .forUpdate()
+          .executeTakeFirst()
+      : await db
+          .selectFrom("Product")
+          .selectAll()
+          .where("code", "=", (input as { code: string }).code)
+          .forUpdate()
+          .executeTakeFirst();
+
+  if (!product) {
+    const key = "id" in input ? (input as { id: string }).id : (input as { code: string }).code;
+    return err(new ProductNotFoundError(key));
   }
 
-  // Check if any fields to update
+  // 2. Check if any fields to update
   const hasNameUpdate = name !== undefined;
   const hasDescriptionUpdate = description !== undefined;
   const hasUnitUpdate = unitId !== undefined;
   const hasCustomFields = Object.keys(customFields).length > 0;
 
   if (!hasNameUpdate && !hasDescriptionUpdate && !hasUnitUpdate && !hasCustomFields) {
-    return err(new NoFieldsToUpdateError(id));
+    return err(new NoFieldsToUpdateError(product.id));
   }
 
-  // Validate name if provided
+  // 3. Validate name if provided
   if (hasNameUpdate && !name?.trim()) {
     return err(new MissingRequiredFieldError("name"));
   }
 
-  // UoM can only be updated in DRAFT status
+  // 4. UoM can only be updated in DRAFT status
   if (hasUnitUpdate) {
     if (product.status !== "DRAFT") {
-      return err(new UomLockedError(id));
+      return err(new UomLockedError(product.id));
     }
     const unitResult = await primitivesQueries.getUnit(db, { id: unitId }, ctx);
     if (!unitResult.ok) return err(new InvalidUomError(unitId));
@@ -75,9 +92,9 @@ export async function run<CF extends Record<string, unknown>>(
     }
   }
 
-  // Build update payload
+  // 5. Build update payload
   const updates: Record<string, unknown> = {
-    ...(customFields as Record<string, unknown>),
+    ...customFields,
     updatedAt: new Date(),
   };
   if (hasNameUpdate) updates.name = name;
@@ -87,7 +104,7 @@ export async function run<CF extends Record<string, unknown>>(
   const updated = await db
     .updateTable("Product")
     .set(updates)
-    .where("id", "=", id)
+    .where("id", "=", product.id)
     .returningAll()
     .executeTakeFirst();
 

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

@@ -1,11 +1,7 @@
 import { describe, expect, it } from "vitest";
 import { createMockDb } from "../../../testing/index";
 import { Transaction } from "../generated/kysely-tailordb";
-import {
-  AttributeNotFoundError,
-  CodeImmutableError,
-  MissingRequiredFieldError,
-} from "../lib/errors.generated";
+import { AttributeNotFoundError, MissingRequiredFieldError } from "../lib/errors.generated";
 import { baseColorAttribute } from "../testing/fixtures";
 import { run } from "./updateProductAttribute";
 
@@ -22,22 +18,6 @@ describe("updateProductAttribute", () => {
     }
   });
 
-  it("returns error when trying to change code", async () => {
-    const { db, spies } = createMockDb<Transaction>();
-    spies.select.mockReturnValueOnce(baseColorAttribute);
-
-    const result = await run(db, {
-      id: baseColorAttribute.id,
-      code: "NEW-CODE",
-      name: "Color",
-    });
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error).toBeInstanceOf(CodeImmutableError);
-    }
-  });
-
   it("returns error when no fields provided", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(baseColorAttribute);
@@ -98,4 +78,19 @@ describe("updateProductAttribute", () => {
     }
     expect(spies.update).toHaveBeenCalled();
   });
+
+  it("looks up attribute by code and updates name", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedAttribute = { ...baseColorAttribute, name: "Updated Color" };
+
+    spies.select.mockReturnValueOnce(baseColorAttribute);
+    spies.update.mockReturnValue(updatedAttribute);
+
+    const result = await run(db, { code: baseColorAttribute.code, name: "Updated Color" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.attribute.name).toBe("Updated Color");
+    }
+  });
 });

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

@@ -1,50 +1,64 @@
 import { Transaction } from "../generated/kysely-tailordb";
-import {
-  AttributeNotFoundError,
-  CodeImmutableError,
-  MissingRequiredFieldError,
-} from "../lib/errors.generated";
+import { AttributeNotFoundError, MissingRequiredFieldError } from "../lib/errors.generated";
 import { ok, err } from "@tailor-platform/erp-kit/module";
 
-export interface UpdateProductAttributeInput {
-  id: string;
-  code?: string;
+export type UpdateProductAttributeInput = (
+  | {
+      id: string;
+    }
+  | {
+      code: string;
+    }
+) & {
   name?: string;
-}
+};
 
 /**
  * Function: updateProductAttribute
  *
- * Updates the display name of an existing attribute.
+ * Updates the display name of an existing product attribute.
+ * The attribute can be looked up by id or code.
  */
 export async function run<CF extends Record<string, unknown>>(
   db: Transaction,
-  input: UpdateProductAttributeInput & CF,
+  input: UpdateProductAttributeInput & Omit<Partial<CF>, "status">,
 ) {
-  const { id, code, name, ...rawCustomFields } = input;
+  const { name } = input;
 
-  const customFields = rawCustomFields as Record<string, unknown>;
+  const KNOWN_KEYS = new Set(["id", "code", "name"]);
+  const customFields: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(input as Record<string, unknown>)) {
+    if (!KNOWN_KEYS.has(key)) {
+      customFields[key] = value;
+    }
+  }
 
-  const attribute = await db
-    .selectFrom("ProductAttribute")
-    .selectAll()
-    .where("id", "=", id)
-    .forUpdate()
-    .executeTakeFirst();
+  // 1. Check attribute exists (lookup by id or code)
+  const attribute =
+    "id" in input
+      ? await db
+          .selectFrom("ProductAttribute")
+          .selectAll()
+          .where("id", "=", (input as { id: string }).id)
+          .forUpdate()
+          .executeTakeFirst()
+      : await db
+          .selectFrom("ProductAttribute")
+          .selectAll()
+          .where("code", "=", (input as { code: string }).code)
+          .forUpdate()
+          .executeTakeFirst();
 
   if (!attribute) {
-    return err(new AttributeNotFoundError(id));
-  }
-
-  if (code !== undefined) {
-    return err(new CodeImmutableError(id));
+    const key = "id" in input ? (input as { id: string }).id : (input as { code: string }).code;
+    return err(new AttributeNotFoundError(key));
   }
 
   const hasNameUpdate = name !== undefined;
   const hasCustomFields = Object.keys(customFields).length > 0;
 
   if (!hasNameUpdate && !hasCustomFields) {
-    return err(new MissingRequiredFieldError(id));
+    return err(new MissingRequiredFieldError(attribute.id));
   }
 
   if (hasNameUpdate && !name?.trim()) {
@@ -60,7 +74,7 @@ export async function run<CF extends Record<string, unknown>>(
   const updated = await db
     .updateTable("ProductAttribute")
     .set(updates)
-    .where("id", "=", id)
+    .where("id", "=", attribute.id)
     .returningAll()
     .executeTakeFirst();
 

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

@@ -6,11 +6,10 @@ import {
 } from "../lib/errors.generated";
 import { ok, err } from "@tailor-platform/erp-kit/module";
 
-export interface UpdateProductAttributeValueInput {
+export type UpdateProductAttributeValueInput = {
   id: string;
   label: string;
-}
-
+};
 /**
  * Function: updateProductAttributeValue
  *

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

@@ -2,11 +2,7 @@ import { describe, expect, it } from "vitest";
 import { createMockDb } from "../../../testing/index";
 import type { Transaction } from "../generated/kysely-tailordb";
 import { baseRootCategory } from "../testing/fixtures";
-import {
-  CategoryNotFoundError,
-  CodeImmutableError,
-  MissingRequiredFieldError,
-} from "../lib/errors.generated";
+import { CategoryNotFoundError, MissingRequiredFieldError } from "../lib/errors.generated";
 import { run } from "./updateProductCategory";
 
 describe("updateProductCategory", () => {
@@ -21,20 +17,6 @@ describe("updateProductCategory", () => {
     }
   });
 
-  it("should return CodeImmutableError when code is provided", async () => {
-    const { db, spies } = createMockDb<Transaction>();
-    spies.select.mockReturnValueOnce(baseRootCategory);
-    const input = {
-      id: baseRootCategory.id,
-      code: "NEW-CODE",
-    };
-    const result = await run(db, input);
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error).toBeInstanceOf(CodeImmutableError);
-    }
-  });
-
   it("should return MissingRequiredFieldError when no fields are provided", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(baseRootCategory);
@@ -77,4 +59,17 @@ describe("updateProductCategory", () => {
       expect(result.value.category.name).toBe("Apparel");
     }
   });
+
+  it("should look up category by code and update name", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseRootCategory);
+    const updatedCategory = { ...baseRootCategory, name: "Apparel", updatedAt: new Date() };
+    spies.update.mockReturnValueOnce(updatedCategory);
+
+    const result = await run(db, { code: baseRootCategory.code, name: "Apparel" });
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.category.name).toBe("Apparel");
+    }
+  });
 });

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

@@ -1,48 +1,64 @@
 import { Transaction } from "../generated/kysely-tailordb";
-import {
-  CategoryNotFoundError,
-  CodeImmutableError,
-  MissingRequiredFieldError,
-} from "../lib/errors.generated";
+import { CategoryNotFoundError, MissingRequiredFieldError } from "../lib/errors.generated";
 import { ok, err } from "@tailor-platform/erp-kit/module";
 
-export interface UpdateProductCategoryInput {
-  id: string;
-  code?: string;
+export type UpdateProductCategoryInput = (
+  | {
+      id: string;
+    }
+  | {
+      code: string;
+    }
+) & {
   name?: string;
-}
+};
 
 /**
  * Function: updateProductCategory
  *
- * Updates the display name of an existing category.
+ * Updates the display name of an existing product category.
+ * The category can be looked up by id or code.
  */
 export async function run<CF extends Record<string, unknown>>(
   db: Transaction,
-  input: UpdateProductCategoryInput & CF,
+  input: UpdateProductCategoryInput & Omit<Partial<CF>, "status">,
 ) {
-  const { id, code, name, ...customFields } = input;
-
-  const category = await db
-    .selectFrom("ProductCategory")
-    .selectAll()
-    .where("id", "=", id)
-    .forUpdate()
-    .executeTakeFirst();
+  const { name } = input;
 
-  if (!category) {
-    return err(new CategoryNotFoundError(id));
+  const KNOWN_KEYS = new Set(["id", "code", "name"]);
+  const customFields: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(input as Record<string, unknown>)) {
+    if (!KNOWN_KEYS.has(key)) {
+      customFields[key] = value;
+    }
   }
 
-  if (code !== undefined) {
-    return err(new CodeImmutableError(id));
+  // 1. Check category exists (lookup by id or code)
+  const category =
+    "id" in input
+      ? await db
+          .selectFrom("ProductCategory")
+          .selectAll()
+          .where("id", "=", (input as { id: string }).id)
+          .forUpdate()
+          .executeTakeFirst()
+      : await db
+          .selectFrom("ProductCategory")
+          .selectAll()
+          .where("code", "=", (input as { code: string }).code)
+          .forUpdate()
+          .executeTakeFirst();
+
+  if (!category) {
+    const key = "id" in input ? (input as { id: string }).id : (input as { code: string }).code;
+    return err(new CategoryNotFoundError(key));
   }
 
   const hasNameUpdate = name !== undefined;
   const hasCustomFields = Object.keys(customFields).length > 0;
 
   if (!hasNameUpdate && !hasCustomFields) {
-    return err(new MissingRequiredFieldError(id));
+    return err(new MissingRequiredFieldError(category.id));
   }
 
   if (hasNameUpdate && !name?.trim()) {
@@ -50,7 +66,7 @@ export async function run<CF extends Record<string, unknown>>(
   }
 
   const updates: Record<string, unknown> = {
-    ...(customFields as Record<string, unknown>),
+    ...customFields,
     updatedAt: new Date(),
   };
   if (hasNameUpdate) updates.name = name;
@@ -58,7 +74,7 @@ export async function run<CF extends Record<string, unknown>>(
   const updated = await db
     .updateTable("ProductCategory")
     .set(updates)
-    .where("id", "=", id)
+    .where("id", "=", category.id)
     .returningAll()
     .executeTakeFirst();
 

package/src/modules/product-management/docs/commands/UpdateProduct.md

@@ -2,12 +2,11 @@
 
 ## Overview
 
-updateProduct modifies mutable fields of an existing product — name, description, and UoM. Product code is immutable and cannot be changed. The set of updatable fields may depend on the product's lifecycle status: UoM can only be updated in DRAFT status, while name and description can be updated in any status.
+updateProduct modifies mutable fields of an existing product — name, description, and UoM. The product can be looked up by `id` or `code`. The set of updatable fields may depend on the product's lifecycle status: UoM can only be updated in DRAFT status, while name and description can be updated in any status.
 
 ## Business Rules
 
-- Target product must exist
-- Product code is immutable — any attempt to change code returns an error
+- Target product must exist (looked up by `id` or `code`)
 - Name can be updated in any status (DRAFT, ACTIVE, ARCHIVED); must remain non-empty
 - Description can be updated in any status
 - UoM can be updated only in DRAFT status — once activated, UoM is locked to preserve variant consistency
@@ -18,20 +17,18 @@ updateProduct modifies mutable fields of an existing product — name, descripti
 
 ```mermaid
 flowchart TD
-    A[Receive update request] --> B{Product exists?}
-    B -->|No| C[Return error: PRODUCT_NOT_FOUND]
-    B -->|Yes| D{Code change attempted?}
-    D -->|Yes| E[Return error: CODE_IMMUTABLE]
-    D -->|No| F{Any field provided?}
-    F -->|No| G[Return error: NO_FIELDS_TO_UPDATE]
-    F -->|Yes| H{UoM change requested?}
-    H -->|Yes| I{Status is DRAFT?}
-    I -->|No| J[Return error: UOM_LOCKED]
-    I -->|Yes| K{UoM valid and active?}
-    K -->|No| L[Return error: INVALID_UOM]
-    K -->|Yes| M[Apply updates]
-    H -->|No| M
-    M --> N[Return updated product]
+    A[Receive update request] --> B{Lookup by id or code}
+    B -->|Not found| C[Return error: PRODUCT_NOT_FOUND]
+    B -->|Found| D{Any field provided?}
+    D -->|No| E[Return error: NO_FIELDS_TO_UPDATE]
+    D -->|Yes| F{UoM change requested?}
+    F -->|Yes| G{Status is DRAFT?}
+    G -->|No| H[Return error: UOM_LOCKED]
+    G -->|Yes| I{UoM valid and active?}
+    I -->|No| J[Return error: INVALID_UOM]
+    I -->|Yes| K[Apply updates]
+    F -->|No| K
+    K --> L[Return updated product]
 ```
 
 ## External Dependencies
@@ -40,8 +37,7 @@ flowchart TD
 
 ## Error Scenarios
 
-- **PRODUCT_NOT_FOUND**: Specified product ID does not exist
-- **CODE_IMMUTABLE**: Attempt to change the product code
+- **PRODUCT_NOT_FOUND**: Specified product does not exist
 - **MISSING_REQUIRED_FIELD**: Name is empty or blank when provided
 - **NO_FIELDS_TO_UPDATE**: No updatable fields were provided in the request
 - **UOM_LOCKED**: UoM cannot be changed after product has been activated
@@ -50,7 +46,6 @@ flowchart TD
 ## Test Cases
 
 - returns error when product not found
-- returns error when code change attempted
 - returns error when no fields provided
 - returns error when name is empty
 - returns error when UoM locked on non-DRAFT
@@ -58,4 +53,5 @@ flowchart TD
 - updates description successfully
 - updates UoM successfully on DRAFT product
 - updates name successfully
+- looks up product by code and updates name
 - passes custom fields through