@tailor-platform/erp-kit 0.7.0 → 0.8.0

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

@@ -0,0 +1,227 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CompanyNotFoundError,
+  DuplicateProfitCenterCodeError,
+  InvalidNameError,
+  ValidFromRequiredError,
+  InvalidValidityPeriodError,
+} from "../lib/errors.generated";
+import { baseCompany, baseProfitCenter } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./createProfitCenter";
+
+describe("createProfitCenter", () => {
+  it("creates profit center in DRAFT status with required fields", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany).mockReturnValueOnce(undefined);
+    spies.insert.mockReturnValueOnce(baseProfitCenter);
+
+    const result = await run(
+      db,
+      {
+        companyId: baseCompany.id,
+        code: "PC-001",
+        name: "Product Line Alpha",
+        validFrom: new Date("2024-01-01"),
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.profitCenter).toEqual(baseProfitCenter);
+  });
+
+  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",
+        code: "PC-001",
+        name: "Test",
+        validFrom: new Date("2024-01-01"),
+      },
+      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,
+        code: "PC-001",
+        name: "Test",
+        validFrom: new Date("2024-01-01"),
+      },
+      commandCtx,
+    );
+
+    expectErr(result, CompanyNotFoundError);
+  });
+
+  it("returns error when code already exists within the company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany).mockReturnValueOnce(baseProfitCenter);
+
+    const result = await run(
+      db,
+      {
+        companyId: baseCompany.id,
+        code: "PC-001",
+        name: "Test",
+        validFrom: new Date("2024-01-01"),
+      },
+      commandCtx,
+    );
+
+    expectErr(result, DuplicateProfitCenterCodeError);
+  });
+
+  it("returns error when name is missing", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany).mockReturnValueOnce(undefined);
+
+    const result = await run(
+      db,
+      {
+        companyId: baseCompany.id,
+        code: "PC-002",
+        name: "",
+        validFrom: new Date("2024-01-01"),
+      },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidNameError);
+  });
+
+  it("returns error when validFrom is not provided", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany).mockReturnValueOnce(undefined);
+
+    const result = await run(
+      db,
+      {
+        companyId: baseCompany.id,
+        code: "PC-002",
+        name: "Test",
+        validFrom: null,
+      },
+      commandCtx,
+    );
+
+    expectErr(result, ValidFromRequiredError);
+  });
+
+  it("returns error when validTo is before validFrom", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany).mockReturnValueOnce(undefined);
+
+    const result = await run(
+      db,
+      {
+        companyId: baseCompany.id,
+        code: "PC-002",
+        name: "Test",
+        validFrom: new Date("2024-06-01"),
+        validTo: new Date("2024-01-01"),
+      },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidValidityPeriodError);
+  });
+
+  it("creates profit center with optional description", async () => {
+    const pcWithDesc = { ...baseProfitCenter, description: "A description" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany).mockReturnValueOnce(undefined);
+    spies.insert.mockReturnValueOnce(pcWithDesc);
+
+    const result = await run(
+      db,
+      {
+        companyId: baseCompany.id,
+        code: "PC-001",
+        name: "Product Line Alpha",
+        description: "A description",
+        validFrom: new Date("2024-01-01"),
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.profitCenter.description).toBe("A description");
+  });
+
+  it("creates profit center without validTo", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany).mockReturnValueOnce(undefined);
+    spies.insert.mockReturnValueOnce(baseProfitCenter);
+
+    const result = await run(
+      db,
+      {
+        companyId: baseCompany.id,
+        code: "PC-001",
+        name: "Product Line Alpha",
+        validFrom: new Date("2024-01-01"),
+      },
+      commandCtx,
+    );
+
+    expectOk(result);
+  });
+
+  it("profit centers from different companies are isolated", async () => {
+    const companyB = { id: "company-2", status: "ACTIVE" };
+    const pcCompanyB = { ...baseProfitCenter, id: "pc-b", companyId: companyB.id };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(companyB).mockReturnValueOnce(undefined);
+    spies.insert.mockReturnValueOnce(pcCompanyB);
+
+    const result = await run(
+      db,
+      {
+        companyId: companyB.id,
+        code: "PC-001",
+        name: "Product Line Alpha",
+        validFrom: new Date("2024-01-01"),
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.profitCenter.companyId).toBe(companyB.id);
+  });
+
+  it("emits audit event recording acting user, timestamp, and initial field values", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany).mockReturnValueOnce(undefined);
+    spies.insert.mockReturnValueOnce(baseProfitCenter);
+
+    const result = await run(
+      db,
+      {
+        companyId: baseCompany.id,
+        code: "PC-001",
+        name: "Product Line Alpha",
+        validFrom: new Date("2024-01-01"),
+      },
+      commandCtx,
+    );
+
+    expectOk(result);
+    expect(spies.insert).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,81 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CompanyNotFoundError,
+  DuplicateProfitCenterCodeError,
+  InvalidNameError,
+  ValidFromRequiredError,
+  InvalidValidityPeriodError,
+} from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface CreateProfitCenterInput {
+  companyId: string;
+  code: string;
+  name: string;
+  description?: string | null;
+  responsiblePersonId?: string | null;
+  validFrom?: Date | null;
+  validTo?: Date | null;
+}
+
+export async function run(db: Transaction, input: CreateProfitCenterInput, 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 code uniqueness within company
+  const existing = await db
+    .selectFrom("ProfitCenter")
+    .where("companyId", "=", input.companyId)
+    .where("code", "=", input.code)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (existing) {
+    return err(new DuplicateProfitCenterCodeError(input.code));
+  }
+
+  // Validate name is non-empty
+  if (!input.name || input.name.trim() === "") {
+    return err(new InvalidNameError(input.companyId));
+  }
+
+  // Validate validFrom is provided
+  if (!input.validFrom) {
+    return err(new ValidFromRequiredError(input.companyId));
+  }
+
+  // Validate validTo >= validFrom when both set
+  if (input.validTo && input.validTo < input.validFrom) {
+    return err(new InvalidValidityPeriodError(input.companyId));
+  }
+
+  // Create profit center in DRAFT status
+  const profitCenter = await db
+    .insertInto("ProfitCenter")
+    .values({
+      companyId: input.companyId,
+      code: input.code,
+      name: input.name,
+      description: input.description ?? null,
+      responsiblePersonId: input.responsiblePersonId ?? null,
+      validFrom: input.validFrom,
+      validTo: input.validTo ?? null,
+      status: "DRAFT",
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ profitCenter: profitCenter! });
+}

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

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

package/src/modules/accounting/command/createProfitCenterHierarchy.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, baseProfitCenterHierarchy } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./createProfitCenterHierarchy";
+
+describe("createProfitCenterHierarchy", () => {
+  it("creates a profit center hierarchy with name and company reference", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany);
+    spies.insert.mockReturnValueOnce(baseProfitCenterHierarchy);
+
+    const result = await run(db, { companyId: baseCompany.id, name: "Product Lines" }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.profitCenterHierarchy).toEqual(baseProfitCenterHierarchy);
+  });
+
+  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: "Test" }, 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: "Test" }, commandCtx);
+
+    expectErr(result, CompanyNotFoundError);
+  });
+
+  it("returns error when name is missing", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany);
+
+    const result = await run(db, { companyId: baseCompany.id, name: "" }, commandCtx);
+
+    expectErr(result, InvalidNameError);
+  });
+
+  it("hierarchies from different companies are isolated", async () => {
+    const companyB = { id: "company-2", status: "ACTIVE" };
+    const hierarchyB = {
+      ...baseProfitCenterHierarchy,
+      id: "pc-hierarchy-b",
+      companyId: companyB.id,
+    };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(companyB);
+    spies.insert.mockReturnValueOnce(hierarchyB);
+
+    const result = await run(db, { companyId: companyB.id, name: "Product Lines B" }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.profitCenterHierarchy.companyId).toBe(companyB.id);
+  });
+
+  it("a company can have multiple profit center hierarchies", async () => {
+    const secondHierarchy = {
+      ...baseProfitCenterHierarchy,
+      id: "pc-hierarchy-2",
+      name: "Regional",
+    };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany);
+    spies.insert.mockReturnValueOnce(secondHierarchy);
+
+    const result = await run(db, { companyId: baseCompany.id, name: "Regional" }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.profitCenterHierarchy.name).toBe("Regional");
+  });
+
+  it("emits audit event recording acting user, timestamp, and initial field values", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany);
+    spies.insert.mockReturnValueOnce(baseProfitCenterHierarchy);
+
+    const result = await run(db, { companyId: baseCompany.id, name: "Product Lines" }, commandCtx);
+
+    expectOk(result);
+    expect(spies.insert).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,46 @@
+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 CreateProfitCenterHierarchyInput {
+  companyId: string;
+  name: string;
+}
+
+export async function run(
+  db: Transaction,
+  input: CreateProfitCenterHierarchyInput,
+  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 the hierarchy
+  const hierarchy = await db
+    .insertInto("ProfitCenterHierarchy")
+    .values({
+      companyId: input.companyId,
+      name: input.name,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ profitCenterHierarchy: hierarchy! });
+}

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

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

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

@@ -0,0 +1,160 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  HierarchyNotFoundError,
+  ParentNodeNotFoundError,
+  DuplicateRootNodeError,
+  SelfReferenceError,
+  CircularReferenceError,
+} from "../lib/errors.generated";
+import {
+  baseProfitCenterHierarchy,
+  rootProfitCenterNode,
+  childProfitCenterNode,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./createProfitCenterHierarchyNode";
+
+describe("createProfitCenterHierarchyNode", () => {
+  it("creates a root node in an existing hierarchy", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // hierarchy exists, no existing root, insert returns node
+    spies.select
+      .mockReturnValueOnce(baseProfitCenterHierarchy) // hierarchy lookup
+      .mockReturnValueOnce(undefined); // no existing root
+    spies.insert.mockReturnValueOnce(rootProfitCenterNode);
+
+    const result = await run(
+      db,
+      { hierarchyId: baseProfitCenterHierarchy.id, name: "Root" },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.profitCenterHierarchyNode).toEqual(rootProfitCenterNode);
+  });
+
+  it("creates a child node under an existing parent node", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseProfitCenterHierarchy) // hierarchy lookup
+      .mockReturnValueOnce(rootProfitCenterNode) // parent node lookup
+      .mockReturnValueOnce(rootProfitCenterNode); // ancestor walk: root has no parent, loop ends
+    spies.insert.mockReturnValueOnce(childProfitCenterNode);
+
+    const result = await run(
+      db,
+      {
+        hierarchyId: baseProfitCenterHierarchy.id,
+        name: "Product Line A",
+        parentNodeId: rootProfitCenterNode.id,
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.profitCenterHierarchyNode).toEqual(childProfitCenterNode);
+  });
+
+  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", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseProfitCenterHierarchy).mockReturnValueOnce(undefined); // parent not found
+
+    const result = await run(
+      db,
+      {
+        hierarchyId: baseProfitCenterHierarchy.id,
+        name: "Child",
+        parentNodeId: "missing-parent",
+      },
+      commandCtx,
+    );
+
+    expectErr(result, ParentNodeNotFoundError);
+  });
+
+  it("returns error when attempting to create a second root node", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseProfitCenterHierarchy)
+      .mockReturnValueOnce(rootProfitCenterNode); // existing root found
+
+    const result = await run(
+      db,
+      { hierarchyId: baseProfitCenterHierarchy.id, name: "Second Root" },
+      commandCtx,
+    );
+
+    expectErr(result, DuplicateRootNodeError);
+  });
+
+  it("returns error when node references itself as parent", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseProfitCenterHierarchy) // hierarchy exists
+      .mockReturnValueOnce(rootProfitCenterNode) // parent node found
+      .mockReturnValueOnce({ ...rootProfitCenterNode, parentNodeId: rootProfitCenterNode.id }); // ancestor walk: self-loop detected
+
+    const result = await run(
+      db,
+      {
+        hierarchyId: baseProfitCenterHierarchy.id,
+        name: "Child",
+        parentNodeId: rootProfitCenterNode.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 = { ...rootProfitCenterNode, id: "node-a", parentNodeId: "node-b" };
+    const nodeB = { ...childProfitCenterNode, id: "node-b", parentNodeId: "node-a" };
+
+    spies.select
+      .mockReturnValueOnce(baseProfitCenterHierarchy) // 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: baseProfitCenterHierarchy.id,
+        name: "New Child",
+        parentNodeId: "node-a",
+      },
+      commandCtx,
+    );
+
+    expectErr(result, CircularReferenceError);
+  });
+
+  it("emits audit event recording acting user, timestamp, and initial field values", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseProfitCenterHierarchy).mockReturnValueOnce(undefined);
+    spies.insert.mockReturnValueOnce(rootProfitCenterNode);
+
+    const result = await run(
+      db,
+      { hierarchyId: baseProfitCenterHierarchy.id, name: "Root" },
+      commandCtx,
+    );
+
+    expectOk(result);
+    expect(spies.insert).toHaveBeenCalled();
+  });
+});