@tailor-platform/erp-kit 0.5.0 → 0.6.0

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

@@ -0,0 +1,145 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ProductionOrderNotFoundError,
+  ProductionOrderNotMutableError,
+  InvalidPlannedQuantityError,
+  ImmutableScopeFieldError,
+  CrossScopeMasterReferenceError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface UpdateProductionOrderInput {
+  id: string;
+  plannedQuantity?: number | null;
+  plannedStartDate?: Date | null;
+  plannedEndDate?: Date | null;
+  selectedBomVersionId?: string | null;
+  selectedRoutingRevisionId?: string | null;
+  orderedItemId?: string | null;
+  companyId?: string | null;
+  siteId?: string | null;
+}
+
+/**
+ * Function: updateProductionOrder
+ *
+ * Revises mutable draft planning fields such as dates, quantity, and
+ * preferred BOM or routing before release freezes execution assumptions.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: UpdateProductionOrderInput & CF,
+  _ctx: CommandContext,
+) {
+  const {
+    id,
+    plannedQuantity,
+    plannedStartDate,
+    plannedEndDate,
+    selectedBomVersionId,
+    selectedRoutingRevisionId,
+    orderedItemId,
+    companyId,
+    siteId,
+    ...customFields
+  } = input;
+
+  // 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. Only DRAFT orders are mutable
+  if (order.status !== "DRAFT") {
+    return err(new ProductionOrderNotMutableError(id));
+  }
+
+  // 3. Validate planned quantity if provided
+  if (plannedQuantity != null && plannedQuantity <= 0) {
+    return err(new InvalidPlannedQuantityError(id));
+  }
+
+  // 4. Immutable scope fields
+  if (
+    orderedItemId !== undefined &&
+    orderedItemId !== null &&
+    orderedItemId !== order.orderedItemId
+  ) {
+    return err(new ImmutableScopeFieldError(id));
+  }
+  if (companyId !== undefined && companyId !== null && companyId !== order.companyId) {
+    return err(new ImmutableScopeFieldError(id));
+  }
+  if (siteId !== undefined && siteId !== null && siteId !== order.siteId) {
+    return err(new ImmutableScopeFieldError(id));
+  }
+
+  // 5. Validate optional BOM reference scope
+  const effectiveBomId =
+    selectedBomVersionId !== undefined ? selectedBomVersionId : order.selectedBomVersionId;
+  if (effectiveBomId) {
+    const bom = await db
+      .selectFrom("BillOfMaterial")
+      .selectAll()
+      .where("id", "=", effectiveBomId)
+      .executeTakeFirst();
+
+    if (
+      bom &&
+      (bom.companyId !== order.companyId || (bom.siteId != null && bom.siteId !== order.siteId))
+    ) {
+      return err(new CrossScopeMasterReferenceError(id));
+    }
+  }
+
+  // 6. Validate optional routing reference scope
+  const effectiveRoutingId =
+    selectedRoutingRevisionId !== undefined
+      ? selectedRoutingRevisionId
+      : order.selectedRoutingRevisionId;
+  if (effectiveRoutingId) {
+    const routing = await db
+      .selectFrom("Routing")
+      .selectAll()
+      .where("id", "=", effectiveRoutingId)
+      .executeTakeFirst();
+
+    if (
+      routing &&
+      (routing.companyId !== order.companyId ||
+        (routing.siteId != null && routing.siteId !== order.siteId))
+    ) {
+      return err(new CrossScopeMasterReferenceError(id));
+    }
+  }
+
+  // 7. Build update set
+  const updateSet: Record<string, unknown> = {
+    ...customFields,
+    updatedAt: new Date(),
+  };
+
+  if (plannedQuantity !== undefined) updateSet.plannedQuantity = plannedQuantity;
+  if (plannedStartDate !== undefined) updateSet.plannedStartDate = plannedStartDate;
+  if (plannedEndDate !== undefined) updateSet.plannedEndDate = plannedEndDate;
+  if (selectedBomVersionId !== undefined) updateSet.selectedBomVersionId = selectedBomVersionId;
+  if (selectedRoutingRevisionId !== undefined)
+    updateSet.selectedRoutingRevisionId = selectedRoutingRevisionId;
+
+  // 8. Persist changes
+  const updated = await db
+    .updateTable("ProductionOrder")
+    .set(updateSet)
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ productionOrder: updated });
+}

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

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

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

@@ -0,0 +1,211 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  RoutingNotFoundError,
+  RoutingNotMutableError,
+  DuplicateOperationSequenceError,
+  InvalidStandardTimeError,
+  WorkCenterNotFoundError,
+  CrossCompanyWorkCenterError,
+} from "../lib/errors.generated";
+import { baseDraftRouting, baseActiveRouting, baseActiveWorkCenter } from "../testing/fixtures";
+import { run } from "./updateRouting";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("updateRouting", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["manufacturing:updateRouting"],
+  };
+
+  const validOperations = [
+    {
+      sequenceNumber: 10,
+      operationDescription: "Revised assembly",
+      workCenterId: "work-center-2",
+      standardSetupTime: 25,
+      standardRunTime: 55,
+      operatorInstructions: null,
+    },
+    {
+      sequenceNumber: 20,
+      operationDescription: "Revised QC",
+      workCenterId: "work-center-2",
+      standardSetupTime: 15,
+      standardRunTime: 20,
+      operatorInstructions: null,
+    },
+  ];
+
+  const validInput = {
+    id: "routing-1",
+    operations: validOperations,
+  };
+
+  it("updates draft routing operations", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Routing lookup
+    spies.select.mockReturnValueOnce(baseDraftRouting);
+    // select: WorkCenter lookup for op 1
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+    // select: WorkCenter lookup for op 2
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+    // update: Routing header
+    spies.update.mockReturnValue({ ...baseDraftRouting, updatedAt: new Date() });
+    // insert: new operations
+    spies.insert.mockReturnValue({
+      id: "op-new",
+      routingId: "routing-1",
+      sequenceNumber: 10,
+      operationDescription: "Revised assembly",
+      workCenterId: "work-center-2",
+      standardSetupTime: 25,
+      standardRunTime: 55,
+      operatorInstructions: null,
+      createdAt: new Date(),
+      updatedAt: null,
+    });
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.routing).toBeDefined();
+    }
+    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, { ...validInput, id: "routing-2" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(RoutingNotMutableError);
+    }
+  });
+
+  it("returns error when revised sequence numbers conflict", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Routing lookup
+    spies.select.mockReturnValueOnce(baseDraftRouting);
+
+    const duplicateOps = [
+      { ...validOperations[0], sequenceNumber: 10 },
+      { ...validOperations[1], sequenceNumber: 10 },
+    ];
+
+    const result = await run(db, { ...validInput, operations: duplicateOps }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateOperationSequenceError);
+    }
+  });
+
+  it("returns error when a revised standard time is negative", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Routing lookup
+    spies.select.mockReturnValueOnce(baseDraftRouting);
+
+    const badOps = [{ ...validOperations[0], standardRunTime: -1 }];
+
+    const result = await run(db, { ...validInput, operations: badOps }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStandardTimeError);
+    }
+  });
+
+  it("returns error when a referenced work center does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Routing lookup
+    spies.select.mockReturnValueOnce(baseDraftRouting);
+    // select: WorkCenter 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(WorkCenterNotFoundError);
+    }
+  });
+
+  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: 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);
+    }
+  });
+
+  it("preserves released routing snapshots after update", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Routing lookup - DRAFT (only DRAFT can be updated)
+    spies.select.mockReturnValueOnce(baseDraftRouting);
+    // select: WorkCenter lookup for op 1
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+    // update: Routing header
+    spies.update.mockReturnValue({ ...baseDraftRouting, updatedAt: new Date() });
+    // insert: new operations
+    spies.insert.mockReturnValue({
+      id: "op-new",
+      routingId: "routing-1",
+      sequenceNumber: 10,
+      operationDescription: "Revised assembly",
+      workCenterId: "work-center-2",
+      standardSetupTime: 25,
+      standardRunTime: 55,
+      operatorInstructions: null,
+      createdAt: new Date(),
+      updatedAt: null,
+    });
+
+    const singleOp = [validOperations[0]];
+    const result = await run(db, { ...validInput, operations: singleOp }, ctx);
+
+    // The update only touches the Routing and RoutingOperation tables,
+    // not ProductionOrderRoutingSnapshot, preserving frozen snapshots.
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.routing.status).toBe("DRAFT");
+    }
+  });
+});

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

@@ -0,0 +1,124 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  RoutingNotFoundError,
+  RoutingNotMutableError,
+  DuplicateOperationSequenceError,
+  InvalidStandardTimeError,
+  WorkCenterNotFoundError,
+  CrossCompanyWorkCenterError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface UpdateRoutingOperationInput {
+  sequenceNumber: number;
+  operationDescription?: string | null;
+  workCenterId: string;
+  standardSetupTime: number;
+  standardRunTime: number;
+  operatorInstructions?: string | null;
+}
+
+export interface UpdateRoutingInput {
+  id: string;
+  revisionNumber?: string | null;
+  operations: UpdateRoutingOperationInput[];
+}
+
+/**
+ * Function: updateRouting
+ *
+ * Updates a draft routing's operations. Only DRAFT routings are mutable.
+ * Replaces all existing operations with the revised set.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: UpdateRoutingInput & CF,
+  _ctx: CommandContext,
+) {
+  const { id, revisionNumber, operations, ...customFields } = 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 DRAFT status
+  if (routing.status !== "DRAFT") {
+    return err(new RoutingNotMutableError(id));
+  }
+
+  // 3. 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));
+  }
+
+  // 4. Validate standard times >= 0
+  for (const op of operations) {
+    if (op.standardSetupTime < 0 || op.standardRunTime < 0) {
+      return err(new InvalidStandardTimeError(id));
+    }
+  }
+
+  // 5. Validate work centers exist and belong to same company
+  for (const op of operations) {
+    const workCenter = await db
+      .selectFrom("WorkCenter")
+      .selectAll()
+      .where("id", "=", op.workCenterId)
+      .executeTakeFirst();
+
+    if (!workCenter) {
+      return err(new WorkCenterNotFoundError(op.workCenterId));
+    }
+
+    if (workCenter.companyId !== routing.companyId) {
+      return err(new CrossCompanyWorkCenterError(op.workCenterId));
+    }
+  }
+
+  // 6. Update routing header
+  const updatedRouting = await db
+    .updateTable("Routing")
+    .set({
+      ...(customFields as Record<string, unknown>),
+      ...(revisionNumber !== undefined ? { revisionNumber } : {}),
+      updatedAt: new Date(),
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  // 7. Delete existing operations and replace
+  await db.deleteFrom("RoutingOperation").where("routingId", "=", id).execute();
+
+  const createdOperations = [];
+  for (const op of operations) {
+    const operation = await db
+      .insertInto("RoutingOperation")
+      .values({
+        routingId: id,
+        sequenceNumber: op.sequenceNumber,
+        operationDescription: op.operationDescription ?? null,
+        workCenterId: op.workCenterId,
+        standardSetupTime: op.standardSetupTime,
+        standardRunTime: op.standardRunTime,
+        operatorInstructions: op.operatorInstructions ?? null,
+        createdAt: new Date(),
+        updatedAt: null,
+      })
+      .returningAll()
+      .executeTakeFirst();
+    createdOperations.push(operation!);
+  }
+
+  return ok({ routing: updatedRouting!, operations: createdOperations });
+}

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

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

package/src/modules/manufacturing/command/updateWorkCenter.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 {
+  WorkCenterNotFoundError,
+  InvalidCapacityError,
+  InvalidRateError,
+  InvalidOverheadMethodError,
+  OverheadCurrencyRequiredError,
+  ImmutableScopeFieldError,
+} from "../lib/errors.generated";
+import { baseActiveWorkCenter } from "../testing/fixtures";
+import { run } from "./updateWorkCenter";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("updateWorkCenter", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["manufacturing:updateWorkCenter"],
+  };
+
+  const validInput = {
+    id: baseActiveWorkCenter.id,
+    capacityAssumptions: 200,
+    laborRate: 30.0,
+  };
+
+  it("updates an active work center without changing scope identity", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+    spies.update.mockReturnValue({
+      ...baseActiveWorkCenter,
+      capacityAssumptions: 200,
+      laborRate: 30.0,
+    });
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.workCenter.capacityAssumptions).toBe(200);
+      expect(result.value.workCenter.laborRate).toBe(30.0);
+    }
+    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, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(WorkCenterNotFoundError);
+    }
+  });
+
+  it("returns error when immutable scope fields are changed", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(
+      db,
+      { ...validInput, companyId: "other-company" } as Parameters<typeof run>[1],
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ImmutableScopeFieldError);
+    }
+  });
+
+  it("returns error when capacity is not positive", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+
+    const result = await run(db, { ...validInput, capacityAssumptions: 0 }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidCapacityError);
+    }
+  });
+
+  it("returns error when a rate is negative", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+
+    const result = await run(db, { ...validInput, laborRate: -1 }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidRateError);
+    }
+  });
+
+  it("preserves released cost baselines after update", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+    spies.update.mockReturnValue({
+      ...baseActiveWorkCenter,
+      machineRate: 75.0,
+    });
+
+    const result = await run(db, { id: baseActiveWorkCenter.id, machineRate: 75.0 }, ctx);
+
+    expect(result.ok).toBe(true);
+    expect(spies.update).toHaveBeenCalledTimes(1);
+    expect(spies.set).toHaveBeenCalledWith(expect.objectContaining({ machineRate: 75.0 }));
+    expect(spies.set).toHaveBeenCalledWith(
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      expect.not.objectContaining({ companyId: expect.anything() }),
+    );
+  });
+
+  it("returns error when the overhead method is not supported", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+
+    const result = await run(
+      db,
+      { id: baseActiveWorkCenter.id, overheadAbsorptionMethod: "PER_ORDER" },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidOverheadMethodError);
+    }
+  });
+
+  it("returns error when fixed-amount overhead omits currency", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+
+    const result = await run(
+      db,
+      {
+        id: baseActiveWorkCenter.id,
+        overheadAbsorptionMethod: "FIXED_AMOUNT_PER_GOOD_UNIT",
+        overheadAbsorptionCurrency: null,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(OverheadCurrencyRequiredError);
+    }
+  });
+});