expose per-side facility flags

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

@@ -8,6 +8,24 @@ import { UpdateYardDto } from '../dto/update-yard.dto';
 import { Yard } from '../entities/yard.entity';
 import { IYardsRepository, YARDS_REPOSITORY } from '../interfaces/yards.repository.interface';
 import { DisplayOrderService } from './display-order.service';
+import { YardFacilitiesService, YardSideFlags } from './yard-facilities.service';
+
+/** Yard rows the config page lists/edits carry the stored per-side facility flags. */
+export type YardWithSideFlags = Yard & YardSideFlags;
+
+const SIDE_FLAG_KEYS = [
+  'hasContainerFacilityOrigin',
+  'hasBulkFacilityOrigin',
+  'hasContainerFacilityDestination',
+  'hasBulkFacilityDestination',
+] as const;
+
+const NO_FLAGS: YardSideFlags = {
+  hasContainerFacilityOrigin: false,
+  hasBulkFacilityOrigin: false,
+  hasContainerFacilityDestination: false,
+  hasBulkFacilityDestination: false,
+};
 
 @Injectable()
 export class YardsService {
@@ -15,18 +33,34 @@ export class YardsService {
     @Inject(YARDS_REPOSITORY)
     private readonly repository: IYardsRepository,
     private readonly displayOrder: DisplayOrderService,
+    private readonly facilities: YardFacilitiesService,
   ) {}
 
   /** List yards — standard paginated envelope with server-side search. */
-  async findAll(query: ListYardsQueryDto): Promise<PaginatedResponse<Yard>> {
-    return this.repository.findPaged(query);
+  async findAll(query: ListYardsQueryDto): Promise<PaginatedResponse<YardWithSideFlags>> {
+    const page = await this.repository.findPaged(query);
+    const flags = await this.facilities.sideFlagsForYards(page.items.map((y) => y.id));
+    return {
+      ...page,
+      items: page.items.map((y) => ({ ...y, ...NO_FLAGS, ...flags.get(y.id) })),
+    };
   }
 
   /** Get a yard by ID. */
-  async findById(id: string): Promise<Yard> {
+  async findById(id: string): Promise<YardWithSideFlags> {
     const entity = await this.repository.findById(id);
     if (!entity) throw new NotFoundException(`Yard ${id} not found`);
-    return entity;
+    const flags = await this.facilities.sideFlagsForYards([id]);
+    return { ...entity, ...NO_FLAGS, ...flags.get(id) };
+  }
+
+  /** The per-side facility flags present in the dto, or null when none were sent. */
+  private pickSideFlags(dto: Partial<CreateYardDto>): Partial<YardSideFlags> | null {
+    const flags: Partial<YardSideFlags> = {};
+    for (const key of SIDE_FLAG_KEYS) {
+      if (dto[key] !== undefined) flags[key] = dto[key];
+    }
+    return Object.keys(flags).length > 0 ? flags : null;
   }
 
   /** Create a yard. */
@@ -43,7 +77,7 @@ export class YardsService {
       insertAfterId: dto.insertAfterId,
     });
 
-    return this.repository.create({
+    const yard = await this.repository.create({
       code,
       label: dto.label,
       country: dto.country,
@@ -51,15 +85,28 @@ export class YardsService {
       hasFacility: dto.hasFacility ?? false,
       displayOrder,
     });
+
+    const flags = this.pickSideFlags(dto);
+    if (flags) await this.facilities.upsertSideFlags(yard.id, flags);
+    return this.findById(yard.id);
   }
 
   /** Update a yard. */
   async update(id: string, dto: UpdateYardDto): Promise<Yard> {
     await this.findById(id);
     if (dto.label !== undefined) await this.assertLabelAvailable(dto.label, id);
-    const updated = await this.repository.update(id, dto);
-    if (!updated) throw new NotFoundException(`Yard ${id} not found`);
-    return updated;
+
+    // Per-side flags live on yard_facilities, not the yards row — split them out.
+    const flags = this.pickSideFlags(dto);
+    const yardDto = { ...dto };
+    for (const key of SIDE_FLAG_KEYS) delete yardDto[key];
+
+    if (Object.keys(yardDto).length > 0) {
+      const updated = await this.repository.update(id, yardDto);
+      if (!updated) throw new NotFoundException(`Yard ${id} not found`);
+    }
+    if (flags) await this.facilities.upsertSideFlags(id, flags);
+    return this.findById(id);
   }
 
   /** No two active yards may share a label (case/whitespace-insensitive). */