@tailor-platform/erp-kit 0.5.1 → 0.6.0

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

@@ -0,0 +1,210 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ParentItemNotFoundError,
+  ParentItemNotManufacturedError,
+  InvalidBomTypeError,
+  ComponentLineRequiredError,
+  InvalidComponentQuantityError,
+  ComponentItemInactiveError,
+  BomVersionConflictError,
+} from "../lib/errors.generated";
+import { baseDraftBom, baseBomLine } from "../testing/fixtures";
+import { run } from "./createBillOfMaterial";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("createBillOfMaterial", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["manufacturing:createBillOfMaterial"],
+  };
+
+  const validInput = {
+    parentItemId: "item-1",
+    companyId: "company-1",
+    siteId: null,
+    bomType: "MANUFACTURE",
+    effectivityStartDate: null,
+    effectivityEndDate: null,
+    defaultSelection: true,
+    revisionNumber: "V1",
+    lines: [
+      {
+        itemId: "item-2",
+        requiredQuantity: 2.0,
+        unitOfMeasure: "EA",
+        scrapAssumption: 5.0,
+        isSubassembly: false,
+      },
+    ],
+  };
+
+  it("creates a draft BOM for an active manufactured item", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const createdBom = {
+      ...baseDraftBom,
+      id: "new-bom-id",
+    };
+
+    // parent item exists
+    spies.select.mockReturnValueOnce({ id: "item-1", status: "ACTIVE", isManufacturable: true });
+    // component item exists
+    spies.select.mockReturnValueOnce({ id: "item-2", status: "ACTIVE" });
+    // no existing BOM with same version identity
+    spies.select.mockReturnValueOnce(undefined);
+    // insert BOM
+    spies.insert.mockReturnValueOnce(createdBom);
+    // insert BOM line
+    spies.insert.mockReturnValueOnce({ ...baseBomLine, billOfMaterialId: "new-bom-id" });
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.billOfMaterial.status).toBe("DRAFT");
+      expect(result.value.billOfMaterial.id).toBe("new-bom-id");
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("returns error when the parent item does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // parent item 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(ParentItemNotFoundError);
+    }
+  });
+
+  it("returns error when the parent item is not manufacturable", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // parent item exists but not manufacturable
+    spies.select.mockReturnValueOnce({ id: "item-1", status: "ACTIVE", isManufacturable: false });
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ParentItemNotManufacturedError);
+    }
+  });
+
+  it("returns error when bomType is invalid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // parent item exists
+    spies.select.mockReturnValueOnce({ id: "item-1", status: "ACTIVE", isManufacturable: true });
+
+    const result = await run(db, { ...validInput, bomType: "UNSUPPORTED" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidBomTypeError);
+    }
+  });
+
+  it("returns error when no component lines are provided", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // parent item exists
+    spies.select.mockReturnValueOnce({ id: "item-1", status: "ACTIVE", isManufacturable: true });
+
+    const result = await run(db, { ...validInput, lines: [] }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ComponentLineRequiredError);
+    }
+  });
+
+  it("returns error when a component quantity is not positive", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // parent item exists
+    spies.select.mockReturnValueOnce({ id: "item-1", status: "ACTIVE", isManufacturable: true });
+
+    const result = await run(
+      db,
+      {
+        ...validInput,
+        lines: [{ itemId: "item-2", requiredQuantity: 0, unitOfMeasure: "EA" }],
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidComponentQuantityError);
+    }
+  });
+
+  it("returns error when a component item is inactive", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // parent item exists
+    spies.select.mockReturnValueOnce({ id: "item-1", status: "ACTIVE", isManufacturable: true });
+    // component item not found (treated as inactive)
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ComponentItemInactiveError);
+    }
+  });
+
+  it("returns error when a component item exists but is inactive", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // parent item exists
+    spies.select.mockReturnValueOnce({ id: "item-1", status: "ACTIVE", isManufacturable: true });
+    // component item exists but is inactive
+    spies.select.mockReturnValueOnce({ id: "item-2", isActive: false });
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ComponentItemInactiveError);
+    }
+  });
+
+  it("returns error when the version identity already exists in scope", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // parent item exists
+    spies.select.mockReturnValueOnce({ id: "item-1", status: "ACTIVE", isManufacturable: true });
+    // component item exists
+    spies.select.mockReturnValueOnce({ id: "item-2", status: "ACTIVE" });
+    // existing BOM with same version identity
+    spies.select.mockReturnValueOnce(baseDraftBom);
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(BomVersionConflictError);
+    }
+  });
+
+  it("returns error when the parent item is inactive", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    spies.select.mockReturnValueOnce({ id: "item-1", status: "INACTIVE", isManufacturable: true });
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ParentItemNotManufacturedError);
+    }
+  });
+});

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

@@ -0,0 +1,176 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ParentItemNotFoundError,
+  ParentItemNotManufacturedError,
+  InvalidBomTypeError,
+  ComponentLineRequiredError,
+  InvalidComponentQuantityError,
+  ComponentItemInactiveError,
+  BomVersionConflictError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+const VALID_BOM_TYPES = ["MANUFACTURE", "PHANTOM", "KIT"] as const;
+
+export interface CreateBillOfMaterialLineInput {
+  itemId: string;
+  requiredQuantity: number;
+  unitOfMeasure?: string | null;
+  scrapAssumption?: number | null;
+  isSubassembly?: boolean | null;
+}
+
+export interface CreateBillOfMaterialInput {
+  parentItemId: string;
+  companyId: string;
+  siteId?: string | null;
+  bomType: string;
+  effectivityStartDate?: Date | null;
+  effectivityEndDate?: Date | null;
+  defaultSelection?: boolean | null;
+  revisionNumber?: string | null;
+  lines: CreateBillOfMaterialLineInput[];
+}
+
+/**
+ * Function: createBillOfMaterial
+ *
+ * Creates a draft BOM version for one manufactured parent item at company or
+ * site scope. Establishes the initial bomType, effectivity window,
+ * default-selection intent, and component-line payload.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: CreateBillOfMaterialInput & CF,
+  _ctx: CommandContext,
+) {
+  const {
+    parentItemId,
+    companyId,
+    siteId,
+    bomType,
+    effectivityStartDate,
+    effectivityEndDate,
+    defaultSelection,
+    revisionNumber,
+    lines,
+    ...customFields
+  } = input;
+
+  // 1. Validate parent item exists
+  const parentItem = await db
+    .selectFrom("Item")
+    .selectAll()
+    .where("id", "=", parentItemId)
+    .executeTakeFirst();
+
+  if (!parentItem) {
+    return err(new ParentItemNotFoundError(parentItemId));
+  }
+
+  // 2. Validate parent item is active and manufacturable.
+  const parentItemRecord = parentItem as Record<string, unknown>;
+  const isInactive =
+    ("status" in parentItemRecord && parentItemRecord.status !== "ACTIVE") ||
+    ("isActive" in parentItemRecord && parentItemRecord.isActive === false);
+  const isNotManufacturable =
+    "isManufacturable" in parentItemRecord && parentItemRecord.isManufacturable === false;
+
+  if (isInactive || isNotManufacturable) {
+    return err(new ParentItemNotManufacturedError(parentItemId));
+  }
+
+  // 3. Validate bomType
+  if (!VALID_BOM_TYPES.includes(bomType as (typeof VALID_BOM_TYPES)[number])) {
+    return err(new InvalidBomTypeError(parentItemId));
+  }
+
+  // 4. Validate at least one component line
+  if (!lines || lines.length === 0) {
+    return err(new ComponentLineRequiredError(parentItemId));
+  }
+
+  // 5. Validate each component line
+  for (const line of lines) {
+    if (line.requiredQuantity <= 0) {
+      return err(new InvalidComponentQuantityError(line.itemId));
+    }
+
+    // Check component item is not inactive (exists in Item table)
+    const componentItem = await db
+      .selectFrom("Item")
+      .selectAll()
+      .where("id", "=", line.itemId)
+      .executeTakeFirst();
+
+    if (!componentItem) {
+      return err(new ComponentItemInactiveError(line.itemId));
+    }
+
+    // Check component item is active
+    if ("isActive" in componentItem && componentItem.isActive === false) {
+      return err(new ComponentItemInactiveError(line.itemId));
+    }
+    if ("status" in componentItem && componentItem.status === "INACTIVE") {
+      return err(new ComponentItemInactiveError(line.itemId));
+    }
+  }
+
+  // 6. Check version identity uniqueness within same parent item and scope
+  const existingBomQuery = db
+    .selectFrom("BillOfMaterial")
+    .selectAll()
+    .where("parentItemId", "=", parentItemId)
+    .where("companyId", "=", companyId);
+
+  const existingBom = await (
+    siteId ? existingBomQuery.where("siteId", "=", siteId) : existingBomQuery
+  )
+    .where("revisionNumber", "=", revisionNumber ?? null)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (existingBom) {
+    return err(new BomVersionConflictError(parentItemId));
+  }
+
+  // 7. Create draft BOM
+  const billOfMaterial = await db
+    .insertInto("BillOfMaterial")
+    .values({
+      ...(customFields as Record<string, unknown>),
+      parentItemId,
+      companyId,
+      siteId: siteId ?? null,
+      bomType: bomType as "MANUFACTURE" | "PHANTOM" | "KIT",
+      effectivityStartDate: effectivityStartDate ?? null,
+      effectivityEndDate: effectivityEndDate ?? null,
+      defaultSelection: defaultSelection ?? null,
+      revisionNumber: revisionNumber ?? null,
+      status: "DRAFT",
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  // 8. Create component lines
+  for (const line of lines) {
+    await db
+      .insertInto("BillOfMaterialLine")
+      .values({
+        billOfMaterialId: billOfMaterial!.id,
+        itemId: line.itemId,
+        requiredQuantity: line.requiredQuantity,
+        unitOfMeasure: line.unitOfMeasure ?? null,
+        scrapAssumption: line.scrapAssumption ?? null,
+        isSubassembly: line.isSubassembly ?? null,
+        createdAt: new Date(),
+        updatedAt: null,
+      })
+      .returningAll()
+      .executeTakeFirst();
+  }
+
+  return ok({ billOfMaterial: billOfMaterial! });
+}

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

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

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);