@tailor-platform/erp-kit 0.5.0 → 0.6.0

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

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

@@ -0,0 +1,151 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ProductionOrderNotFoundError,
+  ProductionOrderNotCancellableError,
+  ExecutionAlreadyStartedError,
+  InventoryHandoffExistsError,
+} from "../lib/errors.generated";
+import {
+  baseDraftProductionOrder,
+  baseReleasedProductionOrder,
+  baseInProgressProductionOrder,
+  basePendingWorkOrder,
+  baseInProgressWorkOrder,
+  baseCollectingCostSummary,
+} from "../testing/fixtures";
+import { run } from "./cancelProductionOrder";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("cancelProductionOrder", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["manufacturing:cancelProductionOrder"],
+  };
+
+  it("cancels a draft production order", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const cancelled = { ...baseDraftProductionOrder, status: "CANCELLED" as const };
+
+    // order lookup
+    spies.select.mockReturnValueOnce(baseDraftProductionOrder);
+    // update order status
+    spies.update.mockReturnValue(cancelled);
+
+    const result = await run(db, { id: baseDraftProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.productionOrder.status).toBe("CANCELLED");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("cancels a released order before execution starts", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const cancelled = { ...baseReleasedProductionOrder, status: "CANCELLED" as const };
+
+    // order lookup
+    spies.select.mockReturnValueOnce(baseReleasedProductionOrder);
+    // work orders - all pending
+    spies.select.mockReturnValueOnce([basePendingWorkOrder]);
+    // cost summary - no actuals
+    spies.select.mockReturnValueOnce(baseCollectingCostSummary);
+    // cascade cancel work orders
+    spies.update.mockReturnValueOnce(undefined);
+    // update order status
+    spies.update.mockReturnValue(cancelled);
+
+    const result = await run(db, { id: baseReleasedProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.productionOrder.status).toBe("CANCELLED");
+    }
+  });
+
+  it("returns error when the order 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(ProductionOrderNotFoundError);
+    }
+  });
+
+  it("returns error when the status does not allow cancellation", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseInProgressProductionOrder);
+
+    const result = await run(db, { id: baseInProgressProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ProductionOrderNotCancellableError);
+    }
+  });
+
+  it("returns error when execution evidence already exists", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // order lookup
+    spies.select.mockReturnValueOnce(baseReleasedProductionOrder);
+    // work orders - one in progress
+    spies.select.mockReturnValueOnce([baseInProgressWorkOrder]);
+
+    const result = await run(db, { id: baseReleasedProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ExecutionAlreadyStartedError);
+    }
+  });
+
+  it("returns error when inventory handoff evidence already exists", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const costSummaryWithActuals = {
+      ...baseCollectingCostSummary,
+      actualMaterialCost: 500,
+    };
+
+    // order lookup
+    spies.select.mockReturnValueOnce(baseReleasedProductionOrder);
+    // work orders - all pending
+    spies.select.mockReturnValueOnce([basePendingWorkOrder]);
+    // cost summary with actual costs
+    spies.select.mockReturnValueOnce(costSummaryWithActuals);
+
+    const result = await run(db, { id: baseReleasedProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InventoryHandoffExistsError);
+    }
+  });
+
+  it("cascades cancellation to pending work orders", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const cancelled = { ...baseReleasedProductionOrder, status: "CANCELLED" as const };
+
+    // order lookup
+    spies.select.mockReturnValueOnce(baseReleasedProductionOrder);
+    // work orders - all pending
+    spies.select.mockReturnValueOnce([basePendingWorkOrder]);
+    // cost summary - no actuals
+    spies.select.mockReturnValueOnce(baseCollectingCostSummary);
+    // cascade cancel work orders (first update call)
+    spies.update.mockReturnValueOnce(undefined);
+    // update order status (second update call)
+    spies.update.mockReturnValue(cancelled);
+
+    const result = await run(db, { id: baseReleasedProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    // update should be called at least twice: once for work orders, once for order
+    expect(spies.update).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,114 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ProductionOrderNotFoundError,
+  ProductionOrderNotCancellableError,
+  ExecutionAlreadyStartedError,
+  InventoryHandoffExistsError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+const CANCELLABLE_STATUSES = ["DRAFT", "RELEASED"] as const;
+
+export interface CancelProductionOrderInput {
+  id: string;
+  from?: string[];
+}
+
+/**
+ * Function: cancelProductionOrder
+ *
+ * Abandons a draft or not-yet-started released order. Preserves audit
+ * history while blocking further execution updates and cascading
+ * cancellation to pending work orders.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: CancelProductionOrderInput & CF,
+  _ctx: CommandContext,
+) {
+  const { id, from, ...customFields } = input;
+  void customFields;
+
+  const allowedStatuses = from ?? [...CANCELLABLE_STATUSES];
+
+  // 1. Fetch production order with lock
+  const order = await db
+    .selectFrom("ProductionOrder")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!order) {
+    return err(new ProductionOrderNotFoundError(id));
+  }
+
+  // 2. Validate status is cancellable
+  if (!allowedStatuses.includes(order.status)) {
+    return err(new ProductionOrderNotCancellableError(id));
+  }
+
+  // 3. For released orders, check execution and inventory evidence
+  if (order.status === "RELEASED") {
+    // Check work orders for execution evidence
+    const workOrders = await db
+      .selectFrom("WorkOrder")
+      .selectAll()
+      .where("productionOrderId", "=", id)
+      .execute();
+
+    const hasExecution = workOrders.some(
+      (wo) =>
+        wo.status === "IN_PROGRESS" ||
+        wo.status === "PAUSED" ||
+        wo.status === "COMPLETE" ||
+        wo.completedQuantity > 0 ||
+        wo.actualStartDate != null,
+    );
+
+    if (hasExecution) {
+      return err(new ExecutionAlreadyStartedError(id));
+    }
+
+    // Check for inventory handoff evidence
+    const costSummary = await db
+      .selectFrom("ManufacturingCostSummary")
+      .selectAll()
+      .where("productionOrderId", "=", id)
+      .executeTakeFirst();
+
+    if (
+      costSummary &&
+      (costSummary.actualMaterialCost > 0 ||
+        costSummary.actualLaborCost > 0 ||
+        costSummary.actualMachineCost > 0 ||
+        costSummary.actualOverheadCost > 0)
+    ) {
+      return err(new InventoryHandoffExistsError(id));
+    }
+
+    // 4. Cascade cancellation to pending work orders
+    await db
+      .updateTable("WorkOrder")
+      .set({
+        status: "CANCELLED",
+        updatedAt: new Date(),
+      })
+      .where("productionOrderId", "=", id)
+      .where("status", "=", "PENDING")
+      .execute();
+  }
+
+  // 5. Set order status to CANCELLED
+  const cancelledOrder = await db
+    .updateTable("ProductionOrder")
+    .set({
+      status: "CANCELLED",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ productionOrder: cancelledOrder });
+}

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

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

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

@@ -0,0 +1,126 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ProductionOrderNotFoundError,
+  ProductionOrderNotClosableError,
+  OpenWorkRemainsError,
+  CostSummaryNotSettledError,
+} from "../lib/errors.generated";
+import {
+  baseTechCompleteProductionOrder,
+  baseCompletedProductionOrder,
+  baseClosedProductionOrder,
+  baseCompleteWorkOrder,
+  baseCancelledWorkOrder,
+  basePendingWorkOrder,
+  baseSettledCostSummary,
+  basePendingReviewCostSummary,
+} from "../testing/fixtures";
+import { run } from "./closeProductionOrder";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("closeProductionOrder", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["manufacturing:closeProductionOrder"],
+  };
+
+  it("closes a technically complete order with a settled cost summary", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const closed = { ...baseTechCompleteProductionOrder, status: "CLOSED" as const };
+
+    // order lookup
+    spies.select.mockReturnValueOnce(baseTechCompleteProductionOrder);
+    // work orders - all complete or cancelled
+    spies.select.mockReturnValueOnce([baseCompleteWorkOrder, baseCancelledWorkOrder]);
+    // cost summary in SETTLED
+    spies.select.mockReturnValueOnce({
+      ...baseSettledCostSummary,
+      productionOrderId: baseTechCompleteProductionOrder.id,
+    });
+    // update order status
+    spies.update.mockReturnValue(closed);
+
+    const result = await run(db, { id: baseTechCompleteProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.productionOrder.status).toBe("CLOSED");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("returns error when the order 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(ProductionOrderNotFoundError);
+    }
+  });
+
+  it("returns error when the order is not technically complete", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompletedProductionOrder);
+
+    const result = await run(db, { id: baseCompletedProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ProductionOrderNotClosableError);
+    }
+  });
+
+  it("returns error when open work or execution exceptions remain", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // order lookup
+    spies.select.mockReturnValueOnce(baseTechCompleteProductionOrder);
+    // work orders - one still pending
+    spies.select.mockReturnValueOnce([baseCompleteWorkOrder, basePendingWorkOrder]);
+
+    const result = await run(db, { id: baseTechCompleteProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(OpenWorkRemainsError);
+    }
+  });
+
+  it("returns error when the linked cost summary is not settled", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // order lookup
+    spies.select.mockReturnValueOnce(baseTechCompleteProductionOrder);
+    // work orders - all complete
+    spies.select.mockReturnValueOnce([baseCompleteWorkOrder]);
+    // cost summary not settled
+    spies.select.mockReturnValueOnce({
+      ...basePendingReviewCostSummary,
+      productionOrderId: baseTechCompleteProductionOrder.id,
+    });
+
+    const result = await run(db, { id: baseTechCompleteProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CostSummaryNotSettledError);
+    }
+  });
+
+  it("blocks further execution commands after close", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseClosedProductionOrder);
+
+    const result = await run(db, { id: baseClosedProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ProductionOrderNotClosableError);
+    }
+  });
+});