@tailor-platform/erp-kit 0.7.0 → 0.8.0

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

@@ -0,0 +1,179 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CompanyNotFoundError,
+  DuplicateCostCenterCodeError,
+  InvalidCategoryError,
+  HierarchyNodeNotFoundError,
+  CompanyMismatchError,
+  InvalidValidityPeriodError,
+  InvalidNameError,
+} from "../lib/errors.generated";
+import {
+  baseCompany,
+  baseCostCenter,
+  baseCostCenterHierarchy,
+  childCostCenterNode,
+  baseDepartment,
+  baseUser,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./createCostCenter";
+
+const validInput = {
+  companyId: baseCompany.id,
+  code: "CC-NEW",
+  name: "New Cost Center",
+  category: "overhead",
+  hierarchyNodeId: childCostCenterNode.id,
+  validFrom: new Date("2024-01-01"),
+  responsiblePersonId: baseUser.id,
+  departmentId: baseDepartment.id,
+};
+
+describe("createCostCenter", () => {
+  it("returns error when company does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { ...validInput, companyId: "missing" }, commandCtx);
+
+    expectErr(result, CompanyNotFoundError);
+  });
+
+  it("returns error when company is not ACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce({ ...baseCompany, status: "INACTIVE" });
+
+    const result = await run(db, validInput, commandCtx);
+
+    expectErr(result, CompanyNotFoundError);
+  });
+
+  it("returns error when name is empty", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany);
+
+    const result = await run(db, { ...validInput, name: "" }, commandCtx);
+
+    expectErr(result, InvalidNameError);
+  });
+
+  it("returns error when code already exists within company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCompany) // company exists
+      .mockReturnValueOnce(baseCostCenter); // duplicate code found
+
+    const result = await run(db, { ...validInput, code: baseCostCenter.code }, commandCtx);
+
+    expectErr(result, DuplicateCostCenterCodeError);
+  });
+
+  it("returns error when category is invalid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCompany) // company exists
+      .mockReturnValueOnce(undefined); // no duplicate code
+
+    const result = await run(db, { ...validInput, category: "invalid_category" }, commandCtx);
+
+    expectErr(result, InvalidCategoryError);
+  });
+
+  it("returns error when hierarchy node does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCompany) // company exists
+      .mockReturnValueOnce(undefined) // no duplicate code
+      .mockReturnValueOnce(undefined); // hierarchy node not found
+
+    const result = await run(db, { ...validInput, hierarchyNodeId: "missing-node" }, commandCtx);
+
+    expectErr(result, HierarchyNodeNotFoundError);
+  });
+
+  it("returns error when hierarchy node belongs to different company", async () => {
+    const otherCompanyHierarchy = { ...baseCostCenterHierarchy, companyId: "other-company" };
+
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCompany) // company exists
+      .mockReturnValueOnce(undefined) // no duplicate code
+      .mockReturnValueOnce(childCostCenterNode) // hierarchy node found
+      .mockReturnValueOnce(otherCompanyHierarchy); // hierarchy belongs to different company
+
+    const result = await run(db, validInput, commandCtx);
+
+    expectErr(result, CompanyMismatchError);
+  });
+
+  it("returns error when validTo is before validFrom", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCompany) // company exists
+      .mockReturnValueOnce(undefined) // no duplicate code
+      .mockReturnValueOnce(childCostCenterNode) // hierarchy node found
+      .mockReturnValueOnce(baseCostCenterHierarchy); // hierarchy in same company
+
+    const result = await run(
+      db,
+      {
+        ...validInput,
+        validFrom: new Date("2024-12-31"),
+        validTo: new Date("2024-01-01"),
+      },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidValidityPeriodError);
+  });
+
+  it("creates cost center with valid inputs", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCompany) // company exists
+      .mockReturnValueOnce(undefined) // no duplicate code
+      .mockReturnValueOnce(childCostCenterNode) // hierarchy node found
+      .mockReturnValueOnce(baseCostCenterHierarchy); // hierarchy in same company
+    spies.insert.mockReturnValueOnce(baseCostCenter);
+
+    const result = await run(db, validInput, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.costCenter).toEqual(baseCostCenter);
+  });
+
+  it("creates cost center without optional fields", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCompany)
+      .mockReturnValueOnce(undefined)
+      .mockReturnValueOnce(childCostCenterNode)
+      .mockReturnValueOnce(baseCostCenterHierarchy);
+    spies.insert.mockReturnValueOnce({
+      ...baseCostCenter,
+      responsiblePersonId: null,
+      departmentId: null,
+      description: null,
+      validTo: null,
+    });
+
+    const result = await run(
+      db,
+      {
+        companyId: baseCompany.id,
+        code: "CC-NEW",
+        name: "New Cost Center",
+        category: "overhead",
+        hierarchyNodeId: childCostCenterNode.id,
+        validFrom: new Date("2024-01-01"),
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.costCenter).toBeDefined();
+  });
+});

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

@@ -0,0 +1,112 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CompanyNotFoundError,
+  DuplicateCostCenterCodeError,
+  InvalidCategoryError,
+  HierarchyNodeNotFoundError,
+  CompanyMismatchError,
+  InvalidValidityPeriodError,
+  InvalidNameError,
+} from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+const VALID_CATEGORIES = ["overhead", "production", "administration", "sales", "research"];
+
+export interface CreateCostCenterInput {
+  companyId: string;
+  code: string;
+  name: string;
+  description?: string | null;
+  category: string;
+  responsiblePersonId?: string | null;
+  departmentId?: string | null;
+  hierarchyNodeId: string;
+  validFrom: Date;
+  validTo?: Date | null;
+}
+
+export async function run(db: Transaction, input: CreateCostCenterInput, ctx: CommandContext) {
+  void ctx;
+
+  // Validate company exists and is ACTIVE
+  const company = await db
+    .selectFrom("Company" as never)
+    .where("id" as never, "=", input.companyId as never)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (!company || (company as Record<string, unknown>).status !== "ACTIVE") {
+    return err(new CompanyNotFoundError(input.companyId));
+  }
+
+  // Validate name is non-empty
+  if (!input.name || input.name.trim() === "") {
+    return err(new InvalidNameError(input.companyId));
+  }
+
+  // Validate code uniqueness within company
+  const existingCode = await db
+    .selectFrom("CostCenter")
+    .where("companyId", "=", input.companyId)
+    .where("code", "=", input.code)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (existingCode) {
+    return err(new DuplicateCostCenterCodeError(input.code));
+  }
+
+  // Validate category
+  if (!VALID_CATEGORIES.includes(input.category)) {
+    return err(new InvalidCategoryError(input.category));
+  }
+
+  // Validate hierarchy node exists
+  const hierarchyNode = await db
+    .selectFrom("CostCenterHierarchyNode")
+    .where("id", "=", input.hierarchyNodeId)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (!hierarchyNode) {
+    return err(new HierarchyNodeNotFoundError(input.hierarchyNodeId));
+  }
+
+  // Validate hierarchy node belongs to same company via hierarchy
+  const hierarchy = await db
+    .selectFrom("CostCenterHierarchy")
+    .where("id", "=", hierarchyNode.hierarchyId)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (hierarchy?.companyId !== input.companyId) {
+    return err(new CompanyMismatchError(input.hierarchyNodeId));
+  }
+
+  // Validate validity dates
+  if (input.validTo && input.validFrom > input.validTo) {
+    return err(new InvalidValidityPeriodError(input.code));
+  }
+
+  // Create cost center
+  const costCenter = await db
+    .insertInto("CostCenter")
+    .values({
+      companyId: input.companyId,
+      code: input.code,
+      name: input.name,
+      description: input.description ?? null,
+      category: input.category,
+      responsiblePersonId: input.responsiblePersonId ?? null,
+      departmentId: input.departmentId ?? null,
+      hierarchyNodeId: input.hierarchyNodeId,
+      validFrom: input.validFrom,
+      validTo: input.validTo ?? null,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ costCenter: costCenter! });
+}

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

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

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

@@ -0,0 +1,91 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { CompanyNotFoundError, InvalidNameError } from "../lib/errors.generated";
+import { baseCompany, baseCostCenterHierarchy } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./createCostCenterHierarchy";
+
+describe("createCostCenterHierarchy", () => {
+  it("returns error when company does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(
+      db,
+      { companyId: "missing-company", name: "Hierarchy", version: "V1" },
+      commandCtx,
+    );
+
+    expectErr(result, CompanyNotFoundError);
+  });
+
+  it("returns error when company is not ACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce({ ...baseCompany, status: "INACTIVE" });
+
+    const result = await run(
+      db,
+      { companyId: baseCompany.id, name: "Hierarchy", version: "V1" },
+      commandCtx,
+    );
+
+    expectErr(result, CompanyNotFoundError);
+  });
+
+  it("returns error when name is empty", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany);
+
+    const result = await run(
+      db,
+      { companyId: baseCompany.id, name: "", version: "V1" },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidNameError);
+  });
+
+  it("returns error when name is whitespace only", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany);
+
+    const result = await run(
+      db,
+      { companyId: baseCompany.id, name: "   ", version: "V1" },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidNameError);
+  });
+
+  it("creates hierarchy with valid inputs", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany);
+    spies.insert.mockReturnValueOnce(baseCostCenterHierarchy);
+
+    const result = await run(
+      db,
+      { companyId: baseCompany.id, name: "Standard Hierarchy", version: "V1" },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.hierarchy).toEqual(baseCostCenterHierarchy);
+  });
+
+  it("emits audit event by calling insert", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany);
+    spies.insert.mockReturnValueOnce(baseCostCenterHierarchy);
+
+    const result = await run(
+      db,
+      { companyId: baseCompany.id, name: "Standard Hierarchy", version: "V1" },
+      commandCtx,
+    );
+
+    expectOk(result);
+    expect(spies.insert).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,48 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { CompanyNotFoundError, InvalidNameError } from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface CreateCostCenterHierarchyInput {
+  companyId: string;
+  name: string;
+  version: string;
+}
+
+export async function run(
+  db: Transaction,
+  input: CreateCostCenterHierarchyInput,
+  ctx: CommandContext,
+) {
+  void ctx;
+
+  // Validate company exists and is ACTIVE
+  const company = await db
+    .selectFrom("Company" as never)
+    .where("id" as never, "=", input.companyId as never)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (!company || (company as Record<string, unknown>).status !== "ACTIVE") {
+    return err(new CompanyNotFoundError(input.companyId));
+  }
+
+  // Validate name is non-empty
+  if (!input.name || input.name.trim() === "") {
+    return err(new InvalidNameError(input.companyId));
+  }
+
+  // Create hierarchy
+  const hierarchy = await db
+    .insertInto("CostCenterHierarchy")
+    .values({
+      companyId: input.companyId,
+      name: input.name,
+      version: input.version,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ hierarchy: hierarchy! });
+}

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

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

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

@@ -0,0 +1,171 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  HierarchyNotFoundError,
+  ParentNodeNotFoundError,
+  DuplicateRootNodeError,
+  InvalidNameError,
+  SelfReferenceError,
+  CircularReferenceError,
+} from "../lib/errors.generated";
+import {
+  baseCostCenterHierarchy,
+  rootCostCenterNode,
+  childCostCenterNode,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./createCostCenterHierarchyNode";
+
+describe("createCostCenterHierarchyNode", () => {
+  it("returns error when name is empty", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(db, { hierarchyId: baseCostCenterHierarchy.id, name: "" }, commandCtx);
+
+    expectErr(result, InvalidNameError);
+  });
+
+  it("returns error when hierarchy does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { hierarchyId: "missing-hierarchy", name: "Root" }, commandCtx);
+
+    expectErr(result, HierarchyNotFoundError);
+  });
+
+  it("returns error when parent node does not exist in hierarchy", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenterHierarchy) // hierarchy exists
+      .mockReturnValueOnce(undefined); // parent node not found
+
+    const result = await run(
+      db,
+      {
+        hierarchyId: baseCostCenterHierarchy.id,
+        name: "Child",
+        parentNodeId: "missing-parent",
+      },
+      commandCtx,
+    );
+
+    expectErr(result, ParentNodeNotFoundError);
+  });
+
+  it("returns error when creating duplicate root node (no parentNodeId)", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenterHierarchy) // hierarchy exists
+      .mockReturnValueOnce(rootCostCenterNode); // existing root found
+
+    const result = await run(
+      db,
+      { hierarchyId: baseCostCenterHierarchy.id, name: "Another Root" },
+      commandCtx,
+    );
+
+    expectErr(result, DuplicateRootNodeError);
+  });
+
+  it("creates root node when no root exists", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenterHierarchy) // hierarchy exists
+      .mockReturnValueOnce(undefined); // no existing root
+    spies.insert.mockReturnValueOnce(rootCostCenterNode);
+
+    const result = await run(
+      db,
+      { hierarchyId: baseCostCenterHierarchy.id, name: "Root" },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.node).toEqual(rootCostCenterNode);
+  });
+
+  it("creates child node with correct computed level", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenterHierarchy) // hierarchy exists
+      .mockReturnValueOnce(rootCostCenterNode) // parent node found (level 0)
+      .mockReturnValueOnce(rootCostCenterNode); // ancestor walk: root has no parent, loop ends
+    spies.insert.mockReturnValueOnce(childCostCenterNode);
+
+    const result = await run(
+      db,
+      {
+        hierarchyId: baseCostCenterHierarchy.id,
+        name: "Administration",
+        parentNodeId: rootCostCenterNode.id,
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.node).toEqual(childCostCenterNode);
+    expect(value.node.level).toBe(1);
+  });
+
+  it("returns error when node references itself as parent", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenterHierarchy) // hierarchy exists
+      .mockReturnValueOnce(rootCostCenterNode) // parent node found
+      .mockReturnValueOnce({ ...rootCostCenterNode, parentNodeId: rootCostCenterNode.id }); // ancestor walk: self-loop detected
+
+    const result = await run(
+      db,
+      {
+        hierarchyId: baseCostCenterHierarchy.id,
+        name: "Child",
+        parentNodeId: rootCostCenterNode.id,
+      },
+      commandCtx,
+    );
+
+    expectErr(result, SelfReferenceError);
+  });
+
+  it("returns error when node would create a circular reference", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // Setup: node-a -> node-b -> node-a (circular chain)
+    const nodeA = { ...rootCostCenterNode, id: "node-a", parentNodeId: "node-b" };
+    const nodeB = { ...childCostCenterNode, id: "node-b", parentNodeId: "node-a" };
+
+    spies.select
+      .mockReturnValueOnce(baseCostCenterHierarchy) // hierarchy exists
+      .mockReturnValueOnce(nodeA) // parent node (A) found
+      .mockReturnValueOnce(nodeA) // ancestor walk iteration 1: fetch A, parentNodeId = "node-b"
+      .mockReturnValueOnce(nodeB); // ancestor walk iteration 2: fetch B, parentNodeId = "node-a" (already visited) → circular
+
+    const result = await run(
+      db,
+      {
+        hierarchyId: baseCostCenterHierarchy.id,
+        name: "New Child",
+        parentNodeId: "node-a",
+      },
+      commandCtx,
+    );
+
+    expectErr(result, CircularReferenceError);
+  });
+
+  it("emits audit event by calling insert", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostCenterHierarchy).mockReturnValueOnce(undefined); // no root
+    spies.insert.mockReturnValueOnce(rootCostCenterNode);
+
+    const result = await run(
+      db,
+      { hierarchyId: baseCostCenterHierarchy.id, name: "Root" },
+      commandCtx,
+    );
+
+    expectOk(result);
+    expect(spies.insert).toHaveBeenCalled();
+  });
+});