@tailor-platform/erp-kit 0.7.0 → 0.8.0

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

@@ -0,0 +1,206 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CompanyNotFoundError,
+  DuplicateOrderNumberError,
+  InvalidOrderTypeError,
+  DescriptionRequiredError,
+  ResponsiblePersonRequiredError,
+  CostCenterNotFoundError,
+  InvalidValidityPeriodError,
+} from "../lib/errors.generated";
+import { baseCompany, baseCostCenter, baseInternalOrder, baseUser } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./createInternalOrder";
+
+const validInput = {
+  companyId: baseCompany.id,
+  orderNumber: "IO-001",
+  orderType: "OVERHEAD",
+  description: "IT Infrastructure Upgrade",
+  responsiblePersonId: baseUser.id,
+  costCenterId: baseCostCenter.id,
+};
+
+describe("createInternalOrder", () => {
+  it("creates internal order in CREATED status with required fields", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // company lookup, duplicate check, cost center lookup
+    spies.select
+      .mockReturnValueOnce(baseCompany)
+      .mockReturnValueOnce(undefined)
+      .mockReturnValueOnce(baseCostCenter);
+    spies.insert.mockReturnValueOnce(baseInternalOrder);
+
+    const result = await run(db, validInput, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.internalOrder).toEqual(baseInternalOrder);
+  });
+
+  it("returns error when company does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { ...validInput, companyId: "missing-company" }, 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, validInput, commandCtx);
+
+    expectErr(result, CompanyNotFoundError);
+  });
+
+  it("returns error when order number already exists within the company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany).mockReturnValueOnce(baseInternalOrder);
+
+    const result = await run(db, validInput, commandCtx);
+
+    expectErr(result, DuplicateOrderNumberError);
+  });
+
+  it("returns error when order type is invalid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany).mockReturnValueOnce(undefined);
+
+    const result = await run(db, { ...validInput, orderType: "INVALID_TYPE" }, commandCtx);
+
+    expectErr(result, InvalidOrderTypeError);
+  });
+
+  it("returns error when description is missing", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany).mockReturnValueOnce(undefined);
+
+    const result = await run(db, { ...validInput, description: "" }, commandCtx);
+
+    expectErr(result, DescriptionRequiredError);
+  });
+
+  it("returns error when responsible person is missing", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany).mockReturnValueOnce(undefined);
+
+    const result = await run(db, { ...validInput, responsiblePersonId: "" }, commandCtx);
+
+    expectErr(result, ResponsiblePersonRequiredError);
+  });
+
+  it("returns error when cost center does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCompany)
+      .mockReturnValueOnce(undefined)
+      .mockReturnValueOnce(undefined);
+
+    const result = await run(db, { ...validInput, costCenterId: "missing-cc" }, commandCtx);
+
+    expectErr(result, CostCenterNotFoundError);
+  });
+
+  it("returns error when cost center belongs to a different company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // company found, no duplicate, cost center query returns undefined (wrong company filter)
+    spies.select
+      .mockReturnValueOnce(baseCompany)
+      .mockReturnValueOnce(undefined)
+      .mockReturnValueOnce(undefined);
+
+    const result = await run(db, { ...validInput, costCenterId: "cc-other-company" }, commandCtx);
+
+    expectErr(result, CostCenterNotFoundError);
+  });
+
+  it("returns error when validFrom is after validTo", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCompany)
+      .mockReturnValueOnce(undefined)
+      .mockReturnValueOnce(baseCostCenter);
+
+    const result = await run(
+      db,
+      {
+        ...validInput,
+        validFrom: new Date("2025-12-31"),
+        validTo: new Date("2025-01-01"),
+      },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidValidityPeriodError);
+  });
+
+  it("creates internal order with optional validity dates", async () => {
+    const orderWithDates = {
+      ...baseInternalOrder,
+      validFrom: new Date("2024-01-01"),
+      validTo: new Date("2024-12-31"),
+    };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCompany)
+      .mockReturnValueOnce(undefined)
+      .mockReturnValueOnce(baseCostCenter);
+    spies.insert.mockReturnValueOnce(orderWithDates);
+
+    const result = await run(
+      db,
+      {
+        ...validInput,
+        validFrom: new Date("2024-01-01"),
+        validTo: new Date("2024-12-31"),
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.internalOrder).toEqual(orderWithDates);
+  });
+
+  it("internal orders from different companies are isolated", async () => {
+    const companyB = { id: "company-2", status: "ACTIVE" };
+    const costCenterB = { ...baseCostCenter, id: "cc-b", companyId: companyB.id };
+    const orderB = { ...baseInternalOrder, id: "io-b", companyId: companyB.id };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(companyB)
+      .mockReturnValueOnce(undefined)
+      .mockReturnValueOnce(costCenterB);
+    spies.insert.mockReturnValueOnce(orderB);
+
+    const result = await run(
+      db,
+      {
+        ...validInput,
+        companyId: companyB.id,
+        costCenterId: costCenterB.id,
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.internalOrder.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)
+      .mockReturnValueOnce(baseCostCenter);
+    spies.insert.mockReturnValueOnce(baseInternalOrder);
+
+    const result = await run(db, validInput, commandCtx);
+
+    expectOk(result);
+    expect(spies.insert).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,104 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CompanyNotFoundError,
+  DuplicateOrderNumberError,
+  InvalidOrderTypeError,
+  DescriptionRequiredError,
+  ResponsiblePersonRequiredError,
+  CostCenterNotFoundError,
+  InvalidValidityPeriodError,
+} from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+const VALID_ORDER_TYPES = ["OVERHEAD", "INVESTMENT", "ACCRUAL"];
+
+export interface CreateInternalOrderInput {
+  companyId: string;
+  orderNumber: string;
+  orderType: string;
+  description: string;
+  responsiblePersonId: string;
+  costCenterId: string;
+  validFrom?: Date | null;
+  validTo?: Date | null;
+}
+
+export async function run(db: Transaction, input: CreateInternalOrderInput, 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 unique order number within company
+  const existing = await db
+    .selectFrom("InternalOrder")
+    .where("companyId", "=", input.companyId)
+    .where("orderNumber", "=", input.orderNumber)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (existing) {
+    return err(new DuplicateOrderNumberError(input.orderNumber));
+  }
+
+  // Validate order type
+  if (!VALID_ORDER_TYPES.includes(input.orderType)) {
+    return err(new InvalidOrderTypeError(input.orderType));
+  }
+
+  // Validate description
+  if (!input.description || input.description.trim() === "") {
+    return err(new DescriptionRequiredError(input.companyId));
+  }
+
+  // Validate responsible person
+  if (!input.responsiblePersonId) {
+    return err(new ResponsiblePersonRequiredError(input.companyId));
+  }
+
+  // Validate cost center exists in same company
+  const costCenter = await db
+    .selectFrom("CostCenter")
+    .where("id", "=", input.costCenterId)
+    .where("companyId", "=", input.companyId)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (!costCenter) {
+    return err(new CostCenterNotFoundError(input.costCenterId));
+  }
+
+  // Validate validity dates
+  if (input.validFrom && input.validTo && input.validFrom > input.validTo) {
+    return err(new InvalidValidityPeriodError(input.companyId));
+  }
+
+  // Create internal order
+  const internalOrder = await db
+    .insertInto("InternalOrder")
+    .values({
+      companyId: input.companyId,
+      orderNumber: input.orderNumber,
+      orderType: input.orderType as "OVERHEAD" | "INVESTMENT" | "ACCRUAL",
+      description: input.description,
+      responsiblePersonId: input.responsiblePersonId,
+      costCenterId: input.costCenterId,
+      validFrom: input.validFrom ?? null,
+      validTo: input.validTo ?? null,
+      status: "CREATED",
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ internalOrder: internalOrder! });
+}

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

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

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

@@ -0,0 +1,230 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CompanyNotFoundError,
+  InvalidNameError,
+  InvalidVersionTypeError,
+  BaseVersionNotFoundError,
+} from "../lib/errors.generated";
+import { baseCompany, basePlanVersion } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./createPlanVersion";
+
+describe("createPlanVersion", () => {
+  it("creates a plan version of type BUDGET", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany);
+    spies.insert.mockReturnValueOnce(basePlanVersion);
+
+    const result = await run(
+      db,
+      {
+        companyId: baseCompany.id,
+        name: "FY2024 Budget",
+        type: "BUDGET",
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.planVersion).toEqual(basePlanVersion);
+  });
+
+  it("creates a plan version of type FORECAST", async () => {
+    const forecastVersion = {
+      ...basePlanVersion,
+      id: "plan-version-forecast",
+      type: "FORECAST" as const,
+    };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany);
+    spies.insert.mockReturnValueOnce(forecastVersion);
+
+    const result = await run(
+      db,
+      {
+        companyId: baseCompany.id,
+        name: "FY2024 Forecast",
+        type: "FORECAST",
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.planVersion.type).toBe("FORECAST");
+  });
+
+  it("creates a plan version of type SIMULATION", async () => {
+    const simulationVersion = {
+      ...basePlanVersion,
+      id: "plan-version-sim",
+      type: "SIMULATION" as const,
+    };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany);
+    spies.insert.mockReturnValueOnce(simulationVersion);
+
+    const result = await run(
+      db,
+      {
+        companyId: baseCompany.id,
+        name: "FY2024 Simulation",
+        type: "SIMULATION",
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.planVersion.type).toBe("SIMULATION");
+  });
+
+  it("creates a plan version with a base version reference", async () => {
+    const versionWithBase = {
+      ...basePlanVersion,
+      id: "plan-version-with-base",
+      baseVersionId: basePlanVersion.id,
+    };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany).mockReturnValueOnce(basePlanVersion); // base version lookup
+    spies.insert.mockReturnValueOnce(versionWithBase);
+
+    const result = await run(
+      db,
+      {
+        companyId: baseCompany.id,
+        name: "FY2024 Budget v2",
+        type: "BUDGET",
+        baseVersionId: basePlanVersion.id,
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.planVersion.baseVersionId).toBe(basePlanVersion.id);
+  });
+
+  it("creates a plan version without a base version reference", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany);
+    spies.insert.mockReturnValueOnce(basePlanVersion);
+
+    const result = await run(
+      db,
+      {
+        companyId: baseCompany.id,
+        name: "FY2024 Budget",
+        type: "BUDGET",
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.planVersion.baseVersionId).toBeNull();
+  });
+
+  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: "FY2024 Budget",
+        type: "BUDGET",
+      },
+      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: "FY2024 Budget",
+        type: "BUDGET",
+      },
+      commandCtx,
+    );
+
+    expectErr(result, CompanyNotFoundError);
+  });
+
+  it("returns error when version type is invalid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany);
+
+    const result = await run(
+      db,
+      {
+        companyId: baseCompany.id,
+        name: "FY2024 Budget",
+        type: "INVALID_TYPE",
+      },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidVersionTypeError);
+  });
+
+  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: "",
+        type: "BUDGET",
+      },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidNameError);
+  });
+
+  it("returns error when base version does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany).mockReturnValueOnce(undefined); // base version not found
+
+    const result = await run(
+      db,
+      {
+        companyId: baseCompany.id,
+        name: "FY2024 Budget v2",
+        type: "BUDGET",
+        baseVersionId: "missing-version",
+      },
+      commandCtx,
+    );
+
+    expectErr(result, BaseVersionNotFoundError);
+  });
+
+  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(basePlanVersion);
+
+    const result = await run(
+      db,
+      {
+        companyId: baseCompany.id,
+        name: "FY2024 Budget",
+        type: "BUDGET",
+      },
+      commandCtx,
+    );
+
+    expectOk(result);
+    expect(spies.insert).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,71 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CompanyNotFoundError,
+  InvalidNameError,
+  InvalidVersionTypeError,
+  BaseVersionNotFoundError,
+} from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+const VALID_VERSION_TYPES = ["BUDGET", "FORECAST", "SIMULATION"] as const;
+
+export interface CreatePlanVersionInput {
+  companyId: string;
+  name: string;
+  type: string;
+  baseVersionId?: string | null;
+}
+
+export async function run(db: Transaction, input: CreatePlanVersionInput, 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 version type
+  if (!VALID_VERSION_TYPES.includes(input.type as (typeof VALID_VERSION_TYPES)[number])) {
+    return err(new InvalidVersionTypeError(input.type));
+  }
+
+  // Validate name is non-empty
+  if (!input.name || input.name.trim() === "") {
+    return err(new InvalidNameError(input.companyId));
+  }
+
+  // Validate base version if provided
+  if (input.baseVersionId) {
+    const baseVersion = await db
+      .selectFrom("PlanVersion")
+      .where("id", "=", input.baseVersionId)
+      .selectAll()
+      .executeTakeFirst();
+
+    if (!baseVersion) {
+      return err(new BaseVersionNotFoundError(input.baseVersionId));
+    }
+  }
+
+  // Create plan version
+  const planVersion = await db
+    .insertInto("PlanVersion")
+    .values({
+      companyId: input.companyId,
+      name: input.name,
+      type: input.type as "BUDGET" | "FORECAST" | "SIMULATION",
+      baseVersionId: input.baseVersionId ?? null,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ planVersion: planVersion! });
+}

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

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