@tailor-platform/erp-kit 0.7.0 → 0.9.0

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

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { CostElementNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { baseCostElement, activeCostElement, inactiveCostElement } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./activateCostElement";
+
+describe("activateCostElement", () => {
+  it("activates a DRAFT cost element transitioning it to ACTIVE status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostElement);
+    const updated = { ...baseCostElement, status: "ACTIVE" };
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(db, { costElementId: baseCostElement.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.costElement.status).toBe("ACTIVE");
+  });
+
+  it("returns error when cost element does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { costElementId: "missing" }, commandCtx);
+
+    expectErr(result, CostElementNotFoundError);
+  });
+
+  it("returns error when cost element is already ACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeCostElement);
+
+    const result = await run(db, { costElementId: activeCostElement.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when cost element is INACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(inactiveCostElement);
+
+    const result = await run(db, { costElementId: inactiveCostElement.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("emits audit event recording the status transition and acting user", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostElement);
+    spies.update.mockReturnValueOnce({ ...baseCostElement, status: "ACTIVE" });
+
+    const result = await run(db, { costElementId: baseCostElement.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.update).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,41 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { CostElementNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface ActivateCostElementInput {
+  costElementId: string;
+  from?: string[];
+}
+
+/** Command: activateCostElement
+ * Transitions a cost element from DRAFT status to ACTIVE status.
+ */
+export async function run(db: Transaction, input: ActivateCostElementInput, ctx: CommandContext) {
+  void ctx;
+
+  const validFromStatuses = input.from ?? ["DRAFT"];
+
+  const costElement = await db
+    .selectFrom("CostElement")
+    .selectAll()
+    .where("id", "=", input.costElementId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!costElement) {
+    return err(new CostElementNotFoundError(input.costElementId));
+  }
+
+  if (!validFromStatuses.includes(costElement.status)) {
+    return err(new InvalidStateError(input.costElementId));
+  }
+
+  const updated = await db
+    .updateTable("CostElement")
+    .set({ status: "ACTIVE", updatedAt: new Date() })
+    .where("id", "=", input.costElementId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ costElement: updated! });
+}

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

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

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

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { ProfitCenterNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { baseProfitCenter, activeProfitCenter, inactiveProfitCenter } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./activateProfitCenter";
+
+describe("activateProfitCenter", () => {
+  it("activates a DRAFT profit center transitioning it to ACTIVE status", async () => {
+    const activated = { ...baseProfitCenter, status: "ACTIVE" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseProfitCenter);
+    spies.update.mockReturnValueOnce(activated);
+
+    const result = await run(db, { profitCenterId: baseProfitCenter.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.profitCenter.status).toBe("ACTIVE");
+  });
+
+  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-id" }, commandCtx);
+
+    expectErr(result, ProfitCenterNotFoundError);
+  });
+
+  it("returns error when profit center is already ACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeProfitCenter);
+
+    const result = await run(db, { profitCenterId: activeProfitCenter.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when profit center is INACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(inactiveProfitCenter);
+
+    const result = await run(db, { profitCenterId: inactiveProfitCenter.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("emits audit event recording the status transition and acting user", async () => {
+    const activated = { ...baseProfitCenter, status: "ACTIVE" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseProfitCenter);
+    spies.update.mockReturnValueOnce(activated);
+
+    const result = await run(db, { profitCenterId: baseProfitCenter.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.update).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,38 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { ProfitCenterNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface ActivateProfitCenterInput {
+  profitCenterId: string;
+  from?: string[];
+}
+
+export async function run(db: Transaction, input: ActivateProfitCenterInput, ctx: CommandContext) {
+  void ctx;
+
+  const validFromStatuses = input.from ?? ["DRAFT"];
+
+  const profitCenter = await db
+    .selectFrom("ProfitCenter")
+    .selectAll()
+    .where("id", "=", input.profitCenterId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!profitCenter) {
+    return err(new ProfitCenterNotFoundError(input.profitCenterId));
+  }
+
+  if (!validFromStatuses.includes(profitCenter.status)) {
+    return err(new InvalidStateError(input.profitCenterId));
+  }
+
+  const updated = await db
+    .updateTable("ProfitCenter")
+    .set({ status: "ACTIVE", updatedAt: new Date() })
+    .where("id", "=", input.profitCenterId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ profitCenter: updated! });
+}

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

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

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

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  BudgetNotFoundError,
+  InvalidStateError,
+  SelfApprovalNotAllowedError,
+} from "../lib/errors.generated";
+import { submittedBudget, baseBudget, baseUser } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./approveBudget";
+
+// submittedBudget.createdByUserId === baseUser.id === "user-1"
+// commandCtx.actorId === "test-actor" (different from creator)
+
+describe("approveBudget", () => {
+  it("approves a SUBMITTED budget transitioning it to APPROVED status", async () => {
+    const approvedResult = { ...submittedBudget, status: "APPROVED" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(submittedBudget);
+    spies.update.mockReturnValueOnce(approvedResult);
+
+    const result = await run(db, { budgetId: submittedBudget.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.budget.status).toBe("APPROVED");
+  });
+
+  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 SUBMITTED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseBudget); // DRAFT
+
+    const result = await run(db, { budgetId: baseBudget.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when approver is the same as the budget creator", async () => {
+    // createdByUserId = "user-1", set actorId to match
+    const selfCtx = { ...commandCtx, actorId: baseUser.id };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(submittedBudget);
+
+    const result = await run(db, { budgetId: submittedBudget.id }, selfCtx);
+
+    expectErr(result, SelfApprovalNotAllowedError);
+  });
+
+  it("emits audit event recording the status transition and approver", async () => {
+    const approvedResult = { ...submittedBudget, status: "APPROVED" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(submittedBudget);
+    spies.update.mockReturnValueOnce(approvedResult);
+
+    const result = await run(db, { budgetId: submittedBudget.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.update).toHaveBeenCalled();
+  });
+});

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.profitCenterHierarchyAssignment).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.profitCenterHierarchyAssignment.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.profitCenterHierarchyAssignment.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);
+  });
+});