@tailor-platform/erp-kit 0.5.0 → 0.6.0

package/src/modules/manufacturing/command/activateBillOfMaterial.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./activateBillOfMaterial";
+import { defineCommand } from "@tailor-platform/erp-kit/module";
+
+export const activateBillOfMaterial = defineCommand(permissions.activateBillOfMaterial, run);

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

@@ -0,0 +1,166 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  BomNotFoundError,
+  BomNotActivatableError,
+  ComponentLineRequiredError,
+  ComponentItemInactiveError,
+  CircularBomReferenceError,
+  EffectivityConflictError,
+} from "../lib/errors.generated";
+import { baseDraftBom, baseActiveBom, baseBomLine } from "../testing/fixtures";
+import { run } from "./activateBillOfMaterial";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("activateBillOfMaterial", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["manufacturing:activateBillOfMaterial"],
+  };
+
+  it("activates a valid draft BOM", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const activatedBom = { ...baseDraftBom, status: "ACTIVE" as const };
+
+    // BOM exists and is DRAFT
+    spies.select.mockReturnValueOnce(baseDraftBom);
+    // lines exist
+    spies.select.mockReturnValueOnce([baseBomLine]);
+    // component item exists (active)
+    spies.select.mockReturnValueOnce({ id: "item-2" });
+    // no conflicting active BOM
+    spies.select.mockReturnValueOnce(undefined);
+    // update to ACTIVE
+    spies.update.mockReturnValue(activatedBom);
+
+    const result = await run(db, { id: "bom-1" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.billOfMaterial.status).toBe("ACTIVE");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("returns error when the BOM does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "bom-nonexistent" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(BomNotFoundError);
+    }
+  });
+
+  it("returns error when the BOM is not in DRAFT", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    spies.select.mockReturnValueOnce(baseActiveBom);
+
+    const result = await run(db, { id: "bom-2" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(BomNotActivatableError);
+    }
+  });
+
+  it("returns error when the BOM has no component lines", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // BOM exists and is DRAFT
+    spies.select.mockReturnValueOnce(baseDraftBom);
+    // no lines
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, { id: "bom-1" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ComponentLineRequiredError);
+    }
+  });
+
+  it("returns error when a component item is inactive", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // BOM exists and is DRAFT
+    spies.select.mockReturnValueOnce(baseDraftBom);
+    // lines exist
+    spies.select.mockReturnValueOnce([baseBomLine]);
+    // component item not found (inactive)
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "bom-1" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ComponentItemInactiveError);
+    }
+  });
+
+  it("returns error when a circular manufactured-item structure is detected", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const bomWithSubassembly = {
+      ...baseDraftBom,
+    };
+    const subassemblyLine = {
+      ...baseBomLine,
+      isSubassembly: true,
+      itemId: "item-sub",
+    };
+
+    // BOM exists and is DRAFT
+    spies.select.mockReturnValueOnce(bomWithSubassembly);
+    // lines with subassembly
+    spies.select.mockReturnValueOnce([subassemblyLine]);
+    // component item exists
+    spies.select.mockReturnValueOnce({ id: "item-sub" });
+    // child BOMs exist for subassembly item (execute returns array)
+    spies.select.mockReturnValueOnce([
+      {
+        ...baseDraftBom,
+        id: "child-bom",
+        parentItemId: "item-sub",
+      },
+    ]);
+    // child BOM lines reference back to parent item (circular)
+    spies.select.mockReturnValueOnce([{ ...baseBomLine, itemId: "item-1" }]);
+
+    const result = await run(db, { id: "bom-1" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CircularBomReferenceError);
+    }
+  });
+
+  it("returns error when activation would create an effectivity conflict", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // BOM exists and is DRAFT with default selection
+    spies.select.mockReturnValueOnce(baseDraftBom);
+    // lines exist
+    spies.select.mockReturnValueOnce([baseBomLine]);
+    // component item exists
+    spies.select.mockReturnValueOnce({ id: "item-2" });
+    // conflicting active BOM with same parent + default selection + no date bounds
+    spies.select.mockReturnValueOnce({
+      ...baseActiveBom,
+      defaultSelection: true,
+      effectivityStartDate: null,
+      effectivityEndDate: null,
+    });
+
+    const result = await run(db, { id: "bom-1" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(EffectivityConflictError);
+    }
+  });
+});

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

@@ -0,0 +1,173 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  BomNotFoundError,
+  BomNotActivatableError,
+  ComponentLineRequiredError,
+  ComponentItemInactiveError,
+  CircularBomReferenceError,
+  EffectivityConflictError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface ActivateBillOfMaterialInput {
+  id: string;
+  from?: string[];
+}
+
+/**
+ * Function: activateBillOfMaterial
+ *
+ * Validates a draft BOM version and makes it selectable for production-order
+ * release. Activation enforces circular-reference checks, effectivity
+ * conflicts, and component readiness.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: ActivateBillOfMaterialInput & CF,
+  _ctx: CommandContext,
+) {
+  const { id, from, ...customFields } = input;
+  void customFields;
+
+  const allowedStatuses = from ?? ["DRAFT"];
+
+  // 1. Fetch BOM with lock
+  const bom = await db
+    .selectFrom("BillOfMaterial")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!bom) {
+    return err(new BomNotFoundError(id));
+  }
+
+  // 2. Validate status is activatable
+  if (!allowedStatuses.includes(bom.status)) {
+    return err(new BomNotActivatableError(id));
+  }
+
+  // 3. Validate at least one component line exists
+  const lines = await db
+    .selectFrom("BillOfMaterialLine")
+    .selectAll()
+    .where("billOfMaterialId", "=", id)
+    .execute();
+
+  if (!lines || lines.length === 0) {
+    return err(new ComponentLineRequiredError(id));
+  }
+
+  // 4. Validate all component items are active
+  for (const line of lines) {
+    const componentItem = await db
+      .selectFrom("Item")
+      .selectAll()
+      .where("id", "=", line.itemId)
+      .executeTakeFirst();
+
+    if (!componentItem) {
+      return err(new ComponentItemInactiveError(line.itemId));
+    }
+  }
+
+  // 5. Check for circular references using DFS traversal
+  const circularResult = await detectCircularReference(
+    db,
+    bom.parentItemId,
+    lines,
+    new Set<string>([bom.parentItemId]),
+  );
+  if (circularResult) {
+    return err(new CircularBomReferenceError(id));
+  }
+
+  // 6. Check effectivity conflicts — overlapping active effectivity windows
+  //    for the same parent item and scope
+  const conflictingBom = await db
+    .selectFrom("BillOfMaterial")
+    .selectAll()
+    .where("parentItemId", "=", bom.parentItemId)
+    .where("companyId", "=", bom.companyId)
+    .where("id", "!=", id)
+    .where("status", "=", "ACTIVE")
+    .executeTakeFirst();
+
+  if (conflictingBom) {
+    // Check date overlap
+    const bomStart = bom.effectivityStartDate;
+    const bomEnd = bom.effectivityEndDate;
+    const conflictStart = conflictingBom.effectivityStartDate;
+    const conflictEnd = conflictingBom.effectivityEndDate;
+
+    const hasOverlap =
+      (!bomStart || !conflictEnd || bomStart <= conflictEnd) &&
+      (!bomEnd || !conflictStart || bomEnd >= conflictStart);
+
+    if (hasOverlap && bom.defaultSelection && conflictingBom.defaultSelection) {
+      return err(new EffectivityConflictError(id));
+    }
+  }
+
+  // 7. Set status to ACTIVE
+  const updatedBom = await db
+    .updateTable("BillOfMaterial")
+    .set({
+      status: "ACTIVE",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ billOfMaterial: updatedBom! });
+}
+
+async function detectCircularReference(
+  db: Transaction,
+  rootParentItemId: string,
+  lines: { itemId: string; isSubassembly: boolean | null }[],
+  visitedItems: Set<string>,
+): Promise<boolean> {
+  for (const line of lines) {
+    // If this item has already been visited in the path, we have a cycle
+    if (visitedItems.has(line.itemId)) {
+      return true;
+    }
+
+    if (!line.isSubassembly) continue;
+
+    // Find ALL child BOMs for this item (multiple versions may exist)
+    const childBoms = await db
+      .selectFrom("BillOfMaterial")
+      .selectAll()
+      .where("parentItemId", "=", line.itemId)
+      .where("status", "in", ["DRAFT", "ACTIVE"])
+      .execute();
+
+    if (childBoms.length > 0) {
+      visitedItems.add(line.itemId);
+
+      for (const childBom of childBoms) {
+        const childLines = await db
+          .selectFrom("BillOfMaterialLine")
+          .selectAll()
+          .where("billOfMaterialId", "=", childBom.id)
+          .execute();
+
+        const hasCycle = await detectCircularReference(
+          db,
+          rootParentItemId,
+          childLines,
+          visitedItems,
+        );
+
+        if (hasCycle) return true;
+      }
+
+      visitedItems.delete(line.itemId);
+    }
+  }
+  return false;
+}

package/src/modules/manufacturing/command/activateRouting.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./activateRouting";
+import { defineCommand } from "@tailor-platform/erp-kit/module";
+
+export const activateRouting = defineCommand(permissions.activateRouting, run);

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

@@ -0,0 +1,152 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  RoutingNotFoundError,
+  RoutingNotActivatableError,
+  OperationRequiredError,
+  DuplicateOperationSequenceError,
+  WorkCenterNotActiveError,
+  CrossCompanyWorkCenterError,
+} from "../lib/errors.generated";
+import {
+  baseDraftRouting,
+  baseActiveRouting,
+  baseRoutingOperation,
+  baseActiveWorkCenter,
+  baseInactiveWorkCenter,
+} from "../testing/fixtures";
+import { run } from "./activateRouting";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("activateRouting", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["manufacturing:activateRouting"],
+  };
+
+  const validInput = { id: "routing-1" };
+
+  it("activates a valid draft routing", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Routing lookup
+    spies.select.mockReturnValueOnce(baseDraftRouting);
+    // select: RoutingOperation list
+    spies.select.mockReturnValueOnce([baseRoutingOperation]);
+    // select: WorkCenter lookup for operation
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+    // update: status to ACTIVE
+    spies.update.mockReturnValue({ ...baseDraftRouting, status: "ACTIVE" });
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.routing.status).toBe("ACTIVE");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("returns error when the routing does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Routing lookup - not found
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(RoutingNotFoundError);
+    }
+  });
+
+  it("returns error when the routing is not in DRAFT", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Routing lookup - ACTIVE
+    spies.select.mockReturnValueOnce(baseActiveRouting);
+
+    const result = await run(db, { id: "routing-2" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(RoutingNotActivatableError);
+    }
+  });
+
+  it("returns error when the routing has no operations", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Routing lookup
+    spies.select.mockReturnValueOnce(baseDraftRouting);
+    // select: RoutingOperation list - empty
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(OperationRequiredError);
+    }
+  });
+
+  it("returns error when operation sequence numbers are duplicated", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Routing lookup
+    spies.select.mockReturnValueOnce(baseDraftRouting);
+    // select: RoutingOperation list with duplicate sequences
+    spies.select.mockReturnValueOnce([
+      baseRoutingOperation,
+      { ...baseRoutingOperation, id: "operation-dup", sequenceNumber: 10 },
+    ]);
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateOperationSequenceError);
+    }
+  });
+
+  it("returns error when a referenced work center is inactive", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Routing lookup
+    spies.select.mockReturnValueOnce(baseDraftRouting);
+    // select: RoutingOperation list
+    spies.select.mockReturnValueOnce([baseRoutingOperation]);
+    // select: WorkCenter lookup - INACTIVE
+    spies.select.mockReturnValueOnce(baseInactiveWorkCenter);
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(WorkCenterNotActiveError);
+    }
+  });
+
+  it("returns error when a referenced work center is outside the routing company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Routing lookup
+    spies.select.mockReturnValueOnce(baseDraftRouting);
+    // select: RoutingOperation list
+    spies.select.mockReturnValueOnce([baseRoutingOperation]);
+    // select: WorkCenter lookup - different company
+    spies.select.mockReturnValueOnce({
+      ...baseActiveWorkCenter,
+      companyId: "other-company",
+    });
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CrossCompanyWorkCenterError);
+    }
+  });
+});

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

@@ -0,0 +1,92 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  RoutingNotFoundError,
+  RoutingNotActivatableError,
+  OperationRequiredError,
+  DuplicateOperationSequenceError,
+  WorkCenterNotActiveError,
+  CrossCompanyWorkCenterError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface ActivateRoutingInput {
+  id: string;
+  from?: string[];
+}
+
+/**
+ * Function: activateRouting
+ *
+ * Validates a draft routing and transitions it to ACTIVE status.
+ * Enforces operation completeness, sequence integrity, and active
+ * work-center readiness.
+ */
+export async function run(db: Transaction, input: ActivateRoutingInput, _ctx: CommandContext) {
+  const { id, from = ["DRAFT"] } = input;
+
+  // 1. Fetch routing
+  const routing = await db
+    .selectFrom("Routing")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!routing) {
+    return err(new RoutingNotFoundError(id));
+  }
+
+  // 2. Verify allowed source status
+  if (!from.includes(routing.status)) {
+    return err(new RoutingNotActivatableError(id));
+  }
+
+  // 3. Fetch operations
+  const operations = await db
+    .selectFrom("RoutingOperation")
+    .selectAll()
+    .where("routingId", "=", id)
+    .execute();
+
+  // 4. At least one operation required
+  if (operations.length === 0) {
+    return err(new OperationRequiredError(id));
+  }
+
+  // 5. Validate unique sequence numbers
+  const seqNumbers = operations.map((op) => op.sequenceNumber);
+  const uniqueSeqs = new Set(seqNumbers);
+  if (uniqueSeqs.size !== seqNumbers.length) {
+    return err(new DuplicateOperationSequenceError(id));
+  }
+
+  // 6. Validate work centers are active and in same company
+  for (const op of operations) {
+    const workCenter = await db
+      .selectFrom("WorkCenter")
+      .selectAll()
+      .where("id", "=", op.workCenterId)
+      .executeTakeFirst();
+
+    if (workCenter?.status !== "ACTIVE") {
+      return err(new WorkCenterNotActiveError(op.workCenterId));
+    }
+
+    if (workCenter.companyId !== routing.companyId) {
+      return err(new CrossCompanyWorkCenterError(op.workCenterId));
+    }
+  }
+
+  // 7. Set status to ACTIVE
+  const updatedRouting = await db
+    .updateTable("Routing")
+    .set({
+      status: "ACTIVE",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ routing: updatedRouting! });
+}

package/src/modules/manufacturing/command/activateWorkCenter.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./activateWorkCenter";
+import { defineCommand } from "@tailor-platform/erp-kit/module";
+
+export const activateWorkCenter = defineCommand(permissions.activateWorkCenter, run);