graphql.schema.idl.SchemaParser Java Examples

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

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

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

/**
 * 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;
}
 

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

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

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

public RootQuery(DataSetRepository dataSetRepository, SupportedExportFormats supportedFormats,
                 String archetypes, Function<Runnable, RdfWiringFactory> wiringFactory,
                 DerivedSchemaGenerator typeGenerator, ObjectMapper objectMapper,
                 ResourceSyncFileLoader resourceSyncFileLoader, ResourceSyncService resourceSyncService,
                 ExecutorService schemaAccessQueue)
  throws IOException {
  this.dataSetRepository = dataSetRepository;
  this.supportedFormats = supportedFormats;
  this.archetypes = archetypes;
  this.wiringFactory = wiringFactory.apply(this::scheduleRebuild);
  this.typeGenerator = typeGenerator;
  this.objectMapper = objectMapper;
  this.resourceSyncFileLoader = resourceSyncFileLoader;
  this.resourceSyncService = resourceSyncService;
  this.schemaAccessQueue = schemaAccessQueue;
  staticQuery = Resources.toString(getResource(RootQuery.class, "schema.graphql"), Charsets.UTF_8);
  schemaParser = new SchemaParser();
  dataSetRepository.subscribeToDataSetsUpdated(this::scheduleRebuild);
}
 

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

/**
 * This method validate the payload
 *
 * @param messageContext message context of the request
 * @param document       graphQL schema of the request
 * @return true or false
 */
private boolean validatePayloadWithSchema(MessageContext messageContext, Document document) {
    ArrayList<String> validationErrorMessageList = new ArrayList<>();
    List<ValidationError> validationErrors;
    String validationErrorMessage;

    synchronized (apiUUID + CLASS_NAME_AND_METHOD) {
        if (schema == null) {
            Entry localEntryObj = (Entry) messageContext.getConfiguration().getLocalRegistry().get(apiUUID +
                    GRAPHQL_IDENTIFIER);
            if (localEntryObj != null) {
                SchemaParser schemaParser = new SchemaParser();
                schemaDefinition = localEntryObj.getValue().toString();
                TypeDefinitionRegistry registry = schemaParser.parse(schemaDefinition);
                schema = UnExecutableSchemaGenerator.makeUnExecutableSchema(registry);
            }
        }
    }

    validationErrors = validator.validateDocument(schema, document);
    if (validationErrors != null && validationErrors.size() > 0) {
        if (log.isDebugEnabled()) {
            log.debug("Validation failed for " + document);
        }
        for (ValidationError error : validationErrors) {
            validationErrorMessageList.add(error.getDescription());
        }
        validationErrorMessage = String.join(",", validationErrorMessageList);
        handleFailure(messageContext, validationErrorMessage);
        return false;
    }
    return true;
}
 

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

private TypeDefinitionRegistry buildTypeDefinitionRegistry() {
  try (InputStream stream = getClass().getResourceAsStream(GRID_SCHEMA)) {
    return new SchemaParser().parse(stream);
  } catch (IOException e) {
    throw new UncheckedIOException(e);
  }
}
 

private TypeDefinitionRegistry parseSchema() {
    try {
        return new SchemaParser().parse(schemaString);
    } catch (Exception e) {
        throw new GraphQlGeneratorException("can't parse schema: " + schemaString, e);
    }
}
 

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

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

@Test
void testPrinterFilter() {
    TypeDefinitionRegistry typeDefinitionRegistry = new SchemaParser().parse(printerFilterSDL);
    RuntimeWiring runtimeWiring = RuntimeWiring.newRuntimeWiring()
            .type("Interface1", typeWiring -> typeWiring
                    .typeResolver(env -> null)
            )
            .type("Interface2", typeWiring -> typeWiring
                    .typeResolver(env -> null)
            )
            .scalar(GraphQLScalarType.newScalar()
                    .name("Scalar1")
                    .coercing(Scalars.GraphQLString.getCoercing())
                    .build()
            )
            .scalar(GraphQLScalarType.newScalar()
                    .name("Scalar2")
                    .coercing(Scalars.GraphQLString.getCoercing())
                    .build()
            )
            .build();
    GraphQLSchema graphQLSchema = new SchemaGenerator().makeExecutableSchema(
            typeDefinitionRegistry,
            runtimeWiring
    );
    Assertions.assertEquals(
            printerFilterExpectedSDL.trim(),
            new FederationSdlPrinter(FederationSdlPrinter.Options.defaultOptions()
                    .includeScalarTypes(true)
                    .includeDirectiveDefinitions(def ->
                            !def.getName().endsWith("1") && !standardDirectives.contains(def.getName())
                    )
                    .includeTypeDefinitions(def -> !def.getName().endsWith("1"))
            ).print(graphQLSchema).trim()
    );
}