@tailor-platform/erp-kit 0.5.1 → 0.6.0

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

@@ -0,0 +1,78 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  BomNotFoundError,
+  BomNotDeactivatableError,
+  ReplacementRequiredError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface DeactivateBillOfMaterialInput {
+  id: string;
+  from?: string[];
+}
+
+/**
+ * Function: deactivateBillOfMaterial
+ *
+ * Removes an active BOM version from future selection. Preserves audit
+ * history and any released production-order snapshots that already depend
+ * on the version.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: DeactivateBillOfMaterialInput & CF,
+  _ctx: CommandContext,
+) {
+  const { id, from, ...customFields } = input;
+  void customFields;
+
+  const allowedStatuses = from ?? ["ACTIVE"];
+
+  // 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 deactivatable
+  if (!allowedStatuses.includes(bom.status)) {
+    return err(new BomNotDeactivatableError(id));
+  }
+
+  // 3. Check replacement policy — if this is the only active BOM for this
+  //    parent item in scope and it is the default selection, a replacement
+  //    active version must exist before deactivation
+  if (bom.defaultSelection) {
+    const replacementBom = await db
+      .selectFrom("BillOfMaterial")
+      .selectAll()
+      .where("parentItemId", "=", bom.parentItemId)
+      .where("companyId", "=", bom.companyId)
+      .where("id", "!=", id)
+      .where("status", "=", "ACTIVE")
+      .executeTakeFirst();
+
+    if (!replacementBom) {
+      return err(new ReplacementRequiredError(id));
+    }
+  }
+
+  // 4. Set status to INACTIVE
+  const updatedBom = await db
+    .updateTable("BillOfMaterial")
+    .set({
+      status: "INACTIVE",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ billOfMaterial: updatedBom! });
+}

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

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

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

@@ -0,0 +1,112 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  RoutingNotFoundError,
+  RoutingNotDeactivatableError,
+  ReplacementRequiredError,
+} from "../lib/errors.generated";
+import {
+  baseActiveRouting,
+  baseDraftRouting,
+  baseReleasedProductionOrder,
+} from "../testing/fixtures";
+import { run } from "./deactivateRouting";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("deactivateRouting", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["manufacturing:deactivateRouting"],
+  };
+
+  const validInput = { id: "routing-2" };
+
+  it("deactivates an active routing", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Routing lookup
+    spies.select.mockReturnValueOnce(baseActiveRouting);
+    // select: Replacement routing lookup - another active routing exists
+    spies.select.mockReturnValueOnce({ ...baseActiveRouting, id: "routing-4" });
+    // update: status to INACTIVE
+    spies.update.mockReturnValue({ ...baseActiveRouting, status: "INACTIVE" });
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.routing.status).toBe("INACTIVE");
+    }
+    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, { id: "nonexistent" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(RoutingNotFoundError);
+    }
+  });
+
+  it("returns error when the routing is not active", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Routing lookup - DRAFT
+    spies.select.mockReturnValueOnce(baseDraftRouting);
+
+    const result = await run(db, { id: "routing-1" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(RoutingNotDeactivatableError);
+    }
+  });
+
+  it("returns error when replacement policy blocks deactivation", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Routing lookup
+    spies.select.mockReturnValueOnce(baseActiveRouting);
+    // select: Replacement routing lookup - no replacement found
+    spies.select.mockReturnValueOnce(undefined);
+    // select: Dependent production order - exists in RELEASED
+    spies.select.mockReturnValueOnce({
+      ...baseReleasedProductionOrder,
+      selectedRoutingRevisionId: "routing-2",
+    });
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ReplacementRequiredError);
+    }
+  });
+
+  it("preserves released operation snapshots after deactivation", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Routing lookup
+    spies.select.mockReturnValueOnce(baseActiveRouting);
+    // select: Replacement routing exists
+    spies.select.mockReturnValueOnce({ ...baseActiveRouting, id: "routing-4" });
+    // update: status to INACTIVE
+    spies.update.mockReturnValue({ ...baseActiveRouting, status: "INACTIVE" });
+
+    const result = await run(db, validInput, ctx);
+
+    // Deactivation only updates the Routing status,
+    // not ProductionOrderRoutingSnapshot, preserving frozen snapshots.
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.routing.status).toBe("INACTIVE");
+    }
+  });
+});

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

@@ -0,0 +1,76 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  RoutingNotFoundError,
+  RoutingNotDeactivatableError,
+  ReplacementRequiredError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface DeactivateRoutingInput {
+  id: string;
+  from?: string[];
+}
+
+/**
+ * Function: deactivateRouting
+ *
+ * Removes an active routing from future production-order selection.
+ * Released production orders keep their frozen operation plan.
+ */
+export async function run(db: Transaction, input: DeactivateRoutingInput, _ctx: CommandContext) {
+  const { id, from = ["ACTIVE"] } = 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 RoutingNotDeactivatableError(id));
+  }
+
+  // 3. Replacement policy: check if another active routing exists for same item+company
+  const replacement = await db
+    .selectFrom("Routing")
+    .selectAll()
+    .where("parentItemId", "=", routing.parentItemId)
+    .where("companyId", "=", routing.companyId)
+    .where("status", "=", "ACTIVE")
+    .where("id", "!=", id)
+    .executeTakeFirst();
+
+  if (!replacement) {
+    // Check if any production orders reference this routing in released/in-progress state
+    const dependentOrder = await db
+      .selectFrom("ProductionOrder")
+      .selectAll()
+      .where("selectedRoutingRevisionId", "=", id)
+      .where("status", "in", ["RELEASED", "IN_PROGRESS"])
+      .executeTakeFirst();
+
+    if (dependentOrder) {
+      return err(new ReplacementRequiredError(id));
+    }
+  }
+
+  // 4. Set status to INACTIVE
+  const updatedRouting = await db
+    .updateTable("Routing")
+    .set({
+      status: "INACTIVE",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ routing: updatedRouting! });
+}

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

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

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

@@ -0,0 +1,113 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  WorkCenterNotFoundError,
+  WorkCenterNotDeactivatableError,
+  WorkCenterInUseError,
+} from "../lib/errors.generated";
+import { baseActiveWorkCenter, baseDraftWorkCenter } from "../testing/fixtures";
+import { run } from "./deactivateWorkCenter";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("deactivateWorkCenter", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["manufacturing:deactivateWorkCenter"],
+  };
+
+  it("deactivates an active work center with no blocking dependencies", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const deactivated = { ...baseActiveWorkCenter, status: "INACTIVE" as const };
+
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter); // fetch work center
+    spies.select.mockReturnValueOnce(undefined); // no active routing dependency
+    spies.select.mockReturnValueOnce(undefined); // no open work orders
+    spies.update.mockReturnValue(deactivated);
+
+    const result = await run(db, { id: baseActiveWorkCenter.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.workCenter.status).toBe("INACTIVE");
+    }
+    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 work center is not active", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseDraftWorkCenter);
+
+    const result = await run(db, { id: baseDraftWorkCenter.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(WorkCenterNotDeactivatableError);
+    }
+  });
+
+  it("returns error when open routing or released-work dependencies block deactivation", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter); // fetch work center
+    spies.select.mockReturnValueOnce({ id: "operation-1" }); // active routing dependency found
+
+    const result = await run(db, { id: baseActiveWorkCenter.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(WorkCenterInUseError);
+    }
+  });
+
+  it("returns error when open work orders block deactivation", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter); // fetch work center
+    spies.select.mockReturnValueOnce(undefined); // no active routing dependency
+    spies.select.mockReturnValueOnce({ id: "work-order-1" }); // open work order found
+
+    const result = await run(db, { id: baseActiveWorkCenter.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(WorkCenterInUseError);
+    }
+  });
+
+  it("preserves historical work-order and cost data after deactivation", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const deactivated = {
+      ...baseActiveWorkCenter,
+      status: "INACTIVE" as const,
+      updatedAt: new Date(),
+    };
+
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+    spies.select.mockReturnValueOnce(undefined); // no active routing dependency
+    spies.select.mockReturnValueOnce(undefined); // no open work orders
+    spies.update.mockReturnValue(deactivated);
+
+    const result = await run(db, { id: baseActiveWorkCenter.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      // The work center is deactivated but its identity and historical fields are preserved
+      expect(result.value.workCenter.id).toBe(baseActiveWorkCenter.id);
+      expect(result.value.workCenter.code).toBe(baseActiveWorkCenter.code);
+      expect(result.value.workCenter.status).toBe("INACTIVE");
+    }
+  });
+});

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

@@ -0,0 +1,85 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  WorkCenterNotFoundError,
+  WorkCenterNotDeactivatableError,
+  WorkCenterInUseError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface DeactivateWorkCenterInput {
+  id: string;
+  from?: string[];
+}
+
+/**
+ * Function: deactivateWorkCenter
+ *
+ * Removes a work center from future routing and release selection.
+ * Preserves historical work-order and cost records while blocking
+ * new execution use.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: DeactivateWorkCenterInput & CF,
+  _ctx: CommandContext,
+) {
+  const { id, from, ...customFields } = input;
+  void customFields;
+
+  const allowedStatuses = from ?? ["ACTIVE"];
+
+  // 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 deactivatable
+  if (!allowedStatuses.includes(workCenter.status)) {
+    return err(new WorkCenterNotDeactivatableError(workCenter.code));
+  }
+
+  // 3. Check for blocking dependencies — active routings that reference this work center
+  const activeRoutingDependency = await db
+    .selectFrom("RoutingOperation")
+    .innerJoin("Routing", "Routing.id", "RoutingOperation.routingId")
+    .select("RoutingOperation.id")
+    .where("RoutingOperation.workCenterId", "=", id)
+    .where("Routing.status", "=", "ACTIVE")
+    .executeTakeFirst();
+
+  if (activeRoutingDependency) {
+    return err(new WorkCenterInUseError(workCenter.code));
+  }
+
+  // 4. Check for open work orders that still reference this work center
+  const openWorkOrder = await db
+    .selectFrom("WorkOrder")
+    .select("WorkOrder.id")
+    .where("WorkOrder.workCenterId", "=", id)
+    .where("WorkOrder.status", "in", ["PENDING", "IN_PROGRESS", "PAUSED"])
+    .executeTakeFirst();
+
+  if (openWorkOrder) {
+    return err(new WorkCenterInUseError(workCenter.code));
+  }
+
+  // 5. Set status to INACTIVE
+  const updatedWorkCenter = await db
+    .updateTable("WorkCenter")
+    .set({
+      status: "INACTIVE",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ workCenter: updatedWorkCenter! });
+}

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

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

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

@@ -0,0 +1,118 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  WorkOrderNotFoundError,
+  WorkOrderNotPausableError,
+  PauseReasonRequiredError,
+} from "../lib/errors.generated";
+import { baseInProgressWorkOrder, basePendingWorkOrder } from "../testing/fixtures";
+import { run } from "./pauseWorkOrder";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("pauseWorkOrder", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["manufacturing:pauseWorkOrder"],
+  };
+
+  it("pauses an in-progress work order", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const pausedWorkOrder = {
+      ...baseInProgressWorkOrder,
+      status: "PAUSED" as const,
+      pauseReason: "Machine maintenance",
+    };
+
+    // work order lookup
+    spies.select.mockReturnValueOnce(baseInProgressWorkOrder);
+    // update work order
+    spies.update.mockReturnValueOnce(pausedWorkOrder);
+    // insert execution event
+    spies.insert.mockReturnValueOnce(undefined);
+
+    const result = await run(
+      db,
+      { id: baseInProgressWorkOrder.id, pauseReason: "Machine maintenance" },
+      ctx,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.workOrder.status).toBe("PAUSED");
+      expect(result.value.workOrder.pauseReason).toBe("Machine maintenance");
+    }
+    expect(spies.update).toHaveBeenCalled();
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("returns error when the work order does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent", pauseReason: "Some reason" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(WorkOrderNotFoundError);
+    }
+  });
+
+  it("returns error when the work order is not in progress", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePendingWorkOrder);
+
+    const result = await run(db, { id: basePendingWorkOrder.id, pauseReason: "Some reason" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(WorkOrderNotPausableError);
+    }
+  });
+
+  it("returns error when no pause reason is provided", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(db, { id: baseInProgressWorkOrder.id, pauseReason: "" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(PauseReasonRequiredError);
+    }
+  });
+
+  it("preserves prior execution quantities and time after pause", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const pausedWorkOrder = {
+      ...baseInProgressWorkOrder,
+      status: "PAUSED" as const,
+      pauseReason: "Break time",
+      completedQuantity: baseInProgressWorkOrder.completedQuantity,
+      scrapQuantity: baseInProgressWorkOrder.scrapQuantity,
+      actualSetupTime: baseInProgressWorkOrder.actualSetupTime,
+      actualRunTime: baseInProgressWorkOrder.actualRunTime,
+    };
+
+    // work order lookup
+    spies.select.mockReturnValueOnce(baseInProgressWorkOrder);
+    // update work order
+    spies.update.mockReturnValueOnce(pausedWorkOrder);
+    // insert execution event
+    spies.insert.mockReturnValueOnce(undefined);
+
+    const result = await run(
+      db,
+      { id: baseInProgressWorkOrder.id, pauseReason: "Break time" },
+      ctx,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.workOrder.completedQuantity).toBe(
+        baseInProgressWorkOrder.completedQuantity,
+      );
+      expect(result.value.workOrder.actualSetupTime).toBe(baseInProgressWorkOrder.actualSetupTime);
+      expect(result.value.workOrder.actualRunTime).toBe(baseInProgressWorkOrder.actualRunTime);
+    }
+  });
+});

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

@@ -0,0 +1,82 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  WorkOrderNotFoundError,
+  WorkOrderNotPausableError,
+  PauseReasonRequiredError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface PauseWorkOrderInput {
+  id: string;
+  pauseReason: string;
+}
+
+/**
+ * Function: pauseWorkOrder
+ *
+ * Temporarily halts an in-progress work order and records the reason for
+ * the interruption. Preserves accumulated execution history so the work
+ * order can later resume.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: PauseWorkOrderInput & CF,
+  _ctx: CommandContext,
+) {
+  const { id, pauseReason, ...customFields } = input;
+  void customFields;
+
+  // 1. Validate pause reason is provided
+  if (!pauseReason || pauseReason.trim() === "") {
+    return err(new PauseReasonRequiredError(id));
+  }
+
+  // 2. Fetch work order with lock
+  const workOrder = await db
+    .selectFrom("WorkOrder")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!workOrder) {
+    return err(new WorkOrderNotFoundError(id));
+  }
+
+  // 3. Validate status is IN_PROGRESS
+  if (workOrder.status !== "IN_PROGRESS") {
+    return err(new WorkOrderNotPausableError(id));
+  }
+
+  // 4. Record pause event and set PAUSED
+  const now = new Date();
+
+  const updatedWorkOrder = await db
+    .updateTable("WorkOrder")
+    .set({
+      status: "PAUSED",
+      pauseReason,
+      updatedAt: now,
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  // 5. Create PAUSED execution event
+  await db
+    .insertInto("WorkOrderExecutionEvent")
+    .values({
+      workOrderId: id,
+      eventType: "PAUSED",
+      timestamp: now,
+      quantity: null,
+      timeValue: null,
+      scrapValue: null,
+      notes: pauseReason,
+      createdAt: now,
+      updatedAt: null,
+    })
+    .execute();
+
+  return ok({ workOrder: updatedWorkOrder });
+}