graphql.schema.idl.RuntimeWiring Java Examples

private static RuntimeWiring buildWiring(final GraphQLDataFetchers graphQLDataFetchers) {
  return RuntimeWiring.newRuntimeWiring()
      .scalar(Scalars.addressScalar())
      .scalar(Scalars.bigIntScalar())
      .scalar(Scalars.bytesScalar())
      .scalar(Scalars.bytes32Scalar())
      .scalar(Scalars.longScalar())
      .type(
          TypeRuntimeWiring.newTypeWiring("Query")
              .dataFetcher("account", graphQLDataFetchers.getAccountDataFetcher())
              .dataFetcher("block", graphQLDataFetchers.getBlockDataFetcher())
              .dataFetcher("blocks", graphQLDataFetchers.getRangeBlockDataFetcher())
              .dataFetcher("logs", graphQLDataFetchers.getLogsDataFetcher())
              .dataFetcher("transaction", graphQLDataFetchers.getTransactionDataFetcher())
              .dataFetcher("gasPrice", graphQLDataFetchers.getGasPriceDataFetcher())
              .dataFetcher("syncing", graphQLDataFetchers.getSyncingDataFetcher())
              .dataFetcher("pending", graphQLDataFetchers.getPendingStateDataFetcher())
              .dataFetcher(
                  "protocolVersion", graphQLDataFetchers.getProtocolVersionDataFetcher()))
      .type(
          TypeRuntimeWiring.newTypeWiring("Mutation")
              .dataFetcher(
                  "sendRawTransaction", graphQLDataFetchers.getSendRawTransactionDataFetcher()))
      .build();
}
 

private GraphQL setupWsGraphQL() {
  String schema = vertx.fileSystem().readFileBlocking("counter.graphqls").toString();

  SchemaParser schemaParser = new SchemaParser();
  TypeDefinitionRegistry typeDefinitionRegistry = schemaParser.parse(schema);

  RuntimeWiring runtimeWiring = newRuntimeWiring()
    .type("Query", builder -> builder.dataFetcher("staticCounter", this::staticCounter))
    .type("Subscription", builder -> builder.dataFetcher("counter", this::counter))
    .build();

  SchemaGenerator schemaGenerator = new SchemaGenerator();
  GraphQLSchema graphQLSchema = schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring);

  return GraphQL.newGraphQL(graphQLSchema)
    .build();
}
 

private GraphQL setupGraphQL() {
  String schema = vertx.fileSystem().readFileBlocking("links.graphqls").toString();
  String uploadSchema = vertx.fileSystem().readFileBlocking("upload.graphqls").toString();

  SchemaParser schemaParser = new SchemaParser();
  TypeDefinitionRegistry typeDefinitionRegistry = schemaParser.parse(schema)
    .merge(schemaParser.parse(uploadSchema));

  RuntimeWiring runtimeWiring = newRuntimeWiring()
    .scalar(UploadScalar.build())
    .type("Query", builder -> builder.dataFetcher("allLinks", this::getAllLinks))
    .type("Mutation", builder -> builder.dataFetcher("singleUpload", this::singleUpload))
    .build();

  SchemaGenerator schemaGenerator = new SchemaGenerator();
  GraphQLSchema graphQLSchema = schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring);

  return GraphQL.newGraphQL(graphQLSchema)
    .build();
}
 

@Override
protected GraphQL graphQL() {
  String schema = vertx.fileSystem().readFileBlocking("links.graphqls").toString();

  SchemaParser schemaParser = new SchemaParser();
  TypeDefinitionRegistry typeDefinitionRegistry = schemaParser.parse(schema);

  RuntimeWiring runtimeWiring = newRuntimeWiring()
    .type("Query", builder -> builder.dataFetcher("allLinks", this::getAllLinks))
    .type("Link", builder -> builder.dataFetcher("postedBy", this::getLinkPostedBy))
    .build();

  SchemaGenerator schemaGenerator = new SchemaGenerator();
  GraphQLSchema graphQLSchema = schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring);
  DataLoaderDispatcherInstrumentation dispatcherInstrumentation = new DataLoaderDispatcherInstrumentation();

  return GraphQL.newGraphQL(graphQLSchema)
    .instrumentation(dispatcherInstrumentation)
    .build();
}
 

@Override
protected GraphQL graphQL() {
  String schema = vertx.fileSystem().readFileBlocking("links.graphqls").toString();

  SchemaParser schemaParser = new SchemaParser();
  TypeDefinitionRegistry typeDefinitionRegistry = schemaParser.parse(schema);

  RuntimeWiring runtimeWiring = newRuntimeWiring()
    .type("Query", builder -> {
      VertxDataFetcher<Object> dataFetcher = VertxDataFetcher.create((env, fut) -> fut.complete(getAllLinks(env)));
      return builder.dataFetcher("allLinks", dataFetcher);
    })
    .build();

  SchemaGenerator schemaGenerator = new SchemaGenerator();
  GraphQLSchema graphQLSchema = schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring);

  return GraphQL.newGraphQL(graphQLSchema)
    .build();
}
 

@Override
protected GraphQL graphQL() {
  String schema = vertx.fileSystem().readFileBlocking("links.graphqls").toString();

  SchemaParser schemaParser = new SchemaParser();
  TypeDefinitionRegistry typeDefinitionRegistry = schemaParser.parse(schema);

  RuntimeWiring runtimeWiring = newRuntimeWiring()
    .type("Query", builder -> builder.dataFetcher("allLinks", this::getAllLinks))
    .type("Link", builder -> builder.dataFetcher("postedBy", this::getLinkPostedBy))
    .build();

  SchemaGenerator schemaGenerator = new SchemaGenerator();
  GraphQLSchema graphQLSchema = schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring);
  DataLoaderDispatcherInstrumentation dispatcherInstrumentation = new DataLoaderDispatcherInstrumentation();

  return GraphQL.newGraphQL(graphQLSchema)
    .instrumentation(dispatcherInstrumentation)
    .build();
}
 

protected GraphQL graphQL() {
  String schema = vertx.fileSystem().readFileBlocking("links.graphqls").toString();

  SchemaParser schemaParser = new SchemaParser();
  TypeDefinitionRegistry typeDefinitionRegistry = schemaParser.parse(schema);

  RuntimeWiring runtimeWiring = newRuntimeWiring()
    .type("Query", builder -> builder.dataFetcher("allLinks", this::getAllLinks))
    .build();

  SchemaGenerator schemaGenerator = new SchemaGenerator();
  GraphQLSchema graphQLSchema = schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring);

  return GraphQL.newGraphQL(graphQLSchema)
    .build();
}
 

protected GraphQL graphQL() {
  String schema = vertx.fileSystem().readFileBlocking("locale.graphqls").toString();

  SchemaParser schemaParser = new SchemaParser();
  TypeDefinitionRegistry typeDefinitionRegistry = schemaParser.parse(schema);

  RuntimeWiring runtimeWiring = newRuntimeWiring()
    .type("Query", builder -> builder.dataFetcher("locale", this::getLocale))
    .build();

  SchemaGenerator schemaGenerator = new SchemaGenerator();
  GraphQLSchema graphQLSchema = schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring);

  return GraphQL.newGraphQL(graphQLSchema)
    .build();
}
 

private GraphQL graphQL() {
  final String schema = vertx.fileSystem().readFileBlocking("upload.graphqls").toString();
  final String emptyQueryschema = vertx.fileSystem().readFileBlocking("emptyQuery.graphqls").toString();

  final SchemaParser schemaParser = new SchemaParser();
  final TypeDefinitionRegistry typeDefinitionRegistry = schemaParser.parse(schema)
    .merge(schemaParser.parse(emptyQueryschema));

  final RuntimeWiring runtimeWiring = RuntimeWiring.newRuntimeWiring()
    .scalar(UploadScalar.build())
    .type("Mutation", builder -> {
      builder.dataFetcher("singleUpload", this::singleUpload);
      builder.dataFetcher("multipleUpload", this::multipleUpload);
      return builder;
    }).build();

  final SchemaGenerator schemaGenerator = new SchemaGenerator();
  final GraphQLSchema graphQLSchema = schemaGenerator
    .makeExecutableSchema(typeDefinitionRegistry, runtimeWiring);

  return GraphQL.newGraphQL(graphQLSchema).build();
}
 

protected GraphQL graphQL() {
  String schema = vertx.fileSystem().readFileBlocking("counter.graphqls").toString();

  SchemaParser schemaParser = new SchemaParser();
  TypeDefinitionRegistry typeDefinitionRegistry = schemaParser.parse(schema);

  RuntimeWiring runtimeWiring = newRuntimeWiring()
    .type("Query", builder -> builder.dataFetcher("staticCounter", this::getStaticCounter))
    .type("Subscription", builder -> builder.dataFetcher("counter", this::getCounter))
    .build();

  SchemaGenerator schemaGenerator = new SchemaGenerator();
  GraphQLSchema graphQLSchema = schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring);

  return GraphQL.newGraphQL(graphQLSchema)
    .build();
}
 

public void completionStageDataFetcher() {
  DataFetcher<CompletionStage<List<Link>>> dataFetcher = environment -> {

    CompletableFuture<List<Link>> completableFuture = new CompletableFuture<>();

    retrieveLinksFromBackend(environment, ar -> {
      if (ar.succeeded()) {
        completableFuture.complete(ar.result());
      } else {
        completableFuture.completeExceptionally(ar.cause());
      }
    });

    return completableFuture;
  };

  RuntimeWiring runtimeWiring = RuntimeWiring.newRuntimeWiring()
    .type("Query", builder -> builder.dataFetcher("allLinks", dataFetcher))
    .build();
}
 

private static GraphQLSchema getGraphQLSchema() throws Exception {
  SchemaParser schemaParser = new SchemaParser();
  SchemaGenerator schemaGenerator = new SchemaGenerator();

  URL resource = Thread.currentThread().getContextClassLoader().getResource("schema.graphqls");
  Path path = Paths.get(resource.toURI());
  String s = read(path);

  TypeDefinitionRegistry registry = schemaParser.parse(s);

  RuntimeWiring wiring =
      RuntimeWiring.newRuntimeWiring()
          .type(
              newTypeWiring("Query")
                  .dataFetcher("bookById", GraphQLDataFetchers.getBookByIdDataFetcher()))
          .type(
              newTypeWiring("Book")
                  .dataFetcher("author", GraphQLDataFetchers.getAuthorDataFetcher()))
          .build();

  return schemaGenerator.makeExecutableSchema(registry, wiring);
}
 

public void setupRouter(@Observes Router router) {
    String schema = "type Query{hello: String}";

    SchemaParser schemaParser = new SchemaParser();
    TypeDefinitionRegistry typeDefinitionRegistry = schemaParser.parse(schema);

    RuntimeWiring runtimeWiring = RuntimeWiring.newRuntimeWiring()
            .type("Query", builder -> builder.dataFetcher("hello", new StaticDataFetcher("world")))
            .build();

    SchemaGenerator schemaGenerator = new SchemaGenerator();
    GraphQLSchema graphQLSchema = schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring);

    GraphQL graphQL = GraphQL.newGraphQL(graphQLSchema).build();

    router.route("/graphql").handler(ApolloWSHandler.create(graphQL));
    router.route("/graphql").handler(GraphQLHandler.create(graphQL));
}
 

private RuntimeWiring buildWiring() {
    return RuntimeWiring.newRuntimeWiring()
            .type(newTypeWiring("Query")
                    .dataFetcher("characters", starWarsWiring.charactersDataFetcher)
                    .dataFetcher("human", starWarsWiring.humanDataFetcher)
                    .dataFetcher("droid", starWarsWiring.droidDataFetcher)
            )
            .type(newTypeWiring("Human")
                    .dataFetcher("friends", starWarsWiring.friendsDataFetcher)
            )
            .type(newTypeWiring("Droid")
                    .dataFetcher("friends", starWarsWiring.friendsDataFetcher)
            )
            .type(newTypeWiring("Character")
                    .typeResolver(starWarsWiring.characterTypeResolver)
            )
            .type(newTypeWiring("Episode")
                    .enumValues(starWarsWiring.episodeResolver)
            )
            .build();
}
 

private RuntimeWiring buildWiring() {
    return RuntimeWiring.newRuntimeWiring()
            .type(newTypeWiring("Query")
                    .dataFetcher("hero", starWarsWiring.heroDataFetcher)
                    .dataFetcher("human", starWarsWiring.humanDataFetcher)
                    .dataFetcher("droid", starWarsWiring.droidDataFetcher)
            )
            .type(newTypeWiring("Human")
                    .dataFetcher("friends", starWarsWiring.friendsDataFetcher)
            )
            .type(newTypeWiring("Droid")
                    .dataFetcher("friends", starWarsWiring.friendsDataFetcher)
            )

            .type(newTypeWiring("Character")
                    .typeResolver(starWarsWiring.characterTypeResolver)
            )
            .type(newTypeWiring("Episode")
                    .enumValues(starWarsWiring.episodeResolver)
            )
            .build();
}
 

@Bean
@Singleton
public GraphQL graphQL(ResourceResolver resourceResolver, HelloDataFetcher helloDataFetcher) { // <2>

    SchemaParser schemaParser = new SchemaParser();
    SchemaGenerator schemaGenerator = new SchemaGenerator();

    // Parse the schema.
    TypeDefinitionRegistry typeRegistry = new TypeDefinitionRegistry();
    typeRegistry.merge(schemaParser.parse(new BufferedReader(new InputStreamReader(
            resourceResolver.getResourceAsStream("classpath:schema.graphqls").get()))));

    // Create the runtime wiring.
    RuntimeWiring runtimeWiring = RuntimeWiring.newRuntimeWiring()
            .type("Query", typeWiring -> typeWiring
                    .dataFetcher("hello", helloDataFetcher))
            .build();

    // Create the executable schema.
    GraphQLSchema graphQLSchema = schemaGenerator.makeExecutableSchema(typeRegistry, runtimeWiring);

    // Return the GraphQL bean.
    return GraphQL.newGraphQL(graphQLSchema).build();
}
 

private static RuntimeWiring ensureFederationDirectiveDefinitionsExist(
        TypeDefinitionRegistry typeRegistry,
        RuntimeWiring runtimeWiring
) {
    // Add Federation directives if they don't exist.
    FederationDirectives.allDefinitions
            .stream()
            .filter(def -> !typeRegistry.getDirectiveDefinition(def.getName()).isPresent())
            .forEachOrdered(typeRegistry::add);

    // Add scalar type for _FieldSet, since the directives depend on it.
    if (!typeRegistry.getType(_FieldSet.typeName).isPresent()) {
        typeRegistry.add(_FieldSet.definition);
    }

    // Also add the implementation for _FieldSet.
    if (!runtimeWiring.getScalars().containsKey(_FieldSet.typeName)) {
        return copyRuntimeWiring(runtimeWiring).scalar(_FieldSet.type).build();
    } else {
        return runtimeWiring;
    }
}
 

@Test
void testInterfacesAreCovered() {
    final RuntimeWiring wiring = RuntimeWiring.newRuntimeWiring()
            .type(TypeRuntimeWiring.newTypeWiring("Product")
                    .typeResolver(env -> null)
                    .build())
            .build();

    final GraphQLSchema transformed = Federation.transform(interfacesSDL, wiring)
            .resolveEntityType(env -> null)
            .fetchEntities(environment -> null)
            .build();

    final GraphQLUnionType entityType = (GraphQLUnionType) transformed.getType(_Entity.typeName);

    final Iterable<String> unionTypes = entityType
            .getTypes()
            .stream()
            .map(GraphQLNamedType::getName)
            .sorted()
            .collect(Collectors.toList());

    assertIterableEquals(Arrays.asList("Book", "Movie", "Page"), unionTypes);
}
 

@Test
void testPrinterEmpty() {
    TypeDefinitionRegistry typeDefinitionRegistry = new SchemaParser().parse(printerEmptySDL);
    RuntimeWiring runtimeWiring = RuntimeWiring.newRuntimeWiring()
            .type("Interface1", typeWiring -> typeWiring
                    .typeResolver(env -> null)
            )
            .type("Interface2", typeWiring -> typeWiring
                    .typeResolver(env -> null)
            )
            .build();
    GraphQLSchema graphQLSchema = new SchemaGenerator().makeExecutableSchema(
            typeDefinitionRegistry,
            runtimeWiring
    );
    Assertions.assertEquals(
            printerEmptySDL.trim(),
            new FederationSdlPrinter(FederationSdlPrinter.Options.defaultOptions()
                    .includeDirectiveDefinitions(def -> !standardDirectives.contains(def.getName()))
            ).print(graphQLSchema).trim()
    );
}
 

public void generate(String sourceSdlResource, String targetIntrospectionFile) {
  String schema = readResource(sourceSdlResource);
  TypeDefinitionRegistry registry = new SchemaParser().parse(schema);
  RuntimeWiring wiring = RuntimeWiring
      .newRuntimeWiring()
      .scalar(objectNodeScalar())
      .build();
  GraphQLSchema graphQLSchema = new SchemaGenerator().makeExecutableSchema(registry, wiring);
  GraphQL graphql = GraphQL.newGraphQL(graphQLSchema).build();
  String introspectionQuery = readResource("introspection.query");
  ExecutionResult result = graphql.execute(introspectionQuery);
  String introspectionJson = serializeToJson(result);
  writeFile(targetIntrospectionFile, introspectionJson);
}
 

private RuntimeWiring buildRuntimeWiring() {
  return RuntimeWiring.newRuntimeWiring()
    .scalar(Types.Uri)
    .scalar(Types.Url)
    .type("GridQuery", typeWiring -> typeWiring
      .dataFetcher("grid", new GridData(distributor, publicUri)))
    .build();
}
 

private static GraphQLSchema buildSchema(
    final String sdl, final GraphQLDataFetchers graphQLDataFetchers) {
  final TypeDefinitionRegistry typeRegistry = new SchemaParser().parse(sdl);
  final RuntimeWiring runtimeWiring = buildWiring(graphQLDataFetchers);
  final SchemaGenerator schemaGenerator = new SchemaGenerator();
  return schemaGenerator.makeExecutableSchema(typeRegistry, runtimeWiring);
}
 

public static SchemaTransformer transform(final TypeDefinitionRegistry typeRegistry, final RuntimeWiring runtimeWiring) {
    ensureQueryTypeExists(typeRegistry);
    RuntimeWiring newRuntimeWiring = ensureFederationDirectiveDefinitionsExist(typeRegistry, runtimeWiring);
    final GraphQLSchema original = new SchemaGenerator().makeExecutableSchema(
            generatorOptions,
            typeRegistry,
            newRuntimeWiring);
    return transform(original);
}
 

@BeforeEach
void setupSchema() {
    TypeDefinitionRegistry typeDefs = new SchemaParser().parse(tracingSDL);
    RuntimeWiring resolvers = RuntimeWiring.newRuntimeWiring()
            .type("Query", builder ->
                    // return two items
                    builder.dataFetcher("widgets", env -> {
                        ArrayList<Object> objects = new ArrayList<>(2);
                        objects.add(new Object());
                        objects.add(new Object());
                        return objects;
                    }).dataFetcher("listOfLists", env -> {
                        ArrayList<ArrayList<Object>> lists = new ArrayList<>(2);
                        lists.add(new ArrayList<>(2));
                        lists.add(new ArrayList<>(2));
                        lists.get(0).add(new Object());
                        lists.get(0).add(new Object());
                        lists.get(1).add(new Object());
                        lists.get(1).add(new Object());
                        return lists;
                    })
                            .dataFetcher("listOfScalars", env -> new String[]{"one", "two", "three"}))
            .type("Widget", builder ->
                    // Widget.foo works normally, Widget.bar always throws an error
                    builder.dataFetcher("foo", env -> "hello world")
                            .dataFetcher("bar", env -> {
                                throw new GraphQLException("whoops");
                            }))
            .build();

    GraphQLSchema graphQLSchema = new SchemaGenerator().makeExecutableSchema(typeDefs, resolvers);
    graphql = GraphQL.newGraphQL(graphQLSchema)
            .instrumentation(new FederatedTracingInstrumentation())
            .build();
}
 

public void futureDataFetcher() {
  VertxDataFetcher<List<Link>> dataFetcher = VertxDataFetcher.create(environment -> {
    Future<List<Link>> future = retrieveLinksFromBackend(environment);
    return future;
  });

  RuntimeWiring runtimeWiring = RuntimeWiring.newRuntimeWiring()
    .type("Query", builder -> builder.dataFetcher("allLinks", dataFetcher))
    .build();
}
 

public void callbackDataFetcher() {
  VertxDataFetcher<List<Link>> dataFetcher = VertxDataFetcher.create((env, promise) -> {
    retrieveLinksFromBackend(env, promise);
  });

  RuntimeWiring runtimeWiring = RuntimeWiring.newRuntimeWiring()
    .type("Query", builder -> builder.dataFetcher("allLinks", dataFetcher))
    .build();
}
 

/**
 * Build the GraphQL {@link RuntimeWiring}
 *
 * @param configuration Notification configuration
 * @return the GraphQL runtime wiring
 * @throws Exception if unable to connect to Riak
 */
private static RuntimeWiring buildWiring(NotificationConfiguration configuration)
    throws Exception {

  final RiakClient client = configuration.getRiak().build();
  final NotificationStore store = getNotificationStore(client, configuration);
  final RuleStore ruleStore = getRuleStore(client, configuration);

  final RuntimeWiring wiring =
      RuntimeWiring.newRuntimeWiring()
          .scalar(Scalars.graphQLMapScalar("Map"))
          .type(
              "Query",
              typeWiring ->
                  typeWiring
                      .dataFetcher("notifications", new NotificationDataFetcher(store))
                      .dataFetcher("rules", new RuleDataFetcher(ruleStore)))
          .type(
              "Mutation",
              typeWiring ->
                  typeWiring
                      .dataFetcher("createNotification", new CreateNotificationMutation(store))
                      .dataFetcher("removeNotification", new RemoveNotificationMutation(store))
                      .dataFetcher(
                          "removeAllNotifications", new RemoveAllNotificationsMutation(store))
                      .dataFetcher("createRule", new CreateRuleMutation(ruleStore))
                      .dataFetcher("removeRule", new RemoveRuleMutation(ruleStore))
                      .dataFetcher("removeAllRules", new RemoveAllRulesMutation(ruleStore)))
          .build();

  return wiring;
}
 

private static RuntimeWiring buildWiring(HelloWorldConfiguration configuration) {

    final SayingDataFetcher fetcher =
        new SayingDataFetcher(configuration.getTemplate(), configuration.getDefaultName());

    final RuntimeWiring wiring =
        RuntimeWiring.newRuntimeWiring()
            .type("Query", typeWiring -> typeWiring.dataFetcher("saying", fetcher))
            .build();

    return wiring;
  }
 

public BarleyGraphQLSchema(SpecRegistry specRegistry, Environment env, String namespace, CustomQueries customQueries) {
	this.specRegistry = specRegistry;
	this.env = env;
	this.namespace = namespace;
	this.queryCustomizations = new GraphQLQueryCustomizations();
	this.queryCustomizations.setShouldBreakPredicate(new DefaultQueryBreaker(env, namespace, 3, 4));

       GenerateGrapqlSDL graphSdl = new GenerateGrapqlSDL(specRegistry, customQueries);
       
       SchemaParser schemaParser = new SchemaParser();
       sdlString = graphSdl.createSdl();
       LOG.info(sdlString);
       System.out.println(sdlString);
       
       TypeDefinitionRegistry typeDefinitionRegistry = schemaParser.parse(sdlString);
       RuntimeWiring.Builder wiringBuilder = newRuntimeWiring()
               .type("Query", builder -> builder.defaultDataFetcher(new QueryDataFetcher(env, namespace, customQueries)));
       
       specRegistry.getDefinitions().stream()
       .map(DefinitionsSpec::getEntitySpecs)
       .flatMap(Collection::stream)
       .forEach(eSpec -> wiringBuilder.type(getSimpleName(eSpec.getClassName()), builder ->  builder.defaultDataFetcher(new EntityDataFetcher(env, namespace))));
       
        RuntimeWiring runtimeWiring = wiringBuilder.build();        
       
       SchemaGenerator schemaGenerator = new SchemaGenerator();
       this.graphQLSchema = schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring);
}
 

private GraphQLSchema buildSchema() {
    //
    // reads a file that provides the schema types
    //
    Reader streamReader = loadSchemaFile("stocks.graphqls");
    TypeDefinitionRegistry typeRegistry = new SchemaParser().parse(streamReader);

    RuntimeWiring wiring = RuntimeWiring.newRuntimeWiring()
            .type(newTypeWiring("Subscription")
                    .dataFetcher("stockQuotes", stockQuotesSubscriptionFetcher())
            )
            .build();

    return new SchemaGenerator().makeExecutableSchema(typeRegistry, wiring);
}