@tailor-platform/erp-kit 0.7.0 → 0.8.0

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

@@ -0,0 +1,109 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  HierarchyNotFoundError,
+  ParentNodeNotFoundError,
+  DuplicateRootNodeError,
+  SelfReferenceError,
+  CircularReferenceError,
+} from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface CreateProfitCenterHierarchyNodeInput {
+  hierarchyId: string;
+  name: string;
+  parentNodeId?: string | null;
+  sortOrder?: number;
+}
+
+export async function run(
+  db: Transaction,
+  input: CreateProfitCenterHierarchyNodeInput,
+  ctx: CommandContext,
+) {
+  void ctx;
+
+  // Validate hierarchy exists
+  const hierarchy = await db
+    .selectFrom("ProfitCenterHierarchy")
+    .selectAll()
+    .where("id", "=", input.hierarchyId)
+    .executeTakeFirst();
+
+  if (!hierarchy) {
+    return err(new HierarchyNotFoundError(input.hierarchyId));
+  }
+
+  const isRootNode = !input.parentNodeId;
+  let level = 0;
+
+  if (isRootNode) {
+    // Check if a root node already exists in this hierarchy
+    const existingRoot = await db
+      .selectFrom("ProfitCenterHierarchyNode")
+      .selectAll()
+      .where("hierarchyId", "=", input.hierarchyId)
+      .where("parentNodeId", "is", null)
+      .executeTakeFirst();
+
+    if (existingRoot) {
+      return err(new DuplicateRootNodeError(input.hierarchyId));
+    }
+  } else {
+    // Validate parent node exists within the hierarchy
+    const parentNode = await db
+      .selectFrom("ProfitCenterHierarchyNode")
+      .selectAll()
+      .where("id", "=", input.parentNodeId!)
+      .where("hierarchyId", "=", input.hierarchyId)
+      .executeTakeFirst();
+
+    if (!parentNode) {
+      return err(new ParentNodeNotFoundError(input.parentNodeId!));
+    }
+
+    // Check for self-reference and circular reference by walking the ancestor chain
+    const visited = new Set<string>();
+    let currentNodeId: string | null = input.parentNodeId!;
+
+    while (currentNodeId !== null) {
+      if (visited.has(currentNodeId)) {
+        return err(new CircularReferenceError(input.parentNodeId!));
+      }
+      visited.add(currentNodeId);
+
+      const currentNode = await db
+        .selectFrom("ProfitCenterHierarchyNode")
+        .where("id", "=", currentNodeId)
+        .select(["id", "parentNodeId"])
+        .executeTakeFirst();
+
+      if (!currentNode) break;
+
+      // Self-reference: node is its own parent
+      if (currentNode.parentNodeId === currentNode.id) {
+        return err(new SelfReferenceError(currentNodeId));
+      }
+
+      currentNodeId = currentNode.parentNodeId;
+    }
+
+    level = parentNode.level + 1;
+  }
+
+  // Create the node
+  const node = await db
+    .insertInto("ProfitCenterHierarchyNode")
+    .values({
+      hierarchyId: input.hierarchyId,
+      name: input.name,
+      parentNodeId: input.parentNodeId ?? null,
+      sortOrder: input.sortOrder ?? 1,
+      level,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ profitCenterHierarchyNode: node! });
+}

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

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

package/src/modules/accounting/command/deactivateCostElement.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 { CostElementNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { baseCostElement, activeCostElement, inactiveCostElement } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./deactivateCostElement";
+
+describe("deactivateCostElement", () => {
+  it("deactivates an ACTIVE cost element transitioning it to INACTIVE status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeCostElement);
+    const updated = { ...activeCostElement, status: "INACTIVE" };
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(db, { costElementId: activeCostElement.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.costElement.status).toBe("INACTIVE");
+  });
+
+  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 DRAFT status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostElement);
+
+    const result = await run(db, { costElementId: baseCostElement.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when cost element is already INACTIVE", 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 status transition and acting user", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeCostElement);
+    spies.update.mockReturnValueOnce({ ...activeCostElement, status: "INACTIVE" });
+
+    const result = await run(db, { costElementId: activeCostElement.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.update).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,41 @@
+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 DeactivateCostElementInput {
+  costElementId: string;
+  from?: string[];
+}
+
+/** Command: deactivateCostElement
+ * Transitions a cost element from ACTIVE status to INACTIVE status.
+ */
+export async function run(db: Transaction, input: DeactivateCostElementInput, ctx: CommandContext) {
+  void ctx;
+
+  const validFromStatuses = input.from ?? ["ACTIVE"];
+
+  const costElement = await db
+    .selectFrom("CostElement")
+    .selectAll()
+    .where("id", "=", input.costElementId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!costElement) {
+    return err(new CostElementNotFoundError(input.costElementId));
+  }
+
+  if (!validFromStatuses.includes(costElement.status)) {
+    return err(new InvalidStateError(input.costElementId));
+  }
+
+  const updated = await db
+    .updateTable("CostElement")
+    .set({ status: "INACTIVE", updatedAt: new Date() })
+    .where("id", "=", input.costElementId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ costElement: updated! });
+}

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

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

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

@@ -0,0 +1,60 @@
+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 "./deactivateProfitCenter";
+
+describe("deactivateProfitCenter", () => {
+  it("deactivates an ACTIVE profit center transitioning it to INACTIVE status", async () => {
+    const deactivated = { ...activeProfitCenter, status: "INACTIVE" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeProfitCenter);
+    spies.update.mockReturnValueOnce(deactivated);
+
+    const result = await run(db, { profitCenterId: activeProfitCenter.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.profitCenter.status).toBe("INACTIVE");
+  });
+
+  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 DRAFT status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseProfitCenter);
+
+    const result = await run(db, { profitCenterId: baseProfitCenter.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when profit center is already INACTIVE", 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 status transition and acting user", async () => {
+    const deactivated = { ...activeProfitCenter, status: "INACTIVE" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeProfitCenter);
+    spies.update.mockReturnValueOnce(deactivated);
+
+    const result = await run(db, { profitCenterId: activeProfitCenter.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.update).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,42 @@
+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 DeactivateProfitCenterInput {
+  profitCenterId: string;
+  from?: string[];
+}
+
+export async function run(
+  db: Transaction,
+  input: DeactivateProfitCenterInput,
+  ctx: CommandContext,
+) {
+  void ctx;
+
+  const validFromStatuses = input.from ?? ["ACTIVE"];
+
+  const profitCenter = await db
+    .selectFrom("ProfitCenter")
+    .selectAll()
+    .where("id", "=", input.profitCenterId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!profitCenter) {
+    return err(new ProfitCenterNotFoundError(input.profitCenterId));
+  }
+
+  if (!validFromStatuses.includes(profitCenter.status)) {
+    return err(new InvalidStateError(input.profitCenterId));
+  }
+
+  const updated = await db
+    .updateTable("ProfitCenter")
+    .set({ status: "INACTIVE", updatedAt: new Date() })
+    .where("id", "=", input.profitCenterId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ profitCenter: updated! });
+}

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

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

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

@@ -0,0 +1,90 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { AllocationCycleNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import {
+  baseAllocationCycle,
+  validatedAllocationCycle,
+  executedAllocationCycle,
+  postedAllocationCycle,
+  reversedAllocationCycle,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./deleteAllocationCycle";
+
+describe("deleteAllocationCycle", () => {
+  it("deletes a DRAFT allocation cycle successfully", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseAllocationCycle);
+
+    const result = await run(db, { allocationCycleId: baseAllocationCycle.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.allocationCycleId).toBe(baseAllocationCycle.id);
+  });
+
+  it("deletes a DRAFT allocation cycle and removes associated rules", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseAllocationCycle);
+
+    const result = await run(db, { allocationCycleId: baseAllocationCycle.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.delete).toHaveBeenCalled();
+  });
+
+  it("returns error when allocation cycle does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { allocationCycleId: "missing-id" }, commandCtx);
+
+    expectErr(result, AllocationCycleNotFoundError);
+  });
+
+  it("returns error when allocation cycle is in VALIDATED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(validatedAllocationCycle);
+
+    const result = await run(db, { allocationCycleId: validatedAllocationCycle.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when allocation cycle is in EXECUTED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(executedAllocationCycle);
+
+    const result = await run(db, { allocationCycleId: executedAllocationCycle.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when allocation cycle is in POSTED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(postedAllocationCycle);
+
+    const result = await run(db, { allocationCycleId: postedAllocationCycle.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when allocation cycle is in REVERSED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(reversedAllocationCycle);
+
+    const result = await run(db, { allocationCycleId: reversedAllocationCycle.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("emits audit event recording the deletion and acting user", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseAllocationCycle);
+
+    const result = await run(db, { allocationCycleId: baseAllocationCycle.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.delete).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,39 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { AllocationCycleNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface DeleteAllocationCycleInput {
+  allocationCycleId: string;
+}
+
+export async function run(db: Transaction, input: DeleteAllocationCycleInput, ctx: CommandContext) {
+  void ctx;
+
+  // Validate allocation cycle exists
+  const cycle = await db
+    .selectFrom("AllocationCycle")
+    .where("id", "=", input.allocationCycleId)
+    .selectAll()
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!cycle) {
+    return err(new AllocationCycleNotFoundError(input.allocationCycleId));
+  }
+
+  // Validate status is DRAFT
+  if (cycle.status !== "DRAFT") {
+    return err(new InvalidStateError(input.allocationCycleId));
+  }
+
+  // Delete associated rules first
+  await db
+    .deleteFrom("AllocationRule")
+    .where("allocationCycleId", "=", input.allocationCycleId)
+    .execute();
+
+  // Delete the cycle
+  await db.deleteFrom("AllocationCycle").where("id", "=", input.allocationCycleId).execute();
+
+  return ok({ allocationCycleId: input.allocationCycleId });
+}

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

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

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

@@ -0,0 +1,98 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { AllocationRuleNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import {
+  baseAllocationRule,
+  baseAllocationCycle,
+  validatedAllocationCycle,
+  executedAllocationCycle,
+  postedAllocationCycle,
+  reversedAllocationCycle,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./deleteAllocationRule";
+
+describe("deleteAllocationRule", () => {
+  it("deletes an allocation rule from a DRAFT allocation cycle", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseAllocationRule) // rule lookup
+      .mockReturnValueOnce(baseAllocationCycle); // cycle lookup
+
+    const result = await run(db, { allocationRuleId: baseAllocationRule.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.allocationRuleId).toBe(baseAllocationRule.id);
+  });
+
+  it("returns error when allocation rule does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { allocationRuleId: "missing-id" }, commandCtx);
+
+    expectErr(result, AllocationRuleNotFoundError);
+  });
+
+  it("returns error when parent cycle is in VALIDATED status", async () => {
+    const ruleForValidated = {
+      ...baseAllocationRule,
+      allocationCycleId: validatedAllocationCycle.id,
+    };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(ruleForValidated)
+      .mockReturnValueOnce(validatedAllocationCycle);
+
+    const result = await run(db, { allocationRuleId: ruleForValidated.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when parent cycle is in EXECUTED status", async () => {
+    const ruleForExecuted = {
+      ...baseAllocationRule,
+      allocationCycleId: executedAllocationCycle.id,
+    };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(ruleForExecuted).mockReturnValueOnce(executedAllocationCycle);
+
+    const result = await run(db, { allocationRuleId: ruleForExecuted.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when parent cycle is in POSTED status", async () => {
+    const ruleForPosted = { ...baseAllocationRule, allocationCycleId: postedAllocationCycle.id };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(ruleForPosted).mockReturnValueOnce(postedAllocationCycle);
+
+    const result = await run(db, { allocationRuleId: ruleForPosted.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when parent cycle is in REVERSED status", async () => {
+    const ruleForReversed = {
+      ...baseAllocationRule,
+      allocationCycleId: reversedAllocationCycle.id,
+    };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(ruleForReversed).mockReturnValueOnce(reversedAllocationCycle);
+
+    const result = await run(db, { allocationRuleId: ruleForReversed.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("emits audit event recording the rule deletion and acting user", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseAllocationRule).mockReturnValueOnce(baseAllocationCycle);
+
+    const result = await run(db, { allocationRuleId: baseAllocationRule.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.delete).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,40 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { AllocationRuleNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface DeleteAllocationRuleInput {
+  allocationRuleId: string;
+}
+
+export async function run(db: Transaction, input: DeleteAllocationRuleInput, ctx: CommandContext) {
+  void ctx;
+
+  // Validate allocation rule exists
+  const rule = await db
+    .selectFrom("AllocationRule")
+    .where("id", "=", input.allocationRuleId)
+    .selectAll()
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!rule) {
+    return err(new AllocationRuleNotFoundError(input.allocationRuleId));
+  }
+
+  // Validate parent cycle is in DRAFT status
+  const cycle = await db
+    .selectFrom("AllocationCycle")
+    .where("id", "=", rule.allocationCycleId)
+    .selectAll()
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (cycle?.status !== "DRAFT") {
+    return err(new InvalidStateError(input.allocationRuleId));
+  }
+
+  // Delete the rule
+  await db.deleteFrom("AllocationRule").where("id", "=", input.allocationRuleId).execute();
+
+  return ok({ allocationRuleId: input.allocationRuleId });
+}

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

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