@tailor-platform/erp-kit 0.6.0 → 0.8.0

package/src/modules/accounting/query/calculateBudgetAvailability.test.ts

@@ -0,0 +1,229 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  AccountingPeriodNotFoundError,
+  CostElementNotFoundError,
+  CostObjectNotFoundError,
+} from "../lib/errors.generated";
+import {
+  activeBudget,
+  activeCostElement,
+  baseAccountingPeriod,
+  baseBudgetLineItem,
+  baseCommitment,
+  baseCostCenter,
+} from "../testing/fixtures";
+import { expectErr } from "../testing/commandTestUtils";
+import { run } from "./calculateBudgetAvailability";
+
+const baseInput = {
+  costElementId: activeCostElement.id,
+  costObjectType: "CostCenter",
+  costObjectId: baseCostCenter.id,
+  accountingPeriodId: baseAccountingPeriod.id,
+};
+
+function queueHappyPath(
+  spies: ReturnType<typeof createMockDb<DB>>["spies"],
+  options?: {
+    budgetLineItem?: Record<string, unknown>;
+    actualRows?: Record<string, unknown>[];
+    commitmentAmount?: number;
+  },
+) {
+  spies.select
+    .mockReturnValueOnce(activeCostElement)
+    .mockReturnValueOnce(baseCostCenter)
+    .mockReturnValueOnce(baseAccountingPeriod)
+    .mockReturnValueOnce({ id: activeBudget.id })
+    .mockReturnValueOnce(options?.budgetLineItem ?? baseBudgetLineItem)
+    .mockReturnValueOnce({ totalCommitment: options?.commitmentAmount ?? 0 })
+    .mockReturnValueOnce(options?.actualRows ?? []);
+}
+
+describe("calculateBudgetAvailability", () => {
+  it("returns error when cost element does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { ...baseInput, costElementId: "missing-cost-element" });
+
+    expectErr(result, CostElementNotFoundError);
+  });
+
+  it("returns error when cost object does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(activeCostElement).mockReturnValueOnce(undefined);
+
+    const result = await run(db, { ...baseInput, costObjectId: "missing-cost-object" });
+
+    expectErr(result, CostObjectNotFoundError);
+  });
+
+  it("returns error when accounting period does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(activeCostElement)
+      .mockReturnValueOnce(baseCostCenter)
+      .mockReturnValueOnce(undefined);
+
+    const result = await run(db, { ...baseInput, accountingPeriodId: "missing-period" });
+
+    expectErr(result, AccountingPeriodNotFoundError);
+  });
+
+  it("returns budget availability with all component amounts when budget and line item exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    queueHappyPath(spies);
+
+    const result = await run(db, baseInput);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.availability).not.toBeNull();
+      expect(result.value.availability?.plannedAmount).toEqual(baseBudgetLineItem.plannedAmount);
+      expect(result.value.availability?.encumbranceAmount).toEqual(0);
+      expect(result.value.availability?.availableAmount).toBeDefined();
+    }
+  });
+
+  it("computes available as budget minus actual plus commitments plus encumbrances", async () => {
+    const { db, spies } = createMockDb<DB>();
+    queueHappyPath(spies, {
+      actualRows: [{ costElementId: activeCostElement.id, functionalDebitAmount: 2000 }],
+      commitmentAmount: 3000,
+    });
+
+    const result = await run(db, baseInput);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.availability?.availableAmount).toEqual(5000);
+      expect(result.value.availability?.commitmentAmount).toEqual(3000);
+    }
+  });
+
+  it("returns actual amount aggregated from posted journal entries only", async () => {
+    const { db, spies } = createMockDb<DB>();
+    queueHappyPath(spies, {
+      actualRows: [{ costElementId: activeCostElement.id, functionalDebitAmount: 2500 }],
+    });
+
+    const result = await run(db, baseInput);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.availability?.actualAmount).toEqual(2500);
+    }
+  });
+
+  it("excludes draft journal entries from actual amount calculation", async () => {
+    const { db, spies } = createMockDb<DB>();
+    queueHappyPath(spies, {
+      actualRows: [{ costElementId: "other-cost-element", functionalDebitAmount: 2500 }],
+    });
+
+    const result = await run(db, baseInput);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.availability?.actualAmount).toEqual(0);
+    }
+  });
+
+  it("returns commitment amount from outstanding purchase order records", async () => {
+    const { db, spies } = createMockDb<DB>();
+    queueHappyPath(spies, { commitmentAmount: baseCommitment.amount });
+
+    const result = await run(db, baseInput);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.availability?.commitmentAmount).toEqual(baseCommitment.amount);
+    }
+  });
+
+  it("returns encumbrance amount as zero", async () => {
+    const { db, spies } = createMockDb<DB>();
+    queueHappyPath(spies);
+
+    const result = await run(db, baseInput);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.availability?.encumbranceAmount).toEqual(0);
+    }
+  });
+
+  it("returns null availability with NO_BUDGET_DEFINED flag when no active budget exists", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(activeCostElement)
+      .mockReturnValueOnce(baseCostCenter)
+      .mockReturnValueOnce(baseAccountingPeriod)
+      .mockReturnValueOnce(undefined);
+
+    const result = await run(db, baseInput);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.availability).toBeNull();
+      if (result.value.availability === null) {
+        expect((result.value as { availability: null; reason: string }).reason).toEqual(
+          "NO_BUDGET_DEFINED",
+        );
+      }
+    }
+  });
+
+  it("returns null availability with NO_BUDGET_LINE_ITEM flag when line item does not exist for cost element and period", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(activeCostElement)
+      .mockReturnValueOnce(baseCostCenter)
+      .mockReturnValueOnce(baseAccountingPeriod)
+      .mockReturnValueOnce({ id: activeBudget.id })
+      .mockReturnValueOnce(undefined);
+
+    const result = await run(db, baseInput);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.availability).toBeNull();
+      if (result.value.availability === null) {
+        expect((result.value as { availability: null; reason: string }).reason).toEqual(
+          "NO_BUDGET_LINE_ITEM",
+        );
+      }
+    }
+  });
+
+  it("handles zero budget amount gracefully", async () => {
+    const { db, spies } = createMockDb<DB>();
+    queueHappyPath(spies, { budgetLineItem: { ...baseBudgetLineItem, plannedAmount: 0 } });
+
+    const result = await run(db, baseInput);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.availability?.plannedAmount).toEqual(0);
+      expect(result.value.availability?.availableAmount).toEqual(0);
+    }
+  });
+
+  it("handles case where actual exceeds budget resulting in negative availability", async () => {
+    const { db, spies } = createMockDb<DB>();
+    queueHappyPath(spies, {
+      actualRows: [{ costElementId: activeCostElement.id, functionalDebitAmount: 12000 }],
+      commitmentAmount: 3000,
+    });
+
+    const result = await run(db, baseInput);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.availability?.availableAmount).toEqual(-5000);
+    }
+  });
+});

package/src/modules/accounting/query/calculateBudgetAvailability.ts

@@ -0,0 +1,147 @@
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  CostElementNotFoundError,
+  CostObjectNotFoundError,
+  AccountingPeriodNotFoundError,
+} from "../lib/errors.generated";
+import { sumPostedActualAmount } from "../lib/actualAmounts";
+import { err, ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface CalculateBudgetAvailabilityInput {
+  costObjectType: string;
+  costObjectId: string;
+  costElementId: string;
+  accountingPeriodId: string;
+}
+
+/**
+ * Function: calculateBudgetAvailability
+ *
+ * Computes budget availability for a given cost element, cost object, and
+ * accounting period using the formula:
+ * Available = Budget - (Actual + Commitments + Encumbrances)
+ *
+ * Encumbrances are reserved for future extension (treated as 0).
+ */
+export async function run(db: ReadonlyDB<DB>, input: CalculateBudgetAvailabilityInput) {
+  // Step 1: Validate cost element exists
+  const costElement = await db
+    .selectFrom("CostElement")
+    .selectAll()
+    .where("id", "=", input.costElementId)
+    .executeTakeFirst();
+
+  if (!costElement) {
+    return err(new CostElementNotFoundError(input.costElementId));
+  }
+
+  // Step 2: Validate cost object exists (polymorphic: CostCenter, ProfitCenter, or InternalOrder)
+  let costObject: unknown;
+  if (input.costObjectType === "CostCenter") {
+    costObject = await db
+      .selectFrom("CostCenter")
+      .selectAll()
+      .where("id", "=", input.costObjectId)
+      .executeTakeFirst();
+  } else if (input.costObjectType === "ProfitCenter") {
+    costObject = await db
+      .selectFrom("ProfitCenter")
+      .selectAll()
+      .where("id", "=", input.costObjectId)
+      .executeTakeFirst();
+  } else if (input.costObjectType === "InternalOrder") {
+    costObject = await db
+      .selectFrom("InternalOrder")
+      .selectAll()
+      .where("id", "=", input.costObjectId)
+      .executeTakeFirst();
+  }
+
+  if (!costObject) {
+    return err(new CostObjectNotFoundError(input.costObjectId));
+  }
+
+  // Step 3: Validate accounting period exists
+  const accountingPeriod = await db
+    .selectFrom("AccountingPeriod")
+    .selectAll()
+    .where("id", "=", input.accountingPeriodId)
+    .executeTakeFirst();
+
+  if (!accountingPeriod) {
+    return err(new AccountingPeriodNotFoundError(input.accountingPeriodId));
+  }
+
+  // Step 4: Find the ACTIVE budget for the given cost object and fiscal year
+  // where the plan version type is BUDGET
+  const budget = await db
+    .selectFrom("Budget")
+    .innerJoin("PlanVersion", "PlanVersion.id", "Budget.planVersionId")
+    .select(["Budget.id"])
+    .where("Budget.costObjectType", "=", input.costObjectType)
+    .where("Budget.costObjectId", "=", input.costObjectId)
+    .where("Budget.fiscalYearId", "=", accountingPeriod.fiscalYearId)
+    .where("Budget.status", "=", "ACTIVE")
+    .where("PlanVersion.type", "=", "BUDGET")
+    .executeTakeFirst();
+
+  // Step 5: If no active budget found, return null availability
+  if (!budget) {
+    return ok({ availability: null, reason: "NO_BUDGET_DEFINED" });
+  }
+
+  // Step 6: Find the budget line item matching the cost element and period
+  const lineItem = await db
+    .selectFrom("BudgetLineItem")
+    .selectAll()
+    .where("budgetId", "=", budget.id)
+    .where("costElementId", "=", input.costElementId)
+    .where("accountingPeriodId", "=", input.accountingPeriodId)
+    .executeTakeFirst();
+
+  // Step 7: If no matching line item, return null availability
+  if (!lineItem) {
+    return ok({ availability: null, reason: "NO_BUDGET_LINE_ITEM" });
+  }
+
+  // Step 8: Get the planned amount from the budget line item
+  const plannedAmount = lineItem.plannedAmount;
+
+  // Step 9: Sum commitment amounts for the same cost element, cost object, and
+  // period where status is not "RELEASED"
+  const commitmentResult = await db
+    .selectFrom("Commitment")
+    .select((eb) => eb.fn.sum<number>("amount").as("totalCommitment"))
+    .where("costElementId", "=", input.costElementId)
+    .where("costObjectType", "=", input.costObjectType)
+    .where("costObjectId", "=", input.costObjectId)
+    .where("accountingPeriodId", "=", input.accountingPeriodId)
+    .where("status", "!=", "RELEASED")
+    .executeTakeFirst();
+
+  const commitmentAmount = commitmentResult?.totalCommitment ?? 0;
+
+  // Step 10: Sum posted actual amounts from finance-ledger journal lines
+  const actualAmount = await sumPostedActualAmount(db, {
+    accountingPeriodId: input.accountingPeriodId,
+    costObjectType: input.costObjectType,
+    costObjectId: input.costObjectId,
+    costElementId: input.costElementId,
+  });
+
+  // Step 11: Encumbrance amount is zero (future extension placeholder)
+  const encumbranceAmount = 0;
+
+  // Step 12: Compute available = plannedAmount - (actualAmount + commitmentAmount + encumbranceAmount)
+  const availableAmount = plannedAmount - (actualAmount + commitmentAmount + encumbranceAmount);
+
+  return ok({
+    availability: {
+      plannedAmount,
+      actualAmount,
+      commitmentAmount,
+      encumbranceAmount,
+      availableAmount,
+    },
+  });
+}

package/src/modules/accounting/query/getAllocationCycle.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./getAllocationCycle";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const getAllocationCycle = defineQuery(run);

package/src/modules/accounting/query/getAllocationCycle.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  baseAllocationCycle,
+  validatedAllocationCycle,
+  executedAllocationCycle,
+  baseAllocationRule,
+  baseAllocationResult,
+} from "../testing/fixtures";
+import { run } from "./getAllocationCycle";
+
+describe("getAllocationCycle", () => {
+  it("returns allocation cycle with all fields and allocation rules when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseAllocationCycle)
+      .mockReturnValueOnce([baseAllocationRule])
+      .mockReturnValueOnce([]);
+
+    const result = await run(db, { id: baseAllocationCycle.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.allocationCycle).toEqual(baseAllocationCycle);
+      expect(result.value.rules).toEqual([baseAllocationRule]);
+    }
+  });
+
+  it("returns allocation cycle with allocation results when cycle has been executed", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(executedAllocationCycle)
+      .mockReturnValueOnce([baseAllocationRule])
+      .mockReturnValueOnce([baseAllocationResult]);
+
+    const result = await run(db, { id: executedAllocationCycle.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.allocationCycle?.status).toEqual("EXECUTED");
+      expect(result.value.results).toEqual([baseAllocationResult]);
+    }
+  });
+
+  it("returns allocation cycle with empty results when cycle is in DRAFT or VALIDATED status", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(validatedAllocationCycle)
+      .mockReturnValueOnce([baseAllocationRule])
+      .mockReturnValueOnce([]);
+
+    const result = await run(db, { id: validatedAllocationCycle.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.allocationCycle?.status).toEqual("VALIDATED");
+      expect(result.value.results).toEqual([]);
+    }
+  });
+
+  it("returns allocation rules with sender, receiver, and percentage details", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseAllocationCycle)
+      .mockReturnValueOnce([baseAllocationRule])
+      .mockReturnValueOnce([]);
+
+    const result = await run(db, { id: baseAllocationCycle.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.rules[0]).toMatchObject({
+        senderCostCenterId: baseAllocationRule.senderCostCenterId,
+        receiverId: baseAllocationRule.receiverId,
+        percentage: baseAllocationRule.percentage,
+      });
+    }
+  });
+
+  it("returns null when no allocation cycle matches the given id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "non-existent" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.allocationCycle).toBeNull();
+      expect(result.value.rules).toEqual([]);
+      expect(result.value.results).toEqual([]);
+    }
+  });
+});

package/src/modules/accounting/query/getAllocationCycle.ts

@@ -0,0 +1,37 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetAllocationCycleInput {
+  id: string;
+}
+
+/**
+ * Function: getAllocationCycle
+ *
+ * Retrieves a single allocation cycle by id, along with its rules and results.
+ */
+export async function run(db: ReadonlyDB<DB>, input: GetAllocationCycleInput) {
+  const cycle = await db
+    .selectFrom("AllocationCycle")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  if (!cycle) {
+    return ok({ allocationCycle: null, rules: [], results: [] });
+  }
+
+  const rules = await db
+    .selectFrom("AllocationRule")
+    .selectAll()
+    .where("allocationCycleId", "=", input.id)
+    .execute();
+
+  const results = await db
+    .selectFrom("AllocationResult")
+    .selectAll()
+    .where("allocationCycleId", "=", input.id)
+    .execute();
+
+  return ok({ allocationCycle: cycle, rules, results });
+}

package/src/modules/accounting/query/getBudget.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./getBudget";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const getBudget = defineQuery(run);

package/src/modules/accounting/query/getBudget.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  baseBudget,
+  baseBudgetLineItem,
+  activeCostElement,
+  baseAccountingPeriod,
+} from "../testing/fixtures";
+import { run } from "./getBudget";
+
+describe("getBudget", () => {
+  it("returns budget with all header fields and line items when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseBudget).mockReturnValueOnce([baseBudgetLineItem]);
+
+    const result = await run(db, { id: baseBudget.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.budget).toEqual(baseBudget);
+      expect(result.value.lineItems).toEqual([baseBudgetLineItem]);
+    }
+  });
+
+  it("returns budget line items with cost element, period, and planned amount", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseBudget).mockReturnValueOnce([baseBudgetLineItem]);
+
+    const result = await run(db, { id: baseBudget.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.lineItems[0]).toMatchObject({
+        costElementId: activeCostElement.id,
+        accountingPeriodId: baseAccountingPeriod.id,
+        plannedAmount: baseBudgetLineItem.plannedAmount,
+      });
+    }
+  });
+
+  it("returns budget line items with derived GL account from cost element mapping", async () => {
+    const lineItemWithGlAccount = { ...baseBudgetLineItem, glAccountId: "account-1" };
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseBudget).mockReturnValueOnce([lineItemWithGlAccount]);
+
+    const result = await run(db, { id: baseBudget.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.lineItems[0].glAccountId).toEqual("account-1");
+    }
+  });
+
+  it("returns budget with empty line items when budget has no line items", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseBudget).mockReturnValueOnce([]);
+
+    const result = await run(db, { id: baseBudget.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.budget).toEqual(baseBudget);
+      expect(result.value.lineItems).toEqual([]);
+    }
+  });
+
+  it("returns null when no budget matches the given id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "non-existent" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.budget).toBeNull();
+      expect(result.value.lineItems).toEqual([]);
+    }
+  });
+});

package/src/modules/accounting/query/getBudget.ts

@@ -0,0 +1,31 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetBudgetInput {
+  id: string;
+}
+
+/**
+ * Function: getBudget
+ *
+ * Retrieves a single budget by id, along with its line items.
+ */
+export async function run(db: ReadonlyDB<DB>, input: GetBudgetInput) {
+  const budget = await db
+    .selectFrom("Budget")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  if (!budget) {
+    return ok({ budget: null, lineItems: [] });
+  }
+
+  const lineItems = await db
+    .selectFrom("BudgetLineItem")
+    .selectAll()
+    .where("budgetId", "=", input.id)
+    .execute();
+
+  return ok({ budget, lineItems });
+}

package/src/modules/accounting/query/getCostCenter.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./getCostCenter";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const getCostCenter = defineQuery(run);

package/src/modules/accounting/query/getCostCenter.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseCostCenter, childCostCenterNode } from "../testing/fixtures";
+import { run } from "./getCostCenter";
+
+describe("getCostCenter", () => {
+  it("returns cost center with all fields and hierarchy node assignment when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseCostCenter).mockReturnValueOnce(childCostCenterNode);
+
+    const result = await run(db, { id: baseCostCenter.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.costCenter).toEqual(baseCostCenter);
+      if (result.value.costCenter !== null) {
+        expect(
+          (result.value as { costCenter: typeof baseCostCenter; hierarchyNode: unknown })
+            .hierarchyNode,
+        ).toEqual(childCostCenterNode);
+      }
+    }
+  });
+
+  it("returns cost center with responsible person and department reference populated", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseCostCenter).mockReturnValueOnce(childCostCenterNode);
+
+    const result = await run(db, { id: baseCostCenter.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.costCenter?.responsiblePersonId).not.toBeNull();
+      expect(result.value.costCenter?.departmentId).not.toBeNull();
+    }
+  });
+
+  it("returns null when no cost center matches the given id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "non-existent" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.costCenter).toBeNull();
+    }
+  });
+});