@tailor-platform/erp-kit 0.5.0 → 0.6.0

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

@@ -0,0 +1,81 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { SiteScopeRequiredError } from "../lib/errors.generated";
+import { baseActiveWorkCenter, baseDraftWorkCenter } from "../testing/fixtures";
+import { expectOk, expectErr } from "../testing/commandTestUtils";
+import { run } from "./listWorkCentersBySite";
+
+describe("listWorkCentersBySite", () => {
+  it("lists work centers for a site", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseActiveWorkCenter, baseDraftWorkCenter]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      siteId: "site-1",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(2);
+  });
+
+  it("filters work centers by status when provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseActiveWorkCenter]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      siteId: "site-1",
+      status: "ACTIVE",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("filters work centers by work-center type and accepts name ordering", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([{ ...baseActiveWorkCenter, name: "Assembly Cell A" }]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      siteId: "site-1",
+      workCenterType: "ASSEMBLY",
+      orderBy: "name",
+    });
+    const { items } = expectOk<{ items: { code: string }[]; hasNextPage: boolean }>(
+      result as never,
+    );
+
+    expect(items).toHaveLength(1);
+    expect(items[0].code).toBe(baseActiveWorkCenter.code);
+  });
+
+  it("returns an empty list when the site has no work centers", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      siteId: "site-1",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(0);
+  });
+
+  it("returns error when company scope is missing", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, { companyId: "", siteId: "site-1" });
+    expectErr(result as never, SiteScopeRequiredError);
+  });
+
+  it("returns error when site scope is missing", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, { companyId: "company-1", siteId: "" });
+    expectErr(result as never, SiteScopeRequiredError);
+  });
+});

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

@@ -0,0 +1,70 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { SiteScopeRequiredError } from "../lib/errors.generated";
+import {
+  ok,
+  err,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "@tailor-platform/erp-kit/module";
+
+type OrderByField = "code" | "name";
+
+export interface ListWorkCentersBySiteInput extends PaginationInput<OrderByField> {
+  companyId: string;
+  siteId: string;
+  status?: string;
+  workCenterType?: string;
+}
+
+/**
+ * Function: listWorkCentersBySite
+ *
+ * Lists work centers for one company and site with optional status or
+ * work-center-type filters and code/name ordering.
+ */
+export async function run(db: ReadonlyDB<DB>, input: ListWorkCentersBySiteInput) {
+  if (!input.companyId || !input.siteId) {
+    return err(new SiteScopeRequiredError(input.companyId ?? input.siteId ?? "missing"));
+  }
+
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = (input.orderBy ?? "code") as "code" | "name";
+  const orderDirection = input.orderDirection ?? "asc";
+
+  let query = db
+    .selectFrom("WorkCenter")
+    .selectAll()
+    .where("companyId", "=", input.companyId)
+    .where("siteId", "=", input.siteId);
+
+  if (input.status) {
+    query = query.where("status", "=", input.status as "DRAFT" | "ACTIVE" | "INACTIVE");
+  }
+
+  if (input.workCenterType) {
+    query = (query as never as { where: (...args: unknown[]) => typeof query }).where(
+      "workCenterType",
+      "=",
+      input.workCenterType,
+    );
+  }
+
+  const items = await (
+    query as never as {
+      orderBy: (...args: unknown[]) => {
+        limit: (...args: unknown[]) => {
+          offset: (...args: unknown[]) => { execute: () => Promise<unknown[]> };
+        };
+      };
+    }
+  )
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+
+  return ok(buildPaginatedResult(items, limit));
+}

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

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

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

@@ -0,0 +1,102 @@
+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 { basePendingWorkOrder, baseInProgressWorkOrder } from "../testing/fixtures";
+import { ProductionOrderReferenceRequiredError } from "../lib/errors.generated";
+import { run } from "./listWorkOrdersByProductionOrder";
+
+describe("listWorkOrdersByProductionOrder", () => {
+  it("lists work orders for a production order in sequence order", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const workOrder20 = {
+      ...basePendingWorkOrder,
+      id: "work-order-20",
+      routingOperationSequenceNumber: 20,
+    };
+    spies.select.mockReturnValueOnce([basePendingWorkOrder, workOrder20]);
+
+    const result = await run(db, {
+      productionOrderId: "production-order-2",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(2);
+    expect(items[0]).toEqual(basePendingWorkOrder);
+    expect(items[1]).toEqual(workOrder20);
+  });
+
+  it("filters work orders by status when provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseInProgressWorkOrder]);
+
+    const result = await run(db, {
+      productionOrderId: "production-order-2",
+      status: "IN_PROGRESS",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+    expect(items[0]).toEqual(baseInProgressWorkOrder);
+  });
+
+  it("filters work orders by work center when provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([basePendingWorkOrder]);
+
+    const result = await run(db, {
+      productionOrderId: "production-order-2",
+      workCenterId: "work-center-2",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+    expect(items[0]).toEqual(basePendingWorkOrder);
+  });
+
+  it("returns summary fields with sequence and progress data", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseInProgressWorkOrder]);
+
+    const result = await run(db, {
+      productionOrderId: "production-order-2",
+    });
+    const { items } = expectOk<{
+      items: {
+        routingOperationSequenceNumber: number;
+        completedQuantity: number;
+        plannedQuantity: number;
+      }[];
+      hasNextPage: boolean;
+    }>(result as never);
+
+    expect(items[0].routingOperationSequenceNumber).toBe(10);
+    expect(items[0].completedQuantity).toBe(50);
+    expect(items[0].plannedQuantity).toBe(100);
+  });
+
+  it("returns an empty list when no work orders exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, {
+      productionOrderId: "production-order-2",
+    });
+    const { items, hasNextPage } = expectOk<{
+      items: unknown[];
+      hasNextPage: boolean;
+    }>(result as never);
+
+    expect(items).toHaveLength(0);
+    expect(hasNextPage).toBe(false);
+  });
+
+  it("returns error when the production-order reference is missing", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, {
+      productionOrderId: "",
+    });
+    expectErr(result as never, ProductionOrderReferenceRequiredError);
+  });
+});

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

@@ -0,0 +1,53 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ProductionOrderReferenceRequiredError } from "../lib/errors.generated";
+import {
+  ok,
+  err,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "@tailor-platform/erp-kit/module";
+
+type OrderByField = "routingOperationSequenceNumber";
+
+export interface ListWorkOrdersByProductionOrderInput extends PaginationInput<OrderByField> {
+  productionOrderId: string;
+  status?: string;
+  workCenterId?: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: ListWorkOrdersByProductionOrderInput) {
+  if (!input.productionOrderId) {
+    return err(new ProductionOrderReferenceRequiredError("missing"));
+  }
+
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = input.orderBy ?? "routingOperationSequenceNumber";
+  const orderDirection = input.orderDirection ?? "asc";
+
+  let query = db
+    .selectFrom("WorkOrder")
+    .selectAll()
+    .where("productionOrderId", "=", input.productionOrderId);
+
+  if (input.status) {
+    query = query.where(
+      "status",
+      "=",
+      input.status as "PENDING" | "IN_PROGRESS" | "PAUSED" | "COMPLETE" | "CANCELLED",
+    );
+  }
+  if (input.workCenterId) {
+    query = query.where("workCenterId", "=", input.workCenterId);
+  }
+
+  const items = await query
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+
+  return ok(buildPaginatedResult(items, limit));
+}

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

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

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

@@ -0,0 +1,143 @@
+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 {
+  basePendingWorkOrder,
+  baseInProgressWorkOrder,
+  baseActiveWorkCenter,
+} from "../testing/fixtures";
+import { WorkCenterReferenceRequiredError, WorkCenterNotFoundError } from "../lib/errors.generated";
+import { run } from "./listWorkOrdersByWorkCenter";
+
+describe("listWorkOrdersByWorkCenter", () => {
+  it("lists pending and in-progress work orders for one work center across multiple production orders", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const workOrderFromAnotherPO = {
+      ...basePendingWorkOrder,
+      id: "work-order-10",
+      productionOrderId: "production-order-3",
+    };
+    // 1st select: WorkCenter lookup
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+    // 2nd select: WorkOrder list
+    spies.select.mockReturnValueOnce([
+      basePendingWorkOrder,
+      baseInProgressWorkOrder,
+      workOrderFromAnotherPO,
+    ]);
+
+    const result = await run(db, {
+      workCenterId: "work-center-2",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(3);
+  });
+
+  it("filters work orders by status when provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    // 1st select: WorkCenter lookup
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+    // 2nd select: WorkOrder list filtered by status
+    spies.select.mockReturnValueOnce([baseInProgressWorkOrder]);
+
+    const result = await run(db, {
+      workCenterId: "work-center-2",
+      status: "IN_PROGRESS",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+    expect(items[0]).toEqual(baseInProgressWorkOrder);
+  });
+
+  it("orders the result for bottleneck review by execution priority and planned timing", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const workOrderSeq20 = {
+      ...basePendingWorkOrder,
+      id: "work-order-20",
+      routingOperationSequenceNumber: 20,
+    };
+    // 1st select: WorkCenter lookup
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+    // 2nd select: WorkOrder list ordered by routingOperationSequenceNumber asc
+    spies.select.mockReturnValueOnce([basePendingWorkOrder, workOrderSeq20]);
+
+    const result = await run(db, {
+      workCenterId: "work-center-2",
+    });
+    const { items } = expectOk<{
+      items: { routingOperationSequenceNumber: number }[];
+      hasNextPage: boolean;
+    }>(result as never);
+
+    expect(items[0].routingOperationSequenceNumber).toBe(10);
+    expect(items[1].routingOperationSequenceNumber).toBe(20);
+  });
+
+  it("returns summary fields with production-order reference operation sequence and progress totals", async () => {
+    const { db, spies } = createMockDb<DB>();
+    // 1st select: WorkCenter lookup
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+    // 2nd select: WorkOrder list
+    spies.select.mockReturnValueOnce([baseInProgressWorkOrder]);
+
+    const result = await run(db, {
+      workCenterId: "work-center-2",
+    });
+    const { items } = expectOk<{
+      items: {
+        productionOrderId: string;
+        routingOperationSequenceNumber: number;
+        completedQuantity: number;
+        plannedQuantity: number;
+      }[];
+      hasNextPage: boolean;
+    }>(result as never);
+
+    expect(items[0].productionOrderId).toBe("production-order-2");
+    expect(items[0].routingOperationSequenceNumber).toBe(10);
+    expect(items[0].completedQuantity).toBe(50);
+    expect(items[0].plannedQuantity).toBe(100);
+  });
+
+  it("returns an empty list when the work center has no assigned work orders", async () => {
+    const { db, spies } = createMockDb<DB>();
+    // 1st select: WorkCenter lookup
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+    // 2nd select: empty WorkOrder list
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, {
+      workCenterId: "work-center-2",
+    });
+    const { items, hasNextPage } = expectOk<{
+      items: unknown[];
+      hasNextPage: boolean;
+    }>(result as never);
+
+    expect(items).toHaveLength(0);
+    expect(hasNextPage).toBe(false);
+  });
+
+  it("returns error when the work-center reference is missing", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, {
+      workCenterId: "",
+    });
+    expectErr(result as never, WorkCenterReferenceRequiredError);
+  });
+
+  it("returns error when the work center does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    // 1st select: WorkCenter lookup returns undefined
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, {
+      workCenterId: "nonexistent-wc",
+    });
+    expectErr(result as never, WorkCenterNotFoundError);
+  });
+});

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

@@ -0,0 +1,56 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { WorkCenterReferenceRequiredError, WorkCenterNotFoundError } from "../lib/errors.generated";
+import {
+  ok,
+  err,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "@tailor-platform/erp-kit/module";
+
+type OrderByField = "routingOperationSequenceNumber";
+
+export interface ListWorkOrdersByWorkCenterInput extends PaginationInput<OrderByField> {
+  workCenterId: string;
+  status?: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: ListWorkOrdersByWorkCenterInput) {
+  if (!input.workCenterId) {
+    return err(new WorkCenterReferenceRequiredError("missing"));
+  }
+
+  const workCenter = await db
+    .selectFrom("WorkCenter")
+    .selectAll()
+    .where("id", "=", input.workCenterId)
+    .executeTakeFirst();
+
+  if (!workCenter) {
+    return err(new WorkCenterNotFoundError(input.workCenterId));
+  }
+
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = input.orderBy ?? "routingOperationSequenceNumber";
+  const orderDirection = input.orderDirection ?? "asc";
+
+  let query = db.selectFrom("WorkOrder").selectAll().where("workCenterId", "=", input.workCenterId);
+
+  if (input.status) {
+    query = query.where(
+      "status",
+      "=",
+      input.status as "PENDING" | "IN_PROGRESS" | "PAUSED" | "COMPLETE" | "CANCELLED",
+    );
+  }
+
+  const items = await query
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+
+  return ok(buildPaginatedResult(items, limit));
+}

package/src/modules/manufacturing/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/manufacturing/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: "manufacturing",
+  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" }),
+);

package/src/modules/manufacturing/tailor.d.ts

@@ -0,0 +1,13 @@
+// This file is auto-generated by @tailor-platform/sdk
+// Do not edit this file manually
+// Regenerated automatically when running 'tailor-sdk apply' or 'tailor-sdk generate'
+
+declare module "@tailor-platform/sdk" {
+  interface AttributeMap {}
+  interface AttributeList {
+    __tuple?: [];
+  }
+  interface Env {}
+}
+
+export {};

package/src/modules/manufacturing/testing/commandTestUtils.ts

@@ -0,0 +1,29 @@
+import { expect } from "vitest";
+
+interface OkResult<T> {
+  ok: true;
+  value: T;
+}
+
+interface ErrResult {
+  ok: false;
+  error: unknown;
+}
+
+export function expectErr(
+  result: OkResult<unknown> | ErrResult,
+  errorClass: abstract new (...args: never[]) => Error,
+) {
+  expect(result.ok).toBe(false);
+  if (!result.ok) {
+    expect(result.error).toBeInstanceOf(errorClass);
+  }
+}
+
+export function expectOk<T>(result: OkResult<T> | ErrResult) {
+  expect(result.ok).toBe(true);
+  if (!result.ok) {
+    throw result.error;
+  }
+  return result.value;
+}