@tailor-platform/erp-kit 0.6.0 → 0.8.0

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

@@ -0,0 +1,112 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { BudgetNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import {
+  baseBudget,
+  submittedBudget,
+  approvedBudget,
+  activeBudget,
+  closedBudget,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./updateBudget";
+
+describe("updateBudget", () => {
+  it("updates name on a DRAFT budget", async () => {
+    const updatedBudget = { ...baseBudget, name: "Updated Name" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseBudget);
+    spies.update.mockReturnValueOnce(updatedBudget);
+
+    const result = await run(db, { budgetId: baseBudget.id, name: "Updated Name" }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.budget.name).toBe("Updated Name");
+  });
+
+  it("updates description on a DRAFT budget", async () => {
+    const updatedBudget = { ...baseBudget, description: "New description" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseBudget);
+    spies.update.mockReturnValueOnce(updatedBudget);
+
+    const result = await run(
+      db,
+      { budgetId: baseBudget.id, description: "New description" },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.budget.description).toBe("New description");
+  });
+
+  it("updates budget holder on a DRAFT budget", async () => {
+    const updatedBudget = { ...baseBudget, budgetHolderId: "user-2" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseBudget);
+    spies.update.mockReturnValueOnce(updatedBudget);
+
+    const result = await run(db, { budgetId: baseBudget.id, budgetHolderId: "user-2" }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.budget.budgetHolderId).toBe("user-2");
+  });
+
+  it("returns error when budget does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { budgetId: "missing" }, commandCtx);
+
+    expectErr(result, BudgetNotFoundError);
+  });
+
+  it("returns error when budget is in SUBMITTED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(submittedBudget);
+
+    const result = await run(db, { budgetId: submittedBudget.id, name: "X" }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when budget is in APPROVED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(approvedBudget);
+
+    const result = await run(db, { budgetId: approvedBudget.id, name: "X" }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when budget is in ACTIVE status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeBudget);
+
+    const result = await run(db, { budgetId: activeBudget.id, name: "X" }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when budget is in CLOSED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(closedBudget);
+
+    const result = await run(db, { budgetId: closedBudget.id, name: "X" }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("emits audit event recording previous and new field values", async () => {
+    const updatedBudget = { ...baseBudget, name: "Audited" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseBudget);
+    spies.update.mockReturnValueOnce(updatedBudget);
+
+    const result = await run(db, { budgetId: baseBudget.id, name: "Audited" }, commandCtx);
+
+    expectOk(result);
+    expect(spies.update).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,44 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { BudgetNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export type UpdateBudgetInput = {
+  budgetId: string;
+  name?: string;
+  description?: string | null;
+  budgetHolderId?: string;
+};
+export async function run(db: Transaction, input: UpdateBudgetInput, ctx: CommandContext) {
+  void ctx;
+
+  // Fetch budget with lock
+  const budget = await db
+    .selectFrom("Budget")
+    .where("id", "=", input.budgetId)
+    .selectAll()
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!budget) {
+    return err(new BudgetNotFoundError(input.budgetId));
+  }
+
+  if (budget.status !== "DRAFT") {
+    return err(new InvalidStateError(input.budgetId));
+  }
+
+  // Apply updates
+  const updated = await db
+    .updateTable("Budget")
+    .set({
+      ...(input.name !== undefined && { name: input.name }),
+      ...(input.description !== undefined && { description: input.description }),
+      ...(input.budgetHolderId !== undefined && { budgetHolderId: input.budgetHolderId }),
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.budgetId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ budget: updated! });
+}

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

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

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

@@ -0,0 +1,105 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CostCenterNotFoundError,
+  InvalidCategoryError,
+  InvalidValidityPeriodError,
+  InvalidNameError,
+} from "../lib/errors.generated";
+import { baseCostCenter } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./updateCostCenter";
+
+describe("updateCostCenter", () => {
+  it("returns error when cost center does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { costCenterId: "missing-cc", name: "Updated" }, commandCtx);
+
+    expectErr(result, CostCenterNotFoundError);
+  });
+
+  it("returns error when name is empty string", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostCenter);
+
+    const result = await run(db, { costCenterId: baseCostCenter.id, name: "" }, commandCtx);
+
+    expectErr(result, InvalidNameError);
+  });
+
+  it("returns error when category is invalid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostCenter);
+
+    const result = await run(
+      db,
+      { costCenterId: baseCostCenter.id, category: "not-a-category" },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidCategoryError);
+  });
+
+  it("returns error when validTo is before validFrom", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostCenter);
+
+    const result = await run(
+      db,
+      {
+        costCenterId: baseCostCenter.id,
+        validFrom: new Date("2025-12-31"),
+        validTo: new Date("2024-01-01"),
+      },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidValidityPeriodError);
+  });
+
+  it("updates cost center with valid fields", async () => {
+    const updatedCc = { ...baseCostCenter, name: "Updated Name", updatedAt: new Date() };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostCenter);
+    spies.update.mockReturnValueOnce(updatedCc);
+
+    const result = await run(
+      db,
+      { costCenterId: baseCostCenter.id, name: "Updated Name" },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.costCenter.name).toBe("Updated Name");
+  });
+
+  it("updates multiple fields at once", async () => {
+    const updatedCc = {
+      ...baseCostCenter,
+      name: "New Name",
+      category: "sales",
+      description: "New desc",
+      updatedAt: new Date(),
+    };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostCenter);
+    spies.update.mockReturnValueOnce(updatedCc);
+
+    const result = await run(
+      db,
+      {
+        costCenterId: baseCostCenter.id,
+        name: "New Name",
+        category: "sales",
+        description: "New desc",
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.costCenter).toEqual(updatedCc);
+  });
+});

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

@@ -0,0 +1,79 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CostCenterNotFoundError,
+  InvalidCategoryError,
+  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 type UpdateCostCenterInput = {
+  costCenterId: string;
+  name?: string;
+  description?: string | null;
+  category?: string;
+  responsiblePersonId?: string | null;
+  departmentId?: string | null;
+  validFrom?: Date;
+  validTo?: Date | null;
+};
+
+export async function run(db: Transaction, input: UpdateCostCenterInput, ctx: CommandContext) {
+  void ctx;
+
+  const { name, description, category, responsiblePersonId, departmentId, validFrom, validTo } =
+    input;
+
+  // Validate cost center exists
+  const costCenter = await db
+    .selectFrom("CostCenter")
+    .where("id", "=", input.costCenterId)
+    .selectAll()
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!costCenter) {
+    return err(new CostCenterNotFoundError(input.costCenterId));
+  }
+
+  // Validate name if provided
+  if (name !== undefined && (!name || name.trim() === "")) {
+    return err(new InvalidNameError(costCenter.id));
+  }
+
+  // Validate category if provided
+  if (category !== undefined && !VALID_CATEGORIES.includes(category)) {
+    return err(new InvalidCategoryError(category));
+  }
+
+  // Validate validity dates
+  const newValidFrom = validFrom ?? costCenter.validFrom;
+  const newValidTo = validTo !== undefined ? validTo : costCenter.validTo;
+  if (newValidTo && newValidFrom > newValidTo) {
+    return err(new InvalidValidityPeriodError(costCenter.id));
+  }
+
+  // Build update set
+  const updateSet: Record<string, unknown> = {
+    updatedAt: new Date(),
+  };
+
+  if (name !== undefined) updateSet.name = name;
+  if (description !== undefined) updateSet.description = description;
+  if (category !== undefined) updateSet.category = category;
+  if (responsiblePersonId !== undefined) updateSet.responsiblePersonId = responsiblePersonId;
+  if (departmentId !== undefined) updateSet.departmentId = departmentId;
+  if (validFrom !== undefined) updateSet.validFrom = validFrom;
+  if (validTo !== undefined) updateSet.validTo = validTo;
+
+  const updatedCostCenter = await db
+    .updateTable("CostCenter")
+    .set(updateSet)
+    .where("id", "=", costCenter.id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ costCenter: updatedCostCenter! });
+}

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

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

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

@@ -0,0 +1,265 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CostElementNotFoundError,
+  InvalidStateError,
+  TypeChangeNotAllowedError,
+  CategoryChangeNotAllowedError,
+  GlAccountChangeNotAllowedError,
+  InvalidCategoryForTypeError,
+  GlAccountNotFoundError,
+  DuplicateGlAccountReferenceError,
+  InvalidValidityPeriodError,
+} from "../lib/errors.generated";
+import {
+  baseCostElement,
+  activeCostElement,
+  inactiveCostElement,
+  baseAccount2,
+  baseChartOfAccounts,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./updateCostElement";
+
+describe("updateCostElement", () => {
+  it("updates description on a DRAFT cost element", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostElement);
+    const updated = { ...baseCostElement, description: "Updated desc" };
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { costElementId: baseCostElement.id, description: "Updated desc" },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.costElement.description).toBe("Updated desc");
+  });
+
+  it("updates description on an ACTIVE cost element", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeCostElement);
+    const updated = { ...activeCostElement, description: "Updated desc" };
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { costElementId: activeCostElement.id, description: "Updated desc" },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.costElement.description).toBe("Updated desc");
+  });
+
+  it("updates name on a DRAFT cost element", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostElement);
+    const updated = { ...baseCostElement, name: "New Name" };
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { costElementId: baseCostElement.id, name: "New Name" },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.costElement.name).toBe("New Name");
+  });
+
+  it("updates name on an ACTIVE cost element", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeCostElement);
+    const updated = { ...activeCostElement, name: "New Name" };
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { costElementId: activeCostElement.id, name: "New Name" },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.costElement.name).toBe("New Name");
+  });
+
+  it("updates category on a DRAFT cost element", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostElement);
+    const updated = { ...baseCostElement, category: "material" };
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { costElementId: baseCostElement.id, category: "material" },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.costElement.category).toBe("material");
+  });
+
+  it("returns error when changing category on an ACTIVE cost element", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeCostElement);
+
+    const result = await run(
+      db,
+      { costElementId: activeCostElement.id, category: "material" },
+      commandCtx,
+    );
+
+    expectErr(result, CategoryChangeNotAllowedError);
+  });
+
+  it("returns error when changing type on any cost element", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostElement);
+
+    const result = await run(
+      db,
+      { costElementId: baseCostElement.id, type: "SECONDARY" },
+      commandCtx,
+    );
+
+    expectErr(result, TypeChangeNotAllowedError);
+  });
+
+  it("returns error when changing GL account on an ACTIVE cost element", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeCostElement);
+
+    const result = await run(
+      db,
+      { costElementId: activeCostElement.id, glAccountId: baseAccount2.id },
+      commandCtx,
+    );
+
+    expectErr(result, GlAccountChangeNotAllowedError);
+  });
+
+  it("updates GL account on a DRAFT PRIMARY cost element", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCostElement)
+      .mockReturnValueOnce(baseAccount2)
+      .mockReturnValueOnce(baseChartOfAccounts)
+      .mockReturnValueOnce(undefined);
+    const updated = { ...baseCostElement, glAccountId: baseAccount2.id };
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { costElementId: baseCostElement.id, glAccountId: baseAccount2.id },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.costElement.glAccountId).toBe(baseAccount2.id);
+  });
+
+  it("returns error when updated GL account does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostElement).mockReturnValueOnce(undefined);
+
+    const result = await run(
+      db,
+      { costElementId: baseCostElement.id, glAccountId: "missing-account" },
+      commandCtx,
+    );
+
+    expectErr(result, GlAccountNotFoundError);
+  });
+
+  it("returns error when updated GL account is already referenced by another PRIMARY element", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCostElement)
+      .mockReturnValueOnce(baseAccount2)
+      .mockReturnValueOnce(baseChartOfAccounts)
+      .mockReturnValueOnce({
+        ...baseCostElement,
+        id: "other-element",
+        glAccountId: baseAccount2.id,
+      });
+
+    const result = await run(
+      db,
+      { costElementId: baseCostElement.id, glAccountId: baseAccount2.id },
+      commandCtx,
+    );
+
+    expectErr(result, DuplicateGlAccountReferenceError);
+  });
+
+  it("returns error when new category does not match the element type", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostElement);
+
+    const result = await run(
+      db,
+      { costElementId: baseCostElement.id, category: "assessment" },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidCategoryForTypeError);
+  });
+
+  it("returns error when cost element does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { costElementId: "missing" }, commandCtx);
+
+    expectErr(result, CostElementNotFoundError);
+  });
+
+  it("returns error when cost element is INACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(inactiveCostElement);
+
+    const result = await run(
+      db,
+      { costElementId: inactiveCostElement.id, description: "test" },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when validFrom is after validTo", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostElement);
+
+    const result = await run(
+      db,
+      {
+        costElementId: baseCostElement.id,
+        validFrom: new Date("2025-12-31"),
+        validTo: new Date("2025-01-01"),
+      },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidValidityPeriodError);
+  });
+
+  it("emits audit event recording previous and new field values", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostElement);
+    spies.update.mockReturnValueOnce({ ...baseCostElement, name: "Updated" });
+
+    const result = await run(
+      db,
+      { costElementId: baseCostElement.id, name: "Updated" },
+      commandCtx,
+    );
+
+    expectOk(result);
+    expect(spies.update).toHaveBeenCalled();
+  });
+});