changes

apps/edr-freight-api/src/modules/rule-engine/services/priority-configs.service.ts

@@ -10,6 +10,31 @@ import {
 } from '../interfaces/priority-configs.repository.interface';
 import { DisplayOrderService } from './display-order.service';
 
+/** Hard ceiling of each type's wagon-count chain (1..cap, contiguous). */
+export const RANGE_CAPS: Record<'WAGON' | 'CURRENCY' | 'CUSTOMS', number> = {
+  WAGON: 50,
+  CURRENCY: 35,
+  CUSTOMS: 15,
+};
+
+/**
+ * Lowest wagon count ≥ 1 not covered by any of `rules` — where the next range
+ * must start. Null when the chain is already complete up to the type's cap.
+ */
+function nextRangeStart(
+  rules: Pick<PriorityConfig, 'type' | 'minWagonCount' | 'maxWagonCount'>[],
+): number | null {
+  const cap = rules.length ? RANGE_CAPS[rules[0].type] : null;
+  const sorted = [...rules].sort((a, b) => a.minWagonCount - b.minWagonCount);
+  let next = 1;
+  for (const r of sorted) {
+    if (r.minWagonCount > next) break; // gap before this rule — fill it
+    next = Math.max(next, r.maxWagonCount + 1);
+  }
+  if (cap != null && next > cap) return null;
+  return next;
+}
+
 @Injectable()
 export class PriorityConfigsService {
   constructor(
@@ -73,10 +98,13 @@ export class PriorityConfigsService {
   }
 
   /**
-   * No two rules of the same type (and, for CURRENCY rules, the same currency)
-   * may cover overlapping wagon-count ranges — a booking must match at most one
-   * rule per type. Rejects an exact duplicate (1–5 vs 1–5) and any partial
-   * overlap (1–5 vs 4–7). Ranges are inclusive on both ends.
+   * Range rules per type (and, for CURRENCY rules, per currency):
+   *  - ranges never overlap — a booking matches at most one rule per type;
+   *  - ranges are contiguous from 1: a new range must START at the lowest
+   *    wagon count not yet covered (after 1–5 the next is 6–…; deleting a
+   *    middle rule opens a gap and the next create must fill it first);
+   *  - each type has a hard ceiling: WAGON 50, CURRENCY 35, CUSTOMS 15.
+   * Ranges are inclusive on both ends.
    */
   async assertNoRangeCollision(input: {
     type: 'WAGON' | 'CURRENCY' | 'CUSTOMS';
@@ -90,13 +118,49 @@ export class PriorityConfigsService {
         'Min wagon count cannot be greater than max wagon count',
       );
     }
-    const siblings = await this.repository.findAll({
-      where: { type: input.type },
-    });
-    const clash = siblings.find(
+    const cap = RANGE_CAPS[input.type];
+    if (input.maxWagonCount > cap) {
+      throw new BadRequestException(
+        `${input.type} ranges may not exceed ${cap} — ` +
+          `${input.minWagonCount}–${input.maxWagonCount} goes past the ceiling.`,
+      );
+    }
+
+    const siblings = (
+      await this.repository.findAll({ where: { type: input.type } })
+    ).filter(
       (s) =>
         s.id !== input.excludeId &&
-        (input.type !== 'CURRENCY' || (s.currency ?? null) === (input.currency ?? null)) &&
+        (input.type !== 'CURRENCY' ||
+          (s.currency ?? null) === (input.currency ?? null)),
+    );
+
+    const expectedStart = nextRangeStart(siblings);
+    // An edited rule may always KEEP its current start (so a gap lower in the
+    // chain never blocks editing an upper rule's points/max) — or move down to
+    // fill that lowest gap.
+    const currentStart = input.excludeId
+      ? (await this.repository.findById(input.excludeId))?.minWagonCount ?? null
+      : null;
+    if (expectedStart == null && currentStart == null) {
+      throw new BadRequestException(
+        `${input.type} rules already cover the full 1–${cap} range — ` +
+          'delete or shrink an existing rule first.',
+      );
+    }
+    if (
+      input.minWagonCount !== expectedStart &&
+      input.minWagonCount !== currentStart
+    ) {
+      throw new BadRequestException(
+        `The next ${input.type} range must start at ${expectedStart} ` +
+          `(ranges are contiguous — no gaps, no overlaps). ` +
+          `You entered ${input.minWagonCount}–${input.maxWagonCount}.`,
+      );
+    }
+
+    const clash = siblings.find(
+      (s) =>
         input.minWagonCount <= s.maxWagonCount &&
         input.maxWagonCount >= s.minWagonCount,
     );
@@ -109,6 +173,24 @@ export class PriorityConfigsService {
     }
   }
 
+  /**
+   * Where the next range for a type/currency must start, and the type's
+   * ceiling — feeds the create form so the min field is auto-filled and
+   * locked. `nextMin` is null when the chain already covers 1..cap.
+   */
+  async nextRange(
+    type: 'WAGON' | 'CURRENCY' | 'CUSTOMS',
+    currency?: string | null,
+  ): Promise<{ nextMin: number | null; maxCap: number }> {
+    const siblings = (
+      await this.repository.findAll({ where: { type } })
+    ).filter(
+      (s) =>
+        type !== 'CURRENCY' || (s.currency ?? null) === (currency ?? null),
+    );
+    return { nextMin: nextRangeStart(siblings), maxCap: RANGE_CAPS[type] };
+  }
+
   async remove(id: string): Promise<void> {
     await this.findById(id);
     await this.repository.softDelete(id);