@tailor-platform/erp-kit 0.7.0 → 0.8.0

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

@@ -0,0 +1,57 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseCostElement, activeCostElement, secondaryCostElement } from "../testing/fixtures";
+import { run } from "./getCostElement";
+
+describe("getCostElement", () => {
+  it("returns cost element with all fields when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseCostElement);
+
+    const result = await run(db, { id: baseCostElement.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.costElement).toEqual(baseCostElement);
+    }
+  });
+
+  it("returns primary cost element with GL account reference populated", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(activeCostElement);
+
+    const result = await run(db, { id: activeCostElement.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.costElement).toEqual(activeCostElement);
+      expect(result.value.costElement?.glAccountId).not.toBeNull();
+    }
+  });
+
+  it("returns secondary cost element with GL account reference as null", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(secondaryCostElement);
+
+    const result = await run(db, { id: secondaryCostElement.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.costElement).toEqual(secondaryCostElement);
+      expect(result.value.costElement?.glAccountId).toBeNull();
+    }
+  });
+
+  it("returns null when no cost element 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.costElement).toBeNull();
+    }
+  });
+});

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

@@ -0,0 +1,21 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetCostElementInput {
+  id: string;
+}
+
+/**
+ * Function: getCostElement
+ *
+ * Retrieves a single cost element by id.
+ */
+export async function run(db: ReadonlyDB<DB>, input: GetCostElementInput) {
+  const result = await db
+    .selectFrom("CostElement")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  return ok({ costElement: result ?? null });
+}

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

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

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

@@ -0,0 +1,73 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  baseInternalOrder,
+  releasedInternalOrder,
+  baseCostCenter,
+  baseBudget,
+} from "../testing/fixtures";
+import { run } from "./getInternalOrder";
+
+describe("getInternalOrder", () => {
+  it("returns internal order with all fields when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseInternalOrder);
+
+    const result = await run(db, { id: baseInternalOrder.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.internalOrder).toEqual(baseInternalOrder);
+    }
+  });
+
+  it("returns internal order with responsible cost center reference populated", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseInternalOrder);
+
+    const result = await run(db, { id: baseInternalOrder.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.internalOrder?.costCenterId).toEqual(baseCostCenter.id);
+    }
+  });
+
+  it("returns internal order with budget assignment when one exists", async () => {
+    const internalOrderWithBudget = { ...baseInternalOrder, budgetId: baseBudget.id };
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(internalOrderWithBudget);
+
+    const result = await run(db, { id: internalOrderWithBudget.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.internalOrder).toEqual(internalOrderWithBudget);
+    }
+  });
+
+  it("returns internal order without budget assignment when none exists", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(releasedInternalOrder);
+
+    const result = await run(db, { id: releasedInternalOrder.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.internalOrder?.status).toEqual("RELEASED");
+    }
+  });
+
+  it("returns null when no internal order 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.internalOrder).toBeNull();
+    }
+  });
+});

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

@@ -0,0 +1,21 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetInternalOrderInput {
+  id: string;
+}
+
+/**
+ * Function: getInternalOrder
+ *
+ * Retrieves a single internal order by id.
+ */
+export async function run(db: ReadonlyDB<DB>, input: GetInternalOrderInput) {
+  const result = await db
+    .selectFrom("InternalOrder")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  return ok({ internalOrder: result ?? null });
+}

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

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

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

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseProfitCenter, baseProfitCenterHierarchyAssignment } from "../testing/fixtures";
+import { run } from "./getProfitCenter";
+
+describe("getProfitCenter", () => {
+  it("returns profit center with all fields when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseProfitCenter)
+      .mockReturnValueOnce([baseProfitCenterHierarchyAssignment]);
+
+    const result = await run(db, { id: baseProfitCenter.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.profitCenter).toEqual(baseProfitCenter);
+    }
+  });
+
+  it("returns profit center with hierarchy node assignment populated", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseProfitCenter)
+      .mockReturnValueOnce([baseProfitCenterHierarchyAssignment]);
+
+    const result = await run(db, { id: baseProfitCenter.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.hierarchyAssignments).toEqual([baseProfitCenterHierarchyAssignment]);
+      expect(result.value.hierarchyAssignments[0]).toMatchObject({
+        profitCenterId: baseProfitCenter.id,
+        hierarchyNodeId: baseProfitCenterHierarchyAssignment.hierarchyNodeId,
+      });
+    }
+  });
+
+  it("returns profit center with responsible person and validity period", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseProfitCenter).mockReturnValueOnce([]);
+
+    const result = await run(db, { id: baseProfitCenter.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.profitCenter?.responsiblePersonId).not.toBeNull();
+      expect(result.value.profitCenter?.validFrom).not.toBeNull();
+    }
+  });
+
+  it("returns null when no profit 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.profitCenter).toBeNull();
+      expect(result.value.hierarchyAssignments).toEqual([]);
+    }
+  });
+});

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

@@ -0,0 +1,31 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetProfitCenterInput {
+  id: string;
+}
+
+/**
+ * Function: getProfitCenter
+ *
+ * Retrieves a single profit center by id, including its hierarchy node assignments.
+ */
+export async function run(db: ReadonlyDB<DB>, input: GetProfitCenterInput) {
+  const result = await db
+    .selectFrom("ProfitCenter")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  if (!result) {
+    return ok({ profitCenter: null, hierarchyAssignments: [] });
+  }
+
+  const assignments = await db
+    .selectFrom("ProfitCenterHierarchyAssignment")
+    .selectAll()
+    .where("profitCenterId", "=", input.id)
+    .execute();
+
+  return ok({ profitCenter: result, hierarchyAssignments: assignments });
+}

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

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

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

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  baseProfitCenter,
+  baseProfitCenterHierarchy,
+  childProfitCenterNode,
+  rootProfitCenterNode,
+} from "../testing/fixtures";
+import { run } from "./getProfitCenterHierarchy";
+
+describe("getProfitCenterHierarchy", () => {
+  it("returns hierarchy with all nodes in tree structure when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseProfitCenterHierarchy)
+      .mockReturnValueOnce([rootProfitCenterNode, childProfitCenterNode])
+      .mockReturnValueOnce([])
+      .mockReturnValueOnce([baseProfitCenter]);
+
+    const result = await run(db, { id: baseProfitCenterHierarchy.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.profitCenterHierarchy).toEqual(baseProfitCenterHierarchy);
+      expect(result.value.nodes).toHaveLength(1);
+      expect(result.value.nodes[0].children).toHaveLength(1);
+    }
+  });
+
+  it("returns hierarchy with root node and nested child nodes", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseProfitCenterHierarchy)
+      .mockReturnValueOnce([rootProfitCenterNode, childProfitCenterNode])
+      .mockReturnValueOnce([])
+      .mockReturnValueOnce([]);
+
+    const result = await run(db, { id: baseProfitCenterHierarchy.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.nodes[0]).toMatchObject({
+        id: rootProfitCenterNode.id,
+        parentNodeId: null,
+      });
+      expect(result.value.nodes[0].children[0]).toMatchObject({
+        id: childProfitCenterNode.id,
+        parentNodeId: rootProfitCenterNode.id,
+      });
+    }
+  });
+
+  it("returns hierarchy nodes with assigned profit centers populated", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseProfitCenterHierarchy)
+      .mockReturnValueOnce([childProfitCenterNode])
+      .mockReturnValueOnce([baseProfitCenter]);
+
+    const result = await run(db, { id: baseProfitCenterHierarchy.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.nodes[0]).toMatchObject({ id: childProfitCenterNode.id });
+      expect(result.value.nodes[0].profitCenters).toEqual([baseProfitCenter]);
+    }
+  });
+
+  it("returns leaf nodes with no children", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseProfitCenterHierarchy)
+      .mockReturnValueOnce([childProfitCenterNode])
+      .mockReturnValueOnce([]);
+
+    const result = await run(db, { id: baseProfitCenterHierarchy.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.profitCenterHierarchy).toBeNull();
+      expect(result.value.nodes).toEqual([]);
+    }
+  });
+});

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);