@tailor-platform/erp-kit 0.5.1 → 0.6.0

package/src/modules/manufacturing/query/listBillOfMaterialsByItem.ts

@@ -0,0 +1,58 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { CompanyScopeRequiredError, ParentItemRequiredError } from "../lib/errors.generated";
+import {
+  ok,
+  err,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "@tailor-platform/erp-kit/module";
+
+type OrderByField = "revisionNumber" | "effectivityStartDate";
+
+export interface ListBillOfMaterialsByItemInput extends PaginationInput<OrderByField> {
+  companyId: string;
+  parentItemId: string;
+  siteId?: string;
+  status?: string;
+  bomType?: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: ListBillOfMaterialsByItemInput) {
+  if (!input.companyId) {
+    return err(new CompanyScopeRequiredError("missing"));
+  }
+  if (!input.parentItemId) {
+    return err(new ParentItemRequiredError("missing"));
+  }
+
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = input.orderBy ?? "effectivityStartDate";
+  const orderDirection = input.orderDirection ?? "asc";
+
+  let query = db
+    .selectFrom("BillOfMaterial")
+    .selectAll()
+    .where("companyId", "=", input.companyId)
+    .where("parentItemId", "=", input.parentItemId);
+
+  if (input.siteId) {
+    query = query.where("siteId", "=", input.siteId);
+  }
+  if (input.status) {
+    query = query.where("status", "=", input.status as "DRAFT" | "ACTIVE" | "INACTIVE");
+  }
+  if (input.bomType) {
+    query = query.where("bomType", "=", input.bomType as "MANUFACTURE" | "PHANTOM" | "KIT");
+  }
+
+  const items = await query
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+
+  return ok(buildPaginatedResult(items, limit));
+}

package/src/modules/manufacturing/query/listManufacturingCostSummariesByStatus.generated.ts

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

package/src/modules/manufacturing/query/listManufacturingCostSummariesByStatus.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { basePendingReviewCostSummary, baseReviewedCostSummary } from "../testing/fixtures";
+import { expectOk, expectErr } from "../testing/commandTestUtils";
+import { StatusFilterRequiredError, CompanyScopeRequiredError } from "../lib/errors.generated";
+import { run } from "./listManufacturingCostSummariesByStatus";
+
+describe("listManufacturingCostSummariesByStatus", () => {
+  it("lists pending-review cost summaries for a company", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([basePendingReviewCostSummary]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      status: "PENDING_VARIANCE_REVIEW",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("lists reviewed cost summaries awaiting settlement", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseReviewedCostSummary]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      status: "VARIANCE_REVIEWED",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("filters summaries by site when provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([basePendingReviewCostSummary]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      status: "PENDING_VARIANCE_REVIEW",
+      siteId: "site-1",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("filters summaries by production order when provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([basePendingReviewCostSummary]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      status: "PENDING_VARIANCE_REVIEW",
+      productionOrderId: "production-order-2",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("returns summary rows with production-order and status context", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([basePendingReviewCostSummary, baseReviewedCostSummary]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      status: ["PENDING_VARIANCE_REVIEW", "VARIANCE_REVIEWED"],
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(2);
+  });
+
+  it("returns error when no status filter is provided", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, {
+      companyId: "company-1",
+      status: [],
+    });
+    expectErr(result as never, StatusFilterRequiredError);
+  });
+
+  it("returns error when company scope is missing", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, {
+      companyId: "",
+      status: "PENDING_VARIANCE_REVIEW",
+    });
+    expectErr(result as never, CompanyScopeRequiredError);
+  });
+});

package/src/modules/manufacturing/query/listManufacturingCostSummariesByStatus.ts

@@ -0,0 +1,77 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { StatusFilterRequiredError, CompanyScopeRequiredError } from "../lib/errors.generated";
+import {
+  ok,
+  err,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "@tailor-platform/erp-kit/module";
+
+export interface ListManufacturingCostSummariesByStatusInput extends PaginationInput {
+  companyId: string;
+  status: string | string[];
+  siteId?: string;
+  productionOrderId?: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: ListManufacturingCostSummariesByStatusInput) {
+  if (!input.companyId) {
+    return err(new CompanyScopeRequiredError("companyId"));
+  }
+
+  const statuses = Array.isArray(input.status) ? input.status : input.status ? [input.status] : [];
+  if (statuses.length === 0) {
+    return err(new StatusFilterRequiredError("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("ManufacturingCostSummary")
+    .innerJoin(
+      "ProductionOrder",
+      "ProductionOrder.id",
+      "ManufacturingCostSummary.productionOrderId",
+    )
+    .select([
+      "ManufacturingCostSummary.id",
+      "ManufacturingCostSummary.productionOrderId",
+      "ManufacturingCostSummary.plannedMaterialCost",
+      "ManufacturingCostSummary.plannedLaborCost",
+      "ManufacturingCostSummary.plannedMachineCost",
+      "ManufacturingCostSummary.plannedOverheadCost",
+      "ManufacturingCostSummary.actualMaterialCost",
+      "ManufacturingCostSummary.actualLaborCost",
+      "ManufacturingCostSummary.actualMachineCost",
+      "ManufacturingCostSummary.actualOverheadCost",
+      "ManufacturingCostSummary.currencyCode",
+      "ManufacturingCostSummary.reviewedDate",
+      "ManufacturingCostSummary.reviewerNotes",
+      "ManufacturingCostSummary.status",
+      "ManufacturingCostSummary.createdAt",
+      "ManufacturingCostSummary.updatedAt",
+    ])
+    .where("ProductionOrder.companyId", "=", input.companyId)
+    .where("ManufacturingCostSummary.status", "in", statuses as never[]);
+
+  if (input.siteId) {
+    query = query.where("ProductionOrder.siteId", "=", input.siteId);
+  }
+
+  if (input.productionOrderId) {
+    query = query.where("ManufacturingCostSummary.productionOrderId", "=", input.productionOrderId);
+  }
+
+  const items = await query
+    .orderBy(`ManufacturingCostSummary.${orderBy}` as never, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+
+  return ok(buildPaginatedResult(items, limit));
+}

package/src/modules/manufacturing/query/listProductionOrdersByStatus.generated.ts

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

package/src/modules/manufacturing/query/listProductionOrdersByStatus.test.ts

@@ -0,0 +1,121 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { expectOk, expectErr } from "../testing/commandTestUtils";
+import { baseReleasedProductionOrder, baseInProgressProductionOrder } from "../testing/fixtures";
+import { StatusFilterRequiredError, CompanyScopeRequiredError } from "../lib/errors.generated";
+import { run } from "./listProductionOrdersByStatus";
+
+describe("listProductionOrdersByStatus", () => {
+  it("lists released production orders for a company", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseReleasedProductionOrder]);
+    spies.select.mockReturnValueOnce([
+      { productionOrderId: "production-order-2", status: "COLLECTING" },
+    ]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      status: "RELEASED",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("lists in-progress production orders for a site", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseInProgressProductionOrder]);
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      status: "IN_PROGRESS",
+      siteId: "site-1",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("filters production orders by produced item when provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseReleasedProductionOrder]);
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      status: "RELEASED",
+      orderedItemId: "item-1",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+    expect(items[0]).toMatchObject({ orderedItemId: "item-1" });
+  });
+
+  it("filters production orders by planned date range when provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseReleasedProductionOrder]);
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      status: "RELEASED",
+      plannedStartDateFrom: new Date("2024-01-01T00:00:00.000Z"),
+      plannedStartDateTo: new Date("2024-12-31T23:59:59.000Z"),
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("returns summary fields with site and cost-summary status", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseReleasedProductionOrder]);
+    spies.select.mockReturnValueOnce([
+      { productionOrderId: "production-order-2", status: "COLLECTING" },
+    ]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      status: "RELEASED",
+    });
+    const { items } = expectOk<{
+      items: {
+        siteId: string;
+        status: string;
+        plannedQuantity: number;
+        plannedStartDate: Date;
+        costSummaryStatus: string | null;
+      }[];
+      hasNextPage: boolean;
+    }>(result as never);
+
+    expect(items[0].siteId).toBe("site-1");
+    expect(items[0].status).toBe("RELEASED");
+    expect(items[0].plannedQuantity).toBe(100);
+    expect(items[0].plannedStartDate).toEqual(new Date("2024-03-01T00:00:00.000Z"));
+    expect(items[0].costSummaryStatus).toBe("COLLECTING");
+  });
+
+  it("returns error when no status filter is provided", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, {
+      companyId: "company-1",
+      status: "",
+    });
+    expectErr(result as never, StatusFilterRequiredError);
+  });
+
+  it("returns error when company scope is missing", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, {
+      companyId: "",
+      status: "RELEASED",
+    });
+    expectErr(result as never, CompanyScopeRequiredError);
+  });
+});

package/src/modules/manufacturing/query/listProductionOrdersByStatus.ts

@@ -0,0 +1,83 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { StatusFilterRequiredError, CompanyScopeRequiredError } from "../lib/errors.generated";
+import {
+  ok,
+  err,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "@tailor-platform/erp-kit/module";
+
+export interface ListProductionOrdersByStatusInput extends PaginationInput<"plannedStartDate"> {
+  companyId: string;
+  status: string | string[];
+  siteId?: string;
+  orderedItemId?: string;
+  plannedStartDateFrom?: Date;
+  plannedStartDateTo?: Date;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: ListProductionOrdersByStatusInput) {
+  if (!input.companyId) {
+    return err(new CompanyScopeRequiredError("companyId"));
+  }
+
+  const statuses = Array.isArray(input.status) ? input.status : input.status ? [input.status] : [];
+  if (statuses.length === 0) {
+    return err(new StatusFilterRequiredError("status"));
+  }
+
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = input.orderBy ?? "plannedStartDate";
+  const orderDirection = input.orderDirection ?? "asc";
+
+  let query = db
+    .selectFrom("ProductionOrder")
+    .selectAll()
+    .where("companyId", "=", input.companyId)
+    .where("status", "in", statuses as never[]);
+
+  if (input.siteId) {
+    query = query.where("siteId", "=", input.siteId);
+  }
+
+  if (input.orderedItemId) {
+    query = query.where("orderedItemId", "=", input.orderedItemId);
+  }
+
+  if (input.plannedStartDateFrom) {
+    query = query.where("plannedStartDate", ">=", input.plannedStartDateFrom as never);
+  }
+
+  if (input.plannedStartDateTo) {
+    query = query.where("plannedStartDate", "<=", input.plannedStartDateTo as never);
+  }
+
+  const rows = await query
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+
+  // Fetch linked cost-summary statuses for the returned production orders
+  const orderIds = rows.map((r) => r.id);
+  const costSummaries =
+    orderIds.length > 0
+      ? await db
+          .selectFrom("ManufacturingCostSummary")
+          .select(["productionOrderId", "status"])
+          .where("productionOrderId", "in", orderIds)
+          .execute()
+      : [];
+
+  const costStatusMap = new Map(costSummaries.map((cs) => [cs.productionOrderId, cs.status]));
+
+  const items = rows.map((row) => ({
+    ...row,
+    costSummaryStatus: costStatusMap.get(row.id) ?? null,
+  }));
+
+  return ok(buildPaginatedResult(items, limit));
+}

package/src/modules/manufacturing/query/listRoutingsByItem.generated.ts

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

package/src/modules/manufacturing/query/listRoutingsByItem.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { CompanyScopeRequiredError, ParentItemRequiredError } from "../lib/errors.generated";
+import { baseActiveRouting, baseDraftRouting, baseInactiveRouting } from "../testing/fixtures";
+import { expectOk, expectErr } from "../testing/commandTestUtils";
+import { run } from "./listRoutingsByItem";
+
+describe("listRoutingsByItem", () => {
+  it("lists routing revisions for a produced item", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseActiveRouting, baseDraftRouting]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      parentItemId: "item-1",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(2);
+  });
+
+  it("filters routing revisions by site when provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseActiveRouting]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      parentItemId: "item-1",
+      siteId: "site-1",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("filters routing revisions by status when provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseActiveRouting]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      parentItemId: "item-1",
+      status: "ACTIVE",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("returns all statuses by default", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseActiveRouting, baseDraftRouting, baseInactiveRouting]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      parentItemId: "item-1",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(3);
+  });
+
+  it("returns an empty list when no routings exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      parentItemId: "item-1",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(0);
+  });
+
+  it("returns routing revisions for the requested company scope", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseActiveRouting]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      parentItemId: "item-1",
+    });
+    const { items } = expectOk<{
+      items: { companyId: string }[];
+      hasNextPage: boolean;
+    }>(result as never);
+
+    expect(items).toHaveLength(1);
+    expect(items[0].companyId).toBe("company-1");
+  });
+
+  it("returns error when the parent item reference is missing", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, {
+      companyId: "company-1",
+      parentItemId: "",
+    });
+    expectErr(result as never, ParentItemRequiredError);
+  });
+
+  it("returns error when company scope is missing", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, { companyId: "", parentItemId: "item-1" });
+    expectErr(result as never, CompanyScopeRequiredError);
+  });
+});

package/src/modules/manufacturing/query/listRoutingsByItem.ts

@@ -0,0 +1,54 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { CompanyScopeRequiredError, ParentItemRequiredError } from "../lib/errors.generated";
+import {
+  ok,
+  err,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "@tailor-platform/erp-kit/module";
+
+type OrderByField = "revisionNumber";
+
+export interface ListRoutingsByItemInput extends PaginationInput<OrderByField> {
+  companyId: string;
+  parentItemId: string;
+  siteId?: string;
+  status?: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: ListRoutingsByItemInput) {
+  if (!input.companyId) {
+    return err(new CompanyScopeRequiredError("missing"));
+  }
+  if (!input.parentItemId) {
+    return err(new ParentItemRequiredError("missing"));
+  }
+
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = input.orderBy ?? "revisionNumber";
+  const orderDirection = input.orderDirection ?? "asc";
+
+  let query = db
+    .selectFrom("Routing")
+    .selectAll()
+    .where("companyId", "=", input.companyId)
+    .where("parentItemId", "=", input.parentItemId);
+
+  if (input.siteId) {
+    query = query.where("siteId", "=", input.siteId);
+  }
+  if (input.status) {
+    query = query.where("status", "=", input.status as "DRAFT" | "ACTIVE" | "INACTIVE");
+  }
+
+  const items = await query
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+
+  return ok(buildPaginatedResult(items, limit));
+}

package/src/modules/manufacturing/query/listWorkCentersBySite.generated.ts

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