@tailor-platform/erp-kit 0.7.0 → 0.8.0

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();
+  });
+});

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

@@ -0,0 +1,158 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CostElementNotFoundError,
+  InvalidStateError,
+  TypeChangeNotAllowedError,
+  CategoryChangeNotAllowedError,
+  GlAccountChangeNotAllowedError,
+  InvalidCategoryForTypeError,
+  GlAccountNotFoundError,
+  DuplicateGlAccountReferenceError,
+  InvalidValidityPeriodError,
+} from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+const PRIMARY_CATEGORIES = ["overhead", "material", "labor", "depreciation"];
+const SECONDARY_CATEGORIES = [
+  "assessment",
+  "distribution",
+  "internal_activity_allocation",
+  "settlement",
+];
+
+export type UpdateCostElementInput = {
+  costElementId: string;
+  name?: string;
+  description?: string | null;
+  category?: string;
+  glAccountId?: string | null;
+  type?: string;
+  validFrom?: Date | null;
+  validTo?: Date | null;
+};
+/** Command: updateCostElement
+ * Modifies fields on an existing cost element that is in DRAFT or ACTIVE status.
+ */
+export async function run(db: Transaction, input: UpdateCostElementInput, ctx: CommandContext) {
+  void ctx;
+
+  // Fetch cost element with lock
+  const costElement = await db
+    .selectFrom("CostElement")
+    .selectAll()
+    .where("id", "=", input.costElementId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!costElement) {
+    return err(new CostElementNotFoundError(input.costElementId));
+  }
+
+  // Must be DRAFT or ACTIVE
+  if (costElement.status !== "DRAFT" && costElement.status !== "ACTIVE") {
+    return err(new InvalidStateError(costElement.id));
+  }
+
+  // Type change is never permitted
+  if (input.type !== undefined && input.type !== costElement.type) {
+    return err(new TypeChangeNotAllowedError(costElement.id));
+  }
+
+  // Category change not permitted when ACTIVE
+  if (
+    input.category !== undefined &&
+    input.category !== costElement.category &&
+    costElement.status === "ACTIVE"
+  ) {
+    return err(new CategoryChangeNotAllowedError(costElement.id));
+  }
+
+  // GL account change not permitted when ACTIVE
+  if (
+    input.glAccountId !== undefined &&
+    input.glAccountId !== costElement.glAccountId &&
+    costElement.status === "ACTIVE"
+  ) {
+    return err(new GlAccountChangeNotAllowedError(costElement.id));
+  }
+
+  // Validate category matches type if changed
+  const effectiveCategory = input.category ?? costElement.category;
+  const effectiveType = costElement.type;
+  if (input.category !== undefined && input.category !== costElement.category) {
+    if (effectiveType === "PRIMARY" && !PRIMARY_CATEGORIES.includes(effectiveCategory)) {
+      return err(new InvalidCategoryForTypeError(costElement.id));
+    }
+    if (effectiveType === "SECONDARY" && !SECONDARY_CATEGORIES.includes(effectiveCategory)) {
+      return err(new InvalidCategoryForTypeError(costElement.id));
+    }
+  }
+
+  // Validate GL account if changed on DRAFT PRIMARY element
+  if (
+    input.glAccountId !== undefined &&
+    input.glAccountId !== costElement.glAccountId &&
+    input.glAccountId !== null
+  ) {
+    // Validate GL account exists and is active in an active CoA
+    const account = await db
+      .selectFrom("Account" as never)
+      .where("id" as never, "=", input.glAccountId as never)
+      .selectAll()
+      .executeTakeFirst();
+
+    if (!account || (account as Record<string, unknown>).status !== "ACTIVE") {
+      return err(new GlAccountNotFoundError(input.glAccountId));
+    }
+
+    const chartOfAccounts = await db
+      .selectFrom("ChartOfAccounts" as never)
+      .where("id" as never, "=", (account as Record<string, unknown>).chartOfAccountsId as never)
+      .selectAll()
+      .executeTakeFirst();
+
+    if (!chartOfAccounts || (chartOfAccounts as Record<string, unknown>).status !== "ACTIVE") {
+      return err(new GlAccountNotFoundError(input.glAccountId));
+    }
+
+    // Check no other PRIMARY element references same GL account in same company
+    const duplicateGlRef = await db
+      .selectFrom("CostElement")
+      .where("companyId", "=", costElement.companyId)
+      .where("glAccountId", "=", input.glAccountId)
+      .where("type", "=", "PRIMARY")
+      .where("id", "!=", costElement.id)
+      .selectAll()
+      .executeTakeFirst();
+
+    if (duplicateGlRef) {
+      return err(new DuplicateGlAccountReferenceError(input.glAccountId));
+    }
+  }
+
+  // Validate validity dates
+  const effectiveValidFrom =
+    input.validFrom !== undefined ? input.validFrom : costElement.validFrom;
+  const effectiveValidTo = input.validTo !== undefined ? input.validTo : costElement.validTo;
+  if (effectiveValidFrom && effectiveValidTo && effectiveValidFrom > effectiveValidTo) {
+    return err(new InvalidValidityPeriodError(costElement.id));
+  }
+
+  // Build update set
+  const updateSet: Record<string, unknown> = { updatedAt: new Date() };
+  if (input.name !== undefined) updateSet.name = input.name;
+  if (input.description !== undefined) updateSet.description = input.description;
+  if (input.category !== undefined) updateSet.category = input.category;
+  if (input.glAccountId !== undefined) updateSet.glAccountId = input.glAccountId;
+  if (input.validFrom !== undefined) updateSet.validFrom = input.validFrom;
+  if (input.validTo !== undefined) updateSet.validTo = input.validTo;
+
+  const updated = await db
+    .updateTable("CostElement")
+    .set(updateSet)
+    .where("id", "=", costElement.id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ costElement: updated! });
+}

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

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

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

@@ -0,0 +1,209 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  InternalOrderNotFoundError,
+  InvalidStateError,
+  OrderTypeChangeNotAllowedError,
+  CostCenterNotFoundError,
+  InvalidValidityPeriodError,
+} from "../lib/errors.generated";
+import {
+  baseInternalOrder,
+  releasedInternalOrder,
+  techCompletedInternalOrder,
+  closedInternalOrder,
+  baseCostCenter2,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./updateInternalOrder";
+
+describe("updateInternalOrder", () => {
+  it("updates description on a CREATED internal order", async () => {
+    const updated = { ...baseInternalOrder, description: "New Description" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseInternalOrder);
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { internalOrderId: baseInternalOrder.id, description: "New Description" },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.internalOrder.description).toBe("New Description");
+  });
+
+  it("updates description on a RELEASED internal order", async () => {
+    const updated = { ...releasedInternalOrder, description: "Updated Desc" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(releasedInternalOrder);
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { internalOrderId: releasedInternalOrder.id, description: "Updated Desc" },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.internalOrder.description).toBe("Updated Desc");
+  });
+
+  it("updates responsible person on a CREATED internal order", async () => {
+    const updated = { ...baseInternalOrder, responsiblePersonId: "user-2" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseInternalOrder);
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { internalOrderId: baseInternalOrder.id, responsiblePersonId: "user-2" },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.internalOrder.responsiblePersonId).toBe("user-2");
+  });
+
+  it("updates cost center on a CREATED internal order", async () => {
+    const updated = { ...baseInternalOrder, costCenterId: baseCostCenter2.id };
+    const { db, spies } = createMockDb<Transaction>();
+    // order lookup, cost center lookup
+    spies.select.mockReturnValueOnce(baseInternalOrder).mockReturnValueOnce(baseCostCenter2);
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { internalOrderId: baseInternalOrder.id, costCenterId: baseCostCenter2.id },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.internalOrder.costCenterId).toBe(baseCostCenter2.id);
+  });
+
+  it("updates validity dates on a CREATED internal order", async () => {
+    const updated = {
+      ...baseInternalOrder,
+      validFrom: new Date("2024-06-01"),
+      validTo: new Date("2024-12-31"),
+    };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseInternalOrder);
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      {
+        internalOrderId: baseInternalOrder.id,
+        validFrom: new Date("2024-06-01"),
+        validTo: new Date("2024-12-31"),
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.internalOrder.validFrom).toEqual(new Date("2024-06-01"));
+    expect(value.internalOrder.validTo).toEqual(new Date("2024-12-31"));
+  });
+
+  it("returns error when internal order does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(
+      db,
+      { internalOrderId: "missing-id", description: "Update" },
+      commandCtx,
+    );
+
+    expectErr(result, InternalOrderNotFoundError);
+  });
+
+  it("returns error when internal order is TECHNICALLY_COMPLETED", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(techCompletedInternalOrder);
+
+    const result = await run(
+      db,
+      { internalOrderId: techCompletedInternalOrder.id, description: "Update" },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when internal order is CLOSED", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(closedInternalOrder);
+
+    const result = await run(
+      db,
+      { internalOrderId: closedInternalOrder.id, description: "Update" },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when changing order type after release", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(releasedInternalOrder);
+
+    const result = await run(
+      db,
+      { internalOrderId: releasedInternalOrder.id, orderType: "INVESTMENT" },
+      commandCtx,
+    );
+
+    expectErr(result, OrderTypeChangeNotAllowedError);
+  });
+
+  it("returns error when updated cost center does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseInternalOrder).mockReturnValueOnce(undefined);
+
+    const result = await run(
+      db,
+      { internalOrderId: baseInternalOrder.id, costCenterId: "missing-cc" },
+      commandCtx,
+    );
+
+    expectErr(result, CostCenterNotFoundError);
+  });
+
+  it("returns error when validFrom is after validTo", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseInternalOrder);
+
+    const result = await run(
+      db,
+      {
+        internalOrderId: baseInternalOrder.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 updated = { ...baseInternalOrder, description: "Audit Test" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseInternalOrder);
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { internalOrderId: baseInternalOrder.id, description: "Audit Test" },
+      commandCtx,
+    );
+
+    expectOk(result);
+    expect(spies.update).toHaveBeenCalled();
+  });
+});