@Override public GraphQLSchema getGraphQLSchema() { return delegate.getGraphQLSchema(); }
@Override public Object convertOutput(Mono<T> original, AnnotatedType type, ResolutionEnvironment resolutionEnvironment) { //For subscriptions, Mono<T> (Publisher<T>) should be returned directly if (resolutionEnvironment.dataFetchingEnvironment.getParentType() == resolutionEnvironment.dataFetchingEnvironment.getGraphQLSchema().getSubscriptionType()) { return original; } //For other operations it must be converted into a CompletableFuture<T> return original.toFuture(); }
@Override public Object convertOutput(Mono<T> original, AnnotatedType type, ResolutionEnvironment resolutionEnvironment) { //For subscriptions, Mono<T> (Publisher<T>) should be returned directly if (resolutionEnvironment.dataFetchingEnvironment.getParentType() == resolutionEnvironment.dataFetchingEnvironment.getGraphQLSchema().getSubscriptionType()) { return original; } //For other operations it must be converted into a CompletableFuture<T> return original.toFuture(); }
@Override public Object convertOutput(Publisher<T> original, AnnotatedType type, ResolutionEnvironment resolutionEnvironment) { //Subscriptions are expected to return a Publisher directly, so no conversion needed if (resolutionEnvironment.dataFetchingEnvironment.getParentType() == resolutionEnvironment.dataFetchingEnvironment.getGraphQLSchema().getSubscriptionType()) { return original; } //Otherwise, convert the Publisher into a CompletableFuture return convertOutputForNonSubscription(original, type, resolutionEnvironment); }
public ResolutionEnvironment(DataFetchingEnvironment env, ValueMapper valueMapper, GlobalEnvironment globalEnvironment, ConverterRegistry converterRegistry) { this.context = env.getSource(); this.rootContext = env.getContext(); this.valueMapper = valueMapper; this.globalEnvironment = globalEnvironment; this.converterRegistry = converterRegistry; this.fields = env.getFields(); this.fieldType = env.getFieldType(); this.parentType = env.getParentType(); this.graphQLSchema = env.getGraphQLSchema(); this.dataFetchingEnvironment = env; this.arguments = new HashMap<>(); }
/** * Creates a resolver for the <em>node</em> query as defined by the Relay GraphQL spec. * <p>This query only takes a singe argument called "id" of type String, and returns the object implementing the * <em>Node</em> interface to which the given id corresponds.</p> * * @param nodeQueriesByType A map of all queries whose return types implement the <em>Node</em> interface, keyed * by their corresponding GraphQL type name * @param relay Relay helper * * @return The node query resolver */ private DataFetcher createNodeResolver(Map<String, String> nodeQueriesByType, Relay relay) { return env -> { String typeName; try { typeName = relay.fromGlobalId(env.getArgument(GraphQLId.RELAY_ID_FIELD_NAME)).getType(); } catch (Exception e) { throw new IllegalArgumentException(env.getArgument(GraphQLId.RELAY_ID_FIELD_NAME) + " is not a valid Relay node ID"); } if (!nodeQueriesByType.containsKey(typeName)) { throw new IllegalArgumentException(typeName + " is not a Relay node type or no registered query can fetch it by ID"); } return env.getGraphQLSchema().getQueryType().getFieldDefinition(nodeQueriesByType.get(typeName)).getDataFetcher().get(env); }; }
public List<Object> getBatched(DataFetchingEnvironment env) { List sources = (List)env.getSource(); if ( isBatched ) { Object result = fetcher.get(env); if ( !(result instanceof List) || ((List)result).size() != sources.size() ) { throw new IllegalStateException("Batched fetcher "+fetcher+" expected to return list of "+sources.size()); } return (List<Object>)result; } List<Object> result = new ArrayList<>(); for ( Object source : sources ) { DataFetchingEnvironment envCopy = new DataFetchingEnvironmentImpl( source, env.getArguments(), env.getContext(), env.getFields(), env.getFieldType(), env.getParentType(), env.getGraphQLSchema(), env.getFragmentsByName(), env.getExecutionId(), env.getSelectionSet()); result.add(fetcher.get(envCopy)); } return result; }
public List<Object> getBatched(DataFetchingEnvironment env) { List sources = (List)env.getSource(); if ( isBatched ) { Object result = fetcher.get(env); if ( !(result instanceof List) || ((List)result).size() != sources.size() ) { throw new IllegalStateException("Batched fetcher "+fetcher+" expected to return list of "+sources.size()); } return (List<Object>)result; } List<Object> result = new ArrayList<>(); for ( Object source : sources ) { DataFetchingEnvironment envCopy = new DataFetchingEnvironmentImpl( source, env.getArguments(), env.getContext(), env.getFields(), env.getFieldType(), env.getParentType(), env.getGraphQLSchema(), env.getFragmentsByName(), env.getExecutionId(), env.getSelectionSet()); result.add(fetcher.get(envCopy)); } return result; }
public Object getUnbatched(DataFetchingEnvironment env) { if ( ! isBatched ) return fetcher.get(env); DataFetchingEnvironment envCopy = new DataFetchingEnvironmentImpl( Collections.singletonList(env.getSource()), env.getArguments(), env.getContext(), env.getFields(), env.getFieldType(), env.getParentType(), env.getGraphQLSchema(), env.getFragmentsByName(), env.getExecutionId(), env.getSelectionSet()); Object result = fetcher.get(envCopy); if ( !(result instanceof List) || ((List)result).size() != 1 ) { throw new IllegalStateException("Batched fetcher "+fetcher+" expected to return list of 1"); } return ((List)result).get(0); }
public Object getUnbatched(DataFetchingEnvironment env) { if ( ! isBatched ) return fetcher.get(env); DataFetchingEnvironment envCopy = new DataFetchingEnvironmentImpl( Collections.singletonList(env.getSource()), env.getArguments(), env.getContext(), env.getFields(), env.getFieldType(), env.getParentType(), env.getGraphQLSchema(), env.getFragmentsByName(), env.getExecutionId(), env.getSelectionSet()); Object result = fetcher.get(envCopy); if ( !(result instanceof List) || ((List)result).size() != 1 ) { throw new IllegalStateException("Batched fetcher "+fetcher+" expected to return list of 1"); } return ((List)result).get(0); }
@Override public Object get(DataFetchingEnvironment environment) { // Exclude arguments DataFetchingEnvironment env = new DataFetchingEnvironmentImpl(environment.getSource(), new HashMap<>(), environment.getContext(), environment.getFields(), environment.getFieldType(), environment.getParentType(), environment.getGraphQLSchema(), environment.getFragmentsByName(), environment.getExecutionId(), environment.getSelectionSet()); Connection conn = constructNewInstance(constructor, actualDataFetcher.get(env)); return conn.get(environment); } }
@Override public Object getArgumentValue(ArgumentInjectorParams params) { GraphQLDirective descriptor = params.getParameter().getAnnotation(GraphQLDirective.class); boolean allDirectives = GenericTypeReflector.isSuperType(Collection.class, params.getType().getType()); ResolutionEnvironment env = params.getResolutionEnvironment(); String fallBackDirectiveName = env.globalEnvironment.typeInfoGenerator.generateDirectiveTypeName(params.getBaseType(), env.globalEnvironment.messageBundle); String directiveName = Utils.coalesce(descriptor.name(), fallBackDirectiveName); Stream<Introspection.DirectiveLocation> locations = descriptor.locations().length != 0 ? Arrays.stream(descriptor.locations()) : sortedLocations(params.getResolutionEnvironment().dataFetchingEnvironment.getGraphQLSchema().getDirective(directiveName).validLocations()); Directives directives = env.getDirectives(); Stream<Map<String, Object>> rawValues = locations .map(loc -> directives.find(loc, directiveName)) .filter(Objects::nonNull) .flatMap(Collection::stream); Object deserializableValue = allDirectives ? rawValues.collect(Collectors.toList()) : rawValues.findFirst().orElse(null); if (deserializableValue == null) { return null; } return params.getResolutionEnvironment().valueMapper.fromInput(deserializableValue, params.getType()); }
private Map<String, Object> parseDirective(Directive dir, DataFetchingEnvironment env) { GraphQLDirective directive = env.getExecutionContext().getGraphQLSchema().getDirective(dir.getName()); if (directive == null) { return null; } return Collections.unmodifiableMap( valuesResolver.getArgumentValues(env.getGraphQLSchema().getFieldVisibility(), directive.getArguments(), dir.getArguments(), env.getExecutionContext().getVariables())); }
environment.getGraphQLSchema(), this.getObjectType(environment, argument), new Field(fieldName)
@Override public T get(DataFetchingEnvironment environment) throws Exception { Object source = environment.getSource(); if (source != null && (!declaringClass.isInstance(source)) && !(source instanceof Map)) { environment = new DataFetchingEnvironmentImpl(newInstance(declaringClass, source), environment.getArguments(), environment.getContext(), environment.getRoot(), environment.getFieldDefinition(), environment.getFields(), environment.getFieldType(), environment.getParentType(), environment.getGraphQLSchema(), environment.getFragmentsByName(), environment.getExecutionId(), environment.getSelectionSet(), environment.getExecutionStepInfo(), environment.getExecutionContext()); } return dataFetcher.get(environment); }
public WherePredicateEnvironment(DataFetchingEnvironment environment, GraphQLFieldDefinition fieldDefinition, Map<String, Object> arguments) { super( environment.getSource(), arguments, environment.getContext(), environment.getRoot(), fieldDefinition, //environment.getFieldDefinition(), environment.getFields(), fieldDefinition.getType(), // environment.getFieldType(), environment.getParentType(), environment.getGraphQLSchema(), environment.getFragmentsByName(), environment.getExecutionId(), environment.getSelectionSet(), environment.getExecutionStepInfo(), environment.getExecutionContext() ); } }
public ArgumentEnvironment(DataFetchingEnvironment environment, String argumentName) { super( environment.getSource(), environment.getArgument(argumentName), environment.getContext(), environment.getRoot(), environment.getFieldDefinition(), environment.getFields(), environment.getFieldType(), environment.getParentType(), environment.getGraphQLSchema(), environment.getFragmentsByName(), environment.getExecutionId(), environment.getSelectionSet(), environment.getExecutionStepInfo(), environment.getExecutionContext() ); } }
@SuppressWarnings( "serial" ) protected Predicate getWherePredicate(CriteriaBuilder cb, Root<?> root, From<?,?> path, DataFetchingEnvironment environment, Argument argument) { ObjectValue whereValue = getValue(argument); if(whereValue.getChildren().isEmpty()) return cb.conjunction(); return getArgumentPredicate(cb, (path != null) ? path : root, new DataFetchingEnvironmentImpl( environment.getSource(), new LinkedHashMap<String,Object>() {{ put(Logical.AND.name(), environment.getArguments()); }}, environment.getContext(), environment.getRoot(), environment.getFieldDefinition(), environment.getFields(), environment.getFieldType(), environment.getParentType(), environment.getGraphQLSchema(), environment.getFragmentsByName(), environment.getExecutionId(), environment.getSelectionSet(), environment.getExecutionStepInfo(), environment.getExecutionContext() ), new Argument(Logical.AND.name(), whereValue) ); }
@SuppressWarnings("serial") private PredicateFilter getPredicateFilter(ObjectField objectField, DataFetchingEnvironment environment, Argument argument) { EnumSet<PredicateFilter.Criteria> options = EnumSet.of(PredicateFilter.Criteria.valueOf(argument.getName())); Object filterValue = convertValue( new DataFetchingEnvironmentImpl( environment.getSource(), new LinkedHashMap<String,Object>() {{ put(objectField.getName(), environment.getArgument(argument.getName())); }}, environment.getContext(), environment.getRoot(), environment.getFieldDefinition(), environment.getFields(), environment.getFieldType(), environment.getParentType(), environment.getGraphQLSchema(), environment.getFragmentsByName(), environment.getExecutionId(), environment.getSelectionSet(), environment.getExecutionStepInfo(), environment.getExecutionContext() ), new Argument(objectField.getName(), argument.getValue()), argument.getValue() ); return new PredicateFilter(objectField.getName(), filterValue, options ); }
public static FragmentDirectiveCollector collect(DataFetchingEnvironment env, ExecutionStepInfo step) { FragmentDirectiveCollector fragmentDirectiveCollector = new FragmentDirectiveCollector(env); // This is safe because top-level fields don't get to here and all deeper fields at least have a parent (source object) and a grand-parent (query root) ExecutionStepInfo rootStep = step.getParent().getParent(); if (rootStep == null) { //Should never be possible, see above return fragmentDirectiveCollector; } GraphQLType rootParentType = GraphQLUtils.unwrapNonNull(rootStep.getType()); while(!(rootParentType instanceof GraphQLObjectType)) { rootStep = rootStep.getParent(); rootParentType = GraphQLUtils.unwrapNonNull(rootStep.getType()); } QueryTraversal traversal = QueryTraversal.newQueryTraversal() .fragmentsByName(env.getExecutionContext().getFragmentsByName()) .schema(env.getGraphQLSchema()) .variables(env.getExecutionContext().getVariables()) .root(env.getExecutionStepInfo().getParent().getField()) .rootParentType((GraphQLObjectType) rootParentType) .build(); traversal.visitPostOrder(fragmentDirectiveCollector); return fragmentDirectiveCollector; }