@tailor-platform/erp-kit 0.6.0 → 0.8.0

package/src/modules/item-management/command/updateItem.ts

@@ -4,68 +4,84 @@ import {
   UnitNotFoundError,
   ItemNotFoundError,
   NoFieldsToUpdateError,
-  SkuImmutableError,
   UomLockedError,
 } from "../lib/errors.generated";
 import { type PrimitivesQueries } from "../module";
 import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
 
-export interface UpdateItemInput {
-  id: string;
-  sku?: string;
+export type UpdateItemInput = (
+  | {
+      id: string;
+    }
+  | {
+      sku: string;
+    }
+) & {
   name?: string;
   barcode?: string | null;
   unitId?: string;
-}
+};
 
 /**
  * Function: updateItem
  *
- * Updates mutable fields of an existing item. SKU is immutable.
- * UoM can only be changed in DRAFT status.
+ * Updates mutable fields of an existing item.
+ * The item can be looked up by id or sku. UoM can only be changed in DRAFT status.
  */
 export async function run<CF extends Record<string, unknown>>(
   db: Transaction,
-  input: UpdateItemInput & Partial<CF>,
+  input: UpdateItemInput & Omit<Partial<CF>, "status">,
   ctx: CommandContext,
   primitivesQueries?: Pick<PrimitivesQueries, "getUnit">,
 ) {
-  const { id, sku, name, barcode, unitId, ...customFields } = input;
-
-  // 1. Check item exists
-  const item = await db
-    .selectFrom("Item")
-    .selectAll()
-    .where("id", "=", id)
-    .forUpdate()
-    .executeTakeFirst();
+  const { name, barcode, unitId } = input;
 
-  if (!item) {
-    return err(new ItemNotFoundError(id));
+  const ITEM_OWN_KEYS = new Set(["id", "sku", "name", "barcode", "unitId"]);
+  const customFields: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(input as Record<string, unknown>)) {
+    if (!ITEM_OWN_KEYS.has(key)) {
+      customFields[key] = value;
+    }
   }
 
-  // 2. SKU is immutable
-  if (sku !== undefined) {
-    return err(new SkuImmutableError(id));
+  // 1. Check item exists (lookup by id or sku)
+  const item =
+    "id" in input
+      ? await db
+          .selectFrom("Item")
+          .selectAll()
+          .where("id", "=", (input as { id: string }).id)
+          .forUpdate()
+          .executeTakeFirst()
+      : await db
+          .selectFrom("Item")
+          .selectAll()
+          .where("sku", "=", (input as { sku: string }).sku)
+          .forUpdate()
+          .executeTakeFirst();
+
+  if (!item) {
+    const key = "id" in input ? (input as { id: string }).id : (input as { sku: string }).sku;
+    return err(new ItemNotFoundError(key));
   }
 
-  // 3. Check at least one field provided
+  // 2. Check at least one field provided
   const hasName = name !== undefined;
   const hasBarcode = barcode !== undefined;
   const hasUnitId = unitId !== undefined;
   const hasCustomFields = Object.keys(customFields).length > 0;
 
   if (!hasName && !hasBarcode && !hasUnitId && !hasCustomFields) {
-    return err(new NoFieldsToUpdateError(id));
+    return err(new NoFieldsToUpdateError(item.id));
   }
 
-  // 4. Check barcode uniqueness when provided (non-null)
+  // 3. Check barcode uniqueness when provided (non-null)
   if (hasBarcode && barcode !== null) {
     const existingBarcode = await db
       .selectFrom("Item")
       .selectAll()
       .where("barcode", "=", barcode)
-      .where("id", "!=", id)
+      .where("id", "!=", item.id)
       .forUpdate()
       .executeTakeFirst();
 
@@ -74,10 +90,10 @@ export async function run<CF extends Record<string, unknown>>(
     }
   }
 
-  // 5. UoM can only be changed in DRAFT status
+  // 4. UoM can only be changed in DRAFT status
   if (hasUnitId) {
     if (item.status !== "DRAFT") {
-      return err(new UomLockedError(id));
+      return err(new UomLockedError(item.id));
     }
 
     // Validate UoM exists and is active
@@ -88,9 +104,9 @@ export async function run<CF extends Record<string, unknown>>(
     }
   }
 
-  // 6. Apply updates
+  // 5. Apply updates
   const updates: Record<string, unknown> = {
-    ...(customFields as Record<string, unknown>),
+    ...customFields,
     updatedAt: new Date(),
   };
   if (hasName) updates.name = name;
@@ -100,7 +116,7 @@ export async function run<CF extends Record<string, unknown>>(
   const updatedItem = await db
     .updateTable("Item")
     .set(updates)
-    .where("id", "=", id)
+    .where("id", "=", item.id)
     .returningAll()
     .executeTakeFirstOrThrow();
 

package/src/modules/item-management/command/updateTaxonomyNode.test.ts

@@ -1,11 +1,7 @@
 import { describe, expect, it } from "vitest";
 import { createMockDb } from "../../../testing/index";
 import { Transaction } from "../generated/kysely-tailordb";
-import {
-  CodeImmutableError,
-  MissingRequiredFieldsError,
-  NodeNotFoundError,
-} from "../lib/errors.generated";
+import { MissingRequiredFieldsError, NodeNotFoundError } from "../lib/errors.generated";
 import { baseRootNode } from "../testing/fixtures";
 import { run } from "./updateTaxonomyNode";
 
@@ -21,17 +17,6 @@ describe("updateTaxonomyNode", () => {
     }
   });
 
-  it("returns error when attempting to change code", async () => {
-    const { db, spies } = createMockDb<Transaction>();
-    spies.select.mockReturnValueOnce(baseRootNode);
-
-    const result = await run(db, { id: baseRootNode.id, code: "NEW-CODE" });
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error).toBeInstanceOf(CodeImmutableError);
-    }
-  });
-
   it("returns error when name is empty", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(baseRootNode);
@@ -69,6 +54,20 @@ describe("updateTaxonomyNode", () => {
     expect(spies.update).toHaveBeenCalled();
   });
 
+  it("looks up node by code and updates name", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedNode = { ...baseRootNode, name: "Consumer Electronics" };
+    spies.select.mockReturnValueOnce(baseRootNode);
+    spies.update.mockReturnValue(updatedNode);
+
+    const result = await run(db, { code: baseRootNode.code, name: "Consumer Electronics" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.node.name).toBe("Consumer Electronics");
+    }
+  });
+
   it("passes custom fields through to set", async () => {
     const { db, spies } = createMockDb<Transaction>();
     const updatedNode = { ...baseRootNode, sortOrder: 5 };

package/src/modules/item-management/command/updateTaxonomyNode.ts

@@ -1,55 +1,68 @@
 import { Transaction } from "../generated/kysely-tailordb";
-import {
-  CodeImmutableError,
-  MissingRequiredFieldsError,
-  NodeNotFoundError,
-} from "../lib/errors.generated";
+import { MissingRequiredFieldsError, NodeNotFoundError } from "../lib/errors.generated";
 import { ok, err } from "@tailor-platform/erp-kit/module";
 
-export interface UpdateTaxonomyNodeInput {
-  id: string;
-  code?: string;
+export type UpdateTaxonomyNodeInput = (
+  | {
+      id: string;
+    }
+  | {
+      code: string;
+    }
+) & {
   name?: string;
-}
+};
 
 /**
  * Function: updateTaxonomyNode
  *
  * Updates the display name of an existing taxonomy node.
- * Node code is immutable.
+ * The node can be looked up by id or code.
  */
 export async function run<CF extends Record<string, unknown>>(
   db: Transaction,
-  input: UpdateTaxonomyNodeInput & Partial<CF>,
+  input: UpdateTaxonomyNodeInput & Omit<Partial<CF>, "status">,
 ) {
-  const { id, code, name, ...customFields } = input;
-
-  // 1. Check node exists
-  const node = await db
-    .selectFrom("TaxonomyNode")
-    .selectAll()
-    .where("id", "=", id)
-    .forUpdate()
-    .executeTakeFirst();
+  const { name } = input;
 
-  if (!node) {
-    return err(new NodeNotFoundError(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;
+    }
   }
 
-  // 2. Code is immutable
-  if (code !== undefined) {
-    return err(new CodeImmutableError(id));
+  // 1. Check node exists (lookup by id or code)
+  const node =
+    "id" in input
+      ? await db
+          .selectFrom("TaxonomyNode")
+          .selectAll()
+          .where("id", "=", (input as { id: string }).id)
+          .forUpdate()
+          .executeTakeFirst()
+      : await db
+          .selectFrom("TaxonomyNode")
+          .selectAll()
+          .where("code", "=", (input as { code: string }).code)
+          .forUpdate()
+          .executeTakeFirst();
+
+  if (!node) {
+    const key = "id" in input ? (input as { id: string }).id : (input as { code: string }).code;
+    return err(new NodeNotFoundError(key));
   }
 
-  // 3. Name must be provided and non-empty (unless custom fields provided)
+  // 2. Name must be provided and non-empty (unless custom fields provided)
   const hasCustomFields = Object.keys(customFields).length > 0;
   if (!name && !hasCustomFields) {
     return err(new MissingRequiredFieldsError("name"));
   }
 
-  // 4. Update fields
+  // 3. Update fields
   const updates: Record<string, unknown> = {
-    ...(customFields as Record<string, unknown>),
+    ...customFields,
     updatedAt: new Date(),
   };
   if (name) updates.name = name;
@@ -57,7 +70,7 @@ export async function run<CF extends Record<string, unknown>>(
   const updatedNode = await db
     .updateTable("TaxonomyNode")
     .set(updates)
-    .where("id", "=", id)
+    .where("id", "=", node.id)
     .returningAll()
     .executeTakeFirstOrThrow();
 

package/src/modules/item-management/docs/commands/UpdateItem.md

@@ -2,14 +2,13 @@
 
 ## Overview
 
-updateItem modifies mutable fields of an existing item — name, barcode, and unit of measure (UoM). SKU is immutable and cannot be changed after creation. The set of updatable fields depends on the item's current lifecycle status.
+updateItem modifies mutable fields of an existing item — name, barcode, and unit of measure (UoM). The item can be looked up by `id` or `sku`. The set of updatable fields depends on the item's current lifecycle status.
 
 This command supports the DRAFT review workflow (correcting barcodes, setting names before activation) as well as post-activation updates to non-transactional fields.
 
 ## Business Rules
 
-- Target item must exist in the system
-- SKU is immutable — any attempt to change SKU returns an error
+- Target item must exist in the system (looked up by `id` or `sku`)
 - Name can be updated in any status (DRAFT, ACTIVE, INACTIVE)
 - Barcode can be updated in any status; must remain unique across all items when provided
 - Barcode can be cleared (set to null) to remove it from the item
@@ -21,11 +20,9 @@ This command supports the DRAFT review workflow (correcting barcodes, setting na
 
 ```mermaid
 flowchart TD
-    A[Receive update request] --> B{Item exists?}
-    B -->|No| C[Return error: not found]
-    B -->|Yes| D{SKU change attempted?}
-    D -->|Yes| E[Return error: SKU immutable]
-    D -->|No| F{Any field provided?}
+    A[Receive update request] --> B{Lookup by id or sku}
+    B -->|Not found| C[Return error: not found]
+    B -->|Found| F{Any field provided?}
     F -->|No| G[Return error: no fields to update]
     F -->|Yes| H{Barcode provided?}
     H -->|Yes| I{Barcode unique?}
@@ -47,8 +44,7 @@ flowchart TD
 
 ## Error Scenarios
 
-- **ITEM_NOT_FOUND**: Specified item ID does not exist
-- **SKU_IMMUTABLE**: Attempt to change the SKU field
+- **ITEM_NOT_FOUND**: Specified item does not exist
 - **DUPLICATE_BARCODE**: An item with the same barcode already exists
 - **UNIT_NOT_FOUND**: Referenced unit does not exist or is inactive
 - **UOM_LOCKED**: UoM cannot be changed after item has been activated (status is ACTIVE or INACTIVE)
@@ -57,13 +53,13 @@ flowchart TD
 ## Test Cases
 
 - returns error when item does not exist
-- returns error when attempting to change SKU
 - returns error when no fields to update
 - returns error when barcode is duplicate
 - returns error when changing UoM on non-DRAFT item
 - returns error when changing UoM on INACTIVE item
 - returns error when new UoM does not exist
 - updates name in any status
+- looks up item by sku and updates name
 - updates barcode in any status
 - clears barcode by setting to null
 - updates UoM in DRAFT status

package/src/modules/item-management/docs/commands/UpdateTaxonomyNode.md

@@ -2,12 +2,11 @@
 
 ## Overview
 
-updateTaxonomyNode modifies the display name of an existing taxonomy node. The node code is immutable and cannot be changed after creation — only the name (display label) can be updated. This supports scenarios such as renaming a classification branch to better reflect its contents or aligning terminology across the organization.
+updateTaxonomyNode modifies the display name of an existing taxonomy node. The node can be looked up by `id` or `code`. This supports scenarios such as renaming a classification branch to better reflect its contents or aligning terminology across the organization.
 
 ## Business Rules
 
-- Target node must exist in the system
-- Node code is immutable — any attempt to change the code returns an error
+- Target node must exist in the system (looked up by `id` or `code`)
 - Name is required and must not be empty
 - Name update does not affect the node's position in the tree, child nodes, or item assignments
 
@@ -15,14 +14,12 @@ updateTaxonomyNode modifies the display name of an existing taxonomy node. The n
 
 ```mermaid
 flowchart TD
-    A[Receive update request] --> B{Node exists?}
-    B -->|No| C[Return error: not found]
-    B -->|Yes| D{Code change attempted?}
-    D -->|Yes| E[Return error: code immutable]
-    D -->|No| F{Name provided and non-empty?}
-    F -->|No| G[Return error: name required]
-    F -->|Yes| H[Update node name]
-    H --> I[Return updated node]
+    A[Receive update request] --> B{Lookup by id or code}
+    B -->|Not found| C[Return error: not found]
+    B -->|Found| D{Name provided and non-empty?}
+    D -->|No| E[Return error: name required]
+    D -->|Yes| F[Update node name]
+    F --> G[Return updated node]
 ```
 
 ## External Dependencies
@@ -31,15 +28,14 @@ flowchart TD
 
 ## Error Scenarios
 
-- **NODE_NOT_FOUND**: Specified node ID does not exist
-- **CODE_IMMUTABLE**: Attempt to change the node code
+- **NODE_NOT_FOUND**: Specified node does not exist
 - **MISSING_REQUIRED_FIELDS**: Name not provided or empty
 
 ## Test Cases
 
 - returns error when node does not exist
-- returns error when attempting to change code
 - returns error when name is empty
 - returns error when name is not provided
 - updates node name
+- looks up node by code and updates name
 - passes custom fields through to set

package/src/modules/manufacturing/command/updateBillOfMaterial.ts

@@ -16,7 +16,7 @@ export interface UpdateBillOfMaterialLineInput {
   isSubassembly?: boolean | null;
 }
 
-export interface UpdateBillOfMaterialInput {
+export type UpdateBillOfMaterialInput = {
   id: string;
   bomType?: string | null;
   effectivityStartDate?: Date | null;
@@ -24,8 +24,7 @@ export interface UpdateBillOfMaterialInput {
   defaultSelection?: boolean | null;
   revisionNumber?: string | null;
   lines?: UpdateBillOfMaterialLineInput[];
-}
-
+};
 /**
  * Function: updateBillOfMaterial
  *
@@ -35,7 +34,7 @@ export interface UpdateBillOfMaterialInput {
  */
 export async function run<CF extends Record<string, unknown>>(
   db: Transaction,
-  input: UpdateBillOfMaterialInput & CF,
+  input: UpdateBillOfMaterialInput & Omit<Partial<CF>, "status">,
   _ctx: CommandContext,
 ) {
   const {

package/src/modules/manufacturing/command/updateProductionOrder.ts

@@ -8,7 +8,7 @@ import {
 } from "../lib/errors.generated";
 import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
 
-export interface UpdateProductionOrderInput {
+export type UpdateProductionOrderInput = {
   id: string;
   plannedQuantity?: number | null;
   plannedStartDate?: Date | null;
@@ -18,8 +18,7 @@ export interface UpdateProductionOrderInput {
   orderedItemId?: string | null;
   companyId?: string | null;
   siteId?: string | null;
-}
-
+};
 /**
  * Function: updateProductionOrder
  *
@@ -28,7 +27,7 @@ export interface UpdateProductionOrderInput {
  */
 export async function run<CF extends Record<string, unknown>>(
   db: Transaction,
-  input: UpdateProductionOrderInput & CF,
+  input: UpdateProductionOrderInput & Omit<Partial<CF>, "status">,
   _ctx: CommandContext,
 ) {
   const {

package/src/modules/manufacturing/command/updateRouting.ts

@@ -18,12 +18,11 @@ export interface UpdateRoutingOperationInput {
   operatorInstructions?: string | null;
 }
 
-export interface UpdateRoutingInput {
+export type UpdateRoutingInput = {
   id: string;
   revisionNumber?: string | null;
   operations: UpdateRoutingOperationInput[];
-}
-
+};
 /**
  * Function: updateRouting
  *
@@ -32,7 +31,7 @@ export interface UpdateRoutingInput {
  */
 export async function run<CF extends Record<string, unknown>>(
   db: Transaction,
-  input: UpdateRoutingInput & CF,
+  input: UpdateRoutingInput & Omit<Partial<CF>, "status">,
   _ctx: CommandContext,
 ) {
   const { id, revisionNumber, operations, ...customFields } = input;

package/src/modules/manufacturing/command/updateWorkCenter.test.ts

@@ -7,7 +7,6 @@ import {
   InvalidRateError,
   InvalidOverheadMethodError,
   OverheadCurrencyRequiredError,
-  ImmutableScopeFieldError,
 } from "../lib/errors.generated";
 import { baseActiveWorkCenter } from "../testing/fixtures";
 import { run } from "./updateWorkCenter";
@@ -56,18 +55,28 @@ describe("updateWorkCenter", () => {
     }
   });
 
-  it("returns error when immutable scope fields are changed", async () => {
-    const { db } = createMockDb<Transaction>();
+  it("looks up a work center by companyId, siteId, and code", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+    spies.update.mockReturnValue({
+      ...baseActiveWorkCenter,
+      capacityAssumptions: 220,
+    });
 
     const result = await run(
       db,
-      { ...validInput, companyId: "other-company" } as Parameters<typeof run>[1],
+      {
+        companyId: baseActiveWorkCenter.companyId,
+        siteId: baseActiveWorkCenter.siteId,
+        code: baseActiveWorkCenter.code,
+        capacityAssumptions: 220,
+      },
       ctx,
     );
 
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error).toBeInstanceOf(ImmutableScopeFieldError);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.workCenter.capacityAssumptions).toBe(220);
     }
   });