Java Code Examples for graphql.schema.idl.TypeDefinitionRegistry

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 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()
    );
}
 

HGQLConfig loadHGQLConfig(final String hgqlConfigPath, final InputStream inputStream, final String username, final String password, boolean classpath) {

        final ObjectMapper mapper = new ObjectMapper();

        try {

            final HGQLConfig config = mapper.readValue(inputStream, HGQLConfig.class);
            final SchemaParser schemaParser = new SchemaParser();

            final String fullSchemaPath = extractFullSchemaPath(hgqlConfigPath, config.getSchemaFile());

            LOGGER.debug("Schema config path: " + fullSchemaPath);

            final Reader reader = selectAppropriateReader(fullSchemaPath, username, password, classpath);
            final TypeDefinitionRegistry registry =
                    schemaParser.parse(reader);

            final HGQLSchemaWiring wiring = new HGQLSchemaWiring(registry, config.getName(), config.getServiceConfigs());
            config.setGraphQLSchema(wiring.getSchema());
            config.setHgqlSchema(wiring.getHgqlSchema());
            return config;

        } catch (IOException | URISyntaxException e) {
            throw new HGQLConfigurationException("Error reading from configuration file", e);
        }
    }
 

@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();
}
 

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 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);
}
 

private HGQLConfig(final InputStream inputStream) {

        ObjectMapper mapper = new ObjectMapper();

        try {
            HGQLConfig config = mapper.readValue(inputStream, HGQLConfig.class);

            SchemaParser schemaParser = new SchemaParser();
            TypeDefinitionRegistry registry = schemaParser.parse(new File(config.schemaFile));

            this.name = config.name;
            this.schemaFile = config.schemaFile;
            this.graphqlConfig = config.graphqlConfig;
            checkServicePorts(config.serviceConfigs);
            this.serviceConfigs = config.serviceConfigs;
            HGQLSchemaWiring wiring = new HGQLSchemaWiring(registry, name, serviceConfigs);
            this.schema = wiring.getSchema();
            this.hgqlSchema = wiring.getHgqlSchema();
        } catch (IOException e) {
            throw new HGQLConfigurationException("Error reading from configuration file", e);
        }
    }
 

public GraphQLSchema build() throws SchemaProblem {
  if (graphQLSchema.isPresent()) {
    return graphQLSchema.get();
  }

  final SchemaParser parser = new SchemaParser();
  final TypeDefinitionRegistry registry = new TypeDefinitionRegistry();

  if (!schemaFiles.isEmpty()) {
    schemaFiles.stream()
        .filter(f -> !Strings.isNullOrEmpty(f))
        .map(f -> getResourceAsReader(f))
        .map(r -> parser.parse(r))
        .forEach(p -> registry.merge(p));
  }

  final SchemaGenerator generator = new SchemaGenerator();
  final GraphQLSchema schema = generator.makeExecutableSchema(registry, runtimeWiring);
  return schema;
}
 

private static ApiDesignResourceInfo fromGraphQLContent(String content) {
    try {
        SchemaParser schemaParser = new SchemaParser();
        TypeDefinitionRegistry typeDefinitionRegistry = schemaParser.parse(content);
        int numTypes = typeDefinitionRegistry.types().size();
        ApiDesignResourceInfo info = new ApiDesignResourceInfo();
        info.setFormat(FormatType.SDL);
        info.setName("Imported GraphQL Schema");
        String typeList = String.join(", ", typeDefinitionRegistry.types().keySet());
        info.setDescription("An imported GraphQL schema with the following " + numTypes + " types: " + typeList);
        info.setType(ApiDesignType.GraphQL);
        return info;
    } catch (Exception e) {
    }
    return null;
}
 

private void completeOperationTypeNamesInSchemaDefinition() {
    CompletionProvider<CompletionParameters> provider = new CompletionProvider<CompletionParameters>() {
        @Override
        protected void addCompletions(@NotNull final CompletionParameters parameters, ProcessingContext context, @NotNull CompletionResultSet result) {
            final PsiElement completionElement = parameters.getPosition();
            final TypeDefinitionRegistry registry = GraphQLTypeDefinitionRegistryServiceImpl.getService(completionElement.getProject()).getRegistry(parameters.getOriginalFile());
            if (registry != null) {
                final Collection<GraphQLTypeName> currentTypes = PsiTreeUtil.findChildrenOfType(PsiTreeUtil.getTopmostParentOfType(completionElement, GraphQLElement.class), GraphQLTypeName.class);
                final Set<String> currentTypeNames = currentTypes.stream().map(PsiNamedElement::getName).collect(Collectors.toSet());
                registry.types().values().forEach(type -> {
                    if (type instanceof ObjectTypeDefinition && !currentTypeNames.contains(type.getName())) {
                        result.addElement(LookupElementBuilder.create(type.getName()));
                    }
                });
            }
        }
    };
    extend(CompletionType.BASIC, psiElement(GraphQLElementTypes.NAME).afterLeaf(":").inside(GraphQLOperationTypeDefinition.class), provider);
}
 

private void completeFieldArgumentTypeName() {
    CompletionProvider<CompletionParameters> provider = new CompletionProvider<CompletionParameters>() {
        @Override
        protected void addCompletions(@NotNull final CompletionParameters parameters, ProcessingContext context, @NotNull CompletionResultSet result) {

            final PsiElement completionElement = parameters.getPosition();
            final TypeDefinitionRegistry registry = GraphQLTypeDefinitionRegistryServiceImpl.getService(completionElement.getProject()).getRegistry(parameters.getOriginalFile());
            addInputTypeCompletions(result, registry);
        }
    };
    extend(CompletionType.BASIC,
            psiElement(GraphQLElementTypes.NAME).afterLeafSkipping(
                    // skip
                    PlatformPatterns.or(psiComment(), psiElement(TokenType.WHITE_SPACE), psiElement().withText("[")),
                    // until argument type colon occurs
                    psiElement().withText(":")
            ).inside(GraphQLInputValueDefinition.class), provider);
}
 

private void completeImplementsTypeName() {
    CompletionProvider<CompletionParameters> provider = new CompletionProvider<CompletionParameters>() {
        @Override
        protected void addCompletions(@NotNull final CompletionParameters parameters, ProcessingContext context, @NotNull CompletionResultSet result) {
            final PsiElement completionElement = parameters.getPosition();
            final GraphQLImplementsInterfaces implementsInterfaces = PsiTreeUtil.getParentOfType(completionElement, GraphQLImplementsInterfaces.class);
            if (implementsInterfaces != null) {
                final Set<String> currentInterfaces = Sets.newHashSet();
                implementsInterfaces.getTypeNameList().forEach(t -> currentInterfaces.add(t.getName()));
                final TypeDefinitionRegistry typeDefinitionRegistry = GraphQLTypeDefinitionRegistryServiceImpl.getService(completionElement.getProject()).getRegistry(parameters.getOriginalFile());
                typeDefinitionRegistry.getTypes(InterfaceTypeDefinition.class).forEach(schemaInterface -> {
                    if (currentInterfaces.add(schemaInterface.getName())) {
                        result.addElement(LookupElementBuilder.create(schemaInterface.getName()));
                    }
                });
            }
        }
    };
    extend(CompletionType.BASIC, psiElement(GraphQLElementTypes.NAME).inside(psiElement(GraphQLElementTypes.TYPE_NAME).inside(psiElement(GraphQLElementTypes.IMPLEMENTS_INTERFACES))), provider);
}
 

/**
 * Gets whether the specified fragment candidate is valid to spread inside the specified required type scope
 *
 * @param typeDefinitionRegistry registry with available schema types, used to resolve union members and interface implementations
 * @param fragmentCandidate      the fragment to check for being able to validly spread under the required type scope
 * @param requiredTypeScope      the type scope in which the fragment is a candidate to spread
 * @return true if the fragment candidate is valid to be spread inside the type scope
 */
private boolean isFragmentApplicableInTypeScope(TypeDefinitionRegistry typeDefinitionRegistry, GraphQLFragmentDefinition fragmentCandidate, GraphQLType requiredTypeScope) {

    // unwrap non-nullable and list types
    requiredTypeScope = GraphQLUtil.getUnmodifiedType(requiredTypeScope);

    final GraphQLTypeCondition typeCondition = fragmentCandidate.getTypeCondition();
    if (typeCondition == null || typeCondition.getTypeName() == null) {
        return false;
    }

    final String fragmentTypeName = Optional.ofNullable(typeCondition.getTypeName().getName()).orElse("");
    if (fragmentTypeName.equals(GraphQLUtil.getName(requiredTypeScope))) {
        // direct match, e.g. User scope, fragment on User
        return true;
    }

    // check whether compatible based on interfaces and unions
    return isCompatibleFragment(typeDefinitionRegistry, requiredTypeScope, fragmentTypeName);

}
 

/**
 * Extract GraphQL Operations from given schema
 * @param schema graphQL Schema
 * @return the arrayList of APIOperationsDTOextractGraphQLOperationList
 *
 */
public List<URITemplate> extractGraphQLOperationList(String schema, String type) {
    List<URITemplate> operationArray = new ArrayList<>();
    SchemaParser schemaParser = new SchemaParser();
    TypeDefinitionRegistry typeRegistry = schemaParser.parse(schema);
    Map<java.lang.String, TypeDefinition> operationList = typeRegistry.types();
    for (Map.Entry<String, TypeDefinition> entry : operationList.entrySet()) {
        if (entry.getValue().getName().equals(APIConstants.GRAPHQL_QUERY) ||
                entry.getValue().getName().equals(APIConstants.GRAPHQL_MUTATION)
                || entry.getValue().getName().equals(APIConstants.GRAPHQL_SUBSCRIPTION)) {
            if (type == null) {
                addOperations(entry, operationArray);
            } else if (type.equals(entry.getValue().getName().toUpperCase())) {
                addOperations(entry, operationArray);
            }
        }
    }
    return operationArray;
}
 

/**
 * Extract GraphQL Types and Fields from given schema
 *
 * @param schema GraphQL Schema
 * @return list of all types and fields
 */
public List<GraphqlSchemaType> extractGraphQLTypeList(String schema) {
    List<GraphqlSchemaType> typeList = new ArrayList<>();
    SchemaParser schemaParser = new SchemaParser();
    TypeDefinitionRegistry typeRegistry = schemaParser.parse(schema);
    Map<java.lang.String, TypeDefinition> list = typeRegistry.types();
    for (Map.Entry<String, TypeDefinition> entry : list.entrySet()) {
        if (entry.getValue() instanceof ObjectTypeDefinition) {
            GraphqlSchemaType graphqlSchemaType = new GraphqlSchemaType();
            List<String> fieldList = new ArrayList<>();
            graphqlSchemaType.setType(entry.getValue().getName());
            for (FieldDefinition fieldDef : ((ObjectTypeDefinition) entry.getValue()).getFieldDefinitions()) {
                fieldList.add(fieldDef.getName());
            }
            graphqlSchemaType.setFieldList(fieldList);
            typeList.add(graphqlSchemaType);
        }
    }
    return typeList;
}
 

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();
}
 

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("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();
}
 

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();
}
 

@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();
}
 

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();
}
 

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();
}
 

/**
 * @see ContentCanonicalizer#canonicalize(io.apicurio.registry.content.ContentHandle)
 */
@Override
public ContentHandle canonicalize(ContentHandle content) {
    try {
        TypeDefinitionRegistry typeRegistry = sparser.parse(content.content());
        String canonicalized = printer.print(schemaGenerator.makeExecutableSchema(typeRegistry, wiring));
        return ContentHandle.create(canonicalized);
    } catch (Exception e) {
        // Must not be a GraphQL file
    }
    return content;
}
 

private static boolean tryGraphQL(ContentHandle content) {
    try {
        TypeDefinitionRegistry typeRegistry = new SchemaParser().parse(content.content());
        if (typeRegistry != null) {
            return true;
        }
    } catch (Exception e) {
        // Must not be a GraphQL file
    }
    return false;
}
 

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);
}
 

private static void ensureQueryTypeExists(TypeDefinitionRegistry typeRegistry) {
    final String queryName = typeRegistry.schemaDefinition()
            .flatMap(sdef -> sdef.getOperationTypeDefinitions()
                    .stream()
                    .filter(op -> "query".equals(op.getName()))
                    .findFirst()
                    .map(def -> def.getTypeName().getName()))
            .orElse("Query");
    if (!typeRegistry.getType(queryName).isPresent()) {
        typeRegistry.add(ObjectTypeDefinition.newObjectTypeDefinition().name(queryName).build());
    }
}
 

@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();
}