feat(freight): added routes and locomotives

apps/edr-freight-api/src/modules/locomotives/dto/create-locomotive.dto.ts

@@ -0,0 +1,59 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Transform } from 'class-transformer';
+import { IsIn, IsNumber, IsOptional, IsString, MaxLength, Min } from 'class-validator';
+
+import { LOCOMOTIVE_STATUSES, LOCOMOTIVE_TYPES } from '../entities/locomotive.entity';
+
+export class CreateLocomotiveDto {
+  @ApiProperty({ example: 'LOCO-001' })
+  @IsString()
+  @MaxLength(32)
+  code!: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  @MaxLength(100)
+  name?: string;
+
+  @ApiProperty({ enum: LOCOMOTIVE_TYPES })
+  @IsIn([...LOCOMOTIVE_TYPES])
+  locomotiveType!: string;
+
+  @ApiProperty({ enum: LOCOMOTIVE_STATUSES })
+  @IsIn([...LOCOMOTIVE_STATUSES])
+  status!: string;
+
+  @ApiProperty({ example: 3500 })
+  @Transform(({ value }) => Number(value))
+  @IsNumber()
+  @Min(0)
+  maxPullWeightTons!: number;
+
+  @ApiProperty({ example: 760 })
+  @Transform(({ value }) => Number(value))
+  @IsNumber()
+  @Min(0)
+  maxTrainLengthMeters!: number;
+
+  @ApiPropertyOptional({ example: 4200 })
+  @IsOptional()
+  @Transform(({ value }) => (value === '' || value == null ? undefined : Number(value)))
+  @IsNumber()
+  @Min(0)
+  powerKw?: number;
+
+  @ApiPropertyOptional({ example: 300 })
+  @IsOptional()
+  @Transform(({ value }) => (value === '' || value == null ? undefined : Number(value)))
+  @IsNumber()
+  @Min(0)
+  tractionForceKn?: number;
+
+  @ApiPropertyOptional({ example: 120 })
+  @IsOptional()
+  @Transform(({ value }) => (value === '' || value == null ? undefined : Number(value)))
+  @IsNumber()
+  @Min(0)
+  maxSpeedKmh?: number;
+}

apps/edr-freight-api/src/modules/locomotives/dto/filter-locomotives.dto.ts

@@ -1,11 +1,16 @@
 import { ApiPropertyOptional } from '@nestjs/swagger';
 import { IsIn, IsOptional } from 'class-validator';
 
-import { LOCOMOTIVE_STATUSES } from '../entities/locomotive.entity';
+import { LOCOMOTIVE_STATUSES, LOCOMOTIVE_TYPES } from '../entities/locomotive.entity';
 
 export class FilterLocomotivesDto {
   @ApiPropertyOptional({ enum: LOCOMOTIVE_STATUSES })
   @IsOptional()
   @IsIn([...LOCOMOTIVE_STATUSES])
   status?: string;
+
+  @ApiPropertyOptional({ enum: LOCOMOTIVE_TYPES })
+  @IsOptional()
+  @IsIn([...LOCOMOTIVE_TYPES])
+  locomotiveType?: string;
 }

apps/edr-freight-api/src/modules/locomotives/dto/update-locomotive.dto.ts

@@ -0,0 +1,5 @@
+import { PartialType } from '@nestjs/swagger';
+
+import { CreateLocomotiveDto } from './create-locomotive.dto';
+
+export class UpdateLocomotiveDto extends PartialType(CreateLocomotiveDto) {}

apps/edr-freight-api/src/modules/locomotives/entities/locomotive.entity.ts

@@ -7,10 +7,13 @@ export const LOCOMOTIVE_STATUSES = [
   'AVAILABLE',
   'ASSIGNED',
   'MAINTENANCE',
-  'INACTIVE',
+  'OUT_OF_SERVICE',
 ] as const;
 
+export const LOCOMOTIVE_TYPES = ['DIESEL', 'ELECTRIC'] as const;
+
 export type LocomotiveStatus = (typeof LOCOMOTIVE_STATUSES)[number];
+export type LocomotiveType = (typeof LOCOMOTIVE_TYPES)[number];
 
 @Entity({ schema: 'freight', name: 'locomotives' })
 @Index(['code'])
@@ -22,14 +25,26 @@ export class Locomotive extends BaseEntity {
   @Column({ name: 'name', type: 'varchar', length: 100, nullable: true })
   name?: string | null;
 
+  @Column({ name: 'locomotive_type', type: 'varchar', length: 20, default: 'DIESEL' })
+  locomotiveType!: LocomotiveType;
+
   @Column({ name: 'max_pull_weight_tons', type: 'numeric', precision: 10, scale: 3 })
   maxPullWeightTons!: number;
 
+  @Column({ name: 'max_train_length_meters', type: 'numeric', precision: 10, scale: 3, default: 760 })
+  maxTrainLengthMeters!: number;
+
   @Column({ name: 'status', type: 'varchar', length: 20, default: 'AVAILABLE' })
   status!: LocomotiveStatus;
 
-  @Column({ name: 'available_from', type: 'timestamptz', nullable: true })
-  availableFrom?: Date | null;
+  @Column({ name: 'power_kw', type: 'numeric', precision: 10, scale: 3, nullable: true })
+  powerKw?: number | null;
+
+  @Column({ name: 'traction_force_kn', type: 'numeric', precision: 10, scale: 3, nullable: true })
+  tractionForceKn?: number | null;
+
+  @Column({ name: 'max_speed_kmh', type: 'numeric', precision: 10, scale: 3, nullable: true })
+  maxSpeedKmh?: number | null;
 
   @OneToMany(() => TrainSet, (trainSet) => trainSet.locomotive)
   trainSets?: TrainSet[];

apps/edr-freight-api/src/modules/locomotives/locomotives.controller.ts

@@ -1,7 +1,9 @@
-import { Controller, Get, Query } from '@nestjs/common';
+import { Body, Controller, Get, Param, ParseUUIDPipe, Patch, Post, Query } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 
+import { CreateLocomotiveDto } from './dto/create-locomotive.dto';
 import { FilterLocomotivesDto } from './dto/filter-locomotives.dto';
+import { UpdateLocomotiveDto } from './dto/update-locomotive.dto';
 import { LocomotivesService } from './locomotives.service';
 
 @ApiTags('locomotives')
@@ -15,4 +17,28 @@ export class LocomotivesController {
   findAll(@Query() filter: FilterLocomotivesDto) {
     return this.locomotivesService.findAll(filter);
   }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get a locomotive by ID' })
+  findOne(@Param('id', ParseUUIDPipe) id: string) {
+    return this.locomotivesService.findById(id);
+  }
+
+  @Post()
+  @ApiOperation({ summary: 'Create a locomotive' })
+  create(@Body() dto: CreateLocomotiveDto) {
+    return this.locomotivesService.create(dto);
+  }
+
+  @Patch(':id')
+  @ApiOperation({ summary: 'Update a locomotive' })
+  update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateLocomotiveDto) {
+    return this.locomotivesService.update(id, dto);
+  }
+
+  @Post(':id/decommission')
+  @ApiOperation({ summary: 'Decommission a locomotive' })
+  decommission(@Param('id', ParseUUIDPipe) id: string) {
+    return this.locomotivesService.decommission(id);
+  }
 }

apps/edr-freight-api/src/modules/locomotives/locomotives.service.ts

@@ -1,7 +1,9 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
+import { ConflictException, Injectable, NotFoundException } from '@nestjs/common';
 
+import { CreateLocomotiveDto } from './dto/create-locomotive.dto';
 import { FilterLocomotivesDto } from './dto/filter-locomotives.dto';
-import { Locomotive, type LocomotiveStatus } from './entities/locomotive.entity';
+import { UpdateLocomotiveDto } from './dto/update-locomotive.dto';
+import { Locomotive, type LocomotiveStatus, type LocomotiveType } from './entities/locomotive.entity';
 import { LocomotivesRepository } from './locomotives.repository';
 
 @Injectable()
@@ -10,13 +12,36 @@ export class LocomotivesService {
 
   findAll(filter: FilterLocomotivesDto): Promise<Locomotive[]> {
     return this.locomotivesRepository.findAll({
-      where: filter.status
-        ? { status: filter.status as LocomotiveStatus }
-        : undefined,
+      where: {
+        ...(filter.status ? { status: filter.status as LocomotiveStatus } : {}),
+        ...(filter.locomotiveType
+          ? { locomotiveType: filter.locomotiveType as LocomotiveType }
+          : {}),
+      },
       order: { code: 'ASC' },
     });
   }
 
+  async create(dto: CreateLocomotiveDto): Promise<Locomotive> {
+    const [existing] = await this.locomotivesRepository.findAll({ where: { code: dto.code } });
+
+    if (existing) {
+      throw new ConflictException(`Locomotive code ${dto.code} already exists`);
+    }
+
+    return this.locomotivesRepository.create({
+      code: dto.code,
+      name: dto.name?.trim() || null,
+      locomotiveType: dto.locomotiveType as LocomotiveType,
+      status: dto.status as LocomotiveStatus,
+      maxPullWeightTons: dto.maxPullWeightTons,
+      maxTrainLengthMeters: dto.maxTrainLengthMeters,
+      powerKw: dto.powerKw ?? null,
+      tractionForceKn: dto.tractionForceKn ?? null,
+      maxSpeedKmh: dto.maxSpeedKmh ?? null,
+    });
+  }
+
   async findById(id: string): Promise<Locomotive> {
     const locomotive = await this.locomotivesRepository.findById(id);
 
@@ -26,4 +51,48 @@ export class LocomotivesService {
 
     return locomotive;
   }
+
+  async update(id: string, dto: UpdateLocomotiveDto): Promise<Locomotive> {
+    const locomotive = await this.findById(id);
+
+    if (dto.code && dto.code !== locomotive.code) {
+      const [existing] = await this.locomotivesRepository.findAll({ where: { code: dto.code } });
+      if (existing && existing.id !== id) {
+        throw new ConflictException(`Locomotive code ${dto.code} already exists`);
+      }
+    }
+
+    const updated = await this.locomotivesRepository.update(id, {
+      ...dto,
+      locomotiveType:
+        dto.locomotiveType === undefined ? locomotive.locomotiveType : dto.locomotiveType as LocomotiveType,
+      status: dto.status === undefined ? locomotive.status : dto.status as LocomotiveStatus,
+      name: dto.name === undefined ? locomotive.name : dto.name?.trim() || null,
+      powerKw: dto.powerKw === undefined ? locomotive.powerKw : dto.powerKw ?? null,
+      tractionForceKn:
+        dto.tractionForceKn === undefined ? locomotive.tractionForceKn : dto.tractionForceKn ?? null,
+      maxSpeedKmh:
+        dto.maxSpeedKmh === undefined ? locomotive.maxSpeedKmh : dto.maxSpeedKmh ?? null,
+    });
+
+    if (!updated) {
+      throw new NotFoundException(`Locomotive ${id} not found`);
+    }
+
+    return updated;
+  }
+
+  async decommission(id: string): Promise<Locomotive> {
+    await this.findById(id);
+
+    const updated = await this.locomotivesRepository.update(id, {
+      status: 'OUT_OF_SERVICE',
+    });
+
+    if (!updated) {
+      throw new NotFoundException(`Locomotive ${id} not found`);
+    }
+
+    return updated;
+  }
 }

apps/edr-freight-api/src/modules/routes/dto/create-route.dto.ts

@@ -0,0 +1,28 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import { ArrayMinSize, IsArray, IsBoolean, IsOptional, IsString, IsUUID, MaxLength, ValidateNested } from 'class-validator';
+
+export class CreateRouteMilestoneDto {
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  yardId!: string;
+}
+
+export class CreateRouteDto {
+  @ApiProperty()
+  @IsString()
+  @MaxLength(120)
+  name!: string;
+
+  @ApiProperty({ type: [CreateRouteMilestoneDto] })
+  @IsArray()
+  @ArrayMinSize(2)
+  @ValidateNested({ each: true })
+  @Type(() => CreateRouteMilestoneDto)
+  milestones!: CreateRouteMilestoneDto[];
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+}

apps/edr-freight-api/src/modules/routes/dto/filter-routes.dto.ts

@@ -0,0 +1,16 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { Transform } from 'class-transformer';
+import { IsBoolean, IsOptional, IsString } from 'class-validator';
+
+export class FilterRoutesDto {
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  search?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @Transform(({ value }) => value === 'true' || value === true)
+  @IsBoolean()
+  isActive?: boolean;
+}

apps/edr-freight-api/src/modules/routes/dto/update-route.dto.ts

@@ -0,0 +1,5 @@
+import { PartialType } from '@nestjs/swagger';
+
+import { CreateRouteDto } from './create-route.dto';
+
+export class UpdateRouteDto extends PartialType(CreateRouteDto) {}

apps/edr-freight-api/src/modules/routes/entities/route-milestone.entity.ts

@@ -0,0 +1,26 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+
+import { Yard } from '../../rule-engine/entities/yard.entity';
+import { Route } from './route.entity';
+
+@Entity({ schema: 'freight', name: 'route_milestones' })
+@Index(['routeId', 'sequenceNo'], { unique: true })
+export class RouteMilestone extends BaseEntity {
+  @Column({ name: 'route_id', type: 'uuid' })
+  routeId!: string;
+
+  @ManyToOne(() => Route, (route) => route.milestones, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'route_id' })
+  route?: Route;
+
+  @Column({ name: 'yard_id', type: 'uuid' })
+  yardId!: string;
+
+  @ManyToOne(() => Yard)
+  @JoinColumn({ name: 'yard_id' })
+  yard?: Yard;
+
+  @Column({ name: 'sequence_no', type: 'int' })
+  sequenceNo!: number;
+}

apps/edr-freight-api/src/modules/routes/entities/route.entity.ts

@@ -0,0 +1,33 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
+
+import { Yard } from '../../rule-engine/entities/yard.entity';
+import { RouteMilestone } from './route-milestone.entity';
+
+@Entity({ schema: 'freight', name: 'routes' })
+@Index(['name'])
+@Index(['isActive'])
+export class Route extends BaseEntity {
+  @Column({ name: 'name', type: 'varchar', length: 120, unique: true })
+  name!: string;
+
+  @Column({ name: 'origin_yard_id', type: 'uuid' })
+  originYardId!: string;
+
+  @ManyToOne(() => Yard)
+  @JoinColumn({ name: 'origin_yard_id' })
+  originYard?: Yard;
+
+  @Column({ name: 'destination_yard_id', type: 'uuid' })
+  destinationYardId!: string;
+
+  @ManyToOne(() => Yard)
+  @JoinColumn({ name: 'destination_yard_id' })
+  destinationYard?: Yard;
+
+  @Column({ name: 'is_active', type: 'boolean', default: true })
+  isActive!: boolean;
+
+  @OneToMany(() => RouteMilestone, (milestone) => milestone.route, { cascade: false })
+  milestones?: RouteMilestone[];
+}

apps/edr-freight-api/src/modules/routes/route-milestones.repository.ts

@@ -0,0 +1,13 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { RouteMilestone } from './entities/route-milestone.entity';
+
+@Injectable()
+export class RouteMilestonesRepository extends BaseRepository<RouteMilestone> {
+  constructor(@InjectRepository(RouteMilestone) repository: Repository<RouteMilestone>) {
+    super(repository);
+  }
+}

apps/edr-freight-api/src/modules/routes/routes.controller.ts

@@ -0,0 +1,44 @@
+import { Body, Controller, Delete, Get, Param, ParseUUIDPipe, Patch, Post, Query } from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import { CreateRouteDto } from './dto/create-route.dto';
+import { FilterRoutesDto } from './dto/filter-routes.dto';
+import { UpdateRouteDto } from './dto/update-route.dto';
+import { RoutesService } from './routes.service';
+
+@ApiTags('routes')
+@ApiBearerAuth()
+@Controller('routes')
+export class RoutesController {
+  constructor(private readonly routesService: RoutesService) {}
+
+  @Get()
+  @ApiOperation({ summary: 'List routes' })
+  findAll(@Query() filter: FilterRoutesDto) {
+    return this.routesService.findAll(filter);
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get route by ID' })
+  findOne(@Param('id', ParseUUIDPipe) id: string) {
+    return this.routesService.findById(id);
+  }
+
+  @Post()
+  @ApiOperation({ summary: 'Create route' })
+  create(@Body() dto: CreateRouteDto) {
+    return this.routesService.create(dto);
+  }
+
+  @Patch(':id')
+  @ApiOperation({ summary: 'Update route' })
+  update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateRouteDto) {
+    return this.routesService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @ApiOperation({ summary: 'Deactivate route' })
+  remove(@Param('id', ParseUUIDPipe) id: string) {
+    return this.routesService.deactivate(id);
+  }
+}

apps/edr-freight-api/src/modules/routes/routes.module.ts

@@ -0,0 +1,18 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { Yard } from '../rule-engine/entities/yard.entity';
+import { RouteMilestone } from './entities/route-milestone.entity';
+import { Route } from './entities/route.entity';
+import { RouteMilestonesRepository } from './route-milestones.repository';
+import { RoutesController } from './routes.controller';
+import { RoutesRepository } from './routes.repository';
+import { RoutesService } from './routes.service';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Route, RouteMilestone, Yard])],
+  controllers: [RoutesController],
+  providers: [RoutesRepository, RouteMilestonesRepository, RoutesService],
+  exports: [RoutesRepository, RouteMilestonesRepository, RoutesService],
+})
+export class RoutesModule {}

apps/edr-freight-api/src/modules/routes/routes.repository.ts

@@ -0,0 +1,13 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { Route } from './entities/route.entity';
+
+@Injectable()
+export class RoutesRepository extends BaseRepository<Route> {
+  constructor(@InjectRepository(Route) repository: Repository<Route>) {
+    super(repository);
+  }
+}

apps/edr-freight-api/src/modules/routes/routes.service.ts

@@ -0,0 +1,171 @@
+import { BadRequestException, ConflictException, Injectable, NotFoundException } from '@nestjs/common';
+import { DataSource, ILike } from 'typeorm';
+
+import { Yard } from '../rule-engine/entities/yard.entity';
+import { CreateRouteDto } from './dto/create-route.dto';
+import { FilterRoutesDto } from './dto/filter-routes.dto';
+import { UpdateRouteDto } from './dto/update-route.dto';
+import { RouteMilestone } from './entities/route-milestone.entity';
+import { Route } from './entities/route.entity';
+import { RoutesRepository } from './routes.repository';
+
+@Injectable()
+export class RoutesService {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly routesRepository: RoutesRepository,
+  ) {}
+
+  findAll(filter: FilterRoutesDto): Promise<Route[]> {
+    return this.routesRepository.findAll({
+      where: {
+        ...(filter.search ? { name: ILike(`%${filter.search.trim()}%`) } : {}),
+        ...(filter.isActive !== undefined ? { isActive: filter.isActive } : {}),
+      },
+      relations: {
+        originYard: true,
+        destinationYard: true,
+        milestones: { yard: true },
+      },
+      order: {
+        name: 'ASC',
+        milestones: { sequenceNo: 'ASC' },
+      },
+    });
+  }
+
+  async findById(id: string): Promise<Route> {
+    const route = await this.dataSource.getRepository(Route).findOne({
+      where: { id },
+      relations: {
+        originYard: true,
+        destinationYard: true,
+        milestones: { yard: true },
+      },
+      order: { milestones: { sequenceNo: 'ASC' } },
+    });
+
+    if (!route) {
+      throw new NotFoundException(`Route ${id} not found`);
+    }
+
+    return route;
+  }
+
+  async create(dto: CreateRouteDto): Promise<Route> {
+    await this.validateRouteName(dto.name);
+    const validated = await this.validateMilestones(dto.milestones);
+
+    const route = await this.dataSource.transaction(async (manager) => {
+      const savedRoute = await manager.getRepository(Route).save(
+        manager.getRepository(Route).create({
+          name: dto.name.trim(),
+          originYardId: validated.originYardId,
+          destinationYardId: validated.destinationYardId,
+          isActive: dto.isActive ?? true,
+        }),
+      );
+
+      await manager.getRepository(RouteMilestone).save(
+        validated.milestones.map((milestone) =>
+          manager.getRepository(RouteMilestone).create({
+            routeId: savedRoute.id,
+            yardId: milestone.yardId,
+            sequenceNo: milestone.sequenceNo,
+          }),
+        ),
+      );
+
+      return savedRoute;
+    });
+
+    return this.findById(route.id);
+  }
+
+  async update(id: string, dto: UpdateRouteDto): Promise<Route> {
+    const existing = await this.findById(id);
+
+    if (dto.name && dto.name.trim() !== existing.name) {
+      await this.validateRouteName(dto.name, id);
+    }
+
+    const milestoneInput = dto.milestones
+      ? await this.validateMilestones(dto.milestones)
+      : null;
+
+    await this.dataSource.transaction(async (manager) => {
+      await manager.getRepository(Route).update(id, {
+        name: dto.name?.trim() ?? existing.name,
+        originYardId: milestoneInput?.originYardId ?? existing.originYardId,
+        destinationYardId: milestoneInput?.destinationYardId ?? existing.destinationYardId,
+        isActive: dto.isActive ?? existing.isActive,
+      });
+
+      if (milestoneInput) {
+        await manager.getRepository(RouteMilestone).delete({ routeId: id });
+        await manager.getRepository(RouteMilestone).save(
+          milestoneInput.milestones.map((milestone) =>
+            manager.getRepository(RouteMilestone).create({
+              routeId: id,
+              yardId: milestone.yardId,
+              sequenceNo: milestone.sequenceNo,
+            }),
+          ),
+        );
+      }
+    });
+
+    return this.findById(id);
+  }
+
+  async deactivate(id: string): Promise<Route> {
+    await this.findById(id);
+    const updated = await this.routesRepository.update(id, { isActive: false });
+
+    if (!updated) {
+      throw new NotFoundException(`Route ${id} not found`);
+    }
+
+    return this.findById(id);
+  }
+
+  private async validateRouteName(name: string, routeId?: string) {
+    const trimmedName = name.trim();
+    const [existing] = await this.routesRepository.findAll({ where: { name: trimmedName } });
+
+    if (existing && existing.id !== routeId) {
+      throw new ConflictException(`Route name ${trimmedName} already exists`);
+    }
+  }
+
+  private async validateMilestones(milestones: Array<{ yardId: string }>) {
+    if (milestones.length < 2) {
+      throw new BadRequestException('A route requires at least two yards');
+    }
+
+    const normalized = milestones.map((milestone, index) => ({
+      yardId: milestone.yardId,
+      sequenceNo: index + 1,
+    }));
+
+    const uniqueYardIds = [...new Set(normalized.map((milestone) => milestone.yardId))];
+    const yards = await this.dataSource.getRepository(Yard).find({ where: uniqueYardIds.map((id) => ({ id })) });
+    const yardIds = new Set(yards.map((yard) => yard.id));
+
+    for (const milestone of normalized) {
+      if (!yardIds.has(milestone.yardId)) {
+        throw new BadRequestException(`Yard ${milestone.yardId} does not exist`);
+      }
+    }
+
+    if (normalized[0].yardId === normalized[normalized.length - 1].yardId) {
+      throw new BadRequestException('Origin and destination yards must be different');
+    }
+
+    return {
+      originYardId: normalized[0].yardId,
+      destinationYardId: normalized[normalized.length - 1].yardId,
+      milestones: normalized,
+    };
+  }
+}

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

@@ -17,6 +17,7 @@ const locomotive = {
   id: 'loc-1',
   code: 'LOC-001',
   maxPullWeightTons: 3500,
+  maxTrainLengthMeters: 760,
   status: 'AVAILABLE',
 };
 

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

@@ -191,6 +191,7 @@ export class TrainSchedulingService {
     const locomotive = await this.selectOrValidateLocomotive(
       dto.locomotiveId,
       validation.summary.totalWeightTons,
+      validation.summary.totalLengthMeters,
     );
 
     const createdSchedule = await this.dataSource.transaction(
@@ -220,6 +221,15 @@ export class TrainSchedulingService {
           );
         }
 
+        if (
+          Number(lockedLocomotive.maxTrainLengthMeters) <
+          validation.summary.totalLengthMeters
+        ) {
+          throw new BadRequestException(
+            `Locomotive ${lockedLocomotive.code} cannot support ${validation.summary.totalLengthMeters}m`,
+          );
+        }
+
         const existingScheduleCount = await manager
           .getRepository(TrainScheduleBooking)
           .count({
@@ -461,10 +471,14 @@ export class TrainSchedulingService {
           where: { status: "AVAILABLE" },
         });
       const canPull = capableLocomotives.some(
-        (locomotive) => Number(locomotive.maxPullWeightTons) >= totalWeightTons,
+        (locomotive) =>
+          Number(locomotive.maxPullWeightTons) >= totalWeightTons &&
+          Number(locomotive.maxTrainLengthMeters) >= totalLengthMeters,
       );
       if (!canPull) {
-        violations.push("No available locomotive can pull the total weight");
+        violations.push(
+          'No available locomotive can support the total train weight and length',
+        );
       }
     }
 
@@ -513,6 +527,7 @@ export class TrainSchedulingService {
   async selectOrValidateLocomotive(
     locomotiveId: string,
     totalWeightTons: number,
+    totalLengthMeters: number,
   ) {
     const locomotive = await this.locomotivesRepository.findById(locomotiveId);
 
@@ -532,6 +547,12 @@ export class TrainSchedulingService {
       );
     }
 
+    if (Number(locomotive.maxTrainLengthMeters) < totalLengthMeters) {
+      throw new BadRequestException(
+        `Locomotive ${locomotive.code} cannot support ${totalLengthMeters}m`,
+      );
+    }
+
     return locomotive;
   }
 
@@ -711,6 +732,9 @@ export class TrainSchedulingService {
               maxPullWeightTons: this.roundTons(
                 Number(schedule.trainSet.locomotive.maxPullWeightTons),
               ),
+              maxTrainLengthMeters: this.roundTons(
+                Number(schedule.trainSet.locomotive.maxTrainLengthMeters),
+              ),
             }
             : null,
           wagons: [...(schedule.trainSet.wagons ?? [])]