private void buildDefinitionMap(List<GraphQLFieldDefinition> fieldDefinitions) { for (GraphQLFieldDefinition fieldDefinition : fieldDefinitions) { String name = fieldDefinition.getName(); if (fieldDefinitionsByName.containsKey(name)) throw new AssertException(format("Duplicated definition for field '%s' in interface '%s'", name, this.name)); fieldDefinitionsByName.put(name, fieldDefinition); } }
private void buildDefinitionMap(List<GraphQLFieldDefinition> fieldDefinitions) { for (GraphQLFieldDefinition fieldDefinition : fieldDefinitions) { String name = fieldDefinition.getName(); if (fieldDefinitionsByName.containsKey(name)) throw new AssertException(format("Duplicated definition for field '%s' in type '%s'", name, this.name)); fieldDefinitionsByName.put(name, fieldDefinition); } }
public Builder field(GraphQLFieldDefinition fieldDefinition) { assertNotNull(fieldDefinition, "fieldDefinition can't be null"); this.fields.put(fieldDefinition.getName(), fieldDefinition); return this; }
public Builder field(GraphQLFieldDefinition fieldDefinition) { assertNotNull(fieldDefinition, "fieldDefinition can't be null"); this.fields.put(fieldDefinition.getName(), fieldDefinition); return this; }
private static Object fakeObjectValue(GraphQLObjectType fieldType) { Map<String, Object> map = new LinkedHashMap<>(); fieldType.getFieldDefinitions().forEach(fldDef -> { GraphQLOutputType innerFieldType = fldDef.getType(); Object obj = null; if (innerFieldType instanceof GraphQLObjectType) { obj = fakeObjectValue((GraphQLObjectType) innerFieldType); } else if (innerFieldType instanceof GraphQLScalarType) { obj = fakeScalarValue(fldDef.getName(), (GraphQLScalarType) innerFieldType); } map.put(fldDef.getName(), obj); }); return map; }
@Override public List<GraphQLFieldDefinition> getFieldDefinitions(GraphQLFieldsContainer fieldsContainer) { return fieldsContainer.getFieldDefinitions().stream() .filter(fieldDefinition -> !block(mkFQN(fieldsContainer.getName(), fieldDefinition.getName()))) .collect(Collectors.toList()); }
/** * Creates new field coordinates * * @param parentType the container of the field * @param fieldDefinition the field definition * * @return new field coordinates represented by the two parameters */ public static FieldCoordinates coordinates(GraphQLFieldsContainer parentType, GraphQLFieldDefinition fieldDefinition) { return new FieldCoordinates(parentType.getName(), fieldDefinition.getName()); }
@Internal public static void addCodeForIntrospectionTypes(GraphQLCodeRegistry.Builder codeRegistry) { // place the system __ fields into the mix. They have no parent types codeRegistry.systemDataFetcher(systemCoordinates(SchemaMetaFieldDef.getName()), SchemaMetaFieldDefDataFetcher); codeRegistry.systemDataFetcher(systemCoordinates(TypeNameMetaFieldDef.getName()), TypeNameMetaFieldDefDataFetcher); codeRegistry.systemDataFetcher(systemCoordinates(TypeMetaFieldDef.getName()), TypeMetaFieldDefDataFetcher); introspectionDataFetchers.forEach(codeRegistry::dataFetcher); }
private GraphQLFieldDefinition getFieldDef(GraphQLSchema schema, GraphQLType parentType, Field field) { if (schema.getQueryType().equals(parentType)) { if (field.getName().equals(SchemaMetaFieldDef.getName())) { return SchemaMetaFieldDef; } if (field.getName().equals(TypeMetaFieldDef.getName())) { return TypeMetaFieldDef; } } if (field.getName().equals(TypeNameMetaFieldDef.getName()) && (parentType instanceof GraphQLObjectType || parentType instanceof GraphQLInterfaceType || parentType instanceof GraphQLUnionType)) { return TypeNameMetaFieldDef; } if (parentType instanceof GraphQLFieldsContainer) { return schema.getFieldVisibility().getFieldDefinition((GraphQLFieldsContainer) parentType, field.getName()); } return null; } }
private void checkObjectImplementsInterface(GraphQLObjectType objectType, GraphQLInterfaceType interfaceType, SchemaValidationErrorCollector validationErrorCollector) { List<GraphQLFieldDefinition> fieldDefinitions = interfaceType.getFieldDefinitions(); for (GraphQLFieldDefinition interfaceFieldDef : fieldDefinitions) { GraphQLFieldDefinition objectFieldDef = objectType.getFieldDefinition(interfaceFieldDef.getName()); if (objectFieldDef == null) { validationErrorCollector.addError( error(format("object type '%s' does not implement interface '%s' because field '%s' is missing", objectType.getName(), interfaceType.getName(), interfaceFieldDef.getName()))); } else { checkFieldTypeCompatibility(objectType, interfaceType, validationErrorCollector, interfaceFieldDef, objectFieldDef); } } }
private static DataFetcher getDataFetcherImpl(GraphQLFieldsContainer parentType, GraphQLFieldDefinition fieldDefinition, Map<FieldCoordinates, DataFetcherFactory> dataFetcherMap, Map<String, DataFetcherFactory> systemDataFetcherMap) { assertNotNull(parentType); assertNotNull(fieldDefinition); DataFetcherFactory dataFetcherFactory = systemDataFetcherMap.get(fieldDefinition.getName()); if (dataFetcherFactory == null) { dataFetcherFactory = dataFetcherMap.get(FieldCoordinates.coordinates(parentType, fieldDefinition)); if (dataFetcherFactory == null) { dataFetcherFactory = DataFetcherFactories.useDataFetcher(new PropertyDataFetcher<>(fieldDefinition.getName())); } } return dataFetcherFactory.get(newDataFetchingFactoryEnvironment() .fieldDefinition(fieldDefinition) .build()); }
@Override public GraphQLFieldDefinition getFieldDefinition(GraphQLFieldsContainer fieldsContainer, String fieldName) { GraphQLFieldDefinition fieldDefinition = fieldsContainer.getFieldDefinition(fieldName); if (fieldDefinition != null) { if (block(mkFQN(fieldsContainer.getName(), fieldDefinition.getName()))) { fieldDefinition = null; } } return fieldDefinition; }
private TypePrinter<GraphQLInterfaceType> interfacePrinter() { return (out, type, visibility) -> { if (isIntrospectionType(type)) { return; } printComments(out, type, ""); out.format("interface %s%s {\n", type.getName(), directivesString(type.getDirectives())); visibility.getFieldDefinitions(type) .stream() .sorted(Comparator.comparing(GraphQLFieldDefinition::getName)) .forEach(fd -> { printComments(out, fd, " "); out.format(" %s%s: %s%s\n", fd.getName(), argsString(fd.getArguments()), typeString(fd.getType()), directivesString(fd.getDirectives())); }); out.format("}\n\n"); }; }
private String mkMessage(ExecutionPath path, UnresolvedTypeException exception, ExecutionStepInfo info) { return format("Can't resolve '%s'. Abstract type '%s' must resolve to an Object type at runtime for field '%s.%s'. %s", path, exception.getInterfaceOrUnionType().getName(), info.getParent().getUnwrappedNonNullType().getName(), info.getFieldDefinition().getName(), exception.getMessage()); }
@Override public DataFetcher getDefaultDataFetcher(FieldWiringEnvironment environment) { return env -> { GraphQLOutputType fieldType = env.getFieldType(); if (fieldType instanceof GraphQLObjectType) { return fakeObjectValue((GraphQLObjectType) fieldType); } else { PropertyDataFetcher<Object> df = new PropertyDataFetcher<>(env.getFieldDefinition().getName()); return df.get(env); } }; }
@SuppressWarnings("unchecked") public Builder(GraphQLFieldDefinition existing) { this.name = existing.getName(); this.description = existing.getDescription(); this.type = existing.getType(); this.dataFetcherFactory = DataFetcherFactories.useDataFetcher(existing.getDataFetcher()); this.deprecationReason = existing.getDeprecationReason(); this.definition = existing.getDefinition(); this.arguments.putAll(getByName(existing.getArguments(), GraphQLArgument::getName)); this.directives.putAll(getByName(existing.getDirectives(), GraphQLDirective::getName)); }
@Override public TraversalControl visitGraphQLFieldDefinition(GraphQLFieldDefinition node, TraverserContext<GraphQLType> context) { GraphQLFieldsContainer parentContainerType = (GraphQLFieldsContainer) context.getParentContext().thisNode(); DataFetcher dataFetcher = node.getDataFetcher(); if (dataFetcher == null) { dataFetcher = new PropertyDataFetcher<>(node.getName()); } FieldCoordinates coordinates = coordinates(parentContainerType, node); codeRegistry.dataFetcherIfAbsent(coordinates, dataFetcher); return CONTINUE; }
@Override public GraphQLFieldDefinition onField(SchemaDirectiveWiringEnvironment<GraphQLFieldDefinition> environment) { GraphQLFieldDefinition field = environment.getElement(); String fetchName = atFetchFromSupport(field.getName(), field.getDirectives()); DataFetcher dataFetcher = new PropertyDataFetcher(fetchName); environment.getCodeRegistry().dataFetcher(coordinates(environment.getFieldsContainer(), field), dataFetcher); return field; }
private void checkFieldTypeCompatibility(GraphQLObjectType objectType, GraphQLInterfaceType interfaceType, SchemaValidationErrorCollector validationErrorCollector, GraphQLFieldDefinition interfaceFieldDef, GraphQLFieldDefinition objectFieldDef) { String interfaceFieldDefStr = simplePrint(interfaceFieldDef.getType()); String objectFieldDefStr = simplePrint(objectFieldDef.getType()); if (!isCompatible(interfaceFieldDef.getType(), objectFieldDef.getType())) { validationErrorCollector.addError( error(format("object type '%s' does not implement interface '%s' because field '%s' is defined as '%s' type and not as '%s' type", objectType.getName(), interfaceType.getName(), interfaceFieldDef.getName(), objectFieldDefStr, interfaceFieldDefStr))); } else { checkFieldArgumentEquivalence(objectType, interfaceType, validationErrorCollector, interfaceFieldDef, objectFieldDef); } }
private FieldDefAndDirectiveParams buildField(BuildContext buildCtx, TypeDefinition parentType, FieldDefinition fieldDef) { buildCtx.enterNode(fieldDef); GraphQLFieldDefinition.Builder builder = GraphQLFieldDefinition.newFieldDefinition(); builder.definition(fieldDef); builder.name(fieldDef.getName()); builder.description(schemaGeneratorHelper.buildDescription(fieldDef, fieldDef.getDescription())); builder.deprecate(schemaGeneratorHelper.buildDeprecationReason(fieldDef.getDirectives())); GraphQLDirective[] directives = buildDirectives(fieldDef.getDirectives(), Collections.emptyList(), DirectiveLocation.FIELD_DEFINITION, buildCtx.getDirectiveDefinitions()); builder.withDirectives( directives ); fieldDef.getInputValueDefinitions().forEach(inputValueDefinition -> builder.argument(buildArgument(buildCtx, inputValueDefinition))); GraphQLOutputType fieldType = buildOutputType(buildCtx, fieldDef.getType()); builder.type(fieldType); GraphQLFieldDefinition fieldDefinition = builder.build(); // if they have already wired in a fetcher - then leave it alone FieldCoordinates coordinates = FieldCoordinates.coordinates(parentType.getName(), fieldDefinition.getName()); if (!buildCtx.codeRegistry.hasDataFetcher(coordinates)) { DataFetcherFactory dataFetcherFactory = buildDataFetcherFactory(buildCtx, parentType, fieldDef, fieldType, Arrays.asList(directives)); buildCtx.getCodeRegistry().dataFetcher(coordinates, dataFetcherFactory); } return buildCtx.exitNode(new FieldDefAndDirectiveParams(fieldDefinition, buildCtx.mkBehaviourParams())); }