@opentripplanner/core-utils 9.0.0-alpha.3 → 9.0.0-alpha.30

package/src/planQuery.graphql

@@ -1,107 +1,223 @@
-query PlanQuery(
-	$fromPlace: String!,
-	$toPlace: String!,
-	$modes: [TransportMode],
-	$time: String,
-	$date: String,
-	$wheelchair: Boolean,
-	$bikeReluctance: Float,
-	$carReluctance: Float,
-	$walkReluctance: Float,
-	$arriveBy: Boolean,
-	$intermediatePlaces: [InputCoordinates],
-	$preferred: InputPreferred,
-	$unpreferred: InputUnpreferred,
-	$banned: InputBanned,
+query Plan(
+  $fromPlace: String! 
+  $toPlace: String! 
+  $modes: [TransportMode]
+  $time: String
+  $date: String 
+  $wheelchair: Boolean 
+  $bikeReluctance: Float 
+  $carReluctance: Float 
+  $walkReluctance: Float 
+  $arriveBy: Boolean 
+  $intermediatePlaces: [InputCoordinates] 
+  $preferred: InputPreferred 
+  $unpreferred: InputUnpreferred 
+  $banned: InputBanned
+  $numItineraries: Int
 ) {
-	plan(
-		fromPlace: $fromPlace
-		toPlace: $toPlace
-		transportModes: $modes
-		locale: "en",
-		time: $time,
-		date: $date,
-		wheelchair: $wheelchair,
-		bikeReluctance: $bikeReluctance,
-		carReluctance: $carReluctance,
-		walkReluctance: $walkReluctance,
-		arriveBy: $arriveBy,
-		intermediatePlaces: $intermediatePlaces,
-		preferred: $preferred,
-		unpreferred: $unpreferred,
-		banned: $banned,
-	) {
-		itineraries {
-			duration
-			endTime
-			startTime
-			waitingTime
-			walkTime
-			legs {
-				distance
-				duration
-				endTime
-				mode
-				realTime
-				realtimeState	
-				startTime
-				transitLeg
-				agency {
-					name
-					id
-					timezone
-					url
-				}
-				legGeometry {
-					length
-					points
-				}
-				intermediateStops {
-					lat
-					lon
-					name
-					stopCode: code
-					stopId: id
-					locationType
-				}
-				route {
-					shortName
-					color
-					textColor
-					id
-					type
-				}
-				from {
-					lat
-					lon
-					name
-					vertexType
-					stop {
-						id
-						code
-						
-					}
-				}
-				to {
-					lat
-					lon
-					name
-					vertexType
-					stop {
-						id
-						code
-					}
-				}
-				steps {
-					distance
-					lat
-					lon
-					elevationProfile {
-						distance
-						elevation
-					}
-				}
-			}
-		}
-	}
-}
+  plan(
+    arriveBy: $arriveBy
+    banned: $banned
+    bikeReluctance: $bikeReluctance
+    carReluctance: $carReluctance
+    date: $date
+    fromPlace: $fromPlace
+    intermediatePlaces: $intermediatePlaces
+    # Currently only supporting EN locale, used for times and text
+    locale: "en"
+    numItineraries: $numItineraries
+    preferred: $preferred
+    time: $time
+    toPlace: $toPlace
+    transportModes: $modes
+    unpreferred: $unpreferred
+    walkReluctance: $walkReluctance
+    wheelchair: $wheelchair
+  ) {
+    itineraries {
+      accessibilityScore
+      duration
+      endTime
+      legs {
+        accessibilityScore
+        agency {
+          alerts {
+            alertDescriptionText
+            alertHeaderText
+            alertUrl
+            effectiveStartDate
+            id
+          }
+          id
+          name
+          timezone
+          url
+        }
+        arrivalDelay
+        departureDelay
+        distance
+        dropoffType
+        duration
+        endTime
+        fareProducts {
+          id
+          product {
+            id
+            medium {
+              id
+              name
+            }
+            name
+            price {
+              amount
+              currency {
+                code
+                digits
+              }
+            }
+            riderCategory {
+              id
+              name
+            }
+          }
+        }
+        from {
+          lat
+          lon
+          name
+          rentalVehicle {
+            id
+            network
+          }
+          stop {
+            alerts {
+              alertDescriptionText
+              alertHeaderText
+              alertUrl
+              effectiveStartDate
+              id
+            }
+            code
+            gtfsId
+            id
+          }
+          vertexType
+        }
+        interlineWithPreviousLeg
+        intermediateStops {
+          lat
+          locationType
+          lon
+          name
+          stopCode: code
+          stopId: id
+        }
+        legGeometry {
+          length
+          points
+        }
+        mode
+        pickupBookingInfo {
+          earliestBookingTime {
+            daysPrior
+          }
+        }
+        pickupType
+        realTime
+        realtimeState
+        rentedBike
+        rideHailingEstimate {
+          arrival
+          maxPrice {
+            amount
+            currency {
+              code
+            }
+          }
+          minPrice {
+            amount
+            currency {
+              code
+            }
+          }
+          provider {
+            id
+          }
+        }
+        route {
+          alerts {
+            alertDescriptionText
+            alertHeaderText
+            alertUrl
+            effectiveStartDate
+            id
+          }
+          color
+          id
+          longName
+          shortName
+          textColor
+          type
+        }
+        startTime
+        steps {
+          absoluteDirection
+          alerts {
+            alertDescriptionText
+            alertHeaderText
+            alertUrl
+            effectiveStartDate
+            id
+          }
+          area
+          distance
+          elevationProfile {
+            distance
+            elevation
+          }
+          lat
+          lon
+          relativeDirection
+          stayOn
+          streetName
+        }
+        to {
+          lat
+          lon
+          name
+          rentalVehicle {
+            id
+            network
+          }
+          stop {
+            alerts {
+              alertDescriptionText
+              alertHeaderText
+              alertUrl
+              effectiveStartDate
+              id
+            }
+            code
+            gtfsId
+            id
+          }
+          vertexType
+        }
+        transitLeg
+        trip {
+          gtfsId
+          id
+          tripHeadsign
+        }
+      }
+      startTime
+      waitingTime
+      walkTime
+    }
+    routingErrors {
+      code
+      description
+      inputField
+    }
+  }
+}

package/src/query-gen.ts

@@ -1,20 +1,81 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
+import { LonLatOutput } from "@conveyal/lonlat";
 import { print } from "graphql";
 import {
   ModeSetting,
   ModeSettingValues,
   TransportMode
 } from "@opentripplanner/types";
-import { LonLatOutput } from "@conveyal/lonlat";
+
 import PlanQuery from "./planQuery.graphql";
 
+type InputBanned = {
+  routes?: string;
+  agencies?: string;
+  trips?: string;
+  stops?: string;
+  stopsHard?: string;
+};
+
+type InputPreferred = {
+  routes?: string;
+  agencies?: string;
+  unpreferredCost?: string;
+};
+
 type OTPQueryParams = {
-  to: LonLatOutput;
-  from: LonLatOutput;
-  modes: Array<TransportMode>;
+  arriveBy: boolean;
+  date?: string;
+  from: LonLatOutput & { name?: string };
+  modes: TransportMode[];
   modeSettings: ModeSetting[];
+  time?: string;
+  numItineraries?: number;
+  to: LonLatOutput & { name?: string };
+  banned?: InputBanned;
+  preferred?: InputPreferred;
+};
+
+type GraphQLQuery = {
+  query: string;
+  variables: Record<string, unknown>;
 };
 
+/**
+ * Mode Settings can contain additional modes to add to the query,
+ * this function extracts those additional modes from the settings
+ * and returns them in an array.
+ * @param modeSettings List of mode settings with values populated
+ * @returns Additional transport modes to add to query
+ */
+export function extractAdditionalModes(
+  modeSettings: ModeSetting[],
+  enabledModes: TransportMode[]
+): TransportMode[] {
+  return modeSettings.reduce<TransportMode[]>((prev, cur) => {
+    // First, ensure that the mode associated with this setting is even enabled
+    if (!enabledModes.map(m => m.mode).includes(cur.applicableMode)) {
+      return prev;
+    }
+
+    // In checkboxes (or submode checkboxes), mode must be enabled and have a transport mode in it
+    if (
+      (cur.type === "CHECKBOX" || cur.type === "SUBMODE") &&
+      cur.addTransportMode &&
+      cur.value
+    ) {
+      return [...prev, cur.addTransportMode];
+    }
+    if (cur.type === "DROPDOWN") {
+      const transportMode = cur.options.find(o => o.value === cur.value)
+        .addTransportMode;
+      if (transportMode) {
+        return [...prev, transportMode];
+      }
+    }
+    return prev;
+  }, []);
+}
+
 /**
  * Generates every possible mathematical subset of the input TransportModes.
  * Uses code from:
@@ -32,6 +93,11 @@ function combinations(array: TransportMode[]): TransportMode[][] {
       .map((e1, i) => array.filter((e2, j) => i & (1 << j)))
   );
 }
+
+/**
+ * This constant maps all the transport mode to a broader mode type,
+ * which is used to determine the valid combinations of modes used in query generation.
+ */
 export const SIMPLIFICATIONS = {
   AIRPLANE: "TRANSIT",
   BICYCLE: "PERSONAL",
@@ -50,6 +116,19 @@ export const SIMPLIFICATIONS = {
   WALK: "WALK"
 };
 
+// Inclusion of "TRANSIT" alone automatically implies "WALK" in OTP
+const VALID_COMBOS = [
+  ["WALK"],
+  ["PERSONAL"],
+  ["TRANSIT", "SHARED"],
+  ["WALK", "SHARED"],
+  ["TRANSIT"],
+  ["TRANSIT", "PERSONAL"],
+  ["TRANSIT", "CAR"]
+];
+
+const BANNED_TOGETHER = ["SCOOTER", "BICYCLE", "CAR"];
+
 export const TRANSIT_SUBMODES = Object.keys(SIMPLIFICATIONS).filter(
   mode => SIMPLIFICATIONS[mode] === "TRANSIT" && mode !== "TRANSIT"
 );
@@ -57,96 +136,115 @@ export const TRANSIT_SUBMODES_AND_TRANSIT = Object.keys(SIMPLIFICATIONS).filter(
   mode => SIMPLIFICATIONS[mode] === "TRANSIT"
 );
 
-export function generateCombinations(params: OTPQueryParams): OTPQueryParams[] {
-  const VALID_COMBOS = [
-    ["WALK"],
-    ["PERSONAL"],
-    ["TRANSIT", "SHARED"],
-    ["WALK", "SHARED"],
-    ["TRANSIT"],
-    ["TRANSIT", "PERSONAL"],
-    ["TRANSIT", "CAR"]
-  ];
+function isCombinationValid(
+  combo: TransportMode[],
+  queryTransitSubmodes: string[]
+): boolean {
+  if (combo.length === 0) return false;
 
-  const BANNED_TOGETHER = ["SCOOTER", "BICYCLE"];
+  // All current qualifiers currently simplify to "SHARED"
+  const simplifiedModes = Array.from(
+    new Set(combo.map(c => (c.qualifier ? "SHARED" : SIMPLIFICATIONS[c.mode])))
+  );
 
-  // List of the transit submodes that are included in the input params
-  const queryTransitSubmodes = params.modes
-    .filter(mode => TRANSIT_SUBMODES.includes(mode.mode))
-    .map(mode => mode.mode);
+  // Ensure that if we have one transit mode, then we include ALL transit modes
+  if (simplifiedModes.includes("TRANSIT")) {
+    // Don't allow TRANSIT along with any other submodes
+    if (queryTransitSubmodes.length && combo.find(c => c.mode === "TRANSIT")) {
+      return false;
+    }
 
-  return (
-    combinations(params.modes)
-      .filter(combo => {
-        if (combo.length === 0) return false;
-
-        // All current qualifiers currently simplify to "SHARED"
-        const simplifiedModes = Array.from(
-          new Set(
-            combo.map(c => (c.qualifier ? "SHARED" : SIMPLIFICATIONS[c.mode]))
-          )
-        );
-
-        // Ensure that if we have one transit mode, then we include ALL transit modes
-        if (simplifiedModes.includes("TRANSIT")) {
-          const flatModes = combo.map(m => m.mode);
-          if (
-            combo.reduce((prev, cur) => {
-              if (queryTransitSubmodes.includes(cur.mode)) {
-                return prev - 1;
-              }
-              return prev;
-            }, queryTransitSubmodes.length) !== 0
-          ) {
-            return false;
-          }
+    if (
+      combo.reduce((prev, cur) => {
+        if (queryTransitSubmodes.includes(cur.mode)) {
+          return prev - 1;
         }
+        return prev;
+      }, queryTransitSubmodes.length) !== 0
+    ) {
+      return false;
+    }
+    // Continue to the other checks
+  }
+
+  // OTP doesn't support multiple non-walk modes
+  if (BANNED_TOGETHER.filter(m => combo.find(c => c.mode === m)).length > 1) {
+    return false;
+  }
 
-        // OTP doesn't support multiple non-walk modes
-        if (BANNED_TOGETHER.every(m => combo.find(c => c.mode === m)))
-          return false;
-
-        return !!VALID_COMBOS.find(
-          vc =>
-            simplifiedModes.every(m => vc.includes(m)) &&
-            vc.every(m => simplifiedModes.includes(m))
-        );
-      })
-      // create new filter that removes subTransit modes from appearing on their own
-      // ONLY IF there's multiple of them!
-      .map(combo => ({ ...params, modes: combo }))
+  return !!VALID_COMBOS.find(
+    vc =>
+      simplifiedModes.every(m => vc.includes(m)) &&
+      vc.every(m => simplifiedModes.includes(m))
   );
 }
 
-// eslint-disable-next-line import/prefer-default-export
-export function generateOtp2Query(params: OTPQueryParams): any {
-  const { to, from, modeSettings } = params;
+/**
+ * Generates a list of queries for OTP to get a comprehensive
+ * set of results based on the modes input.
+ * @param params OTP Query Params
+ * @returns Set of parameters to generate queries
+ */
+export function generateCombinations(params: OTPQueryParams): OTPQueryParams[] {
+  const completeModeList = [
+    ...extractAdditionalModes(params.modeSettings, params.modes),
+    ...params.modes
+  ];
+
+  // List of the transit *submodes* that are included in the input params
+  const queryTransitSubmodes = completeModeList
+    .filter(mode => TRANSIT_SUBMODES.includes(mode.mode))
+    .map(mode => mode.mode);
+
+  return combinations(completeModeList)
+    .filter(combo => isCombinationValid(combo, queryTransitSubmodes))
+    .map(combo => ({ ...params, modes: combo }));
+}
 
+export function generateOtp2Query({
+  arriveBy,
+  banned,
+  date,
+  from,
+  modes,
+  modeSettings,
+  numItineraries,
+  preferred,
+  time,
+  to
+}: OTPQueryParams): GraphQLQuery {
   // This extracts the values from the mode settings to key value pairs
   const modeSettingValues = modeSettings.reduce((prev, cur) => {
+    if (cur.type === "SLIDER" && cur.inverseKey) {
+      prev[cur.inverseKey] = cur.high - cur.value + cur.low;
+    }
     prev[cur.key] = cur.value;
     return prev;
   }, {}) as ModeSettingValues;
 
   const {
-    walkReluctance,
-    wheelchair,
     bikeReluctance,
     carReluctance,
-    allowBikeRental
+    walkReluctance,
+    wheelchair
   } = modeSettingValues;
 
   return {
     query: print(PlanQuery),
     variables: {
-      fromPlace: [from.lat, from.lon].join(","),
-      toPlace: [to.lat, to.lon].join(","),
-      modes: params.modes,
-      allowBikeRental,
-      walkReluctance,
-      wheelchair,
+      arriveBy,
+      banned,
       bikeReluctance,
-      carReluctance
+      carReluctance,
+      date,
+      fromPlace: `${from.name}::${from.lat},${from.lon}}`,
+      modes,
+      numItineraries,
+      preferred,
+      time,
+      toPlace: `${to.name}::${to.lat},${to.lon}}`,
+      walkReluctance,
+      wheelchair
     }
   };
 }

package/tsconfig.json

@@ -5,7 +5,9 @@
     "target": "es2019",
     "outDir": "./lib",
     "rootDir": "./src",
+    "lib": ["es2019", "dom"],
     "skipLibCheck": true
   },
-  "include": ["src/**/*"]
+  "include": ["src/**/*"],
+  "exclude": ["src/__tests__/**/*"]
 }