@tailor-platform/erp-kit 0.6.0 → 0.8.0

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

@@ -0,0 +1,98 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { AllocationRuleNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import {
+  baseAllocationRule,
+  baseAllocationCycle,
+  validatedAllocationCycle,
+  executedAllocationCycle,
+  postedAllocationCycle,
+  reversedAllocationCycle,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./deleteAllocationRule";
+
+describe("deleteAllocationRule", () => {
+  it("deletes an allocation rule from a DRAFT allocation cycle", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseAllocationRule) // rule lookup
+      .mockReturnValueOnce(baseAllocationCycle); // cycle lookup
+
+    const result = await run(db, { allocationRuleId: baseAllocationRule.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.allocationRuleId).toBe(baseAllocationRule.id);
+  });
+
+  it("returns error when allocation rule does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { allocationRuleId: "missing-id" }, commandCtx);
+
+    expectErr(result, AllocationRuleNotFoundError);
+  });
+
+  it("returns error when parent cycle is in VALIDATED status", async () => {
+    const ruleForValidated = {
+      ...baseAllocationRule,
+      allocationCycleId: validatedAllocationCycle.id,
+    };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(ruleForValidated)
+      .mockReturnValueOnce(validatedAllocationCycle);
+
+    const result = await run(db, { allocationRuleId: ruleForValidated.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when parent cycle is in EXECUTED status", async () => {
+    const ruleForExecuted = {
+      ...baseAllocationRule,
+      allocationCycleId: executedAllocationCycle.id,
+    };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(ruleForExecuted).mockReturnValueOnce(executedAllocationCycle);
+
+    const result = await run(db, { allocationRuleId: ruleForExecuted.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when parent cycle is in POSTED status", async () => {
+    const ruleForPosted = { ...baseAllocationRule, allocationCycleId: postedAllocationCycle.id };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(ruleForPosted).mockReturnValueOnce(postedAllocationCycle);
+
+    const result = await run(db, { allocationRuleId: ruleForPosted.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when parent cycle is in REVERSED status", async () => {
+    const ruleForReversed = {
+      ...baseAllocationRule,
+      allocationCycleId: reversedAllocationCycle.id,
+    };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(ruleForReversed).mockReturnValueOnce(reversedAllocationCycle);
+
+    const result = await run(db, { allocationRuleId: ruleForReversed.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("emits audit event recording the rule deletion and acting user", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseAllocationRule).mockReturnValueOnce(baseAllocationCycle);
+
+    const result = await run(db, { allocationRuleId: baseAllocationRule.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.delete).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,40 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { AllocationRuleNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface DeleteAllocationRuleInput {
+  allocationRuleId: string;
+}
+
+export async function run(db: Transaction, input: DeleteAllocationRuleInput, ctx: CommandContext) {
+  void ctx;
+
+  // Validate allocation rule exists
+  const rule = await db
+    .selectFrom("AllocationRule")
+    .where("id", "=", input.allocationRuleId)
+    .selectAll()
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!rule) {
+    return err(new AllocationRuleNotFoundError(input.allocationRuleId));
+  }
+
+  // Validate parent cycle is in DRAFT status
+  const cycle = await db
+    .selectFrom("AllocationCycle")
+    .where("id", "=", rule.allocationCycleId)
+    .selectAll()
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (cycle?.status !== "DRAFT") {
+    return err(new InvalidStateError(input.allocationRuleId));
+  }
+
+  // Delete the rule
+  await db.deleteFrom("AllocationRule").where("id", "=", input.allocationRuleId).execute();
+
+  return ok({ allocationRuleId: input.allocationRuleId });
+}

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

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

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

@@ -0,0 +1,90 @@
+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 {
+  baseBudget,
+  submittedBudget,
+  approvedBudget,
+  activeBudget,
+  closedBudget,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./deleteBudget";
+
+describe("deleteBudget", () => {
+  it("deletes a DRAFT budget successfully", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseBudget);
+
+    const result = await run(db, { budgetId: baseBudget.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.budgetId).toBe(baseBudget.id);
+  });
+
+  it("deletes a DRAFT budget and removes all associated line items", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseBudget);
+
+    const result = await run(db, { budgetId: baseBudget.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.delete).toHaveBeenCalled();
+  });
+
+  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 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 in ACTIVE status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeBudget);
+
+    const result = await run(db, { budgetId: activeBudget.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when budget is in CLOSED status", 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 deletion and acting user", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseBudget);
+
+    const result = await run(db, { budgetId: baseBudget.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.delete).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,35 @@
+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 DeleteBudgetInput {
+  budgetId: string;
+}
+
+export async function run(db: Transaction, input: DeleteBudgetInput, 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 !== "DRAFT") {
+    return err(new InvalidStateError(input.budgetId));
+  }
+
+  // Delete all associated line items
+  await db.deleteFrom("BudgetLineItem").where("budgetId", "=", input.budgetId).execute();
+
+  // Delete the budget
+  await db.deleteFrom("Budget").where("id", "=", input.budgetId).execute();
+
+  return ok({ budgetId: input.budgetId });
+}

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

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

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

@@ -0,0 +1,85 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { BudgetLineItemNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import {
+  baseBudget,
+  submittedBudget,
+  approvedBudget,
+  activeBudget,
+  closedBudget,
+  baseBudgetLineItem,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./deleteBudgetLineItem";
+
+describe("deleteBudgetLineItem", () => {
+  it("deletes a line item from a DRAFT budget", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseBudgetLineItem).mockReturnValueOnce(baseBudget);
+
+    const result = await run(db, { budgetLineItemId: baseBudgetLineItem.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.budgetLineItemId).toBe(baseBudgetLineItem.id);
+  });
+
+  it("returns error when budget line item does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { budgetLineItemId: "missing" }, commandCtx);
+
+    expectErr(result, BudgetLineItemNotFoundError);
+  });
+
+  it("returns error when parent budget is in SUBMITTED status", async () => {
+    const lineItem = { ...baseBudgetLineItem, budgetId: submittedBudget.id };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(lineItem).mockReturnValueOnce(submittedBudget);
+
+    const result = await run(db, { budgetLineItemId: lineItem.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when parent budget is in APPROVED status", async () => {
+    const lineItem = { ...baseBudgetLineItem, budgetId: approvedBudget.id };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(lineItem).mockReturnValueOnce(approvedBudget);
+
+    const result = await run(db, { budgetLineItemId: lineItem.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when parent budget is in ACTIVE status", async () => {
+    const lineItem = { ...baseBudgetLineItem, budgetId: activeBudget.id };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(lineItem).mockReturnValueOnce(activeBudget);
+
+    const result = await run(db, { budgetLineItemId: lineItem.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when parent budget is in CLOSED status", async () => {
+    const lineItem = { ...baseBudgetLineItem, budgetId: closedBudget.id };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(lineItem).mockReturnValueOnce(closedBudget);
+
+    const result = await run(db, { budgetLineItemId: lineItem.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("emits audit event recording the line item deletion and acting user", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseBudgetLineItem).mockReturnValueOnce(baseBudget);
+
+    const result = await run(db, { budgetLineItemId: baseBudgetLineItem.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.delete).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,50 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { BudgetLineItemNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface DeleteBudgetLineItemInput {
+  budgetLineItemId: string;
+}
+
+export async function run(db: Transaction, input: DeleteBudgetLineItemInput, ctx: CommandContext) {
+  void ctx;
+
+  // Fetch the line item
+  const lineItem = await db
+    .selectFrom("BudgetLineItem")
+    .where("id", "=", input.budgetLineItemId)
+    .selectAll()
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!lineItem) {
+    return err(new BudgetLineItemNotFoundError(input.budgetLineItemId));
+  }
+
+  // Fetch parent budget
+  const budget = await db
+    .selectFrom("Budget")
+    .where("id", "=", lineItem.budgetId)
+    .selectAll()
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (budget?.status !== "DRAFT") {
+    return err(new InvalidStateError(lineItem.budgetId));
+  }
+
+  // Delete line item
+  await db.deleteFrom("BudgetLineItem").where("id", "=", input.budgetLineItemId).execute();
+
+  // Update budget totalAmount
+  await db
+    .updateTable("Budget")
+    .set({
+      totalAmount: budget.totalAmount - lineItem.plannedAmount,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", lineItem.budgetId)
+    .execute();
+
+  return ok({ budgetLineItemId: input.budgetLineItemId });
+}

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

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

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

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CostCenterNotFoundError,
+  CostCenterHasPostingsError,
+  CostCenterHasBudgetItemsError,
+  CostCenterHasAllocationRulesError,
+} from "../lib/errors.generated";
+import {
+  baseCostCenter,
+  baseAllocationResult,
+  baseBudget,
+  baseAllocationRule,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./deleteCostCenter";
+
+describe("deleteCostCenter", () => {
+  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" }, commandCtx);
+
+    expectErr(result, CostCenterNotFoundError);
+  });
+
+  it("returns error when cost center has postings", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenter) // cost center exists
+      .mockReturnValueOnce(baseAllocationResult); // has postings
+
+    const result = await run(db, { costCenterId: baseCostCenter.id }, commandCtx);
+
+    expectErr(result, CostCenterHasPostingsError);
+  });
+
+  it("returns error when cost center has budget items", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenter) // cost center exists
+      .mockReturnValueOnce(undefined) // no postings
+      .mockReturnValueOnce(baseBudget); // has budget
+
+    const result = await run(db, { costCenterId: baseCostCenter.id }, commandCtx);
+
+    expectErr(result, CostCenterHasBudgetItemsError);
+  });
+
+  it("returns error when cost center has allocation rules", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenter) // cost center exists
+      .mockReturnValueOnce(undefined) // no postings
+      .mockReturnValueOnce(undefined) // no budgets
+      .mockReturnValueOnce(baseAllocationRule); // has allocation rules
+
+    const result = await run(db, { costCenterId: baseCostCenter.id }, commandCtx);
+
+    expectErr(result, CostCenterHasAllocationRulesError);
+  });
+
+  it("deletes cost center when no dependencies exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenter) // cost center exists
+      .mockReturnValueOnce(undefined) // no postings
+      .mockReturnValueOnce(undefined) // no budgets
+      .mockReturnValueOnce(undefined); // no allocation rules
+
+    const result = await run(db, { costCenterId: baseCostCenter.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.costCenterId).toBe(baseCostCenter.id);
+    expect(spies.delete).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,67 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CostCenterNotFoundError,
+  CostCenterHasPostingsError,
+  CostCenterHasBudgetItemsError,
+  CostCenterHasAllocationRulesError,
+} from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface DeleteCostCenterInput {
+  costCenterId: string;
+}
+
+export async function run(db: Transaction, input: DeleteCostCenterInput, 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));
+  }
+
+  // Check for associated cost postings (AllocationResult referencing this cost center)
+  const posting = await db
+    .selectFrom("AllocationResult")
+    .where("senderCostCenterId", "=", input.costCenterId)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (posting) {
+    return err(new CostCenterHasPostingsError(input.costCenterId));
+  }
+
+  // Check for associated budget line items via budget
+  const budget = await db
+    .selectFrom("Budget")
+    .where("costObjectType", "=", "CostCenter")
+    .where("costObjectId", "=", input.costCenterId)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (budget) {
+    return err(new CostCenterHasBudgetItemsError(input.costCenterId));
+  }
+
+  // Check for associated allocation rules
+  const allocationRule = await db
+    .selectFrom("AllocationRule")
+    .where("senderCostCenterId", "=", input.costCenterId)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (allocationRule) {
+    return err(new CostCenterHasAllocationRulesError(input.costCenterId));
+  }
+
+  // Delete the cost center
+  await db.deleteFrom("CostCenter").where("id", "=", input.costCenterId).execute();
+
+  return ok({ costCenterId: input.costCenterId });
+}

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

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

package/src/modules/accounting/command/deleteCostCenterHierarchyNode.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 {
+  NodeNotFoundError,
+  NodeHasChildrenError,
+  NodeHasAssignedCostCentersError,
+} from "../lib/errors.generated";
+import { rootCostCenterNode, childCostCenterNode, baseCostCenter } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./deleteCostCenterHierarchyNode";
+
+describe("deleteCostCenterHierarchyNode", () => {
+  it("returns error when node does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { nodeId: "missing-node" }, commandCtx);
+
+    expectErr(result, NodeNotFoundError);
+  });
+
+  it("returns error when node has children", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(rootCostCenterNode) // node exists
+      .mockReturnValueOnce(childCostCenterNode); // has children
+
+    const result = await run(db, { nodeId: rootCostCenterNode.id }, commandCtx);
+
+    expectErr(result, NodeHasChildrenError);
+  });
+
+  it("returns error when node has assigned cost centers", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(childCostCenterNode) // node exists
+      .mockReturnValueOnce(undefined) // no children
+      .mockReturnValueOnce(baseCostCenter); // has assigned cost centers
+
+    const result = await run(db, { nodeId: childCostCenterNode.id }, commandCtx);
+
+    expectErr(result, NodeHasAssignedCostCentersError);
+  });
+
+  it("deletes node when it has no children and no assigned cost centers", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(childCostCenterNode) // node exists
+      .mockReturnValueOnce(undefined) // no children
+      .mockReturnValueOnce(undefined); // no assigned cost centers
+
+    const result = await run(db, { nodeId: childCostCenterNode.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.nodeId).toBe(childCostCenterNode.id);
+    expect(spies.delete).toHaveBeenCalled();
+  });
+});