@tailor-platform/erp-kit 0.5.1 → 0.6.0

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

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

@@ -0,0 +1,148 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  InvalidScopeError,
+  DuplicateWorkCenterCodeError,
+  InvalidCapacityError,
+  InvalidRateError,
+  InvalidOverheadMethodError,
+  OverheadCurrencyRequiredError,
+} from "../lib/errors.generated";
+import { baseDraftWorkCenter } from "../testing/fixtures";
+import { run } from "./createWorkCenter";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("createWorkCenter", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["manufacturing:createWorkCenter"],
+  };
+
+  const validInput = {
+    code: "WC-NEW",
+    companyId: "company-1",
+    siteId: "site-1",
+    capacityAssumptions: 100,
+    laborRate: 25.0,
+    machineRate: 50.0,
+    calendarReference: "cal-standard",
+  };
+
+  it("creates a draft work center with positive capacity", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const createdWorkCenter = {
+      ...baseDraftWorkCenter,
+      id: "new-wc-id",
+      code: "WC-NEW",
+    };
+
+    spies.select.mockReturnValueOnce(undefined);
+    spies.insert.mockReturnValue(createdWorkCenter);
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.workCenter.status).toBe("DRAFT");
+      expect(result.value.workCenter.code).toBe("WC-NEW");
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("returns error when scope is missing", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(db, { ...validInput, companyId: "" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidScopeError);
+    }
+  });
+
+  it("creates a draft work center without siteId when not required", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const createdWorkCenter = {
+      ...baseDraftWorkCenter,
+      id: "new-wc-id",
+      code: "WC-NEW",
+      siteId: null,
+    };
+
+    spies.select.mockReturnValueOnce(undefined);
+    spies.insert.mockReturnValue(createdWorkCenter);
+
+    const result = await run(db, { ...validInput, siteId: null }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.workCenter.status).toBe("DRAFT");
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("returns error when the code already exists in scope", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseDraftWorkCenter);
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateWorkCenterCodeError);
+    }
+  });
+
+  it("returns error when capacity is not positive", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(db, { ...validInput, capacityAssumptions: 0 }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidCapacityError);
+    }
+  });
+
+  it("returns error when a rate is negative", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(db, { ...validInput, laborRate: -1 }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidRateError);
+    }
+  });
+
+  it("returns error when overhead method is invalid", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(db, { ...validInput, overheadAbsorptionMethod: "UNSUPPORTED" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidOverheadMethodError);
+    }
+  });
+
+  it("returns error when fixed-amount overhead omits currency", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(
+      db,
+      {
+        ...validInput,
+        overheadAbsorptionMethod: "FIXED_AMOUNT_PER_GOOD_UNIT",
+        overheadAbsorptionCurrency: null,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(OverheadCurrencyRequiredError);
+    }
+  });
+});

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

@@ -0,0 +1,131 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  InvalidScopeError,
+  DuplicateWorkCenterCodeError,
+  InvalidCapacityError,
+  InvalidRateError,
+  InvalidOverheadMethodError,
+  OverheadCurrencyRequiredError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+const VALID_OVERHEAD_METHODS = [
+  "PERCENT_OF_LABOR_COST",
+  "PERCENT_OF_MACHINE_COST",
+  "FIXED_AMOUNT_PER_GOOD_UNIT",
+] as const;
+
+export interface CreateWorkCenterInput {
+  code: string;
+  companyId: string;
+  siteId?: string | null;
+  capacityAssumptions: number;
+  laborRate?: number | null;
+  machineRate?: number | null;
+  calendarReference?: string | null;
+  overheadAbsorptionMethod?: string | null;
+  overheadAbsorptionCurrency?: string | null;
+}
+
+/**
+ * Function: createWorkCenter
+ *
+ * Creates a new work center in DRAFT status with scope, capacity assumptions,
+ * rate context, and optional overhead-absorption policy.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: CreateWorkCenterInput & CF,
+  _ctx: CommandContext,
+) {
+  const {
+    code,
+    companyId,
+    siteId,
+    capacityAssumptions,
+    laborRate,
+    machineRate,
+    calendarReference,
+    overheadAbsorptionMethod,
+    overheadAbsorptionCurrency,
+    ...customFields
+  } = input;
+
+  // 1. Validate scope — company is always required
+  if (!companyId) {
+    return err(new InvalidScopeError(code));
+  }
+
+  // 2. Validate capacity > 0
+  if (capacityAssumptions <= 0) {
+    return err(new InvalidCapacityError(code));
+  }
+
+  // 3. Validate rates >= 0
+  if (laborRate != null && laborRate < 0) {
+    return err(new InvalidRateError(code));
+  }
+  if (machineRate != null && machineRate < 0) {
+    return err(new InvalidRateError(code));
+  }
+
+  // 4. Validate overhead method
+  if (
+    overheadAbsorptionMethod != null &&
+    !VALID_OVERHEAD_METHODS.includes(
+      overheadAbsorptionMethod as (typeof VALID_OVERHEAD_METHODS)[number],
+    )
+  ) {
+    return err(new InvalidOverheadMethodError(code));
+  }
+
+  // 5. Overhead currency required for FIXED_AMOUNT_PER_GOOD_UNIT
+  if (overheadAbsorptionMethod === "FIXED_AMOUNT_PER_GOOD_UNIT" && !overheadAbsorptionCurrency) {
+    return err(new OverheadCurrencyRequiredError(code));
+  }
+
+  // 6. Check code uniqueness within company+site scope
+  let existingQuery = db
+    .selectFrom("WorkCenter")
+    .selectAll()
+    .where("code", "=", code)
+    .where("companyId", "=", companyId);
+
+  if (siteId) {
+    existingQuery = existingQuery.where("siteId", "=", siteId);
+  }
+
+  const existing = await existingQuery.forUpdate().executeTakeFirst();
+
+  if (existing) {
+    return err(new DuplicateWorkCenterCodeError(code));
+  }
+
+  // 7. Create work center in DRAFT status
+  const workCenter = await db
+    .insertInto("WorkCenter")
+    .values({
+      ...(customFields as Record<string, unknown>),
+      code,
+      companyId,
+      siteId: siteId ?? null,
+      capacityAssumptions,
+      laborRate: laborRate ?? null,
+      machineRate: machineRate ?? null,
+      calendarReference: calendarReference ?? null,
+      overheadAbsorptionMethod:
+        (overheadAbsorptionMethod as
+          | "PERCENT_OF_LABOR_COST"
+          | "PERCENT_OF_MACHINE_COST"
+          | "FIXED_AMOUNT_PER_GOOD_UNIT"
+          | null) ?? null,
+      overheadAbsorptionCurrency: overheadAbsorptionCurrency ?? null,
+      status: "DRAFT",
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ workCenter: workCenter! });
+}

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

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

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

@@ -0,0 +1,103 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  BomNotFoundError,
+  BomNotDeactivatableError,
+  ReplacementRequiredError,
+} from "../lib/errors.generated";
+import { baseDraftBom, baseActiveBom } from "../testing/fixtures";
+import { run } from "./deactivateBillOfMaterial";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("deactivateBillOfMaterial", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["manufacturing:deactivateBillOfMaterial"],
+  };
+
+  it("deactivates an active BOM", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const deactivatedBom = { ...baseActiveBom, status: "INACTIVE" as const };
+
+    // BOM exists and is ACTIVE, with defaultSelection = true
+    spies.select.mockReturnValueOnce(baseActiveBom);
+    // replacement BOM exists
+    spies.select.mockReturnValueOnce({ ...baseActiveBom, id: "bom-replacement" });
+    // update to INACTIVE
+    spies.update.mockReturnValue(deactivatedBom);
+
+    const result = await run(db, { id: "bom-2" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.billOfMaterial.status).toBe("INACTIVE");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("returns error when the BOM does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "bom-nonexistent" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(BomNotFoundError);
+    }
+  });
+
+  it("returns error when the BOM is not active", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    spies.select.mockReturnValueOnce(baseDraftBom);
+
+    const result = await run(db, { id: "bom-1" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(BomNotDeactivatableError);
+    }
+  });
+
+  it("returns error when replacement policy blocks deactivation", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // BOM exists and is ACTIVE with default selection
+    spies.select.mockReturnValueOnce(baseActiveBom);
+    // no replacement BOM
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "bom-2" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ReplacementRequiredError);
+    }
+  });
+
+  it("preserves released production-order snapshots after deactivation", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const deactivatedBom = { ...baseActiveBom, status: "INACTIVE" as const };
+
+    // BOM exists and is ACTIVE with default selection
+    spies.select.mockReturnValueOnce(baseActiveBom);
+    // replacement BOM exists
+    spies.select.mockReturnValueOnce({ ...baseActiveBom, id: "bom-replacement" });
+    // update to INACTIVE
+    spies.update.mockReturnValue(deactivatedBom);
+
+    const result = await run(db, { id: "bom-2" }, ctx);
+
+    // Verify that the command only updates the BOM status —
+    // it does not touch ProductionOrderBomSnapshot at all
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.billOfMaterial.status).toBe("INACTIVE");
+    }
+    // The update should only have been called once (for BOM status)
+    expect(spies.update).toHaveBeenCalledTimes(1);
+  });
+});