@tailor-platform/erp-kit 0.7.0 → 0.9.0

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

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CostCenterNotFoundError,
+  CostCenterHasPostingsError,
+  CostCenterHasBudgetItemsError,
+  CostCenterHasAllocationRulesError,
+} from "../lib/errors.generated";
+import {
+  baseCostCenter,
+  baseAllocationResult,
+  baseBudget,
+  baseAllocationRule,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./deleteCostCenter";
+
+describe("deleteCostCenter", () => {
+  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" }, commandCtx);
+
+    expectErr(result, CostCenterNotFoundError);
+  });
+
+  it("returns error when cost center has postings", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenter) // cost center exists
+      .mockReturnValueOnce(baseAllocationResult); // has postings
+
+    const result = await run(db, { costCenterId: baseCostCenter.id }, commandCtx);
+
+    expectErr(result, CostCenterHasPostingsError);
+  });
+
+  it("returns error when cost center has budget items", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenter) // cost center exists
+      .mockReturnValueOnce(undefined) // no postings
+      .mockReturnValueOnce(baseBudget); // has budget
+
+    const result = await run(db, { costCenterId: baseCostCenter.id }, commandCtx);
+
+    expectErr(result, CostCenterHasBudgetItemsError);
+  });
+
+  it("returns error when cost center has allocation rules", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenter) // cost center exists
+      .mockReturnValueOnce(undefined) // no postings
+      .mockReturnValueOnce(undefined) // no budgets
+      .mockReturnValueOnce(baseAllocationRule); // has allocation rules
+
+    const result = await run(db, { costCenterId: baseCostCenter.id }, commandCtx);
+
+    expectErr(result, CostCenterHasAllocationRulesError);
+  });
+
+  it("deletes cost center when no dependencies exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCostCenter) // cost center exists
+      .mockReturnValueOnce(undefined) // no postings
+      .mockReturnValueOnce(undefined) // no budgets
+      .mockReturnValueOnce(undefined); // no allocation rules
+
+    const result = await run(db, { costCenterId: baseCostCenter.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.costCenterId).toBe(baseCostCenter.id);
+    expect(spies.delete).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,67 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CostCenterNotFoundError,
+  CostCenterHasPostingsError,
+  CostCenterHasBudgetItemsError,
+  CostCenterHasAllocationRulesError,
+} from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface DeleteCostCenterInput {
+  costCenterId: string;
+}
+
+export async function run(db: Transaction, input: DeleteCostCenterInput, ctx: CommandContext) {
+  void ctx;
+
+  // 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));
+  }
+
+  // Check for associated cost postings (AllocationResult referencing this cost center)
+  const posting = await db
+    .selectFrom("AllocationResult")
+    .where("senderCostCenterId", "=", input.costCenterId)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (posting) {
+    return err(new CostCenterHasPostingsError(input.costCenterId));
+  }
+
+  // Check for associated budget line items via budget
+  const budget = await db
+    .selectFrom("Budget")
+    .where("costObjectType", "=", "CostCenter")
+    .where("costObjectId", "=", input.costCenterId)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (budget) {
+    return err(new CostCenterHasBudgetItemsError(input.costCenterId));
+  }
+
+  // Check for associated allocation rules
+  const allocationRule = await db
+    .selectFrom("AllocationRule")
+    .where("senderCostCenterId", "=", input.costCenterId)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (allocationRule) {
+    return err(new CostCenterHasAllocationRulesError(input.costCenterId));
+  }
+
+  // Delete the cost center
+  await db.deleteFrom("CostCenter").where("id", "=", input.costCenterId).execute();
+
+  return ok({ costCenterId: input.costCenterId });
+}

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

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

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

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  NodeNotFoundError,
+  NodeHasChildrenError,
+  NodeHasAssignedCostCentersError,
+} from "../lib/errors.generated";
+import { rootCostCenterNode, childCostCenterNode, baseCostCenter } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./deleteCostCenterHierarchyNode";
+
+describe("deleteCostCenterHierarchyNode", () => {
+  it("returns error when node does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { nodeId: "missing-node" }, commandCtx);
+
+    expectErr(result, NodeNotFoundError);
+  });
+
+  it("returns error when node has children", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(rootCostCenterNode) // node exists
+      .mockReturnValueOnce(childCostCenterNode); // has children
+
+    const result = await run(db, { nodeId: rootCostCenterNode.id }, commandCtx);
+
+    expectErr(result, NodeHasChildrenError);
+  });
+
+  it("returns error when node has assigned cost centers", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(childCostCenterNode) // node exists
+      .mockReturnValueOnce(undefined) // no children
+      .mockReturnValueOnce(baseCostCenter); // has assigned cost centers
+
+    const result = await run(db, { nodeId: childCostCenterNode.id }, commandCtx);
+
+    expectErr(result, NodeHasAssignedCostCentersError);
+  });
+
+  it("deletes node when it has no children and no assigned cost centers", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(childCostCenterNode) // node exists
+      .mockReturnValueOnce(undefined) // no children
+      .mockReturnValueOnce(undefined); // no assigned cost centers
+
+    const result = await run(db, { nodeId: childCostCenterNode.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.nodeId).toBe(childCostCenterNode.id);
+    expect(spies.delete).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,58 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  NodeNotFoundError,
+  NodeHasChildrenError,
+  NodeHasAssignedCostCentersError,
+} from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface DeleteCostCenterHierarchyNodeInput {
+  nodeId: string;
+}
+
+export async function run(
+  db: Transaction,
+  input: DeleteCostCenterHierarchyNodeInput,
+  ctx: CommandContext,
+) {
+  void ctx;
+
+  // Validate node exists
+  const node = await db
+    .selectFrom("CostCenterHierarchyNode")
+    .where("id", "=", input.nodeId)
+    .selectAll()
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!node) {
+    return err(new NodeNotFoundError(input.nodeId));
+  }
+
+  // Validate no child nodes exist
+  const childNode = await db
+    .selectFrom("CostCenterHierarchyNode")
+    .where("parentNodeId", "=", input.nodeId)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (childNode) {
+    return err(new NodeHasChildrenError(input.nodeId));
+  }
+
+  // Validate no cost centers are assigned to this node
+  const assignedCostCenter = await db
+    .selectFrom("CostCenter")
+    .where("hierarchyNodeId", "=", input.nodeId)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (assignedCostCenter) {
+    return err(new NodeHasAssignedCostCentersError(input.nodeId));
+  }
+
+  // Delete the node
+  await db.deleteFrom("CostCenterHierarchyNode").where("id", "=", input.nodeId).execute();
+
+  return ok({ nodeId: input.nodeId });
+}

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

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

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

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { CostElementNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { baseCostElement, activeCostElement, inactiveCostElement } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./deleteCostElement";
+
+describe("deleteCostElement", () => {
+  it("deletes a DRAFT cost element successfully", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostElement);
+    spies.delete.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { costElementId: baseCostElement.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.costElement).toEqual(baseCostElement);
+  });
+
+  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 in ACTIVE status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeCostElement);
+
+    const result = await run(db, { costElementId: activeCostElement.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when cost element is in INACTIVE status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(inactiveCostElement);
+
+    const result = await run(db, { costElementId: inactiveCostElement.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("emits audit event recording the deletion and acting user", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostElement);
+    spies.delete.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { costElementId: baseCostElement.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.delete).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,33 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { CostElementNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface DeleteCostElementInput {
+  costElementId: string;
+}
+
+/** Command: deleteCostElement
+ * Permanently removes a cost element that is in DRAFT status.
+ */
+export async function run(db: Transaction, input: DeleteCostElementInput, ctx: CommandContext) {
+  void ctx;
+
+  const costElement = await db
+    .selectFrom("CostElement")
+    .selectAll()
+    .where("id", "=", input.costElementId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!costElement) {
+    return err(new CostElementNotFoundError(input.costElementId));
+  }
+
+  if (costElement.status !== "DRAFT") {
+    return err(new InvalidStateError(input.costElementId));
+  }
+
+  await db.deleteFrom("CostElement").where("id", "=", input.costElementId).executeTakeFirst();
+
+  return ok({ costElement });
+}

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

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

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

@@ -0,0 +1,81 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { InternalOrderNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import {
+  baseInternalOrder,
+  releasedInternalOrder,
+  techCompletedInternalOrder,
+  closedInternalOrder,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./deleteInternalOrder";
+
+describe("deleteInternalOrder", () => {
+  it("deletes a CREATED internal order successfully", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseInternalOrder);
+
+    const result = await run(db, { internalOrderId: baseInternalOrder.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.internalOrder).toEqual(baseInternalOrder);
+    expect(spies.delete).toHaveBeenCalled();
+  });
+
+  it("deletes a CREATED internal order and removes associated budget assignment", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseInternalOrder);
+
+    const result = await run(db, { internalOrderId: baseInternalOrder.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.delete).toHaveBeenCalled();
+  });
+
+  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" }, commandCtx);
+
+    expectErr(result, InternalOrderNotFoundError);
+  });
+
+  it("returns error when internal order is in RELEASED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(releasedInternalOrder);
+
+    const result = await run(db, { internalOrderId: releasedInternalOrder.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when internal order is in TECHNICALLY_COMPLETED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(techCompletedInternalOrder);
+
+    const result = await run(db, { internalOrderId: techCompletedInternalOrder.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when internal order is in CLOSED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(closedInternalOrder);
+
+    const result = await run(db, { internalOrderId: closedInternalOrder.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("emits audit event recording the deletion and acting user", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseInternalOrder);
+
+    const result = await run(db, { internalOrderId: baseInternalOrder.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.delete).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,37 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { InternalOrderNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface DeleteInternalOrderInput {
+  internalOrderId: string;
+}
+
+export async function run(db: Transaction, input: DeleteInternalOrderInput, ctx: CommandContext) {
+  void ctx;
+
+  const order = await db
+    .selectFrom("InternalOrder")
+    .selectAll()
+    .where("id", "=", input.internalOrderId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!order) {
+    return err(new InternalOrderNotFoundError(input.internalOrderId));
+  }
+
+  if (order.status !== "CREATED") {
+    return err(new InvalidStateError(input.internalOrderId));
+  }
+
+  // Remove associated budget assignments
+  await db
+    .deleteFrom("Budget")
+    .where("costObjectId", "=", input.internalOrderId)
+    .where("costObjectType", "=", "InternalOrder")
+    .execute();
+
+  await db.deleteFrom("InternalOrder").where("id", "=", input.internalOrderId).executeTakeFirst();
+
+  return ok({ internalOrder: order });
+}

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

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

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

@@ -0,0 +1,68 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { ProfitCenterNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { baseProfitCenter, activeProfitCenter, inactiveProfitCenter } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./deleteProfitCenter";
+
+describe("deleteProfitCenter", () => {
+  it("deletes a DRAFT profit center successfully", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseProfitCenter);
+
+    const result = await run(db, { profitCenterId: baseProfitCenter.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.profitCenter).toEqual(baseProfitCenter);
+    expect(spies.delete).toHaveBeenCalled();
+  });
+
+  it("deletes a DRAFT profit center and removes its hierarchy assignment", async () => {
+    const pcWithNode = { ...baseProfitCenter, hierarchyNodeId: "pc-node-child-1" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(pcWithNode);
+
+    const result = await run(db, { profitCenterId: pcWithNode.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.delete).toHaveBeenCalled();
+  });
+
+  it("returns error when profit center does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { profitCenterId: "missing-id" }, commandCtx);
+
+    expectErr(result, ProfitCenterNotFoundError);
+  });
+
+  it("returns error when profit center is in ACTIVE status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeProfitCenter);
+
+    const result = await run(db, { profitCenterId: activeProfitCenter.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when profit center is in INACTIVE status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(inactiveProfitCenter);
+
+    const result = await run(db, { profitCenterId: inactiveProfitCenter.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("emits audit event recording the deletion and acting user", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseProfitCenter);
+
+    const result = await run(db, { profitCenterId: baseProfitCenter.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.delete).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,39 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { ProfitCenterNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface DeleteProfitCenterInput {
+  profitCenterId: string;
+}
+
+export async function run(db: Transaction, input: DeleteProfitCenterInput, ctx: CommandContext) {
+  void ctx;
+
+  // Validate profit center exists
+  const profitCenter = await db
+    .selectFrom("ProfitCenter")
+    .selectAll()
+    .where("id", "=", input.profitCenterId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!profitCenter) {
+    return err(new ProfitCenterNotFoundError(input.profitCenterId));
+  }
+
+  // Only DRAFT can be deleted
+  if (profitCenter.status !== "DRAFT") {
+    return err(new InvalidStateError(input.profitCenterId));
+  }
+
+  // Remove all hierarchy assignments
+  await db
+    .deleteFrom("ProfitCenterHierarchyAssignment")
+    .where("profitCenterId", "=", input.profitCenterId)
+    .execute();
+
+  // Delete the profit center
+  await db.deleteFrom("ProfitCenter").where("id", "=", input.profitCenterId).executeTakeFirst();
+
+  return ok({ profitCenter });
+}

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

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