public GraphQL build() { assertNotNull(graphQLSchema, "graphQLSchema must be non null"); assertNotNull(queryExecutionStrategy, "queryStrategy must be non null"); assertNotNull(idProvider, "idProvider must be non null"); return new GraphQL(graphQLSchema, queryExecutionStrategy, mutationExecutionStrategy, subscriptionExecutionStrategy, idProvider, instrumentation, preparsedDocumentProvider); } }
serviceCodes = graph.serviceCodes; this.graph = graph; graphQL = new GraphQL( new IndexGraphQLSchema(this).indexSchema, new ExecutorServiceExecutionStrategy(Executors.newCachedThreadPool(
@Provides @Singleton GraphQL createGraphQL( SchemaTranslator translator) { GraphQLSchema schema = translator.toGraphQL(); return new GraphQL(schema); }
public GraphQL build() { assertNotNull(graphQLSchema, "graphQLSchema must be non null"); assertNotNull(queryExecutionStrategy, "queryStrategy must be non null"); assertNotNull(idProvider, "idProvider must be non null"); return new GraphQL(graphQLSchema, queryExecutionStrategy, mutationExecutionStrategy, subscriptionExecutionStrategy, idProvider, instrumentation, preparsedDocumentProvider); } }
@Inject public GraphQLEndpoint( @Named("elide") Elide elide, @Named("elideUserExtractionFunction") DefaultOpaqueUserFunction getUser) { log.error("Started ~~"); this.elide = elide; this.elideSettings = elide.getElideSettings(); this.getUser = getUser; PersistentResourceFetcher fetcher = new PersistentResourceFetcher(elide.getElideSettings()); ModelBuilder builder = new ModelBuilder(elide.getElideSettings().getDictionary(), fetcher); this.api = new GraphQL(builder.build()); }
@Inject public GraphQLEndpoint( @Named("elide") Elide elide, @Named("elideUserExtractionFunction") DefaultOpaqueUserFunction getUser) { log.error("Started ~~"); this.elide = elide; this.elideSettings = elide.getElideSettings(); this.getUser = getUser; PersistentResourceFetcher fetcher = new PersistentResourceFetcher(elide.getElideSettings()); ModelBuilder builder = new ModelBuilder(elide.getElideSettings().getDictionary(), fetcher); this.api = new GraphQL(builder.build()); }
@SuppressWarnings("rawtypes") private GameDTO getGameNode(String id) throws IOException { ExecutionResult result = new GraphQL(schema).execute(String.format("{ node(id:\"%s\") {...on Game {id, name} } }", id)); assertEquals(0, result.getErrors().size()); return objectMapper.readValue(objectMapper.writeValueAsString(((Map) result.getData()).get("node")), GameDTO.class); }
@SuppressWarnings("rawtypes") private UserDTO getUserNode(String id) throws IOException { ExecutionResult result = new GraphQL(schema).execute(String.format("{ node(id:\"%s\") {...on User {id, name, email} } }", id)); assertEquals(0, result.getErrors().size()); return objectMapper.readValue(objectMapper.writeValueAsString(((Map) result.getData()).get("node")), UserDTO.class); }
private DeleteUserPayload deleteUser(String id, String clientMutationId) throws IOException { ExecutionResult result = new GraphQL(schema).execute(String .format("mutation M { Mutations { deleteUser(input: { id:\"%s\", clientMutationId:\"%s\"}) {clientMutationId} } }", id, clientMutationId)); assertEquals(0, result.getErrors().size()); DeleteUserPayload payload = objectMapper.readValue(objectMapper.writeValueAsString(getMutationResults(result, "deleteUser")), DeleteUserPayload.class); assertEquals(clientMutationId, payload.getClientMutationId()); return payload; }
private DeleteGamePayload deleteGame(String id, String clientMutationId) throws IOException { ExecutionResult result = new GraphQL(schema).execute( String.format("mutation M { Mutations {deleteGame(input:{ id:\"%s\", clientMutationId:\"%s\"}) {clientMutationId} } }", id, clientMutationId)); assertEquals(0, result.getErrors().size()); DeleteGamePayload payload = objectMapper.readValue(objectMapper.writeValueAsString(getMutationResults(result, "deleteGame")), DeleteGamePayload.class); assertEquals(clientMutationId, payload.getClientMutationId()); return payload; }
private RelayConnection<GameDTO> findGames(int first) throws IOException { ExecutionResult result = new GraphQL(schema).execute(String .format("{ Queries { games(first:%d) { edges { node {id, name}, cursor } , pageInfo {hasPreviousPage, hasNextPage} } } }", first)); assertEquals(result.getErrors().toString(), 0, result.getErrors().size()); return deserialize(objectMapper.writeValueAsString(getQueryResults(result, "games")), new TypeReference<RelayConnection<GameDTO>>() { }); }
private NewGamePayload createGame(String name, String clientMutationId) throws IOException { NewGameInput input = objectMapper.readValue(String.format("{\"game\":{\"name\":\"%s\"}, \"clientMutationId\":\"%s\" }", name, clientMutationId), NewGameInput.class); ExecutionResult result = new GraphQL(schema).execute(String.format( "mutation M { Mutations { createGame(input:{ game: {name:\"%s\"}, clientMutationId:\"%s\"}) { game {id, name}, clientMutationId } } }", name, clientMutationId)); assertEquals(0, result.getErrors().size()); NewGamePayload payload = objectMapper.readValue(objectMapper.writeValueAsString(getMutationResults(result, "createGame")), NewGamePayload.class); assertEquals(name, payload.getGame().getName()); assertEquals(clientMutationId, payload.getClientMutationId()); return payload; }
@SuppressWarnings("unchecked") @Test public void testTypeConverterDetection() { GraphQLSchema schema = GraphQLSchemaBuilder.newBuilder() .registerTypeFactory(new JacksonTypeFactory(new ObjectMapper())) .registerGraphQLControllerObjects(ImmutableList.<Object> of(new TypeConverterTest())) .build(); assertEquals("prepend:1", ((Map<String, String>)new GraphQL(schema).execute("{ someStrings }").getData()).get("someStrings")); }
private NewUserPayload createUser(String name, String email, String clientMutationId) throws IOException { ExecutionResult result = new GraphQL(schema).execute(String.format( "mutation M { Mutations {createUser(input: { user: { name:\"%s\", email:\"%s\"}, clientMutationId:\"%s\"}) { user {id, name, email}, clientMutationId} } }", name, email, clientMutationId)); assertEquals(0, result.getErrors().size()); NewUserPayload payload = objectMapper.readValue(objectMapper.writeValueAsString(getMutationResults(result, "createUser")), NewUserPayload.class); assertEquals(name, payload.getUser().getName()); assertEquals(email, payload.getUser().getEmail()); assertEquals(clientMutationId, payload.getClientMutationId()); return payload; }
@Test public void testCompletableFuture() throws Exception { ReactiveExecutionStrategy strategy = new ReactiveExecutionStrategy(); GraphQLSchema schema = newQuerySchema(it -> it .field(newStringField("a").dataFetcher(env -> CompletableFuture.completedFuture("static"))) ); ExecutionResult executionResult = new GraphQL(schema, strategy).execute("{ a }"); Flowable.fromPublisher((Publisher<Change>) executionResult.getData()).timestamp(scheduler).subscribe(subscriber); subscriber .assertChanges(it -> it.containsExactly( tuple("00:000", "", ImmutableMap.of("a", "static")) )) .assertComplete(); }
@Test public void testPlainField() throws Exception { GraphQLSchema schema = newQuerySchema(it -> it .field(newLongField("a").dataFetcher(env -> Flowable.interval(1, SECONDS, scheduler).take(2))) ); ExecutionResult executionResult = new GraphQL(schema, strategy).execute("{ a }"); assertThat(executionResult) .isNotNull() .satisfies(it -> assertThat(it.<Publisher<Change>>getData()).isNotNull().isInstanceOf(Publisher.class)); Flowable.fromPublisher((Publisher<Change>) executionResult.getData()).timestamp(scheduler).subscribe(subscriber); scheduler.advanceTimeBy(2, SECONDS); subscriber .assertChanges(it -> it.containsExactly( tuple("01:000", "", ImmutableMap.of("a", 0L)), tuple("02:000", "a", 1L) )) .assertComplete(); }
public static void main(String[] args) { GraphQLObjectType queryType = newObject() .name("helloWorldQuery") .field(newFieldDefinition() .type(GraphQLString) .name("hello") .staticValue(Observable.just("world")) .build()) .build(); GraphQLSchema schema = GraphQLSchema.newSchema() .query(queryType) .build(); Observable<?> result = ((RxExecutionResult)new GraphQL(schema, new RxExecutionStrategy()).execute("{hello}")).getDataObservable(); result.subscribe(System.out::println); }
@Test public void testStaticValues() throws Exception { GraphQLSchema schema = newQuerySchema(it -> it .field(newStringField("a").dataFetcher(env -> "staticA")) .field(newStringField("b").dataFetcher(env -> "staticB")) ); ExecutionResult executionResult = new GraphQL(schema, strategy).execute("{ a, b }"); Flowable.fromPublisher((Publisher<Change>) executionResult.getData()).timestamp(scheduler).subscribe(subscriber); subscriber .assertChanges(it -> it.containsExactly( tuple("00:000", "", ImmutableMap.of("a", "staticA", "b", "staticB")) )) .assertComplete(); } }
@Test public void testAnyPublisher() throws Exception { Duration tick = Duration.ofSeconds(1); GraphQLSchema schema = newQuerySchema(it -> it // use Flux from Project Reactor .field(newLongField("a").dataFetcher(env -> Flux.interval(tick).take(2))) ); ExecutionResult executionResult = new GraphQL(schema, strategy).execute("{ a }"); // Use Reactor's StepVerifier StepVerifier.withVirtualTime(() -> (Publisher<Change>) executionResult.getData()) .expectSubscription() .expectNoEvent(tick) .assertNext(matchChange("", ImmutableMap.of("a", 0L))) .expectNoEvent(tick) .assertNext(matchChange("a", 1L)) .verifyComplete(); }
@Test public void testStartWith() throws Exception { GraphQLSchema schema = newQuerySchema(it -> it .field(newLongField("a").dataFetcher(env -> Flowable.interval(1, SECONDS, scheduler).take(2).startWith(-42L))) ); ExecutionResult executionResult = new GraphQL(schema, strategy).execute("{ a }"); Flowable.fromPublisher((Publisher<Change>) executionResult.getData()).timestamp(scheduler).subscribe(subscriber); scheduler.advanceTimeBy(2, SECONDS); subscriber .assertChanges(it -> it.containsExactly( tuple("00:000", "", ImmutableMap.of("a", -42L)), tuple("01:000", "a", 0L), tuple("02:000", "a", 1L) )) .assertComplete(); }