@tailor-platform/erp-kit 0.7.0 → 0.8.0

package/src/modules/accounting/query/listCostElements.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  InvalidCategoryFilterError,
+  InvalidStatusFilterError,
+  InvalidTypeFilterError,
+} from "../lib/errors.generated";
+import { baseCostElement, activeCostElement, secondaryCostElement } from "../testing/fixtures";
+import { run } from "./listCostElements";
+
+describe("listCostElements", () => {
+  it("returns all cost elements when no filters are provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseCostElement, activeCostElement]);
+
+    const result = await run(db, {});
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(2);
+    }
+  });
+
+  it("returns cost elements filtered by companyId", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseCostElement]);
+
+    const result = await run(db, { companyId: baseCostElement.companyId });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0]).toEqual(baseCostElement);
+    }
+  });
+
+  it("returns cost elements filtered by type PRIMARY", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseCostElement, activeCostElement]);
+
+    const result = await run(db, { type: "PRIMARY" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(2);
+    }
+  });
+
+  it("returns cost elements filtered by type SECONDARY", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([secondaryCostElement]);
+
+    const result = await run(db, { type: "SECONDARY" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0]).toEqual(secondaryCostElement);
+    }
+  });
+
+  it("returns cost elements filtered by category", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseCostElement]);
+
+    const result = await run(db, { category: "overhead" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0].category).toEqual("overhead");
+    }
+  });
+
+  it("returns cost elements filtered by status ACTIVE", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([activeCostElement]);
+
+    const result = await run(db, { status: "ACTIVE" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0]).toEqual(activeCostElement);
+    }
+  });
+
+  it("returns cost elements matching multiple filters simultaneously", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([activeCostElement]);
+
+    const result = await run(db, {
+      companyId: baseCostElement.companyId,
+      type: "PRIMARY",
+      status: "ACTIVE",
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0]).toEqual(activeCostElement);
+    }
+  });
+
+  it("returns an empty list when no cost elements match the given filters", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, { status: "INACTIVE", companyId: "non-existent" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([]);
+    }
+  });
+
+  it("returns error when type filter is invalid", async () => {
+    const { db } = createMockDb<DB>();
+    const result = await run(db, { type: "INVALID" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toBeInstanceOf(InvalidTypeFilterError);
+  });
+
+  it("returns error when status filter is invalid", async () => {
+    const { db } = createMockDb<DB>();
+    const result = await run(db, { status: "INVALID" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toBeInstanceOf(InvalidStatusFilterError);
+  });
+
+  it("returns error when category filter is invalid", async () => {
+    const { db } = createMockDb<DB>();
+    const result = await run(db, { category: "invalid" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toBeInstanceOf(InvalidCategoryFilterError);
+  });
+});

package/src/modules/accounting/query/listCostElements.ts

@@ -0,0 +1,105 @@
+import type { CostElementStatus, CostElementType } from "../generated/enums";
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  InvalidCategoryFilterError,
+  InvalidStatusFilterError,
+  InvalidTypeFilterError,
+} from "../lib/errors.generated";
+import {
+  err,
+  ok,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "@tailor-platform/erp-kit/module";
+
+type CostElementOrderByField = "name" | "code" | "createdAt";
+
+export interface ListCostElementsInput extends PaginationInput<CostElementOrderByField> {
+  companyId?: string;
+  type?: string;
+  category?: string;
+  status?: string;
+}
+
+/**
+ * Function: listCostElements
+ *
+ * Lists cost elements with optional filters for type, category, and status.
+ */
+export async function run(db: ReadonlyDB<DB>, input: ListCostElementsInput) {
+  if (
+    input.type &&
+    !(["PRIMARY", "SECONDARY"] as const satisfies CostElementType[]).includes(
+      input.type as CostElementType,
+    )
+  ) {
+    return err(new InvalidTypeFilterError(input.type));
+  }
+
+  if (
+    input.status &&
+    !(["DRAFT", "ACTIVE", "INACTIVE"] as const satisfies CostElementStatus[]).includes(
+      input.status as CostElementStatus,
+    )
+  ) {
+    return err(new InvalidStatusFilterError(input.status));
+  }
+
+  if (
+    input.category &&
+    !(
+      [
+        "overhead",
+        "material",
+        "labor",
+        "depreciation",
+        "assessment",
+        "distribution",
+        "internal_activity_allocation",
+        "settlement",
+      ] as const
+    ).includes(
+      input.category as
+        | "overhead"
+        | "material"
+        | "labor"
+        | "depreciation"
+        | "assessment"
+        | "distribution"
+        | "internal_activity_allocation"
+        | "settlement",
+    )
+  ) {
+    return err(new InvalidCategoryFilterError(input.category));
+  }
+
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = input.orderBy ?? "id";
+  const orderDirection = input.orderDirection ?? "asc";
+
+  let query = db.selectFrom("CostElement").selectAll();
+
+  if (input.companyId) {
+    query = query.where("companyId", "=", input.companyId);
+  }
+  if (input.type) {
+    query = query.where("type", "=", input.type as CostElementType);
+  }
+  if (input.category) {
+    query = query.where("category", "=", input.category);
+  }
+  if (input.status) {
+    query = query.where("status", "=", input.status as CostElementStatus);
+  }
+
+  const costElements = await query
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+
+  return ok(buildPaginatedResult(costElements, limit));
+}

package/src/modules/accounting/query/listInternalOrders.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./listInternalOrders";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const listInternalOrders = defineQuery(run);

package/src/modules/accounting/query/listInternalOrders.test.ts

@@ -0,0 +1,129 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  CostCenterNotFoundError,
+  InvalidOrderTypeFilterError,
+  InvalidStatusFilterError,
+} from "../lib/errors.generated";
+import { baseInternalOrder, releasedInternalOrder, baseCostCenter } from "../testing/fixtures";
+import { run } from "./listInternalOrders";
+
+describe("listInternalOrders", () => {
+  it("returns all internal orders when no filters are provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseInternalOrder, releasedInternalOrder]);
+
+    const result = await run(db, {});
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(2);
+    }
+  });
+
+  it("returns internal orders filtered by companyId", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseInternalOrder]);
+
+    const result = await run(db, { companyId: baseInternalOrder.companyId });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0]).toEqual(baseInternalOrder);
+    }
+  });
+
+  it("returns internal orders filtered by orderType OVERHEAD", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseInternalOrder]);
+
+    const result = await run(db, { orderType: "OVERHEAD" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0].orderType).toEqual("OVERHEAD");
+    }
+  });
+
+  it("returns internal orders filtered by status RELEASED", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([releasedInternalOrder]);
+
+    const result = await run(db, { status: "RELEASED" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0].status).toEqual("RELEASED");
+    }
+  });
+
+  it("returns internal orders filtered by costCenterId", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce({ id: baseCostCenter.id })
+      .mockReturnValueOnce([baseInternalOrder]);
+
+    const result = await run(db, { costCenterId: baseCostCenter.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0].costCenterId).toEqual(baseCostCenter.id);
+    }
+  });
+
+  it("returns internal orders matching multiple filters simultaneously", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([releasedInternalOrder]);
+
+    const result = await run(db, {
+      companyId: releasedInternalOrder.companyId,
+      orderType: "OVERHEAD",
+      status: "RELEASED",
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0]).toEqual(releasedInternalOrder);
+    }
+  });
+
+  it("returns an empty list when no internal orders match the given filters", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, { companyId: "non-existent" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([]);
+    }
+  });
+
+  it("returns error when orderType filter is invalid", async () => {
+    const { db } = createMockDb<DB>();
+    const result = await run(db, { orderType: "INVALID" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toBeInstanceOf(InvalidOrderTypeFilterError);
+  });
+
+  it("returns error when status filter is invalid", async () => {
+    const { db } = createMockDb<DB>();
+    const result = await run(db, { status: "INVALID" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toBeInstanceOf(InvalidStatusFilterError);
+  });
+
+  it("returns error when costCenterId does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+    const result = await run(db, { costCenterId: "missing-cost-center" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toBeInstanceOf(CostCenterNotFoundError);
+  });
+});

package/src/modules/accounting/query/listInternalOrders.ts

@@ -0,0 +1,94 @@
+import type { InternalOrderOrderType, InternalOrderStatus } from "../generated/enums";
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  CostCenterNotFoundError,
+  InvalidOrderTypeFilterError,
+  InvalidStatusFilterError,
+} from "../lib/errors.generated";
+import {
+  err,
+  ok,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "@tailor-platform/erp-kit/module";
+
+type InternalOrderOrderByField = "orderNumber" | "createdAt";
+
+export interface ListInternalOrdersInput extends PaginationInput<InternalOrderOrderByField> {
+  companyId?: string;
+  orderType?: string;
+  status?: string;
+  costCenterId?: string;
+}
+
+/**
+ * Function: listInternalOrders
+ *
+ * Lists internal orders with optional filters for order type, status, and cost center.
+ */
+export async function run(db: ReadonlyDB<DB>, input: ListInternalOrdersInput) {
+  if (
+    input.orderType &&
+    !(["OVERHEAD", "INVESTMENT", "ACCRUAL"] as const satisfies InternalOrderOrderType[]).includes(
+      input.orderType as InternalOrderOrderType,
+    )
+  ) {
+    return err(new InvalidOrderTypeFilterError(input.orderType));
+  }
+
+  if (
+    input.status &&
+    !(
+      [
+        "CREATED",
+        "RELEASED",
+        "TECHNICALLY_COMPLETED",
+        "CLOSED",
+      ] as const satisfies InternalOrderStatus[]
+    ).includes(input.status as InternalOrderStatus)
+  ) {
+    return err(new InvalidStatusFilterError(input.status));
+  }
+
+  if (input.costCenterId) {
+    const costCenter = await db
+      .selectFrom("CostCenter")
+      .select("id")
+      .where("id", "=", input.costCenterId)
+      .executeTakeFirst();
+
+    if (!costCenter) {
+      return err(new CostCenterNotFoundError(input.costCenterId));
+    }
+  }
+
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = input.orderBy ?? "id";
+  const orderDirection = input.orderDirection ?? "asc";
+
+  let query = db.selectFrom("InternalOrder").selectAll();
+
+  if (input.companyId) {
+    query = query.where("companyId", "=", input.companyId);
+  }
+  if (input.orderType) {
+    query = query.where("orderType", "=", input.orderType as InternalOrderOrderType);
+  }
+  if (input.status) {
+    query = query.where("status", "=", input.status as InternalOrderStatus);
+  }
+  if (input.costCenterId) {
+    query = query.where("costCenterId", "=", input.costCenterId);
+  }
+
+  const internalOrders = await query
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+
+  return ok(buildPaginatedResult(internalOrders, limit));
+}

package/src/modules/accounting/query/listProfitCenters.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./listProfitCenters";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const listProfitCenters = defineQuery(run);

package/src/modules/accounting/query/listProfitCenters.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { InvalidStatusFilterError } from "../lib/errors.generated";
+import { baseProfitCenter, activeProfitCenter } from "../testing/fixtures";
+import { run } from "./listProfitCenters";
+
+describe("listProfitCenters", () => {
+  it("returns all profit centers when no filters are provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseProfitCenter, activeProfitCenter]);
+
+    const result = await run(db, {});
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(2);
+    }
+  });
+
+  it("returns profit centers filtered by companyId", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseProfitCenter]);
+
+    const result = await run(db, { companyId: baseProfitCenter.companyId });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0]).toEqual(baseProfitCenter);
+    }
+  });
+
+  it("returns profit centers filtered by status ACTIVE", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([activeProfitCenter]);
+
+    const result = await run(db, { status: "ACTIVE" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0]).toEqual(activeProfitCenter);
+    }
+  });
+
+  it("returns profit centers filtered by status DRAFT", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseProfitCenter]);
+
+    const result = await run(db, { status: "DRAFT" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0].status).toEqual("DRAFT");
+    }
+  });
+
+  it("returns profit centers matching companyId and status filters simultaneously", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([activeProfitCenter]);
+
+    const result = await run(db, {
+      companyId: baseProfitCenter.companyId,
+      status: "ACTIVE",
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toHaveLength(1);
+      expect(result.value.items[0]).toEqual(activeProfitCenter);
+    }
+  });
+
+  it("returns an empty list when no profit centers match the given filters", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, { companyId: "non-existent" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([]);
+    }
+  });
+
+  it("returns error when status filter is invalid", async () => {
+    const { db } = createMockDb<DB>();
+    const result = await run(db, { status: "INVALID" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toBeInstanceOf(InvalidStatusFilterError);
+  });
+});

package/src/modules/accounting/query/listProfitCenters.ts

@@ -0,0 +1,56 @@
+import type { ProfitCenterStatus } from "../generated/enums";
+import type { DB } from "../generated/kysely-tailordb";
+import { InvalidStatusFilterError } from "../lib/errors.generated";
+import {
+  err,
+  ok,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "@tailor-platform/erp-kit/module";
+
+type ProfitCenterOrderByField = "name" | "code" | "createdAt";
+
+export interface ListProfitCentersInput extends PaginationInput<ProfitCenterOrderByField> {
+  companyId?: string;
+  status?: string;
+}
+
+/**
+ * Function: listProfitCenters
+ *
+ * Lists profit centers with optional filter for status.
+ */
+export async function run(db: ReadonlyDB<DB>, input: ListProfitCentersInput) {
+  if (
+    input.status &&
+    !(["DRAFT", "ACTIVE", "INACTIVE"] as const satisfies ProfitCenterStatus[]).includes(
+      input.status as ProfitCenterStatus,
+    )
+  ) {
+    return err(new InvalidStatusFilterError(input.status));
+  }
+
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = input.orderBy ?? "id";
+  const orderDirection = input.orderDirection ?? "asc";
+
+  let query = db.selectFrom("ProfitCenter").selectAll();
+
+  if (input.companyId) {
+    query = query.where("companyId", "=", input.companyId);
+  }
+  if (input.status) {
+    query = query.where("status", "=", input.status as ProfitCenterStatus);
+  }
+
+  const profitCenters = await query
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+
+  return ok(buildPaginatedResult(profitCenters, limit));
+}

package/src/modules/accounting/seed/index.ts

@@ -0,0 +1,19 @@
+// Export seed data maps here.
+// Use PascalCase names matching entity types — `erp-kit app generate seed`
+// discovers exports automatically and writes <ExportName>.jsonl files.
+//
+// Example:
+//
+//   import { uuidv5 } from "../../../shared/uuidv5";
+//   const NS = "erp-kit:<module-name>";
+//
+//   export const entityIds = {
+//     foo: uuidv5(NS, "entity:foo"),
+//   } as const;
+//
+//   const entities: Record<string, SeedRow> = {
+//     [entityIds.foo]: { name: "Foo", ... },
+//   };
+//
+//   // Re-export with PascalCase entity name
+//   export { entities as Entity };

package/src/modules/accounting/tailor.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig, definePlugins } from "@tailor-platform/sdk";
+import { kyselyTypePlugin } from "@tailor-platform/sdk/plugin/kysely-type";
+import { enumConstantsPlugin } from "@tailor-platform/sdk/plugin/enum-constants";
+
+export default defineConfig({
+  name: "accounting",
+  db: { "main-db": { files: [`./db/*.ts`, `./lib/_db_deps.ts`] } },
+});
+
+export const plugins = definePlugins(
+  kyselyTypePlugin({ distPath: `./generated/kysely-tailordb.ts` }),
+  enumConstantsPlugin({ distPath: "./generated/enums.ts" }),
+);