feat(train-scheduling): implement day-level booking pool

- Added `unplaced` method in `BookingNotifierService` to log warnings for bookings that cannot be placed on any train.
- Introduced `getAvailableDays` method in `TrainSchedulingService` to retrieve distinct days with open departures for a given route.
- Created `AvailableDaysQueryDto` for querying available days based on origin and destination yards.
- Updated `TrainSchedulingController` to expose an endpoint for available days.
- Modified frontend components to support day-level booking, allowing customers to select only a day without pinning to a specific train.
- Removed references to train schedules in booking forms and review steps, emphasizing day selection.
- Added a database migration to create an index for efficient querying of bookings by route and day.

apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.spec.ts

@@ -20,6 +20,7 @@ describe('BookingBatchService — PAID reconcile', () => {
   let bookingsRepository: {
     findPaidUnlinkedForSchedule: jest.Mock;
     findBatchPool: jest.Mock;
+    findBatchPoolByRouteDay: jest.Mock;
     findReservedForSchedule: jest.Mock;
     update: jest.Mock;
   };
@@ -33,16 +34,24 @@ describe('BookingBatchService — PAID reconcile', () => {
   };
   let trainSchedulingService: {
     tryAutoWagonAllocation: jest.Mock;
+    getBookableSchedules: jest.Mock;
   };
   let dataSource: {
     getRepository: jest.Mock;
     transaction: jest.Mock;
   };
+  let notifier: {
+    payNow: jest.Mock;
+    secured: jest.Mock;
+    expired: jest.Mock;
+    unplaced: jest.Mock;
+  };
 
   beforeEach(() => {
     bookingsRepository = {
       findPaidUnlinkedForSchedule: jest.fn().mockResolvedValue([]),
       findBatchPool: jest.fn().mockResolvedValue([]),
+      findBatchPoolByRouteDay: jest.fn().mockResolvedValue([]),
       findReservedForSchedule: jest.fn().mockResolvedValue([]),
       update: jest.fn().mockResolvedValue(undefined),
     };
@@ -67,11 +76,14 @@ describe('BookingBatchService — PAID reconcile', () => {
         issues: [],
         violations: [],
       }),
+      getBookableSchedules: jest.fn().mockResolvedValue([]),
     };
 
     const bookingRepo = {
       findOne: jest.fn().mockResolvedValue(paidBooking),
       update: jest.fn().mockResolvedValue(undefined),
+      // WagonType.find() / global-rules find() fall back to defaults when empty.
+      find: jest.fn().mockResolvedValue([]),
     };
     dataSource = {
       getRepository: jest.fn().mockReturnValue(bookingRepo),
@@ -83,12 +95,19 @@ describe('BookingBatchService — PAID reconcile', () => {
       }),
     };
 
+    notifier = {
+      payNow: jest.fn(),
+      secured: jest.fn(),
+      expired: jest.fn(),
+      unplaced: jest.fn(),
+    };
+
     service = new BookingBatchService(
       dataSource as never,
       bookingsRepository as never,
       trainSchedulesRepository as never,
       trainScheduleBookingsRepository as never,
-      { payNow: jest.fn(), secured: jest.fn(), expired: jest.fn() } as never,
+      notifier as never,
       { addTimeout: jest.fn(), deleteTimeout: jest.fn(), doesExist: jest.fn() } as never,
       trainSchedulingService as never,
     );
@@ -141,4 +160,96 @@ describe('BookingBatchService — PAID reconcile', () => {
     expect(fillOrder).toBeLessThan(reconcileOrder);
     expect(reconcileOrder).toBeLessThan(wagonOrder);
   });
+
+  describe('fillRouteDay — day-level distribution', () => {
+    const originYardId = 'yard-origin';
+    const destinationYardId = 'yard-dest';
+    const day = '2026-06-20';
+    // 06:00Z and 09:00Z on 2026-06-20 both land on the same EAT day.
+    const trainA = 'train-a';
+    const trainB = 'train-b';
+
+    // A tiny locomotive: default wagon = 14m / 70t → exactly 1 wagon slot fits.
+    const smallLoco = { maxPullWeightTons: 70, maxTrainLengthMeters: 14 };
+
+    const commercial = (id: string, priority: number): Booking =>
+      ({
+        id,
+        reference: id,
+        isGovernment: false,
+        priorityScore: priority,
+        status: 'FULLY_EXECUTED',
+        wagonsRequired: 1,
+        cargoTotalWeightVgm: 10,
+        freightType: 'CONTAINER',
+        bookingContainers: [],
+      }) as unknown as Booking;
+
+    beforeEach(() => {
+      // Two OPEN trains on the same route + day, train A earlier than train B.
+      trainSchedulingService.getBookableSchedules.mockResolvedValue([
+        {
+          id: trainA,
+          scheduleDate: '2026-06-20T06:00:00.000Z',
+          bookingWindowStatus: 'OPEN',
+        },
+        {
+          id: trainB,
+          scheduleDate: '2026-06-20T09:00:00.000Z',
+          bookingWindowStatus: 'OPEN',
+        },
+      ]);
+      trainSchedulesRepository.findByIdWithFullGraph.mockImplementation((id: string) =>
+        Promise.resolve({
+          id,
+          maxWagons: 1,
+          bookingWindowStatus: 'OPEN',
+          trainSetId: `set-${id}`,
+          trainSet: { locomotive: smallLoco },
+          scheduleBookings: [],
+        }),
+      );
+    });
+
+    it('spills overflow to the next train by priority, then reports unplaced', async () => {
+      // 3 commercial bookings, descending priority; only 1 fits per train (2 total).
+      bookingsRepository.findBatchPoolByRouteDay.mockResolvedValue([
+        commercial('hi', 30),
+        commercial('mid', 20),
+        commercial('lo', 10),
+      ]);
+
+      const touched = await service.fillRouteDay(originYardId, destinationYardId, day);
+
+      expect(bookingsRepository.findBatchPoolByRouteDay).toHaveBeenCalledWith(
+        originYardId,
+        destinationYardId,
+        day,
+      );
+      // Both trains were processed.
+      expect(touched).toEqual([trainA, trainB]);
+      // Highest priority reserved on train A, next on train B (commercial → reserve).
+      const reservedOn = notifier.payNow.mock.calls.map((c) => (c[0] as Booking).id);
+      expect(reservedOn).toEqual(['hi', 'mid']);
+      // The third booking fits no train and is reported unplaced (and only it).
+      expect(notifier.unplaced).toHaveBeenCalledTimes(1);
+      expect((notifier.unplaced.mock.calls[0][0] as Booking).id).toBe('lo');
+      expect(notifier.unplaced.mock.calls[0][1]).toBe(day);
+    });
+
+    it('reserves the chosen train id on each commercial booking', async () => {
+      bookingsRepository.findBatchPoolByRouteDay.mockResolvedValue([commercial('hi', 30)]);
+
+      await service.fillRouteDay(originYardId, destinationYardId, day);
+
+      // reserve() persists trainScheduleId so the settle lifecycle can find the train.
+      expect(bookingsRepository.update).toHaveBeenCalledWith(
+        'hi',
+        expect.objectContaining({
+          trainScheduleId: trainA,
+          status: 'SELECTED_FOR_BATCH',
+        }),
+      );
+    });
+  });
 });