@tailor-platform/erp-kit 0.6.0 → 0.8.0

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

@@ -0,0 +1,87 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetProfitCenterHierarchyInput {
+  id: string;
+}
+
+type ProfitCenterHierarchyTreeNode = Awaited<
+  ReturnType<typeof loadNodesWithProfitCenters>
+>[number] & {
+  children: ProfitCenterHierarchyTreeNode[];
+};
+
+async function loadNodesWithProfitCenters(db: ReadonlyDB<DB>, hierarchyId: string) {
+  const nodes = await db
+    .selectFrom("ProfitCenterHierarchyNode")
+    .selectAll()
+    .where("hierarchyId", "=", hierarchyId)
+    .orderBy("level", "asc")
+    .orderBy("sortOrder", "asc")
+    .execute();
+
+  return Promise.all(
+    nodes.map(async (node) => {
+      const profitCenters = await db
+        .selectFrom("ProfitCenterHierarchyAssignment")
+        .innerJoin(
+          "ProfitCenter",
+          "ProfitCenter.id",
+          "ProfitCenterHierarchyAssignment.profitCenterId",
+        )
+        .selectAll("ProfitCenter")
+        .where("ProfitCenterHierarchyAssignment.hierarchyNodeId", "=", node.id)
+        .execute();
+      return { ...node, profitCenters };
+    }),
+  );
+}
+
+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: getProfitCenterHierarchy
+ *
+ * Retrieves a single profit center hierarchy by id, along with its hierarchy nodes
+ * and the profit centers assigned to each node.
+ */
+export async function run(db: ReadonlyDB<DB>, input: GetProfitCenterHierarchyInput) {
+  const hierarchy = await db
+    .selectFrom("ProfitCenterHierarchy")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  if (!hierarchy) {
+    return ok({ profitCenterHierarchy: null, nodes: [] });
+  }
+
+  const nodesWithProfitCenters = await loadNodesWithProfitCenters(db, input.id);
+  const nodes = buildTree(nodesWithProfitCenters) as ProfitCenterHierarchyTreeNode[];
+
+  return ok({ profitCenterHierarchy: hierarchy, nodes });
+}

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

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

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

@@ -0,0 +1,108 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseVarianceReport, baseVarianceReportLine } from "../testing/fixtures";
+import { run } from "./getVarianceReport";
+
+describe("getVarianceReport", () => {
+  it("returns variance report with all header fields and detail lines when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseVarianceReport)
+      .mockReturnValueOnce([baseVarianceReportLine]);
+
+    const result = await run(db, { id: baseVarianceReport.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.varianceReport).toEqual(baseVarianceReport);
+      expect(result.value.lines).toEqual([baseVarianceReportLine]);
+    }
+  });
+
+  it("returns variance report with summary totals matching the sum of detail lines", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseVarianceReport)
+      .mockReturnValueOnce([baseVarianceReportLine]);
+
+    const result = await run(db, { id: baseVarianceReport.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.varianceReport?.totalPlanned).toEqual(
+        baseVarianceReportLine.plannedAmount,
+      );
+      expect(result.value.varianceReport?.totalActual).toEqual(baseVarianceReportLine.actualAmount);
+      expect(result.value.varianceReport?.totalVariance).toEqual(
+        baseVarianceReportLine.varianceAmount,
+      );
+    }
+  });
+
+  it("returns detail lines with planned amount, actual amount, variance amount, and variance percentage", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseVarianceReport)
+      .mockReturnValueOnce([baseVarianceReportLine]);
+
+    const result = await run(db, { id: baseVarianceReport.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.lines[0]).toMatchObject({
+        plannedAmount: baseVarianceReportLine.plannedAmount,
+        actualAmount: baseVarianceReportLine.actualAmount,
+        varianceAmount: baseVarianceReportLine.varianceAmount,
+        variancePercentage: baseVarianceReportLine.variancePercentage,
+      });
+    }
+  });
+
+  it("returns detail lines with variance direction FAVORABLE for cost elements where actual is below plan", async () => {
+    const favorableLine = {
+      ...baseVarianceReportLine,
+      id: "variance-report-line-favorable",
+      plannedAmount: 10000,
+      actualAmount: 8000,
+      varianceAmount: -2000,
+      varianceDirection: "FAVORABLE" as const,
+    };
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseVarianceReport).mockReturnValueOnce([favorableLine]);
+
+    const result = await run(db, { id: baseVarianceReport.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.lines[0].varianceDirection).toEqual("FAVORABLE");
+    }
+  });
+
+  it("returns detail lines with variance direction UNFAVORABLE for cost elements where actual is above plan", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseVarianceReport)
+      .mockReturnValueOnce([baseVarianceReportLine]);
+
+    const result = await run(db, { id: baseVarianceReport.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.lines[0].varianceDirection).toEqual("UNFAVORABLE");
+    }
+  });
+
+  it("returns null when no variance report 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.varianceReport).toBeNull();
+      expect(result.value.lines).toEqual([]);
+    }
+  });
+});

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

@@ -0,0 +1,31 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetVarianceReportInput {
+  id: string;
+}
+
+/**
+ * Function: getVarianceReport
+ *
+ * Retrieves a single variance report by id, along with its report lines.
+ */
+export async function run(db: ReadonlyDB<DB>, input: GetVarianceReportInput) {
+  const varianceReport = await db
+    .selectFrom("VarianceReport")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  if (!varianceReport) {
+    return ok({ varianceReport: null, lines: [] });
+  }
+
+  const lines = await db
+    .selectFrom("VarianceReportLine")
+    .selectAll()
+    .where("varianceReportId", "=", input.id)
+    .execute();
+
+  return ok({ varianceReport, lines });
+}

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

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

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

@@ -0,0 +1,152 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  AccountingPeriodNotFoundError,
+  InvalidStatusFilterError,
+  InvalidTypeFilterError,
+} from "../lib/errors.generated";
+import {
+  baseAllocationCycle,
+  postedAllocationCycle,
+  baseAccountingPeriod,
+} from "../testing/fixtures";
+import { run } from "./listAllocationCycles";
+
+const distributionAllocationCycle = {
+  ...baseAllocationCycle,
+  id: "allocation-cycle-distribution",
+  allocationType: "DISTRIBUTION" as const,
+};
+
+describe("listAllocationCycles", () => {
+  it("returns all allocation cycles when no filters are provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseAllocationCycle, postedAllocationCycle]);
+
+    const result = await run(db, {});
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(2);
+    }
+  });
+
+  it("returns allocation cycles filtered by companyId", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseAllocationCycle]);
+
+    const result = await run(db, { companyId: baseAllocationCycle.companyId });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0]).toEqual(baseAllocationCycle);
+    }
+  });
+
+  it("returns allocation cycles filtered by type ASSESSMENT", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseAllocationCycle]);
+
+    const result = await run(db, { type: "ASSESSMENT" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0].allocationType).toEqual("ASSESSMENT");
+    }
+  });
+
+  it("returns allocation cycles filtered by type DISTRIBUTION", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([distributionAllocationCycle]);
+
+    const result = await run(db, { type: "DISTRIBUTION" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0].allocationType).toEqual("DISTRIBUTION");
+    }
+  });
+
+  it("returns allocation cycles filtered by status POSTED", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([postedAllocationCycle]);
+
+    const result = await run(db, { status: "POSTED" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0].status).toEqual("POSTED");
+    }
+  });
+
+  it("returns allocation cycles filtered by accountingPeriodId", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce({ id: baseAccountingPeriod.id })
+      .mockReturnValueOnce([baseAllocationCycle]);
+
+    const result = await run(db, { accountingPeriodId: baseAccountingPeriod.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0].accountingPeriodId).toEqual(baseAccountingPeriod.id);
+    }
+  });
+
+  it("returns allocation cycles matching multiple filters simultaneously", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([postedAllocationCycle]);
+
+    const result = await run(db, {
+      companyId: postedAllocationCycle.companyId,
+      type: "ASSESSMENT",
+      status: "POSTED",
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0]).toEqual(postedAllocationCycle);
+    }
+  });
+
+  it("returns an empty list when no allocation cycles match the given filters", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, { companyId: "non-existent" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([]);
+    }
+  });
+
+  it("returns error when type filter is invalid", async () => {
+    const { db } = createMockDb<DB>();
+    const result = await run(db, { type: "INVALID" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toBeInstanceOf(InvalidTypeFilterError);
+  });
+
+  it("returns error when status filter is invalid", async () => {
+    const { db } = createMockDb<DB>();
+    const result = await run(db, { status: "INVALID" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toBeInstanceOf(InvalidStatusFilterError);
+  });
+
+  it("returns error when accountingPeriodId does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+    const result = await run(db, { accountingPeriodId: "missing-period" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toBeInstanceOf(AccountingPeriodNotFoundError);
+  });
+});

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

@@ -0,0 +1,96 @@
+import type { AllocationCycleAllocationType, AllocationCycleStatus } from "../generated/enums";
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  AccountingPeriodNotFoundError,
+  InvalidStatusFilterError,
+  InvalidTypeFilterError,
+} from "../lib/errors.generated";
+import {
+  err,
+  ok,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "@tailor-platform/erp-kit/module";
+
+type AllocationCycleOrderByField = "name" | "createdAt";
+
+export interface ListAllocationCyclesInput extends PaginationInput<AllocationCycleOrderByField> {
+  companyId?: string;
+  type?: string;
+  status?: string;
+  accountingPeriodId?: string;
+}
+
+/**
+ * Function: listAllocationCycles
+ *
+ * Lists allocation cycles with optional filters for allocation type, status,
+ * and accounting period.
+ */
+export async function run(db: ReadonlyDB<DB>, input: ListAllocationCyclesInput) {
+  if (
+    input.type &&
+    !(["ASSESSMENT", "DISTRIBUTION"] as const satisfies AllocationCycleAllocationType[]).includes(
+      input.type as AllocationCycleAllocationType,
+    )
+  ) {
+    return err(new InvalidTypeFilterError(input.type));
+  }
+
+  if (
+    input.status &&
+    !(
+      [
+        "DRAFT",
+        "VALIDATED",
+        "EXECUTED",
+        "POSTED",
+        "REVERSED",
+      ] as const satisfies AllocationCycleStatus[]
+    ).includes(input.status as AllocationCycleStatus)
+  ) {
+    return err(new InvalidStatusFilterError(input.status));
+  }
+
+  if (input.accountingPeriodId) {
+    const accountingPeriod = await db
+      .selectFrom("AccountingPeriod")
+      .select("id")
+      .where("id", "=", input.accountingPeriodId)
+      .executeTakeFirst();
+
+    if (!accountingPeriod) {
+      return err(new AccountingPeriodNotFoundError(input.accountingPeriodId));
+    }
+  }
+
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = input.orderBy ?? "id";
+  const orderDirection = input.orderDirection ?? "asc";
+
+  let query = db.selectFrom("AllocationCycle").selectAll();
+
+  if (input.companyId) {
+    query = query.where("companyId", "=", input.companyId);
+  }
+  if (input.type) {
+    query = query.where("allocationType", "=", input.type as AllocationCycleAllocationType);
+  }
+  if (input.status) {
+    query = query.where("status", "=", input.status as AllocationCycleStatus);
+  }
+  if (input.accountingPeriodId) {
+    query = query.where("accountingPeriodId", "=", input.accountingPeriodId);
+  }
+
+  const allocationCycles = await query
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+
+  return ok(buildPaginatedResult(allocationCycles, limit));
+}

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

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

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

@@ -0,0 +1,150 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  InvalidCostObjectTypeFilterError,
+  InvalidStatusFilterError,
+} from "../lib/errors.generated";
+import {
+  baseBudget,
+  activeBudget,
+  baseFiscalYear,
+  baseCostCenter,
+  basePlanVersion,
+} from "../testing/fixtures";
+import { run } from "./listBudgets";
+
+describe("listBudgets", () => {
+  it("returns all budgets when no filters are provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseBudget, activeBudget]);
+
+    const result = await run(db, {});
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(2);
+    }
+  });
+
+  it("returns budgets filtered by companyId", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseBudget]);
+
+    const result = await run(db, { companyId: baseBudget.companyId });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0]).toEqual(baseBudget);
+    }
+  });
+
+  it("returns budgets filtered by fiscalYearId", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseBudget]);
+
+    const result = await run(db, { fiscalYearId: baseFiscalYear.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0].fiscalYearId).toEqual(baseFiscalYear.id);
+    }
+  });
+
+  it("returns budgets filtered by costObjectType", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseBudget]);
+
+    const result = await run(db, { costObjectType: "CostCenter" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0].costObjectType).toEqual("CostCenter");
+    }
+  });
+
+  it("returns budgets filtered by costObjectId", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseBudget]);
+
+    const result = await run(db, { costObjectId: baseCostCenter.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0].costObjectId).toEqual(baseCostCenter.id);
+    }
+  });
+
+  it("returns budgets filtered by status ACTIVE", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([activeBudget]);
+
+    const result = await run(db, { status: "ACTIVE" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0].status).toEqual("ACTIVE");
+    }
+  });
+
+  it("returns budgets filtered by planVersionId", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseBudget]);
+
+    const result = await run(db, { planVersionId: basePlanVersion.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0].planVersionId).toEqual(basePlanVersion.id);
+    }
+  });
+
+  it("returns budgets matching multiple filters simultaneously", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([activeBudget]);
+
+    const result = await run(db, {
+      companyId: activeBudget.companyId,
+      fiscalYearId: baseFiscalYear.id,
+      status: "ACTIVE",
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0]).toEqual(activeBudget);
+    }
+  });
+
+  it("returns an empty list when no budgets match the given filters", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, { companyId: "non-existent" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([]);
+    }
+  });
+
+  it("returns error when status filter is invalid", async () => {
+    const { db } = createMockDb<DB>();
+    const result = await run(db, { status: "INVALID" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toBeInstanceOf(InvalidStatusFilterError);
+  });
+
+  it("returns error when costObjectType filter is invalid", async () => {
+    const { db } = createMockDb<DB>();
+    const result = await run(db, { costObjectType: "InvalidType" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toBeInstanceOf(InvalidCostObjectTypeFilterError);
+  });
+});