Implement connection from checkpoint in Path to timepoint in gtfs

Ayelander · iTzxMigz · commit 48bdfe0ea00b · 2026-04-09T23:25:04.000-04:00
diff --git a/packages/transition-backend/src/services/gtfsExport/ScheduleExporter.ts b/packages/transition-backend/src/services/gtfsExport/ScheduleExporter.ts
@@ -39,7 +39,7 @@ const objectToGtfs = (
 
     const periods = schedule.periods;
 
-    const pathsById: { [key: string]: { path: Path; distances: number[] } } = {};
+    const pathsById: { [key: string]: { path: Path; distances: number[]; checkpointNodeIds: Set<string> } } = {};
 
     for (let periodIdx = 0, countI = periods.length; periodIdx < countI; periodIdx++) {
         const trips = periods[periodIdx].trips || [];
@@ -52,14 +52,26 @@ const objectToGtfs = (
                     continue;
                 }
                 const newPath = pathCollection.newObject(pathGeojson);
-                pathsById[trip.path_id] = { path: newPath, distances: newPath.getCoordinatesDistanceTraveledMeters() };
+                const checkpointNodeIds = new Set<string>();
+                const checkpoints = newPath.attributes.data.segmentTimesCheckpoints;
+                if (checkpoints && checkpoints.length > 0) {
+                    for (const cp of checkpoints) {
+                        checkpointNodeIds.add(cp.fromNodeId);
+                        checkpointNodeIds.add(cp.toNodeId);
+                    }
+                }
+                pathsById[trip.path_id] = {
+                    path: newPath,
+                    distances: newPath.getCoordinatesDistanceTraveledMeters(),
+                    checkpointNodeIds
+                };
                 pathIds[newPath.id] = true;
                 const nodes = newPath.attributes.nodes;
                 for (let nodeI = 0, countNodes = nodes.length; nodeI < countNodes; nodeI++) {
                     nodeIds[nodes[nodeI]] = true;
                 }
             }
-            const { path, distances: pathDistancesTraveledMeters } = pathsById[trip.path_id];
+            const { path, distances: pathDistancesTraveledMeters, checkpointNodeIds } = pathsById[trip.path_id];
             const pathGeography = path.attributes.geography;
             const pathCoordinates = pathGeography.coordinates;
             const pathNodeIds = path.attributes.nodes;
@@ -122,7 +134,13 @@ const objectToGtfs = (
                     continuous_pickup: 1, // optional, TODO: implement other choices (0: continousu pick up, 2: must phone agency, 3: must coordinate with driver)
                     continuous_drop_off: 1, // optional, TODO: implement other choices (0: continousu drop off, 2: must phone agency, 3: must coordinate with driver)
                     shape_dist_traveled: Math.round(distanceTraveledKm * 1000) / 1000, // optional
-                    timepoint: 1 as const // optional, TODO: implement approximate: 0 (exact: 1)
+                    timepoint:
+                        checkpointNodeIds.size === 0 ||
+                        k === 0 ||
+                        k === countK - 1 ||
+                        checkpointNodeIds.has(pathNodeIds[k])
+                            ? (1 as const)
+                            : (0 as const)
                 };
                 gtfsStopTimes.push(stopTime);
             }
diff --git a/packages/transition-backend/src/services/gtfsExport/__tests__/ScheduleExporter.test.ts b/packages/transition-backend/src/services/gtfsExport/__tests__/ScheduleExporter.test.ts
@@ -59,8 +59,25 @@ const pathAttributes2 = {
     nodes: [uuidV4(), uuidV4(), uuidV4(), uuidV4()],
 }
 
+// Third path with checkpoints: nodes[0] and nodes[2] are checkpoint boundaries
+const pathWithCheckpointsAttributes = {
+    ...pathAttributes,
+    id: uuidV4(),
+    nodes: [uuidV4(), uuidV4(), uuidV4(), uuidV4()],
+    data: {
+        segmentTimesCheckpoints: [
+            { fromNodeId: '', toNodeId: '' } // will be set after node IDs are known
+        ]
+    },
+};
+// Set checkpoint to reference nodes[0] → nodes[2]
+pathWithCheckpointsAttributes.data.segmentTimesCheckpoints = [
+    { fromNodeId: pathWithCheckpointsAttributes.nodes[0], toNodeId: pathWithCheckpointsAttributes.nodes[2] }
+];
+
 const path = new Path(pathAttributes, false);
 const path2 = new Path(pathAttributes2, false);
+const pathWithCheckpoints = new Path(pathWithCheckpointsAttributes, false);
 // Convert distances in km, same coordinates for both patsh
 const pathDistances = path.getCoordinatesDistanceTraveledMeters().map(dist => Math.round(dist) / 1000);
 const lineId = uuidV4();
@@ -239,7 +256,7 @@ const mockReadForLines = schedulesDbQueries.readForLines as jest.MockedFunction<
 jest.mock('../../../models/db/transitPaths.db.queries', () => {
     return {
         geojsonCollection: jest.fn().mockImplementation(async () => {
-            return { type: 'FeatureCollection', features: [path.toGeojson(), path2.toGeojson()] };
+            return { type: 'FeatureCollection', features: [path.toGeojson(), path2.toGeojson(), pathWithCheckpoints.toGeojson()] };
         })
     }
 });
@@ -619,3 +636,81 @@ test('Test GTFS compliance - handles >24h times for midnight-crossing schedules'
     expect(firstHour).toBeGreaterThanOrEqual(24);
     expect(secondHour).toBeGreaterThanOrEqual(24);
 });
+
+test('Test checkpoint nodes are exported as timepoints, others as approximate', async () => {
+    // Path has 4 nodes with checkpoint on nodes[0]→nodes[2]
+    // So nodes[0] and nodes[2] are checkpoint boundaries → timepoint=1
+    // nodes[1] is intermediate → timepoint=0
+    // nodes[3] is last stop → timepoint=1 (GTFS convention)
+    const scheduleWithCheckpoints: ScheduleAttributes = {
+        allow_seconds_based_schedules: false,
+        id: uuidV4(),
+        integer_id: 10,
+        line_id: lineId,
+        service_id: serviceId,
+        is_frozen: false,
+        data: {},
+        periods: [{
+            schedule_id: 10,
+            id: uuidV4(),
+            integer_id: 1,
+            data: {},
+            end_at_hour: 12,
+            interval_seconds: 1800,
+            outbound_path_id: pathWithCheckpointsAttributes.id,
+            period_shortname: 'morning',
+            start_at_hour: 7,
+            trips: [{
+                arrival_time_seconds: 27015,
+                departure_time_seconds: 25200,
+                id: uuidV4(),
+                node_arrival_times_seconds: [25200, 25251, 26250, 27015],
+                node_departure_times_seconds: [25200, 25261, 26260, 27015],
+                nodes_can_board: [true, true, true, false],
+                nodes_can_unboard: [false, true, true, true],
+                path_id: pathWithCheckpointsAttributes.id,
+                seated_capacity: 20,
+                total_capacity: 50,
+                schedule_period_id: 1,
+                data: {}
+            }]
+        }],
+        periods_group_shortname: 'all_day',
+    };
+
+    mockReadForLines.mockResolvedValueOnce([scheduleWithCheckpoints]);
+    const response = await exportSchedule([lineId], { directoryPath: 'test', quotesFct: quoteFct, serviceToGtfsId });
+    expect(response.status).toEqual('success');
+
+    const stopTimesOutput = mockWriteStopTimeStream.write.mock.calls[0][0] as string;
+    const stopTimesLines = stopTimesOutput.split('\n').filter(line => line.trim() && !line.startsWith('"trip_id"'));
+
+    expect(stopTimesLines).toHaveLength(4);
+
+    // Parse timepoint values (last field in each CSV line)
+    const timepoints = stopTimesLines.map(line => {
+        const fields = line.split(',');
+        return parseInt(fields[fields.length - 1]);
+    });
+
+    // nodes[0] = checkpoint boundary → 1, nodes[1] = intermediate → 0,
+    // nodes[2] = checkpoint boundary → 1, nodes[3] = last stop → 1
+    expect(timepoints).toEqual([1, 0, 1, 1]);
+});
+
+test('Test path without checkpoints exports all timepoints as 1', async () => {
+    // pathAttributes has no checkpoints (data: {})
+    mockReadForLines.mockResolvedValueOnce([scheduleAttributes1]);
+    const response = await exportSchedule([lineId], { directoryPath: 'test', quotesFct: quoteFct, serviceToGtfsId });
+    expect(response.status).toEqual('success');
+
+    const stopTimesOutput = mockWriteStopTimeStream.write.mock.calls[0][0] as string;
+    const stopTimesLines = stopTimesOutput.split('\n').filter(line => line.trim() && !line.startsWith('"trip_id"'));
+
+    // All timepoints should be 1 when no checkpoints exist
+    stopTimesLines.forEach(line => {
+        const fields = line.split(',');
+        const timepoint = parseInt(fields[fields.length - 1]);
+        expect(timepoint).toBe(1);
+    });
+});
diff --git a/packages/transition-backend/src/services/gtfsImport/PathImporter.ts b/packages/transition-backend/src/services/gtfsImport/PathImporter.ts
@@ -120,6 +120,31 @@ type PathGroup = {
     trips: TripData[];
 };
 
+/** Derive checkpoints from GTFS timepoint data on a representative trip's stop_times.
+ *  Only creates checkpoints if some (but not all) stops are timepoints. */
+const deriveCheckpointsFromTimepoints = (
+    newPath: Path,
+    allStopTimes: StopTime[][],
+    nodeIds: string[],
+    importData: GtfsInternalData
+): void => {
+    const representativeStopTimes = allStopTimes[0];
+    if (!representativeStopTimes || representativeStopTimes.length === 0) return;
+
+    const timepointNodeIds = representativeStopTimes
+        .filter((st) => st.timepoint === 1)
+        .map((st) => importData.nodeIdsByStopGtfsId[st.stop_id]);
+
+    // Only create checkpoints if there's actual segmentation (not all stops are timepoints)
+    if (timepointNodeIds.length >= 2 && timepointNodeIds.length < nodeIds.length) {
+        const checkpoints: { fromNodeId: string; toNodeId: string }[] = [];
+        for (let i = 0; i < timepointNodeIds.length - 1; i++) {
+            checkpoints.push({ fromNodeId: timepointNodeIds[i], toNodeId: timepointNodeIds[i + 1] });
+        }
+        newPath.attributes.data.segmentTimesCheckpoints = checkpoints;
+    }
+};
+
 const generatePathsForLine = (
     line: Line,
     tripsForLine: TripData[],
@@ -205,6 +230,7 @@ const generatePathsForLine = (
                 importData,
                 tripsWithService
             );
+            deriveCheckpointsFromTimepoints(newPath, allStopTimes, nodeIds, importData);
             newPaths.push(newPath);
             const pathsForShape = pathByShapeId[shapeId] || [];
             pathsForShape.push(newPath);
@@ -226,6 +252,7 @@ const generatePathsForLine = (
                 importData,
                 tripsWithService
             );
+            deriveCheckpointsFromTimepoints(newPath, allStopTimes, nodeIds, importData);
             newPaths.push(newPath);
             pathsWithoutShape.push(newPath);
             for (const tripData of trips) {
diff --git a/packages/transition-backend/src/services/gtfsImport/__tests__/PathImporter.test.ts b/packages/transition-backend/src/services/gtfsImport/__tests__/PathImporter.test.ts
@@ -540,3 +540,90 @@ describe('One line, 3 trips with no shape', () => {
     });
 
 });
+
+describe('Timepoint to checkpoint mapping', () => {
+    beforeEach(() => {
+        importData.shapeById = {};
+        importData.shapeById['timepointShape'] = [
+            { shape_id: 'timepointShape', shape_pt_lat: 45.538, shape_pt_lon: -73.614, shape_pt_sequence: 0 },
+            { shape_id: 'timepointShape', shape_pt_lat: 45.539, shape_pt_lon: -73.613, shape_pt_sequence: 5 },
+            { shape_id: 'timepointShape', shape_pt_lat: 45.540, shape_pt_lon: -73.612, shape_pt_sequence: 10 },
+            { shape_id: 'timepointShape', shape_pt_lat: 45.541, shape_pt_lon: -73.611, shape_pt_sequence: 20 },
+        ];
+        importData.stopCoordinatesByStopId = {
+            stop1: [-73.614, 45.538] as [number, number],
+            stop2: [-73.613, 45.539] as [number, number],
+            stop3: [-73.612, 45.540] as [number, number],
+            stop4: [-73.611, 45.541] as [number, number]
+        };
+    });
+
+    test('Creates checkpoints from mixed timepoint values', async () => {
+        const tripId = 'timepointTrip';
+        const tripsByRouteId = {};
+        tripsByRouteId[routeId] = [{
+            trip: { route_id: routeId, service_id: uuidV4(), trip_id: tripId, trip_headsign: 'Test', direction_id: 0, shape_id: 'timepointShape' },
+            stopTimes: [
+                { trip_id: tripId, stop_id: 'stop1', stop_sequence: 1, arrivalTimeSeconds: 36000, departureTimeSeconds: 36000, timepoint: 1 },
+                { trip_id: tripId, stop_id: 'stop2', stop_sequence: 2, arrivalTimeSeconds: 36090, departureTimeSeconds: 36100, timepoint: 0 },
+                { trip_id: tripId, stop_id: 'stop3', stop_sequence: 3, arrivalTimeSeconds: 36180, departureTimeSeconds: 36200, timepoint: 1 },
+                { trip_id: tripId, stop_id: 'stop4', stop_sequence: 4, arrivalTimeSeconds: 36300, departureTimeSeconds: 36300, timepoint: 1 }
+            ]
+        }];
+
+        const result = await PathImporter.generateAndImportPaths(tripsByRouteId, importData, collectionManager) as any;
+        expect(result.status).toEqual('success');
+
+        const createdPathAttribs = (pathsDbQueries.createMultiple as any).mock.calls[0][0][0];
+        // Timepoint stops: stop1 (nodeId1), stop3 (nodeId3), stop4 (nodeId4)
+        // → checkpoints: [{nodeId1, nodeId3}, {nodeId3, nodeId4}]
+        expect(createdPathAttribs.data.segmentTimesCheckpoints).toEqual([
+            { fromNodeId: nodeId1, toNodeId: nodeId3 },
+            { fromNodeId: nodeId3, toNodeId: nodeId4 }
+        ]);
+    });
+
+    test('Does not create checkpoints when all stops are timepoints', async () => {
+        const tripId = 'allTimepointTrip';
+        const tripsByRouteId = {};
+        tripsByRouteId[routeId] = [{
+            trip: { route_id: routeId, service_id: uuidV4(), trip_id: tripId, trip_headsign: 'Test', direction_id: 0, shape_id: 'timepointShape' },
+            stopTimes: [
+                { trip_id: tripId, stop_id: 'stop1', stop_sequence: 1, arrivalTimeSeconds: 36000, departureTimeSeconds: 36000, timepoint: 1 },
+                { trip_id: tripId, stop_id: 'stop2', stop_sequence: 2, arrivalTimeSeconds: 36090, departureTimeSeconds: 36100, timepoint: 1 },
+                { trip_id: tripId, stop_id: 'stop3', stop_sequence: 3, arrivalTimeSeconds: 36180, departureTimeSeconds: 36200, timepoint: 1 },
+                { trip_id: tripId, stop_id: 'stop4', stop_sequence: 4, arrivalTimeSeconds: 36300, departureTimeSeconds: 36300, timepoint: 1 }
+            ]
+        }];
+
+        const result = await PathImporter.generateAndImportPaths(tripsByRouteId, importData, collectionManager) as any;
+        expect(result.status).toEqual('success');
+
+        const createdPathAttribs = (pathsDbQueries.createMultiple as any).mock.calls[0][0][0];
+        expect(createdPathAttribs.data.segmentTimesCheckpoints).toBeUndefined();
+    });
+
+    test('Creates checkpoints from timepoints without shape', async () => {
+        const tripId = 'noShapeTimepointTrip';
+        const tripsByRouteId = {};
+        tripsByRouteId[routeId] = [{
+            trip: { route_id: routeId, service_id: uuidV4(), trip_id: tripId, trip_headsign: 'Test', direction_id: 0 },
+            stopTimes: [
+                { trip_id: tripId, stop_id: 'stop1', stop_sequence: 1, arrivalTimeSeconds: 36000, departureTimeSeconds: 36000, timepoint: 1 },
+                { trip_id: tripId, stop_id: 'stop2', stop_sequence: 2, arrivalTimeSeconds: 36090, departureTimeSeconds: 36100, timepoint: 0 },
+                { trip_id: tripId, stop_id: 'stop3', stop_sequence: 3, arrivalTimeSeconds: 36180, departureTimeSeconds: 36200, timepoint: 0 },
+                { trip_id: tripId, stop_id: 'stop4', stop_sequence: 4, arrivalTimeSeconds: 36300, departureTimeSeconds: 36300, timepoint: 1 }
+            ]
+        }];
+
+        const result = await PathImporter.generateAndImportPaths(tripsByRouteId, importData, collectionManager) as any;
+        expect(result.status).toEqual('success');
+
+        const createdPathAttribs = (pathsDbQueries.createMultiple as any).mock.calls[0][0][0];
+        // Timepoint stops: stop1 (nodeId1), stop4 (nodeId4)
+        // → checkpoints: [{nodeId1, nodeId4}]
+        expect(createdPathAttribs.data.segmentTimesCheckpoints).toEqual([
+            { fromNodeId: nodeId1, toNodeId: nodeId4 }
+        ]);
+    });
+});
