@tailor-platform/erp-kit 0.5.1 → 0.7.0

package/src/modules/manufacturing/command/createProductionOrder.test.ts

@@ -0,0 +1,160 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ProductionItemNotFoundError,
+  ProductionItemNotManufacturableError,
+  InvalidPlannedQuantityError,
+  InvalidSiteScopeError,
+  CrossScopeMasterReferenceError,
+} from "../lib/errors.generated";
+import { baseDraftProductionOrder, baseActiveBom, baseActiveRouting } from "../testing/fixtures";
+import { run } from "./createProductionOrder";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("createProductionOrder", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["manufacturing:createProductionOrder"],
+  };
+
+  const validInput = {
+    orderedItemId: "item-1",
+    companyId: "company-1",
+    siteId: "site-1",
+    plannedQuantity: 100,
+    plannedStartDate: new Date("2024-03-01T00:00:00.000Z"),
+    plannedEndDate: new Date("2024-03-15T00:00:00.000Z"),
+  };
+
+  it("creates a draft production order for a manufacturable item", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const createdOrder = {
+      ...baseDraftProductionOrder,
+      id: "new-order-id",
+    };
+
+    // item lookup
+    spies.select.mockReturnValueOnce({ id: "item-1" });
+    // site lookup
+    spies.select.mockReturnValueOnce({ id: "site-1" });
+    // insert
+    spies.insert.mockReturnValue(createdOrder);
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.productionOrder.status).toBe("DRAFT");
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("returns error when the produced item does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // item lookup returns undefined
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ProductionItemNotFoundError);
+    }
+  });
+
+  it("returns error when the produced item is not manufacturable", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // item exists but not manufacturable
+    spies.select.mockReturnValueOnce({ id: "item-1", isManufacturable: false });
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ProductionItemNotManufacturableError);
+    }
+  });
+
+  it("returns error when planned quantity is not positive", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(db, { ...validInput, plannedQuantity: 0 }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidPlannedQuantityError);
+    }
+  });
+
+  it("returns error when site scope is inconsistent with company", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(db, { ...validInput, siteId: "" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidSiteScopeError);
+    }
+  });
+
+  it("returns error when site does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // item lookup
+    spies.select.mockReturnValueOnce({ id: "item-1" });
+    // site lookup returns undefined
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidSiteScopeError);
+    }
+  });
+
+  it("returns error when an optional BOM reference is outside scope", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const crossScopeBom = { ...baseActiveBom, companyId: "other-company" };
+
+    // item lookup
+    spies.select.mockReturnValueOnce({ id: "item-1" });
+    // site lookup
+    spies.select.mockReturnValueOnce({ id: "site-1" });
+    // bom lookup
+    spies.select.mockReturnValueOnce(crossScopeBom);
+
+    const result = await run(db, { ...validInput, selectedBomVersionId: crossScopeBom.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CrossScopeMasterReferenceError);
+    }
+  });
+
+  it("returns error when an optional routing reference is outside scope", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const crossScopeRouting = { ...baseActiveRouting, companyId: "other-company" };
+
+    // item lookup
+    spies.select.mockReturnValueOnce({ id: "item-1" });
+    // site lookup
+    spies.select.mockReturnValueOnce({ id: "site-1" });
+    // routing lookup
+    spies.select.mockReturnValueOnce(crossScopeRouting);
+
+    const result = await run(
+      db,
+      { ...validInput, selectedRoutingRevisionId: crossScopeRouting.id },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CrossScopeMasterReferenceError);
+    }
+  });
+});

package/src/modules/manufacturing/command/createProductionOrder.ts

@@ -0,0 +1,129 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ProductionItemNotFoundError,
+  ProductionItemNotManufacturableError,
+  InvalidPlannedQuantityError,
+  InvalidSiteScopeError,
+  CrossScopeMasterReferenceError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface CreateProductionOrderInput {
+  orderedItemId: string;
+  companyId: string;
+  siteId: string;
+  plannedQuantity: number;
+  plannedStartDate: Date;
+  plannedEndDate: Date;
+  selectedBomVersionId?: string | null;
+  selectedRoutingRevisionId?: string | null;
+}
+
+/**
+ * Function: createProductionOrder
+ *
+ * Creates a draft manufacturing request with produced item, quantity, site,
+ * and planned dates. Records planner intent without freezing BOM, routing,
+ * work orders, or cost assumptions.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: CreateProductionOrderInput & CF,
+  _ctx: CommandContext,
+) {
+  const {
+    orderedItemId,
+    companyId,
+    siteId,
+    plannedQuantity,
+    plannedStartDate,
+    plannedEndDate,
+    selectedBomVersionId,
+    selectedRoutingRevisionId,
+    ...customFields
+  } = input;
+
+  // 1. Validate planned quantity > 0
+  if (plannedQuantity <= 0) {
+    return err(new InvalidPlannedQuantityError(orderedItemId));
+  }
+
+  // 2. Validate scope
+  if (!companyId || !siteId) {
+    return err(new InvalidSiteScopeError(orderedItemId));
+  }
+
+  // 3. Validate produced item exists
+  const item = await db
+    .selectFrom("Item")
+    .selectAll()
+    .where("id", "=", orderedItemId)
+    .executeTakeFirst();
+
+  if (!item) {
+    return err(new ProductionItemNotFoundError(orderedItemId));
+  }
+
+  // 4. Validate item is manufacturable
+  if (item && "isManufacturable" in item && item.isManufacturable === false) {
+    return err(new ProductionItemNotManufacturableError(orderedItemId));
+  }
+
+  // 5. Validate site belongs to company scope
+  const site = await db.selectFrom("Site").selectAll().where("id", "=", siteId).executeTakeFirst();
+
+  if (!site) {
+    return err(new InvalidSiteScopeError(orderedItemId));
+  }
+
+  // 5. Validate optional BOM reference scope
+  if (selectedBomVersionId) {
+    const bom = await db
+      .selectFrom("BillOfMaterial")
+      .selectAll()
+      .where("id", "=", selectedBomVersionId)
+      .executeTakeFirst();
+
+    if (bom && (bom.companyId !== companyId || (bom.siteId != null && bom.siteId !== siteId))) {
+      return err(new CrossScopeMasterReferenceError(orderedItemId));
+    }
+  }
+
+  // 6. Validate optional routing reference scope
+  if (selectedRoutingRevisionId) {
+    const routing = await db
+      .selectFrom("Routing")
+      .selectAll()
+      .where("id", "=", selectedRoutingRevisionId)
+      .executeTakeFirst();
+
+    if (
+      routing &&
+      (routing.companyId !== companyId || (routing.siteId != null && routing.siteId !== siteId))
+    ) {
+      return err(new CrossScopeMasterReferenceError(orderedItemId));
+    }
+  }
+
+  // 7. Create draft production order
+  const productionOrder = await db
+    .insertInto("ProductionOrder")
+    .values({
+      ...(customFields as Record<string, unknown>),
+      orderedItemId,
+      companyId,
+      siteId,
+      plannedQuantity,
+      plannedStartDate,
+      plannedEndDate,
+      selectedBomVersionId: selectedBomVersionId ?? null,
+      selectedRoutingRevisionId: selectedRoutingRevisionId ?? null,
+      status: "DRAFT",
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ productionOrder: productionOrder! });
+}

package/src/modules/manufacturing/command/createRouting.generated.ts

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

package/src/modules/manufacturing/command/createRouting.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  RoutingItemNotFoundError,
+  OperationRequiredError,
+  DuplicateOperationSequenceError,
+  InvalidStandardTimeError,
+  WorkCenterNotFoundError,
+  CrossCompanyWorkCenterError,
+} from "../lib/errors.generated";
+import { baseDraftRouting, baseActiveWorkCenter } from "../testing/fixtures";
+import { run } from "./createRouting";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("createRouting", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["manufacturing:createRouting"],
+  };
+
+  const validOperations = [
+    {
+      sequenceNumber: 10,
+      operationDescription: "Assembly step",
+      workCenterId: "work-center-2",
+      standardSetupTime: 30,
+      standardRunTime: 60,
+      operatorInstructions: null,
+    },
+    {
+      sequenceNumber: 20,
+      operationDescription: "Quality check",
+      workCenterId: "work-center-2",
+      standardSetupTime: 10,
+      standardRunTime: 15,
+      operatorInstructions: null,
+    },
+  ];
+
+  const validInput = {
+    parentItemId: "item-1",
+    companyId: "company-1",
+    siteId: null,
+    revisionNumber: "R1",
+    operations: validOperations,
+  };
+
+  it("creates a draft routing with ordered operations", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Item lookup
+    spies.select.mockReturnValueOnce({ id: "item-1" });
+    // select: WorkCenter lookup for op 1
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+    // select: WorkCenter lookup for op 2
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+    // insert: Routing
+    spies.insert.mockReturnValue(baseDraftRouting);
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.routing.status).toBe("DRAFT");
+      expect(result.value.routing.parentItemId).toBe("item-1");
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("returns error when no operations are provided", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Item lookup
+    spies.select.mockReturnValueOnce({ id: "item-1" });
+
+    const result = await run(db, { ...validInput, operations: [] }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(OperationRequiredError);
+    }
+  });
+
+  it("returns error when two operations share the same sequence", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Item lookup
+    spies.select.mockReturnValueOnce({ id: "item-1" });
+
+    const duplicateOps = [
+      { ...validOperations[0], sequenceNumber: 10 },
+      { ...validOperations[1], sequenceNumber: 10 },
+    ];
+
+    const result = await run(db, { ...validInput, operations: duplicateOps }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateOperationSequenceError);
+    }
+  });
+
+  it("returns error when a standard time is negative", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Item lookup
+    spies.select.mockReturnValueOnce({ id: "item-1" });
+
+    const badOps = [{ ...validOperations[0], standardSetupTime: -5 }];
+
+    const result = await run(db, { ...validInput, operations: badOps }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStandardTimeError);
+    }
+  });
+
+  it("returns error when a referenced work center does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Item lookup
+    spies.select.mockReturnValueOnce({ id: "item-1" });
+    // select: WorkCenter lookup - not found
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(WorkCenterNotFoundError);
+    }
+  });
+
+  it("returns error when a work center is outside the routing company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Item lookup
+    spies.select.mockReturnValueOnce({ id: "item-1" });
+    // select: WorkCenter lookup - different company
+    spies.select.mockReturnValueOnce({
+      ...baseActiveWorkCenter,
+      companyId: "other-company",
+    });
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CrossCompanyWorkCenterError);
+    }
+  });
+
+  it("returns error when parent item does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // select: Item lookup - not found
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(RoutingItemNotFoundError);
+    }
+  });
+});

package/src/modules/manufacturing/command/createRouting.ts

@@ -0,0 +1,128 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  RoutingItemNotFoundError,
+  OperationRequiredError,
+  DuplicateOperationSequenceError,
+  InvalidStandardTimeError,
+  WorkCenterNotFoundError,
+  CrossCompanyWorkCenterError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface CreateRoutingOperationInput {
+  sequenceNumber: number;
+  operationDescription?: string | null;
+  workCenterId: string;
+  standardSetupTime: number;
+  standardRunTime: number;
+  operatorInstructions?: string | null;
+}
+
+export interface CreateRoutingInput {
+  parentItemId: string;
+  companyId: string;
+  siteId?: string | null;
+  revisionNumber?: string | null;
+  operations: CreateRoutingOperationInput[];
+}
+
+/**
+ * Function: createRouting
+ *
+ * Creates a new routing in DRAFT status with ordered operations.
+ * Validates parent item existence, operation sequence uniqueness,
+ * standard times, and work center references.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: CreateRoutingInput & CF,
+  _ctx: CommandContext,
+) {
+  const { parentItemId, companyId, siteId, revisionNumber, operations, ...customFields } = input;
+
+  // 1. Validate parent item exists
+  const parentItem = await db
+    .selectFrom("Item")
+    .selectAll()
+    .where("id", "=", parentItemId)
+    .executeTakeFirst();
+
+  if (!parentItem) {
+    return err(new RoutingItemNotFoundError(parentItemId));
+  }
+
+  // 2. Validate at least one operation
+  if (!operations || operations.length === 0) {
+    return err(new OperationRequiredError(parentItemId));
+  }
+
+  // 3. Validate unique sequence numbers
+  const seqNumbers = operations.map((op) => op.sequenceNumber);
+  const uniqueSeqs = new Set(seqNumbers);
+  if (uniqueSeqs.size !== seqNumbers.length) {
+    return err(new DuplicateOperationSequenceError(parentItemId));
+  }
+
+  // 4. Validate standard times >= 0
+  for (const op of operations) {
+    if (op.standardSetupTime < 0 || op.standardRunTime < 0) {
+      return err(new InvalidStandardTimeError(parentItemId));
+    }
+  }
+
+  // 5. Validate work centers exist and belong to same company
+  for (const op of operations) {
+    const workCenter = await db
+      .selectFrom("WorkCenter")
+      .selectAll()
+      .where("id", "=", op.workCenterId)
+      .executeTakeFirst();
+
+    if (!workCenter) {
+      return err(new WorkCenterNotFoundError(op.workCenterId));
+    }
+
+    if (workCenter.companyId !== companyId) {
+      return err(new CrossCompanyWorkCenterError(op.workCenterId));
+    }
+  }
+
+  // 6. Create routing in DRAFT status
+  const routing = await db
+    .insertInto("Routing")
+    .values({
+      ...(customFields as Record<string, unknown>),
+      parentItemId,
+      companyId,
+      siteId: siteId ?? null,
+      revisionNumber: revisionNumber ?? null,
+      status: "DRAFT",
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  // 7. Create routing operations
+  const createdOperations = [];
+  for (const op of operations) {
+    const operation = await db
+      .insertInto("RoutingOperation")
+      .values({
+        routingId: routing!.id,
+        sequenceNumber: op.sequenceNumber,
+        operationDescription: op.operationDescription ?? null,
+        workCenterId: op.workCenterId,
+        standardSetupTime: op.standardSetupTime,
+        standardRunTime: op.standardRunTime,
+        operatorInstructions: op.operatorInstructions ?? null,
+        createdAt: new Date(),
+        updatedAt: null,
+      })
+      .returningAll()
+      .executeTakeFirst();
+    createdOperations.push(operation!);
+  }
+
+  return ok({ routing: routing!, operations: createdOperations });
+}

package/src/modules/manufacturing/command/createWorkCenter.generated.ts

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