@transportme/load-ptv-gtfs 1.0.0

package/lib/gtfs-parser/GTFSTrip.mjs

@@ -0,0 +1,169 @@
+import { TRANSIT_MODES } from '../constants.mjs'
+import GTFSCalendar from './GTFSCalendar.mjs'
+
+export default class GTFSTrip {
+  
+  #routeGTFSID
+  #operationDays
+  #tripID
+  #shapeID
+  #headsign
+  #direction
+  #block
+
+  /**
+   * 
+   * @param {Object} param0 The trip data
+   * @param {string} param0.routeGTFSID The route ID associated with the trip. This should be the raw ID, eg "6-123-mjp-1"
+   * @param {GTFSCalendar} param0.calendar The calendar type
+   * @param {string} param0.id The unique trip ID
+   * @param {string} param0.shapeID The shape ID associate with the trip
+   * @param {string} param0.headsign The headsign on the vehicle serving the trip
+   * @param {string} param0.direction The direction of the trip. "0" for outbound and "1" for inbound trips.
+   * @param {string} param0.block The block ID of the trip.
+   */
+  constructor({ routeGTFSID, calendar, id, shapeID, headsign, direction, block }) {
+    this.#routeGTFSID = routeGTFSID
+    this.#operationDays = calendar.getOperationDays()
+    this.#tripID = id
+    this.#shapeID = shapeID
+    this.#headsign = headsign
+    this.#direction = direction
+    this.#block = block
+  }
+
+  /**
+   * Checks if the GTFSTrip (or subclass) is able to process the given trip data
+   * @param {Object} data The trip being checked
+   * @returns true if the class is able to process the trip
+   */
+  static canProcess(data) {
+    return true
+  }
+
+  /**
+   * Creates a new GTFSTrip with the trip data that was passed in
+   * @param {Object} data The trip data being created
+   * @param {string} mode The transit mode
+   * @returns {GTFSTrip} A trip instance representing the data being passed in
+   */
+  static create(data, mode) {
+    let types = [ SmartrakTrip, MetroTrip, GTFSTrip ]
+    for (let type of types) {
+      if (type.canProcess(data, mode)) return new type(data)
+    }
+  }
+
+  /**
+   * Gets the trip data in a database friendly format
+   * @returns {Object} The trip data that will be saved into the database
+   */
+  getTripData() {
+    return {
+      routeGTFSID: this.getRouteGTFSID(),
+      operationDays: this.getOperationDays(),
+      tripID: this.getTripID(),
+      shapeID: this.getShapeID(),
+      block: this.getBlock(),
+      gtfsDirection: this.getGTFSDirection()
+    }
+  }
+
+  getBlock() {
+    return this.#block || null
+  }
+
+  getOperationDays() {
+    return this.#operationDays
+  }
+
+  getRouteGTFSID() {
+    return this.#routeGTFSID
+  }
+
+  getShapeID() {
+    return this.#shapeID
+  }
+
+  getTripID() {
+    return this.#tripID
+  }
+
+  getHeadsign() {
+    return this.#headsign
+  }
+
+  getGTFSDirection() {
+    return parseInt(this.#direction)
+  }
+}
+
+/**
+ * Used to represent a Smartrak bus trip.
+ * 
+ * Trip IDs are of the form DEPOT-ROUTE--ROUTE_VARIANT-ROSTER-TRIP_ID
+ * 
+ * Example: 13-476--1-Sat5-34737060
+ */
+export class SmartrakTrip extends GTFSTrip {
+
+  #depotID
+
+  constructor(data) {
+    super(data)
+
+    let depotID = data.id.match(/^(\d{2})-\w+/)
+    this.#depotID = depotID[1]
+  }
+
+  static canProcess(data, mode) {
+    return mode === TRANSIT_MODES.bus && data.id.match(/^(\d{2})-\w+/)
+  }
+
+  getTripData() {
+    return {
+      ...super.getTripData(),
+      depotID: this.getDepotID()
+    }
+  }
+
+  getDepotID() {
+    return parseInt(this.#depotID)
+  }
+
+}
+
+/**
+ * Used to represent a Metro train trip.
+ * 
+ * Trip IDs are of the form 02-ROUTE--ROUTE_VARIANT-ROSTER-TDN. Note that TDNs are alphanumeric
+ * 
+ * Example: 02-BEG--58-T5_n4-3651
+ */
+export class MetroTrip extends GTFSTrip {
+
+  #runID
+
+  constructor(data) {
+    super(data)
+
+    let runID = data.id.match(/^02-\w{3}-.*-(\w\d{3})$/)
+    this.#runID = runID[1]
+  }
+
+  static canProcess(data, mode) {
+    return mode === TRANSIT_MODES.metroTrain && data.id.match(/^02-\w{3}-.*-(\w\d{3})$/)
+  }
+
+  getTripData() {
+    return {
+      ...super.getTripData(),
+      runID: this.getRunID()
+    }
+  }
+
+  getRunID() {
+    return this.#runID
+  }
+
+}

package/lib/gtfs-parser/readers/GTFSAgencyReader.mjs

@@ -0,0 +1,27 @@
+import GTFSAgency from '../GTFSAgency.mjs'
+import GTFSReader from './GTFSReader.mjs'
+
+export default class GTFSAgencyReader extends GTFSReader {
+ 
+  /**
+   * Converts a CSV row into an operator object
+   * 
+   * @param {object} data A JSON object containing the following fields:
+   * - id: The operator ID
+   * - name: The operator name
+   * - website: The operator's website
+   * - phone: The operator's phone number
+   * 
+   * @returns {GTFSAgency} An object representing the operator data
+   */
+  processEntity(data) {
+    let agencyData = {
+      id: data.agency_id,
+      name: data.agency_name,
+      website: data.agency_url,
+      phone: data.agency_phone
+    }
+
+    return new GTFSAgency(agencyData)
+  }
+}

package/lib/gtfs-parser/readers/GTFSCalendarDatesReader.mjs

@@ -0,0 +1,25 @@
+import GTFSCalendarDate from '../GTFSCalendarDate.mjs'
+import GTFSReader from './GTFSReader.mjs'
+
+export default class GTFSCalendarDateReader extends GTFSReader {
+
+  /**
+   * Converts a CSV row into an operator object
+   * 
+   * @param {object} data A JSON object containing the following fields:
+   * @param {string} data.id The calendar ID
+   * @param {string} data.date The calendar date
+   * @param {string} data.type The exception type
+   * 
+   * @returns {GTFSCalendarDate} An object representing the calendar date entry
+   */
+  processEntity(data) {
+    let calendarDateData = {
+      id: data.service_id,
+      date: data.date,
+      type: data.exception_type
+    }
+
+    return new GTFSCalendarDate(calendarDateData)
+  }
+}

package/lib/gtfs-parser/readers/GTFSCalendarReader.mjs

@@ -0,0 +1,63 @@
+import GTFSCalendar from '../GTFSCalendar.mjs'
+import GTFSCalendarDateReader from './GTFSCalendarDatesReader.mjs'
+import GTFSReader from './GTFSReader.mjs'
+
+export default class GTFSCalendarReader extends GTFSReader {
+
+  #calendarDateFile
+  #calendarDates = {}
+
+  /**
+   * Constructs a new GTFS Calendar reader.
+   * 
+   * @param {string} calendarFile The path to the GTFS Calendar file
+   * @param {string} calendarDateFile The path to the GTFS Calendar Dates file
+   */
+  constructor(calendarFile, calendarDateFile) {
+    super(calendarFile)
+    this.#calendarDateFile = calendarDateFile
+  }
+
+  async open() {
+    await super.open()
+
+    let calendarDateReader = new GTFSCalendarDateReader(this.#calendarDateFile)
+    await calendarDateReader.open()
+    while (calendarDateReader.available()) {
+      let calendarDate = await calendarDateReader.getNextEntity()
+      if (!this.#calendarDates[calendarDate.id]) this.#calendarDates[calendarDate.id] = []
+      this.#calendarDates[calendarDate.id].push(calendarDate)
+    }
+  }
+
+  /**
+   * Converts a CSV row into a calendar object
+   * 
+   * @param {object} data A JSON object containing the following fields:
+   * @param {string} data.id The calendar ID
+   * @param {string} data.monday Indicates if a service will operate on a Monday within the given date range. "1" for operating and "0" for not operating.
+   * @param {string} data.tuesday Same as data.monday but for Tuesday
+   * @param {string} data.wednesday Same as data.monday but for Wednesday
+   * @param {string} data.thursday Same as data.monday but for Thursday
+   * @param {string} data.friday Same as data.monday but for Friday
+   * @param {string} data.saturday Same as data.monday but for Saturday
+   * @param {string} data.sunday Same as data.monday but for Sunday
+   * @param {string} data.startDay The start day of the calendar interval (inclusive).
+   * @param {string} data.endDay The end day of the calendar interval (inclusive).
+   * 
+   * @returns {GTFSCalendar} An object representing the operator data
+   */
+  processEntity(data) {
+    let calendarData = {
+      id: data.service_id,
+      daysOfWeek: [
+        data.monday, data.tuesday, data.wednesday, data.thursday,
+        data.friday, data.saturday, data.sunday
+      ],
+      startDay: data.start_date,
+      endDay: data.end_date
+    }
+
+    return new GTFSCalendar(calendarData, this.#calendarDates[data.service_id])
+  }
+}

package/lib/gtfs-parser/readers/GTFSReader.mjs

@@ -0,0 +1,48 @@
+import CSVLineReader from './line-reader.mjs'
+
+export default class GTFSReader {
+ 
+  /** @type {string} */
+  #file
+  #reader
+
+  constructor(file) {
+    this.#file = file
+    this.#reader = new CSVLineReader(file)
+  }
+
+  /**
+   * Opens the underlying `CSVLineReader`
+   */
+  async open() {
+    await this.#reader.open()
+  }
+
+  /**
+   * Checks if there is more data available for reading
+   * 
+   * @returns {boolean} Returns true if there is more data available
+   */
+  available() {
+    return this.#reader.available()
+  }
+
+  /**
+   * Gets the data of the next entity in the file.
+   * 
+   * @returns {Promise<GTFSEntity>} The data of the next entity
+   */
+  async getNextEntity() {
+    return this.processEntity(await this.#reader.nextLine())
+  }
+
+  /**
+   * Converts a CSV row into its entity data
+   * @param {object} data The CSV row data
+   * 
+   * @returns {GTFSEntity} An object representing the entity data
+   */
+  processEntity(data) {
+    return null
+  }
+}

package/lib/gtfs-parser/readers/GTFSRouteReader.mjs

@@ -0,0 +1,35 @@
+import GTFSRoute from '../GTFSRoute.mjs'
+import GTFSReader from './GTFSReader.mjs'
+
+export default class GTFSRouteReader extends GTFSReader {
+ 
+  /** @type {string} */
+  #mode
+
+  constructor(file, mode) {
+    super(file, mode)
+    this.#mode = mode
+  }
+
+  /**
+   * Converts a CSV row into a route object
+   * 
+   * @param {object} data A JSON object containing the following fields:
+   * - routeGTFSID: The route ID
+   * - agencyID: The route agency ID
+   * - routeNumber: The route number, or empty if it does not exist
+   * - routeName: The route name
+   * @param {string} mode The route mode (eg: bus, metro train)
+   * @returns {GTFSRoute} An object representing the route data
+   */
+  processEntity(data) {
+    let routeData = {
+      routeGTFSID: data.route_id,
+      agencyID: data.agency_id,
+      routeNumber: data.route_short_name,
+      routeName: data.route_long_name
+    }
+
+    return GTFSRoute.create(routeData, this.#mode)
+  } 
+}

package/lib/gtfs-parser/readers/GTFSShapeReader.mjs

@@ -0,0 +1,75 @@
+import { GTFSShape, GTFSShapePoint } from '../GTFSShape.mjs'
+import CSVLineReader from './line-reader.mjs'
+
+export default class GTFSShapeReader {
+
+  /** @type {string} */
+  #file
+  #reader
+
+  constructor(file) {
+    this.#file = file
+    this.#reader = new CSVLineReader(file)
+  }
+
+  /**
+   * Opens the underlying `CSVLineReader`
+   */
+  async open() {
+    await this.#reader.open()
+  }
+
+  /**
+   * Checks if there is more data available for reading
+   * 
+   * @returns {boolean} Returns true if there is more data available
+   */
+  available() {
+    return this.#reader.available()
+  }
+
+  /**
+     * Gets the data of the next entity in the file.
+     * 
+     * @returns {Promise<GTFSEntity>} The data of the next entity
+     */
+  async getNextEntity() {
+    let firstLine = await this.#reader.nextLine()
+    let shapeID = firstLine.shape_id
+    
+    let lines = [ firstLine ]
+
+    while (this.#reader.available()) {
+      let nextLine = await this.#reader.nextLine()
+      if (nextLine.shape_id !== shapeID) {
+        this.#reader.unreadLine()
+        break
+      } else {
+        lines.push(nextLine)
+      }
+    }
+
+    return new GTFSShape(shapeID, lines.map(line => this.processEntity(line)))
+  }
+
+  /**
+   * Converts a CSV row into a shape point object
+   * 
+   * @param {object} data A JSON object containing the following fields:
+   * @param {string} data.shape_pt_lat The shape point's latitude
+   * @param {string} data.shape_pt_lon The shape point's longitude
+   * @param {string} data.shape_pt_sequence The shape point's sequence in the overall shape
+   * @param {string} data.shape_dist_traveled The distance travelled up to that point in the shape
+   * 
+   * @returns {GTFSShapePoint} An object representing the shape data
+   */
+  processEntity(data) {
+    let shapeData = {
+      latitude: parseFloat(data.shape_pt_lat),
+      longitude: parseFloat(data.shape_pt_lon),
+      distance: parseFloat(data.shape_dist_traveled)
+    }
+
+    return new GTFSShapePoint(shapeData)
+  }
+}

package/lib/gtfs-parser/readers/GTFSStopTimesReader.mjs

@@ -0,0 +1,85 @@
+import { GTFSStopTime } from '../GTFSStopTime.mjs'
+import CSVLineReader from './line-reader.mjs'
+
+export default class GTFSStopTimesReader {
+
+  /** @type {string} */
+  #file
+  #reader
+
+  constructor(file) {
+    this.#file = file
+    this.#reader = new CSVLineReader(file)
+  }
+
+  /**
+   * Opens the underlying `CSVLineReader`
+   */
+  async open() {
+    await this.#reader.open()
+  }
+
+  /**
+   * Checks if there is more data available for reading
+   * 
+   * @returns {boolean} Returns true if there is more data available
+   */
+  available() {
+    return this.#reader.available()
+  }
+
+  /**
+     * Gets the data of the next entity in the file.
+     * 
+     * @returns {Promise<GTFSEntity>} The data of the next entity
+     */
+  async getNextEntity() {
+    let firstLine = await this.#reader.nextLine()
+    let tripID = firstLine.trip_id
+    
+    let lines = [ firstLine ]
+
+    while (this.#reader.available()) {
+      let nextLine = await this.#reader.nextLine()
+      if (nextLine.trip_id !== tripID) {
+        this.#reader.unreadLine()
+        break
+      } else {
+        lines.push(nextLine)
+      }
+    }
+
+    return {
+      tripID,
+      stops: lines.map(line => this.processEntity(line))
+    }
+  }
+
+  /**
+   * Converts a CSV row into a stop time object
+   * 
+   * @param {object} data A JSON object containing the following fields:
+   * @param {string} data.arrival_time The stop's arrival time
+   * @param {string} data.departure_time The stop's departure time
+   * @param {string} data.stop_id The stop ID
+   * @param {string} data.stop_sequence The stop sequence
+   * @param {string} data.pickup_type The pickup conditions. "0" for no restrictions and "1" for no pickup allowed
+   * @param {string} data.drop_off_type The dropoff conditions. "0" for no restrictions and "1" for no dropoff allowed
+   * @param {string} data.shape_dist_traveled The distance travelled along the shape
+   * 
+   * @returns {GTFSStopTime} An object representing the stop data
+   */
+  processEntity(data) {
+    let stopData = {
+      arrivalTime: data.arrival_time,
+      departureTime: data.departure_time,
+      stopID: data.stop_id,
+      stopSequence: data.stop_sequence,
+      pickup: data.pickup_type,
+      dropoff: data.drop_off_type,
+      distance: data.shape_dist_traveled
+    }
+
+    return new GTFSStopTime(stopData)
+  }
+}

package/lib/gtfs-parser/readers/GTFSStopsReader.mjs

@@ -0,0 +1,36 @@
+import { GTFSStop, GTFSPlatformStop } from '../GTFSStop.mjs'
+import GTFSReader from './GTFSReader.mjs'
+
+export default class GTFSStopsReader extends GTFSReader {
+ 
+  #suburbData
+
+  constructor(file, suburbData) {
+    super(file)
+    this.#suburbData = suburbData
+  }
+
+  /**
+   * Converts a CSV row into a stop object
+   * 
+   * @param {object} data A JSON object containing the following fields:
+   * @param {string} data.stop_id The stop ID
+   * @param {string} data.stop_name The stop's name
+   * @param {string} data.stop_lat The stop's latitude
+   * @param {string} data.stop_lon The stop's longitude
+   * @param {string} [data.platform] The stop's platform number. Optional, stops without a platform (eg bus stops) do not need to provide this
+   * 
+   * @returns {GTFSStop} An object representing the stop data
+   */
+  processEntity(data) {
+    let stopData = {
+      stopGTFSID: data.stop_id,
+      stopName: data.stop_name,
+      stopLat: data.stop_lat,
+      stopLon: data.stop_lon,
+      platform: data.platform_code
+    }
+
+    return GTFSStop.create(stopData, this.#suburbData)
+  }
+}

package/lib/gtfs-parser/readers/GTFSTripReader.mjs

@@ -0,0 +1,61 @@
+import GTFSTrip from '../GTFSTrip.mjs'
+import GTFSReader from './GTFSReader.mjs'
+
+export default class GTFSTripReader extends GTFSReader {
+ 
+  #calendars
+  #routeMappings
+  #mode
+
+  constructor(tripsFile, calendars, routeMappings, mode) {
+    super(tripsFile)
+    this.#calendars = calendars
+    this.#routeMappings = routeMappings
+    this.#mode = mode
+  }
+
+  /**
+   * Sets the route ID mappings of the trip reader.
+   * 
+   * @param {object} routeMappings The route ID mappings
+   */
+  setRouteMappings(routeMappings) {
+    this.#routeMappings = routeMappings
+  }
+
+  /**
+   * 
+   * @param {object} calendars The calendar ID to GTFSCalendar mappings
+   */
+  setCalendar(calendars) {
+    this.#calendars = calendars
+  }
+
+  /**
+   * Converts a CSV row into a trip object
+   * 
+   * @param {object} data A JSON object containing the following fields:
+   * @param {string} data.route_id The trip's route ID
+   * @param {string} data.service_id The trip's calendar ID
+   * @param {string} data.trip_id The trip's unique trip ID
+   * @param {string} data.shape_id The trip's shape ID
+   * @param {string} data.trip_headsign The trip's headsign
+   * @param {string} data.direction_id The trip's direction ID
+   * @param {string} data.block_id The trip's block ID
+   * 
+   * @returns {GTFSTrip} An object representing the trip data
+   */
+  processEntity(data) {
+    let tripData = {
+      routeGTFSID: this.#routeMappings[data.route_id],
+      calendar: this.#calendars[data.service_id],
+      id: data.trip_id,
+      shapeID: data.shape_id,
+      headsign: data.trip_headsign,
+      direction: data.direction_id,
+      block: data.block_id
+    }
+
+    return GTFSTrip.create(tripData, this.#mode)
+  }
+}