@tailor-platform/erp-kit 0.5.1 → 0.6.0

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);

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

@@ -0,0 +1,135 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  WorkCenterNotFoundError,
+  WorkCenterNotActivatableError,
+  MissingCalendarContextError,
+  InvalidCapacityError,
+  InvalidRateError,
+  OverheadCurrencyRequiredError,
+} from "../lib/errors.generated";
+import {
+  baseDraftWorkCenter,
+  baseActiveWorkCenter,
+  baseInactiveWorkCenter,
+} from "../testing/fixtures";
+import { run } from "./activateWorkCenter";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("activateWorkCenter", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["manufacturing:activateWorkCenter"],
+  };
+
+  it("activates a valid draft work center", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const activated = { ...baseDraftWorkCenter, status: "ACTIVE" as const };
+
+    spies.select.mockReturnValueOnce(baseDraftWorkCenter);
+    spies.update.mockReturnValue(activated);
+
+    const result = await run(db, { id: baseDraftWorkCenter.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.workCenter.status).toBe("ACTIVE");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("reactivates a valid inactive work center", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const reactivated = { ...baseInactiveWorkCenter, status: "ACTIVE" as const };
+
+    spies.select.mockReturnValueOnce(baseInactiveWorkCenter);
+    spies.update.mockReturnValue(reactivated);
+
+    const result = await run(db, { id: baseInactiveWorkCenter.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.workCenter.status).toBe("ACTIVE");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("returns error when the work center does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(WorkCenterNotFoundError);
+    }
+  });
+
+  it("returns error when the status does not allow activation", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+
+    const result = await run(db, { id: baseActiveWorkCenter.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(WorkCenterNotActivatableError);
+    }
+  });
+
+  it("returns error when required calendar context is missing", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const noCalendar = { ...baseDraftWorkCenter, calendarReference: null };
+    spies.select.mockReturnValueOnce(noCalendar);
+
+    const result = await run(db, { id: baseDraftWorkCenter.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingCalendarContextError);
+    }
+  });
+
+  it("returns error when capacity is not positive", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const zeroCapacity = { ...baseDraftWorkCenter, capacityAssumptions: 0 };
+    spies.select.mockReturnValueOnce(zeroCapacity);
+
+    const result = await run(db, { id: baseDraftWorkCenter.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidCapacityError);
+    }
+  });
+
+  it("returns error when a configured rate is negative", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce({ ...baseDraftWorkCenter, laborRate: -1 });
+
+    const result = await run(db, { id: baseDraftWorkCenter.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidRateError);
+    }
+  });
+
+  it("returns error when fixed overhead is missing its currency", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce({
+      ...baseDraftWorkCenter,
+      overheadAbsorptionMethod: "FIXED_AMOUNT_PER_GOOD_UNIT",
+      overheadAbsorptionCurrency: null,
+    });
+
+    const result = await run(db, { id: baseDraftWorkCenter.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(OverheadCurrencyRequiredError);
+    }
+  });
+});

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

@@ -0,0 +1,91 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  WorkCenterNotFoundError,
+  WorkCenterNotActivatableError,
+  MissingCalendarContextError,
+  InvalidCapacityError,
+  InvalidRateError,
+  OverheadCurrencyRequiredError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+const ACTIVATABLE_STATUSES = ["DRAFT", "INACTIVE"] as const;
+
+export interface ActivateWorkCenterInput {
+  id: string;
+  from?: string[];
+}
+
+/**
+ * Function: activateWorkCenter
+ *
+ * Validates that a draft or inactive work center has the execution data
+ * required by planning and costing, then marks it available for routing
+ * and work-order use.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: ActivateWorkCenterInput & CF,
+  _ctx: CommandContext,
+) {
+  const { id, from, ...customFields } = input;
+  void customFields;
+
+  const allowedStatuses = from ?? [...ACTIVATABLE_STATUSES];
+
+  // 1. Fetch work center with lock
+  const workCenter = await db
+    .selectFrom("WorkCenter")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!workCenter) {
+    return err(new WorkCenterNotFoundError(id));
+  }
+
+  // 2. Validate status is activatable
+  if (!allowedStatuses.includes(workCenter.status)) {
+    return err(new WorkCenterNotActivatableError(workCenter.code));
+  }
+
+  // 3. Validate calendar context
+  if (!workCenter.calendarReference) {
+    return err(new MissingCalendarContextError(workCenter.code));
+  }
+
+  // 4. Validate capacity > 0
+  if (workCenter.capacityAssumptions <= 0) {
+    return err(new InvalidCapacityError(workCenter.code));
+  }
+
+  // 5. Validate rates >= 0
+  if (workCenter.laborRate != null && workCenter.laborRate < 0) {
+    return err(new InvalidRateError(workCenter.code));
+  }
+  if (workCenter.machineRate != null && workCenter.machineRate < 0) {
+    return err(new InvalidRateError(workCenter.code));
+  }
+
+  // 6. Validate overhead currency for FIXED_AMOUNT_PER_GOOD_UNIT
+  if (
+    workCenter.overheadAbsorptionMethod === "FIXED_AMOUNT_PER_GOOD_UNIT" &&
+    !workCenter.overheadAbsorptionCurrency
+  ) {
+    return err(new OverheadCurrencyRequiredError(workCenter.code));
+  }
+
+  // 7. Set status to ACTIVE
+  const updatedWorkCenter = await db
+    .updateTable("WorkCenter")
+    .set({
+      status: "ACTIVE",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ workCenter: updatedWorkCenter! });
+}

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

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