Add plan query that follows the relay connection specification

.github/workflows/cibuild.yml

@@ -121,7 +121,7 @@ jobs:
 
       - name: Build GTFS GraphQL API documentation
         run: |
-          npm install -g @magidoc/cli@4.0.0
+          npm install -g @magidoc/cli@4.1.4
           magidoc generate
 
       - name: Deploy compiled HTML to Github pages

pom.xml

@@ -852,12 +852,12 @@
         <dependency>
             <groupId>com.graphql-java</groupId>
             <artifactId>graphql-java</artifactId>
-            <version>21.5</version>
+            <version>22.0</version>
         </dependency>
         <dependency>
             <groupId>com.graphql-java</groupId>
             <artifactId>graphql-java-extended-scalars</artifactId>
-            <version>21.0</version>
+            <version>22.0</version>
         </dependency>
         <dependency>
             <groupId>org.apache.httpcomponents.client5</groupId>

src/ext/java/org/opentripplanner/ext/actuator/MicrometerGraphQLInstrumentation.java

@@ -13,7 +13,6 @@
 import graphql.execution.instrumentation.parameters.InstrumentationExecutionParameters;
 import graphql.execution.instrumentation.parameters.InstrumentationExecutionStrategyParameters;
 import graphql.execution.instrumentation.parameters.InstrumentationFieldFetchParameters;
-import graphql.execution.instrumentation.parameters.InstrumentationFieldParameters;
 import graphql.execution.instrumentation.parameters.InstrumentationValidationParameters;
 import graphql.language.Document;
 import graphql.schema.GraphQLTypeUtil;
@@ -22,7 +21,6 @@
 import io.micrometer.core.instrument.Tag;
 import io.micrometer.core.instrument.Timer;
 import java.util.List;
-import java.util.concurrent.CompletableFuture;
 
 /**
  * Using this instrumentation we can precisely measure how queries and data fetchers are executed
@@ -107,21 +105,13 @@ public ExecutionStrategyInstrumentationContext beginExecutionStrategy(
   ) {
     return new ExecutionStrategyInstrumentationContext() {
       @Override
-      public void onDispatched(CompletableFuture<ExecutionResult> result) {}
+      public void onDispatched() {}
 
       @Override
       public void onCompleted(ExecutionResult result, Throwable t) {}
     };
   }
 
-  @Override
-  public InstrumentationContext<ExecutionResult> beginField(
-    InstrumentationFieldParameters parameters,
-    InstrumentationState state
-  ) {
-    return noOp();
-  }
-
   @Override
   public InstrumentationContext<Object> beginFieldFetch(
     InstrumentationFieldFetchParameters parameters,

src/main/java/org/opentripplanner/apis/gtfs/GraphQLScalars.java

@@ -2,6 +2,8 @@
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import graphql.language.FloatValue;
+import graphql.language.IntValue;
 import graphql.language.StringValue;
 import graphql.relay.Relay;
 import graphql.schema.Coercing;
@@ -13,18 +15,19 @@
 import java.time.OffsetDateTime;
 import java.time.ZonedDateTime;
 import java.time.format.DateTimeFormatter;
+import java.util.Optional;
 import javax.annotation.Nonnull;
 import org.locationtech.jts.geom.Geometry;
 import org.opentripplanner.framework.graphql.scalar.DurationScalarFactory;
 import org.opentripplanner.framework.json.ObjectMappers;
+import org.opentripplanner.framework.model.Cost;
 import org.opentripplanner.framework.model.Grams;
 import org.opentripplanner.framework.time.OffsetDateTimeParser;
 
 public class GraphQLScalars {
 
-  private static final ObjectMapper geoJsonMapper = ObjectMappers.geoJson();
-
-  public static GraphQLScalarType DURATION_SCALAR = DurationScalarFactory.createDurationScalar();
+  private static final ObjectMapper GEOJSON_MAPPER = ObjectMappers.geoJson();
+  public static final GraphQLScalarType DURATION_SCALAR = DurationScalarFactory.createDurationScalar();
 
   public static final GraphQLScalarType POLYLINE_SCALAR = GraphQLScalarType
     .newScalar()
@@ -111,6 +114,127 @@ public OffsetDateTime parseLiteral(Object input) throws CoercingParseLiteralExce
     )
     .build();
 
+  public static final GraphQLScalarType COORDINATE_VALUE_SCALAR = GraphQLScalarType
+    .newScalar()
+    .name("CoordinateValue")
+    .coercing(
+      new Coercing<Double, Double>() {
+        private static final String VALIDATION_ERROR_MESSAGE = "Not a valid WGS84 coordinate value";
+
+        @Override
+        public Double serialize(@Nonnull Object dataFetcherResult)
+          throws CoercingSerializeException {
+          if (dataFetcherResult instanceof Double doubleValue) {
+            return doubleValue;
+          } else if (dataFetcherResult instanceof Float floatValue) {
+            return floatValue.doubleValue();
+          } else {
+            throw new CoercingSerializeException(
+              "Cannot serialize object of class %s as a coordinate number".formatted(
+                  dataFetcherResult.getClass().getSimpleName()
+                )
+            );
+          }
+        }
+
+        @Override
+        public Double parseValue(Object input) throws CoercingParseValueException {
+          if (input instanceof Double doubleValue) {
+            return validateCoordinate(doubleValue)
+              .orElseThrow(() -> new CoercingParseValueException(VALIDATION_ERROR_MESSAGE));
+          }
+          if (input instanceof Integer intValue) {
+            return validateCoordinate(intValue)
+              .orElseThrow(() -> new CoercingParseValueException(VALIDATION_ERROR_MESSAGE));
+          }
+          throw new CoercingParseValueException(
+            "Expected a number, got %s %s".formatted(input.getClass().getSimpleName(), input)
+          );
+        }
+
+        @Override
+        public Double parseLiteral(Object input) throws CoercingParseLiteralException {
+          if (input instanceof FloatValue coordinate) {
+            return validateCoordinate(coordinate.getValue().doubleValue())
+              .orElseThrow(() -> new CoercingParseLiteralException(VALIDATION_ERROR_MESSAGE));
+          }
+          if (input instanceof IntValue coordinate) {
+            return validateCoordinate(coordinate.getValue().doubleValue())
+              .orElseThrow(() -> new CoercingParseLiteralException(VALIDATION_ERROR_MESSAGE));
+          }
+          throw new CoercingParseLiteralException(
+            "Expected a number, got: " + input.getClass().getSimpleName()
+          );
+        }
+
+        private static Optional<Double> validateCoordinate(double coordinate) {
+          if (coordinate >= -180.001 && coordinate <= 180.001) {
+            return Optional.of(coordinate);
+          }
+          return Optional.empty();
+        }
+      }
+    )
+    .build();
+
+  public static final GraphQLScalarType COST_SCALAR = GraphQLScalarType
+    .newScalar()
+    .name("Cost")
+    .coercing(
+      new Coercing<Cost, Integer>() {
+        private static final int MAX_COST = 1000000;
+        private static final String VALIDATION_ERROR_MESSAGE =
+          "Cost cannot be negative or greater than %d".formatted(MAX_COST);
+
+        @Override
+        public Integer serialize(@Nonnull Object dataFetcherResult)
+          throws CoercingSerializeException {
+          if (dataFetcherResult instanceof Integer intValue) {
+            return intValue;
+          } else if (dataFetcherResult instanceof Cost costValue) {
+            return costValue.toSeconds();
+          } else {
+            throw new CoercingSerializeException(
+              "Cannot serialize object of class %s as a cost".formatted(
+                  dataFetcherResult.getClass().getSimpleName()
+                )
+            );
+          }
+        }
+
+        @Override
+        public Cost parseValue(Object input) throws CoercingParseValueException {
+          if (input instanceof Integer intValue) {
+            return validateCost(intValue)
+              .orElseThrow(() -> new CoercingParseValueException(VALIDATION_ERROR_MESSAGE));
+          }
+          throw new CoercingParseValueException(
+            "Expected an integer, got %s %s".formatted(input.getClass().getSimpleName(), input)
+          );
+        }
+
+        @Override
+        public Cost parseLiteral(Object input) throws CoercingParseLiteralException {
+          if (input instanceof IntValue intValue) {
+            var value = intValue.getValue().intValue();
+            return validateCost(value)
+              .orElseThrow(() -> new CoercingParseLiteralException(VALIDATION_ERROR_MESSAGE));
+          }
+          throw new CoercingParseLiteralException(
+            "Expected an integer, got: " + input.getClass().getSimpleName()
+          );
+        }
+
+        private static Optional<Cost> validateCost(int cost) {
+          if (cost >= 0 && cost <= MAX_COST) {
+            return Optional.of(Cost.costOfSeconds(cost));
+          }
+          return Optional.empty();
+        }
+      }
+    )
+    .build();
+
   public static final GraphQLScalarType GEOJSON_SCALAR = GraphQLScalarType
     .newScalar()
     .name("GeoJson")
@@ -121,7 +245,7 @@ public OffsetDateTime parseLiteral(Object input) throws CoercingParseLiteralExce
         public JsonNode serialize(Object dataFetcherResult) throws CoercingSerializeException {
           if (dataFetcherResult instanceof Geometry) {
             var geom = (Geometry) dataFetcherResult;
-            return geoJsonMapper.valueToTree(geom);
+            return GEOJSON_MAPPER.valueToTree(geom);
           }
           return null;
         }
@@ -195,20 +319,159 @@ public Double serialize(Object dataFetcherResult) throws CoercingSerializeExcept
 
         @Override
         public Grams parseValue(Object input) throws CoercingParseValueException {
-          if (input instanceof Double) {
-            var grams = (Double) input;
-            return new Grams(grams);
+          if (input instanceof Double doubleValue) {
+            return new Grams(doubleValue);
           }
-          return null;
+          if (input instanceof Integer intValue) {
+            return new Grams(intValue);
+          }
+          throw new CoercingParseValueException(
+            "Expected a number, got %s %s".formatted(input.getClass().getSimpleName(), input)
+          );
         }
 
         @Override
         public Grams parseLiteral(Object input) throws CoercingParseLiteralException {
-          if (input instanceof Double) {
-            var grams = (Double) input;
-            return new Grams(grams);
+          if (input instanceof FloatValue coordinate) {
+            return new Grams(coordinate.getValue().doubleValue());
           }
-          return null;
+          if (input instanceof IntValue coordinate) {
+            return new Grams(coordinate.getValue().doubleValue());
+          }
+          throw new CoercingParseLiteralException(
+            "Expected a number, got: " + input.getClass().getSimpleName()
+          );
+        }
+      }
+    )
+    .build();
+
+  public static final GraphQLScalarType RATIO_SCALAR = GraphQLScalarType
+    .newScalar()
+    .name("Ratio")
+    .coercing(
+      new Coercing<Double, Double>() {
+        private static final String VALIDATION_ERROR_MESSAGE =
+          "Value is under 0 or greater than 1.";
+
+        @Override
+        public Double serialize(@Nonnull Object dataFetcherResult)
+          throws CoercingSerializeException {
+          var validationException = new CoercingSerializeException(VALIDATION_ERROR_MESSAGE);
+          if (dataFetcherResult instanceof Double doubleValue) {
+            return validateRatio(doubleValue).orElseThrow(() -> validationException);
+          } else if (dataFetcherResult instanceof Float floatValue) {
+            return validateRatio(floatValue.doubleValue()).orElseThrow(() -> validationException);
+          } else {
+            throw new CoercingSerializeException(
+              "Cannot serialize object of class %s as a ratio".formatted(
+                  dataFetcherResult.getClass().getSimpleName()
+                )
+            );
+          }
+        }
+
+        @Override
+        public Double parseValue(Object input) throws CoercingParseValueException {
+          if (input instanceof Double doubleValue) {
+            return validateRatio(doubleValue)
+              .orElseThrow(() -> new CoercingParseValueException(VALIDATION_ERROR_MESSAGE));
+          }
+          if (input instanceof Integer intValue) {
+            return validateRatio(intValue)
+              .orElseThrow(() -> new CoercingParseValueException(VALIDATION_ERROR_MESSAGE));
+          }
+          throw new CoercingParseValueException(
+            "Expected a number, got %s %s".formatted(input.getClass().getSimpleName(), input)
+          );
+        }
+
+        @Override
+        public Double parseLiteral(Object input) throws CoercingParseLiteralException {
+          if (input instanceof FloatValue ratio) {
+            return validateRatio(ratio.getValue().doubleValue())
+              .orElseThrow(() -> new CoercingParseLiteralException(VALIDATION_ERROR_MESSAGE));
+          }
+          if (input instanceof IntValue ratio) {
+            return validateRatio(ratio.getValue().doubleValue())
+              .orElseThrow(() -> new CoercingParseLiteralException(VALIDATION_ERROR_MESSAGE));
+          }
+          throw new CoercingParseLiteralException(
+            "Expected a number, got: " + input.getClass().getSimpleName()
+          );
+        }
+
+        private static Optional<Double> validateRatio(double ratio) {
+          if (ratio >= -0.001 && ratio <= 1.001) {
+            return Optional.of(ratio);
+          }
+          return Optional.empty();
+        }
+      }
+    )
+    .build();
+
+  public static final GraphQLScalarType RELUCTANCE_SCALAR = GraphQLScalarType
+    .newScalar()
+    .name("Reluctance")
+    .coercing(
+      new Coercing<Double, Double>() {
+        private static final double MIN_Reluctance = 0.1;
+        private static final double MAX_Reluctance = 100000;
+        private static final String VALIDATION_ERROR_MESSAGE =
+          "Reluctance needs to be between %s and %s".formatted(MIN_Reluctance, MAX_Reluctance);
+
+        @Override
+        public Double serialize(@Nonnull Object dataFetcherResult)
+          throws CoercingSerializeException {
+          if (dataFetcherResult instanceof Double doubleValue) {
+            return doubleValue;
+          } else if (dataFetcherResult instanceof Float floatValue) {
+            return floatValue.doubleValue();
+          } else {
+            throw new CoercingSerializeException(
+              "Cannot serialize object of class %s as a reluctance".formatted(
+                  dataFetcherResult.getClass().getSimpleName()
+                )
+            );
+          }
+        }
+
+        @Override
+        public Double parseValue(Object input) throws CoercingParseValueException {
+          if (input instanceof Double doubleValue) {
+            return validateReluctance(doubleValue)
+              .orElseThrow(() -> new CoercingParseValueException(VALIDATION_ERROR_MESSAGE));
+          }
+          if (input instanceof Integer intValue) {
+            return validateReluctance(intValue)
+              .orElseThrow(() -> new CoercingParseValueException(VALIDATION_ERROR_MESSAGE));
+          }
+          throw new CoercingParseValueException(
+            "Expected a number, got %s %s".formatted(input.getClass().getSimpleName(), input)
+          );
+        }
+
+        @Override
+        public Double parseLiteral(Object input) throws CoercingParseLiteralException {
+          if (input instanceof FloatValue reluctance) {
+            return validateReluctance(reluctance.getValue().doubleValue())
+              .orElseThrow(() -> new CoercingParseLiteralException(VALIDATION_ERROR_MESSAGE));
+          }
+          if (input instanceof IntValue reluctance) {
+            return validateReluctance(reluctance.getValue().doubleValue())
+              .orElseThrow(() -> new CoercingParseLiteralException(VALIDATION_ERROR_MESSAGE));
+          }
+          throw new CoercingParseLiteralException(
+            "Expected a number, got: " + input.getClass().getSimpleName()
+          );
+        }
+
+        private static Optional<Double> validateReluctance(double reluctance) {
+          if (reluctance >= MIN_Reluctance - 0.001 && reluctance <= MAX_Reluctance + 0.001) {
+            return Optional.of(reluctance);
+          }
+          return Optional.empty();
         }
       }
     )