@tailor-platform/erp-kit 0.7.0 → 0.8.0

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

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

@@ -0,0 +1,33 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetCostCenterInput {
+  id: string;
+}
+
+/**
+ * Function: getCostCenter
+ *
+ * Retrieves a single cost center by id, including the hierarchy node assignment.
+ */
+export async function run(db: ReadonlyDB<DB>, input: GetCostCenterInput) {
+  const result = await db
+    .selectFrom("CostCenter")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  if (!result) {
+    return ok({ costCenter: null });
+  }
+
+  const hierarchyNode = result.hierarchyNodeId
+    ? ((await db
+        .selectFrom("CostCenterHierarchyNode")
+        .selectAll()
+        .where("id", "=", result.hierarchyNodeId)
+        .executeTakeFirst()) ?? null)
+    : null;
+
+  return ok({ costCenter: result, hierarchyNode });
+}

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

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

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

@@ -0,0 +1,100 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  baseCostCenter,
+  baseCostCenter2,
+  baseCostCenterHierarchy,
+  childCostCenterNode,
+  childCostCenterNode2,
+  rootCostCenterNode,
+} from "../testing/fixtures";
+import { run } from "./getCostCenterHierarchy";
+
+describe("getCostCenterHierarchy", () => {
+  it("returns hierarchy with all nodes in tree structure when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenterHierarchy)
+      .mockReturnValueOnce([rootCostCenterNode, childCostCenterNode, childCostCenterNode2])
+      .mockReturnValueOnce([])
+      .mockReturnValueOnce([baseCostCenter])
+      .mockReturnValueOnce([baseCostCenter2]);
+
+    const result = await run(db, { id: baseCostCenterHierarchy.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.costCenterHierarchy).toEqual(baseCostCenterHierarchy);
+      expect(result.value.nodes).toHaveLength(1);
+      expect(result.value.nodes[0].children).toHaveLength(2);
+    }
+  });
+
+  it("returns hierarchy with root node and nested child nodes", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenterHierarchy)
+      .mockReturnValueOnce([rootCostCenterNode, childCostCenterNode])
+      .mockReturnValueOnce([])
+      .mockReturnValueOnce([baseCostCenter]);
+
+    const result = await run(db, { id: baseCostCenterHierarchy.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.nodes[0]).toMatchObject({
+        id: rootCostCenterNode.id,
+        parentNodeId: null,
+      });
+      expect(result.value.nodes[0].children[0]).toMatchObject({
+        id: childCostCenterNode.id,
+        parentNodeId: rootCostCenterNode.id,
+      });
+    }
+  });
+
+  it("returns hierarchy nodes with assigned cost centers populated", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenterHierarchy)
+      .mockReturnValueOnce([childCostCenterNode])
+      .mockReturnValueOnce([baseCostCenter]);
+
+    const result = await run(db, { id: baseCostCenterHierarchy.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.nodes[0]).toMatchObject({ id: childCostCenterNode.id });
+      expect(result.value.nodes[0].costCenters).toEqual([baseCostCenter]);
+    }
+  });
+
+  it("returns leaf nodes with no children", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenterHierarchy)
+      .mockReturnValueOnce([childCostCenterNode])
+      .mockReturnValueOnce([]);
+
+    const result = await run(db, { id: baseCostCenterHierarchy.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.nodes[0].children).toEqual([]);
+    }
+  });
+
+  it("returns null when no hierarchy 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.costCenterHierarchy).toBeNull();
+      expect(result.value.nodes).toEqual([]);
+    }
+  });
+});

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

@@ -0,0 +1,80 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetCostCenterHierarchyInput {
+  id: string;
+}
+
+type CostCenterHierarchyTreeNode = Awaited<ReturnType<typeof loadNodesWithCostCenters>>[number] & {
+  children: CostCenterHierarchyTreeNode[];
+};
+
+async function loadNodesWithCostCenters(db: ReadonlyDB<DB>, hierarchyId: string) {
+  const nodes = await db
+    .selectFrom("CostCenterHierarchyNode")
+    .selectAll()
+    .where("hierarchyId", "=", hierarchyId)
+    .orderBy("level", "asc")
+    .orderBy("sortOrder", "asc")
+    .execute();
+
+  return Promise.all(
+    nodes.map(async (node) => {
+      const costCenters = await db
+        .selectFrom("CostCenter")
+        .selectAll()
+        .where("hierarchyNodeId", "=", node.id)
+        .execute();
+      return { ...node, costCenters };
+    }),
+  );
+}
+
+function buildTree<T extends { id: string; parentNodeId: string | null }>(
+  nodes: T[],
+): (T & { children: (T & { children: unknown[] })[] })[] {
+  const nodeMap = new Map(
+    nodes.map((node) => [node.id, { ...node, children: [] as (T & { children: unknown[] })[] }]),
+  );
+  const roots: (T & { children: (T & { children: unknown[] })[] })[] = [];
+
+  for (const node of nodes) {
+    const treeNode = nodeMap.get(node.id)!;
+    if (!node.parentNodeId) {
+      roots.push(treeNode);
+      continue;
+    }
+
+    const parent = nodeMap.get(node.parentNodeId);
+    if (parent) {
+      parent.children.push(treeNode);
+    } else {
+      roots.push(treeNode);
+    }
+  }
+
+  return roots;
+}
+
+/**
+ * Function: getCostCenterHierarchy
+ *
+ * Retrieves a single cost center hierarchy by id, along with its hierarchy nodes
+ * and the cost centers assigned to each node.
+ */
+export async function run(db: ReadonlyDB<DB>, input: GetCostCenterHierarchyInput) {
+  const hierarchy = await db
+    .selectFrom("CostCenterHierarchy")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  if (!hierarchy) {
+    return ok({ costCenterHierarchy: null, nodes: [] });
+  }
+
+  const nodesWithCostCenters = await loadNodesWithCostCenters(db, input.id);
+  const nodes = buildTree(nodesWithCostCenters) as CostCenterHierarchyTreeNode[];
+
+  return ok({ costCenterHierarchy: hierarchy, nodes });
+}

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

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