@tailor-platform/erp-kit 0.7.0 → 0.8.0

package/src/modules/accounting/command/approveBudget.ts

@@ -0,0 +1,47 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  BudgetNotFoundError,
+  InvalidStateError,
+  SelfApprovalNotAllowedError,
+} from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface ApproveBudgetInput {
+  budgetId: string;
+}
+
+export async function run(db: Transaction, input: ApproveBudgetInput, ctx: CommandContext) {
+  // Fetch budget with lock
+  const budget = await db
+    .selectFrom("Budget")
+    .where("id", "=", input.budgetId)
+    .selectAll()
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!budget) {
+    return err(new BudgetNotFoundError(input.budgetId));
+  }
+
+  if (budget.status !== "SUBMITTED") {
+    return err(new InvalidStateError(input.budgetId));
+  }
+
+  // Segregation of duties: approver must differ from creator
+  if (budget.createdByUserId === ctx.actorId) {
+    return err(new SelfApprovalNotAllowedError(input.budgetId));
+  }
+
+  // Transition to APPROVED
+  const updated = await db
+    .updateTable("Budget")
+    .set({
+      status: "APPROVED",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.budgetId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ budget: updated! });
+}

package/src/modules/accounting/command/assignCostCenterToHierarchyNode.generated.ts

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

package/src/modules/accounting/command/assignCostCenterToHierarchyNode.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 {
+  CostCenterNotFoundError,
+  HierarchyNodeNotFoundError,
+  CompanyMismatchError,
+} from "../lib/errors.generated";
+import {
+  baseCostCenter,
+  childCostCenterNode,
+  childCostCenterNode2,
+  baseCostCenterHierarchy,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./assignCostCenterToHierarchyNode";
+
+describe("assignCostCenterToHierarchyNode", () => {
+  it("returns error when cost center does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(
+      db,
+      { costCenterId: "missing-cc", hierarchyNodeId: childCostCenterNode.id },
+      commandCtx,
+    );
+
+    expectErr(result, CostCenterNotFoundError);
+  });
+
+  it("returns error when target hierarchy node does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenter) // cost center exists
+      .mockReturnValueOnce(undefined); // target node not found
+
+    const result = await run(
+      db,
+      { costCenterId: baseCostCenter.id, hierarchyNodeId: "missing-node" },
+      commandCtx,
+    );
+
+    expectErr(result, HierarchyNodeNotFoundError);
+  });
+
+  it("returns error when cost center and node belong to different companies", async () => {
+    const otherCompanyHierarchy = { ...baseCostCenterHierarchy, companyId: "other-company" };
+
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenter) // cost center exists
+      .mockReturnValueOnce(childCostCenterNode2) // target node exists
+      .mockReturnValueOnce(otherCompanyHierarchy); // hierarchy has different company
+
+    const result = await run(
+      db,
+      { costCenterId: baseCostCenter.id, hierarchyNodeId: childCostCenterNode2.id },
+      commandCtx,
+    );
+
+    expectErr(result, CompanyMismatchError);
+  });
+
+  it("assigns cost center to hierarchy node successfully", async () => {
+    const updatedCostCenter = {
+      ...baseCostCenter,
+      hierarchyNodeId: childCostCenterNode2.id,
+      updatedAt: new Date(),
+    };
+
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenter) // cost center exists
+      .mockReturnValueOnce(childCostCenterNode2) // target node exists
+      .mockReturnValueOnce(baseCostCenterHierarchy); // same company hierarchy
+    spies.update.mockReturnValueOnce(updatedCostCenter);
+
+    const result = await run(
+      db,
+      { costCenterId: baseCostCenter.id, hierarchyNodeId: childCostCenterNode2.id },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.costCenter.hierarchyNodeId).toBe(childCostCenterNode2.id);
+  });
+
+  it("updates the hierarchyNodeId field on the cost center", async () => {
+    const updatedCostCenter = {
+      ...baseCostCenter,
+      hierarchyNodeId: childCostCenterNode2.id,
+      updatedAt: new Date(),
+    };
+
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenter)
+      .mockReturnValueOnce(childCostCenterNode2)
+      .mockReturnValueOnce(baseCostCenterHierarchy);
+    spies.update.mockReturnValueOnce(updatedCostCenter);
+
+    const result = await run(
+      db,
+      { costCenterId: baseCostCenter.id, hierarchyNodeId: childCostCenterNode2.id },
+      commandCtx,
+    );
+
+    expectOk(result);
+    expect(spies.update).toHaveBeenCalled();
+  });
+});

package/src/modules/accounting/command/assignCostCenterToHierarchyNode.ts

@@ -0,0 +1,67 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CostCenterNotFoundError,
+  HierarchyNodeNotFoundError,
+  CompanyMismatchError,
+} from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface AssignCostCenterToHierarchyNodeInput {
+  costCenterId: string;
+  hierarchyNodeId: string;
+}
+
+export async function run(
+  db: Transaction,
+  input: AssignCostCenterToHierarchyNodeInput,
+  ctx: CommandContext,
+) {
+  void ctx;
+
+  // Validate cost center exists
+  const costCenter = await db
+    .selectFrom("CostCenter")
+    .where("id", "=", input.costCenterId)
+    .selectAll()
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!costCenter) {
+    return err(new CostCenterNotFoundError(input.costCenterId));
+  }
+
+  // Validate target hierarchy node exists
+  const hierarchyNode = await db
+    .selectFrom("CostCenterHierarchyNode")
+    .where("id", "=", input.hierarchyNodeId)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (!hierarchyNode) {
+    return err(new HierarchyNodeNotFoundError(input.hierarchyNodeId));
+  }
+
+  // Validate same company: get hierarchy for the target node
+  const hierarchy = await db
+    .selectFrom("CostCenterHierarchy")
+    .where("id", "=", hierarchyNode.hierarchyId)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (hierarchy?.companyId !== costCenter.companyId) {
+    return err(new CompanyMismatchError(input.costCenterId));
+  }
+
+  // Update cost center's hierarchyNodeId
+  const updatedCostCenter = await db
+    .updateTable("CostCenter")
+    .set({
+      hierarchyNodeId: input.hierarchyNodeId,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.costCenterId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ costCenter: updatedCostCenter! });
+}

package/src/modules/accounting/command/assignProfitCenterToHierarchyNode.generated.ts

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

package/src/modules/accounting/command/assignProfitCenterToHierarchyNode.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { ProfitCenterNotFoundError, HierarchyNodeNotFoundError } from "../lib/errors.generated";
+import {
+  baseProfitCenter,
+  activeProfitCenter,
+  rootProfitCenterNode,
+  childProfitCenterNode,
+  baseProfitCenterHierarchy,
+  baseProfitCenterHierarchyAssignment,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./assignProfitCenterToHierarchyNode";
+
+describe("assignProfitCenterToHierarchyNode", () => {
+  it("assigns a profit center to a hierarchy node (creates new assignment)", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseProfitCenter) // profit center exists
+      .mockReturnValueOnce(childProfitCenterNode) // node exists
+      .mockReturnValueOnce(undefined); // no existing assignment
+    spies.insert.mockReturnValueOnce(baseProfitCenterHierarchyAssignment);
+
+    const result = await run(
+      db,
+      { profitCenterId: baseProfitCenter.id, hierarchyNodeId: childProfitCenterNode.id },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.assignment).toEqual(baseProfitCenterHierarchyAssignment);
+    expect(spies.insert).toHaveBeenCalled();
+    expect(spies.update).not.toHaveBeenCalled();
+  });
+
+  it("replaces existing assignment when profit center is already assigned in the same hierarchy", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const existingAssignment = {
+      ...baseProfitCenterHierarchyAssignment,
+      hierarchyNodeId: rootProfitCenterNode.id,
+    };
+    spies.select
+      .mockReturnValueOnce(activeProfitCenter) // profit center with existing assignment
+      .mockReturnValueOnce(childProfitCenterNode) // new node exists
+      .mockReturnValueOnce(existingAssignment); // existing assignment found
+    spies.update.mockReturnValueOnce({
+      ...existingAssignment,
+      hierarchyNodeId: childProfitCenterNode.id,
+    });
+
+    const result = await run(
+      db,
+      { profitCenterId: activeProfitCenter.id, hierarchyNodeId: childProfitCenterNode.id },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.assignment.hierarchyNodeId).toBe(childProfitCenterNode.id);
+    expect(spies.update).toHaveBeenCalled();
+    expect(spies.insert).not.toHaveBeenCalled();
+  });
+
+  it("allows a profit center to be assigned to nodes in multiple hierarchies", async () => {
+    const secondHierarchyNode = {
+      id: "pc-node-second-hierarchy",
+      name: "Second Hierarchy Node",
+      hierarchyId: "pc-hierarchy-2",
+      parentNodeId: null,
+      sortOrder: 1,
+      level: 0,
+      createdAt: baseProfitCenterHierarchy.createdAt,
+      updatedAt: null,
+    };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseProfitCenter) // profit center exists
+      .mockReturnValueOnce(secondHierarchyNode) // node in second hierarchy exists
+      .mockReturnValueOnce(undefined); // no existing assignment in second hierarchy
+    spies.insert.mockReturnValueOnce({
+      ...baseProfitCenterHierarchyAssignment,
+      hierarchyId: secondHierarchyNode.hierarchyId,
+      hierarchyNodeId: secondHierarchyNode.id,
+    });
+
+    const result = await run(
+      db,
+      { profitCenterId: baseProfitCenter.id, hierarchyNodeId: secondHierarchyNode.id },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.assignment.hierarchyNodeId).toBe(secondHierarchyNode.id);
+    expect(spies.insert).toHaveBeenCalled();
+    expect(spies.update).not.toHaveBeenCalled();
+  });
+
+  it("returns error when profit center does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(
+      db,
+      { profitCenterId: "missing-pc", hierarchyNodeId: childProfitCenterNode.id },
+      commandCtx,
+    );
+
+    expectErr(result, ProfitCenterNotFoundError);
+  });
+
+  it("returns error when target hierarchy node does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseProfitCenter).mockReturnValueOnce(undefined);
+
+    const result = await run(
+      db,
+      { profitCenterId: baseProfitCenter.id, hierarchyNodeId: "missing-node" },
+      commandCtx,
+    );
+
+    expectErr(result, HierarchyNodeNotFoundError);
+  });
+});

package/src/modules/accounting/command/assignProfitCenterToHierarchyNode.ts

@@ -0,0 +1,71 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { ProfitCenterNotFoundError, HierarchyNodeNotFoundError } from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface AssignProfitCenterToHierarchyNodeInput {
+  profitCenterId: string;
+  hierarchyNodeId: string;
+}
+
+export async function run(
+  db: Transaction,
+  input: AssignProfitCenterToHierarchyNodeInput,
+  ctx: CommandContext,
+) {
+  void ctx;
+
+  // Validate profit center exists
+  const profitCenter = await db
+    .selectFrom("ProfitCenter")
+    .selectAll()
+    .where("id", "=", input.profitCenterId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!profitCenter) {
+    return err(new ProfitCenterNotFoundError(input.profitCenterId));
+  }
+
+  // Validate target hierarchy node exists
+  const node = await db
+    .selectFrom("ProfitCenterHierarchyNode")
+    .selectAll()
+    .where("id", "=", input.hierarchyNodeId)
+    .executeTakeFirst();
+
+  if (!node) {
+    return err(new HierarchyNodeNotFoundError(input.hierarchyNodeId));
+  }
+
+  const hierarchyId = node.hierarchyId;
+
+  // Check if an assignment already exists for this profit center in this hierarchy
+  const existingAssignment = await db
+    .selectFrom("ProfitCenterHierarchyAssignment")
+    .selectAll()
+    .where("profitCenterId", "=", input.profitCenterId)
+    .where("hierarchyId", "=", hierarchyId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  const assignment = existingAssignment
+    ? await db
+        .updateTable("ProfitCenterHierarchyAssignment")
+        .set({ hierarchyNodeId: input.hierarchyNodeId, updatedAt: new Date() })
+        .where("id", "=", existingAssignment.id)
+        .returningAll()
+        .executeTakeFirstOrThrow()
+    : await db
+        .insertInto("ProfitCenterHierarchyAssignment")
+        .values({
+          profitCenterId: input.profitCenterId,
+          hierarchyId,
+          hierarchyNodeId: input.hierarchyNodeId,
+          createdAt: new Date(),
+          updatedAt: null,
+        })
+        .returningAll()
+        .executeTakeFirstOrThrow();
+
+  return ok({ assignment });
+}

package/src/modules/accounting/command/closeBudget.generated.ts

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

package/src/modules/accounting/command/closeBudget.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { BudgetNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import {
+  activeBudget,
+  baseBudget,
+  submittedBudget,
+  approvedBudget,
+  closedBudget,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./closeBudget";
+
+describe("closeBudget", () => {
+  it("closes an ACTIVE budget transitioning it to CLOSED status", async () => {
+    const closedResult = { ...activeBudget, status: "CLOSED" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeBudget);
+    spies.update.mockReturnValueOnce(closedResult);
+
+    const result = await run(db, { budgetId: activeBudget.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.budget.status).toBe("CLOSED");
+  });
+
+  it("returns error when budget does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { budgetId: "missing" }, commandCtx);
+
+    expectErr(result, BudgetNotFoundError);
+  });
+
+  it("returns error when budget is not in ACTIVE status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(approvedBudget);
+
+    const result = await run(db, { budgetId: approvedBudget.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when budget is in DRAFT status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseBudget);
+
+    const result = await run(db, { budgetId: baseBudget.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when budget is in SUBMITTED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(submittedBudget);
+
+    const result = await run(db, { budgetId: submittedBudget.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when budget is in APPROVED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(approvedBudget);
+
+    const result = await run(db, { budgetId: approvedBudget.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when budget is already CLOSED", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(closedBudget);
+
+    const result = await run(db, { budgetId: closedBudget.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("emits audit event recording the status transition and acting user", async () => {
+    const closedResult = { ...activeBudget, status: "CLOSED" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeBudget);
+    spies.update.mockReturnValueOnce(closedResult);
+
+    const result = await run(db, { budgetId: activeBudget.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.update).toHaveBeenCalled();
+  });
+});

package/src/modules/accounting/command/closeBudget.ts

@@ -0,0 +1,40 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { BudgetNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface CloseBudgetInput {
+  budgetId: string;
+}
+
+export async function run(db: Transaction, input: CloseBudgetInput, ctx: CommandContext) {
+  void ctx;
+
+  // Fetch budget with lock
+  const budget = await db
+    .selectFrom("Budget")
+    .where("id", "=", input.budgetId)
+    .selectAll()
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!budget) {
+    return err(new BudgetNotFoundError(input.budgetId));
+  }
+
+  if (budget.status !== "ACTIVE") {
+    return err(new InvalidStateError(input.budgetId));
+  }
+
+  // Transition to CLOSED
+  const updated = await db
+    .updateTable("Budget")
+    .set({
+      status: "CLOSED",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.budgetId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ budget: updated! });
+}

package/src/modules/accounting/command/closeInternalOrder.generated.ts

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

package/src/modules/accounting/command/closeInternalOrder.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { InternalOrderNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import {
+  baseInternalOrder,
+  releasedInternalOrder,
+  techCompletedInternalOrder,
+  closedInternalOrder,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./closeInternalOrder";
+
+describe("closeInternalOrder", () => {
+  it("closes a TECHNICALLY_COMPLETED internal order transitioning it to CLOSED status", async () => {
+    const updated = { ...techCompletedInternalOrder, status: "CLOSED" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(techCompletedInternalOrder);
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(db, { internalOrderId: techCompletedInternalOrder.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.internalOrder.status).toBe("CLOSED");
+  });
+
+  it("returns error when internal order does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { internalOrderId: "missing-id" }, commandCtx);
+
+    expectErr(result, InternalOrderNotFoundError);
+  });
+
+  it("returns error when internal order is in CREATED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseInternalOrder);
+
+    const result = await run(db, { internalOrderId: baseInternalOrder.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when internal order is in RELEASED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(releasedInternalOrder);
+
+    const result = await run(db, { internalOrderId: releasedInternalOrder.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when internal order is already CLOSED", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(closedInternalOrder);
+
+    const result = await run(db, { internalOrderId: closedInternalOrder.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("emits audit event recording the status transition and acting user", async () => {
+    const updated = { ...techCompletedInternalOrder, status: "CLOSED" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(techCompletedInternalOrder);
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(db, { internalOrderId: techCompletedInternalOrder.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.update).toHaveBeenCalled();
+  });
+});