@tailor-platform/erp-kit 0.5.1 → 0.6.0

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

@@ -0,0 +1,153 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ProductionOrderNotFoundError,
+  ProductionOrderNotTechnicallyCompletableError,
+  ExecutionExceptionRemainsError,
+  PendingMaterialIssueRequestsError,
+  CostSummaryNotReadyError,
+} from "../lib/errors.generated";
+import {
+  baseCompletedProductionOrder,
+  baseInProgressProductionOrder,
+  baseCompleteWorkOrder,
+  baseCancelledWorkOrder,
+  baseInProgressWorkOrder,
+  basePausedWorkOrder,
+  basePendingWorkOrder,
+  baseCollectingCostSummary,
+  basePendingReviewCostSummary,
+} from "../testing/fixtures";
+import { run } from "./technicallyCompleteProductionOrder";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("technicallyCompleteProductionOrder", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["manufacturing:technicallyCompleteProductionOrder"],
+  };
+
+  it("technically completes a completed order and opens variance review", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const techComplete = {
+      ...baseCompletedProductionOrder,
+      status: "TECHNICALLY_COMPLETE" as const,
+    };
+
+    // order lookup
+    spies.select.mockReturnValueOnce(baseCompletedProductionOrder);
+    // work orders - all complete or cancelled
+    spies.select.mockReturnValueOnce([baseCompleteWorkOrder, baseCancelledWorkOrder]);
+    // cost summary in COLLECTING
+    spies.select.mockReturnValueOnce({
+      ...baseCollectingCostSummary,
+      productionOrderId: baseCompletedProductionOrder.id,
+    });
+    // update cost summary
+    spies.update.mockReturnValueOnce(undefined);
+    // update order status
+    spies.update.mockReturnValue(techComplete);
+
+    const result = await run(db, { id: baseCompletedProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.productionOrder.status).toBe("TECHNICALLY_COMPLETE");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("returns error when the order does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ProductionOrderNotFoundError);
+    }
+  });
+
+  it("returns error when the order is not in COMPLETED", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseInProgressProductionOrder);
+
+    const result = await run(db, { id: baseInProgressProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ProductionOrderNotTechnicallyCompletableError);
+    }
+  });
+
+  it("returns error when unresolved execution exceptions remain", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // order lookup
+    spies.select.mockReturnValueOnce(baseCompletedProductionOrder);
+    // work orders - one still in progress
+    spies.select.mockReturnValueOnce([baseInProgressWorkOrder]);
+
+    const result = await run(db, { id: baseCompletedProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ExecutionExceptionRemainsError);
+    }
+  });
+
+  it("returns error when pending material issue requests or unresolved backflush intents remain", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // order lookup
+    spies.select.mockReturnValueOnce(baseCompletedProductionOrder);
+    // work orders - one still pending
+    spies.select.mockReturnValueOnce([baseCompleteWorkOrder, basePendingWorkOrder]);
+
+    const result = await run(db, { id: baseCompletedProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(PendingMaterialIssueRequestsError);
+    }
+  });
+
+  it("returns error when the linked cost summary is not ready for review", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // order lookup
+    spies.select.mockReturnValueOnce(baseCompletedProductionOrder);
+    // work orders - all complete
+    spies.select.mockReturnValueOnce([baseCompleteWorkOrder]);
+    // cost summary already in PENDING_VARIANCE_REVIEW (not COLLECTING)
+    spies.select.mockReturnValueOnce({
+      ...basePendingReviewCostSummary,
+      productionOrderId: baseCompletedProductionOrder.id,
+    });
+
+    const result = await run(db, { id: baseCompletedProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CostSummaryNotReadyError);
+    }
+  });
+
+  it("blocks further shop-floor reporting after technical completion", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // order lookup - already paused work order still open
+    spies.select.mockReturnValueOnce(baseCompletedProductionOrder);
+    // work orders - one paused (execution exception)
+    spies.select.mockReturnValueOnce([basePausedWorkOrder]);
+
+    const result = await run(db, { id: baseCompletedProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ExecutionExceptionRemainsError);
+    }
+  });
+});

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

@@ -0,0 +1,106 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ProductionOrderNotFoundError,
+  ProductionOrderNotTechnicallyCompletableError,
+  ExecutionExceptionRemainsError,
+  PendingMaterialIssueRequestsError,
+  CostSummaryNotReadyError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface TechnicallyCompleteProductionOrderInput {
+  id: string;
+  from?: string[];
+}
+
+/**
+ * Function: technicallyCompleteProductionOrder
+ *
+ * Freezes the production order after physical completion and moves the linked
+ * manufacturing cost summary into variance review. Marks the point where no
+ * more normal execution or rescheduling is expected.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: TechnicallyCompleteProductionOrderInput & CF,
+  _ctx: CommandContext,
+) {
+  const { id, from, ...customFields } = input;
+  void customFields;
+
+  const allowedStatuses = from ?? ["COMPLETED"];
+
+  // 1. Fetch production order with lock
+  const order = await db
+    .selectFrom("ProductionOrder")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!order) {
+    return err(new ProductionOrderNotFoundError(id));
+  }
+
+  // 2. Validate status
+  if (!allowedStatuses.includes(order.status)) {
+    return err(new ProductionOrderNotTechnicallyCompletableError(id));
+  }
+
+  // 3. Check for open execution exceptions (work orders not COMPLETE or CANCELLED)
+  const workOrders = await db
+    .selectFrom("WorkOrder")
+    .selectAll()
+    .where("productionOrderId", "=", id)
+    .execute();
+
+  const hasExecutionExceptions = workOrders.some(
+    (wo) => wo.status === "IN_PROGRESS" || wo.status === "PAUSED",
+  );
+
+  if (hasExecutionExceptions) {
+    return err(new ExecutionExceptionRemainsError(id));
+  }
+
+  // 4. Check for pending material issue requests (work orders still PENDING)
+  const hasPendingWork = workOrders.some((wo) => wo.status === "PENDING");
+
+  if (hasPendingWork) {
+    return err(new PendingMaterialIssueRequestsError(id));
+  }
+
+  // 5. Find and validate cost summary
+  const costSummary = await db
+    .selectFrom("ManufacturingCostSummary")
+    .selectAll()
+    .where("productionOrderId", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (costSummary?.status !== "COLLECTING") {
+    return err(new CostSummaryNotReadyError(id));
+  }
+
+  // 6. Move cost summary to PENDING_VARIANCE_REVIEW
+  await db
+    .updateTable("ManufacturingCostSummary")
+    .set({
+      status: "PENDING_VARIANCE_REVIEW",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", costSummary.id)
+    .execute();
+
+  // 7. Set order status to TECHNICALLY_COMPLETE
+  const techCompleteOrder = await db
+    .updateTable("ProductionOrder")
+    .set({
+      status: "TECHNICALLY_COMPLETE",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ productionOrder: techCompleteOrder });
+}

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

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

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

@@ -0,0 +1,140 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ProductionOrderNotFoundError,
+  ProductionOrderNotUnreleasableError,
+  ExecutionAlreadyStartedError,
+  InventoryHandoffExistsError,
+} from "../lib/errors.generated";
+import {
+  baseDraftProductionOrder,
+  baseReleasedProductionOrder,
+  basePendingWorkOrder,
+  baseInProgressWorkOrder,
+  baseMaterialRequirement,
+  baseCollectingCostSummary,
+} from "../testing/fixtures";
+import { run } from "./unreleaseProductionOrder";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("unreleaseProductionOrder", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["manufacturing:unreleaseProductionOrder"],
+  };
+
+  it("unreleases a released order with no execution evidence", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const draftOrder = { ...baseReleasedProductionOrder, status: "DRAFT" as const };
+
+    // order lookup
+    spies.select.mockReturnValueOnce(baseReleasedProductionOrder);
+    // work orders - all pending
+    spies.select.mockReturnValueOnce([basePendingWorkOrder]);
+    // material requirements
+    spies.select.mockReturnValueOnce([baseMaterialRequirement]);
+    // cost summary - no actuals
+    spies.select.mockReturnValueOnce(baseCollectingCostSummary);
+    // delete operations return
+    spies.delete.mockReturnValue(undefined);
+    // update order status
+    spies.update.mockReturnValue(draftOrder);
+
+    const result = await run(db, { id: baseReleasedProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.productionOrder.status).toBe("DRAFT");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("returns error when the order does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ProductionOrderNotFoundError);
+    }
+  });
+
+  it("returns error when the order is not in RELEASED", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseDraftProductionOrder);
+
+    const result = await run(db, { id: baseDraftProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ProductionOrderNotUnreleasableError);
+    }
+  });
+
+  it("returns error when a work order has already started", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // order lookup
+    spies.select.mockReturnValueOnce(baseReleasedProductionOrder);
+    // work orders - one in progress
+    spies.select.mockReturnValueOnce([baseInProgressWorkOrder]);
+
+    const result = await run(db, { id: baseReleasedProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ExecutionAlreadyStartedError);
+    }
+  });
+
+  it("returns error when inventory handoff evidence already exists", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const costSummaryWithActuals = {
+      ...baseCollectingCostSummary,
+      actualMaterialCost: 500,
+    };
+
+    // order lookup
+    spies.select.mockReturnValueOnce(baseReleasedProductionOrder);
+    // work orders - all pending
+    spies.select.mockReturnValueOnce([basePendingWorkOrder]);
+    // material requirements
+    spies.select.mockReturnValueOnce([baseMaterialRequirement]);
+    // cost summary with actual costs
+    spies.select.mockReturnValueOnce(costSummaryWithActuals);
+
+    const result = await run(db, { id: baseReleasedProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InventoryHandoffExistsError);
+    }
+  });
+
+  it("removes work orders and material requirements when unrelease succeeds", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const draftOrder = { ...baseReleasedProductionOrder, status: "DRAFT" as const };
+
+    // order lookup
+    spies.select.mockReturnValueOnce(baseReleasedProductionOrder);
+    // work orders - all pending
+    spies.select.mockReturnValueOnce([basePendingWorkOrder]);
+    // material requirements
+    spies.select.mockReturnValueOnce([]);
+    // cost summary
+    spies.select.mockReturnValueOnce(baseCollectingCostSummary);
+    // delete operations
+    spies.delete.mockReturnValue(undefined);
+    // update order
+    spies.update.mockReturnValue(draftOrder);
+
+    const result = await run(db, { id: baseReleasedProductionOrder.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    expect(spies.delete).toHaveBeenCalled();
+    expect(spies.update).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,131 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ProductionOrderNotFoundError,
+  ProductionOrderNotUnreleasableError,
+  ExecutionAlreadyStartedError,
+  InventoryHandoffExistsError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface UnreleaseProductionOrderInput {
+  id: string;
+  from?: string[];
+}
+
+/**
+ * Function: unreleaseProductionOrder
+ *
+ * Returns a released order to DRAFT when execution has not meaningfully
+ * started. Removes release artifacts so the planner can safely revise
+ * the order.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: UnreleaseProductionOrderInput & CF,
+  _ctx: CommandContext,
+) {
+  const { id, from, ...customFields } = input;
+  void customFields;
+
+  const allowedStatuses = from ?? ["RELEASED"];
+
+  // 1. Fetch production order with lock
+  const order = await db
+    .selectFrom("ProductionOrder")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!order) {
+    return err(new ProductionOrderNotFoundError(id));
+  }
+
+  // 2. Validate status is unreleasable
+  if (!allowedStatuses.includes(order.status)) {
+    return err(new ProductionOrderNotUnreleasableError(id));
+  }
+
+  // 3. Check no work order has execution evidence
+  const workOrders = await db
+    .selectFrom("WorkOrder")
+    .selectAll()
+    .where("productionOrderId", "=", id)
+    .execute();
+
+  const hasExecution = workOrders.some(
+    (wo) =>
+      wo.status === "IN_PROGRESS" ||
+      wo.status === "PAUSED" ||
+      wo.status === "COMPLETE" ||
+      wo.completedQuantity > 0 ||
+      wo.actualStartDate != null,
+  );
+
+  if (hasExecution) {
+    return err(new ExecutionAlreadyStartedError(id));
+  }
+
+  // 4. Check no irreversible inventory handoff
+  const _materialRequirements = await db
+    .selectFrom("ProductionOrderMaterialRequirement")
+    .selectAll()
+    .where("productionOrderId", "=", id)
+    .execute();
+
+  // Check if any cost summary has actual costs recorded (inventory handoff evidence)
+  const costSummary = await db
+    .selectFrom("ManufacturingCostSummary")
+    .selectAll()
+    .where("productionOrderId", "=", id)
+    .executeTakeFirst();
+
+  if (
+    costSummary &&
+    (costSummary.actualMaterialCost > 0 ||
+      costSummary.actualLaborCost > 0 ||
+      costSummary.actualMachineCost > 0 ||
+      costSummary.actualOverheadCost > 0)
+  ) {
+    return err(new InventoryHandoffExistsError(id));
+  }
+
+  // 5. Remove release artifacts - delete work orders
+  await db.deleteFrom("WorkOrder").where("productionOrderId", "=", id).execute();
+
+  // 6. Remove material requirements
+  await db
+    .deleteFrom("ProductionOrderMaterialRequirement")
+    .where("productionOrderId", "=", id)
+    .execute();
+
+  // 7. Remove BOM snapshot
+  await db.deleteFrom("ProductionOrderBomSnapshot").where("productionOrderId", "=", id).execute();
+
+  // 8. Remove routing snapshot
+  await db
+    .deleteFrom("ProductionOrderRoutingSnapshot")
+    .where("productionOrderId", "=", id)
+    .execute();
+
+  // 9. Remove cost baseline
+  await db.deleteFrom("ProductionOrderCostBaseline").where("productionOrderId", "=", id).execute();
+
+  // 10. Remove cost summary
+  await db.deleteFrom("ManufacturingCostSummary").where("productionOrderId", "=", id).execute();
+
+  // 11. Set status to DRAFT
+  const draftOrder = await db
+    .updateTable("ProductionOrder")
+    .set({
+      selectedBomVersionId: null,
+      selectedRoutingRevisionId: null,
+      status: "DRAFT",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ productionOrder: draftOrder });
+}

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

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

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

@@ -0,0 +1,149 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  BomNotFoundError,
+  BomNotMutableError,
+  InvalidComponentQuantityError,
+  ComponentItemInactiveError,
+  AmbiguousEffectivityRuleError,
+} from "../lib/errors.generated";
+import { baseDraftBom, baseActiveBom, baseBomLine } from "../testing/fixtures";
+import { run } from "./updateBillOfMaterial";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("updateBillOfMaterial", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["manufacturing:updateBillOfMaterial"],
+  };
+
+  const validInput = {
+    id: "bom-1",
+    bomType: "PHANTOM" as const,
+    lines: [
+      {
+        itemId: "item-2",
+        requiredQuantity: 3.0,
+        unitOfMeasure: "EA",
+      },
+    ],
+  };
+
+  it("updates draft BOM metadata and component lines", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedBom = {
+      ...baseDraftBom,
+      bomType: "PHANTOM" as const,
+    };
+
+    // BOM exists and is DRAFT
+    spies.select.mockReturnValueOnce(baseDraftBom);
+    // component item exists
+    spies.select.mockReturnValueOnce({ id: "item-2" });
+    // update BOM header
+    spies.update.mockReturnValueOnce(updatedBom);
+    // delete old lines
+    spies.delete.mockReturnValueOnce(undefined);
+    // insert new line
+    spies.insert.mockReturnValueOnce({ ...baseBomLine, requiredQuantity: 3.0 });
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.billOfMaterial.bomType).toBe("PHANTOM");
+    }
+    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, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(BomNotFoundError);
+    }
+  });
+
+  it("returns error when the BOM is not in DRAFT", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    spies.select.mockReturnValueOnce(baseActiveBom);
+
+    const result = await run(db, { ...validInput, id: "bom-2" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(BomNotMutableError);
+    }
+  });
+
+  it("returns error when a revised component quantity is invalid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    spies.select.mockReturnValueOnce(baseDraftBom);
+
+    const result = await run(
+      db,
+      {
+        ...validInput,
+        lines: [{ itemId: "item-2", requiredQuantity: -1, unitOfMeasure: "EA" }],
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidComponentQuantityError);
+    }
+  });
+
+  it("returns error when a newly referenced component is inactive", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // BOM exists and is DRAFT
+    spies.select.mockReturnValueOnce(baseDraftBom);
+    // component item not found (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 effectivity changes would create ambiguous selection", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+
+    // BOM exists and is DRAFT
+    spies.select.mockReturnValueOnce(baseDraftBom);
+    // conflicting active BOM with same default selection
+    spies.select.mockReturnValueOnce({
+      ...baseActiveBom,
+      defaultSelection: true,
+      effectivityStartDate: null,
+      effectivityEndDate: null,
+    });
+
+    const result = await run(
+      db,
+      {
+        id: "bom-1",
+        defaultSelection: true,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AmbiguousEffectivityRuleError);
+    }
+  });
+});