public TypeExtensionFieldRedefinitionError(TypeDefinition typeDefinition, FieldDefinition fieldDefinition) { super(typeDefinition, formatMessage(typeDefinition, fieldDefinition.getName(), fieldDefinition)); }
public NonUniqueDirectiveError(TypeDefinition typeDefinition, FieldDefinition fieldDefinition, String directiveName) { super(typeDefinition, format("The type '%s' with field '%s' %s has declared a directive with a non unique name '%s'", typeDefinition.getName(), fieldDefinition.getName(), lineCol(typeDefinition), directiveName)); }
public NonUniqueArgumentError(TypeDefinition typeDefinition, FieldDefinition fieldDefinition, String argumentName) { super(typeDefinition, format("The type '%s' with field '%s' %s has declared an argument with a non unique name '%s'", typeDefinition.getName(), fieldDefinition.getName(), lineCol(typeDefinition), argumentName)); }
public InvalidDeprecationDirectiveError(TypeDefinition typeDefinition, FieldDefinition fieldDefinition) { super(typeDefinition, format("The type '%s' with field '%s' %s has declared an invalid deprecation directive. Its must be @deprecated(reason : \"xyz\")", typeDefinition.getName(), fieldDefinition.getName(), lineCol(typeDefinition))); }
public NonUniqueNameError(TypeDefinition typeDefinition, FieldDefinition fieldDefinition) { super(typeDefinition, format("The type '%s' %s has declared a field with a non unique name '%s'", typeDefinition.getName(), lineCol(typeDefinition), fieldDefinition.getName())); }
private void checkForFieldRedefinition(List<GraphQLError> errors, TypeDefinition typeDefinition, List<FieldDefinition> fieldDefinitions, List<FieldDefinition> referenceFieldDefinitions) { Map<String, FieldDefinition> referenceMap = FpKit.getByName(referenceFieldDefinitions, FieldDefinition::getName, mergeFirst()); fieldDefinitions.forEach(fld -> { FieldDefinition reference = referenceMap.get(fld.getName()); if (referenceMap.containsKey(fld.getName())) { // ok they have the same field but is it the same type if (!isSameType(fld.getType(), reference.getType())) { errors.add(new TypeExtensionFieldRedefinitionError(typeDefinition, fld)); } } }); }
private DataFetcher<?> dataFetcherOfLastResort(FieldWiringEnvironment environment) { String fieldName = environment.getFieldDefinition().getName(); return new PropertyDataFetcher(fieldName); }
public InterfaceFieldRedefinitionError(String typeOfType, ObjectTypeDefinition objectType, InterfaceTypeDefinition interfaceTypeDef, FieldDefinition objectFieldDef, String objectFieldType, String interfaceFieldType) { super(objectType, format("The %s type '%s' %s has tried to redefine field '%s' defined via interface '%s' %s from '%s' to '%s'", typeOfType, objectType.getName(), lineCol(objectType), objectFieldDef.getName(), interfaceTypeDef.getName(), lineCol(interfaceTypeDef), interfaceFieldType, objectFieldType)); } }
public MissingInterfaceFieldArgumentsError(String typeOfType, ObjectTypeDefinition objectTypeDef, InterfaceTypeDefinition interfaceTypeDef, FieldDefinition objectFieldDef) { super(objectTypeDef, format("The %s type '%s' %s field '%s' does not have the same number of arguments as specified via interface '%s' %s", typeOfType, objectTypeDef.getName(), lineCol(objectTypeDef), objectFieldDef.getName(), interfaceTypeDef.getName(), lineCol(interfaceTypeDef))); } }
public InterfaceFieldArgumentRedefinitionError(String typeOfType, ObjectTypeDefinition objectTypeDef, InterfaceTypeDefinition interfaceTypeDef, FieldDefinition objectFieldDef, String objectArgStr, String interfaceArgStr) { super(objectTypeDef, format("The %s type '%s' %s has tried to redefine field '%s' arguments defined via interface '%s' %s from '%s' to '%s", typeOfType, objectTypeDef.getName(), lineCol(objectTypeDef), objectFieldDef.getName(), interfaceTypeDef.getName(), lineCol(interfaceTypeDef), interfaceArgStr, objectArgStr)); } }
public MissingInterfaceFieldError(String typeOfType, ObjectTypeDefinition objectType, InterfaceTypeDefinition interfaceTypeDef, FieldDefinition interfaceFieldDef) { super(objectType, format("The %s type '%s' %s does not have a field '%s' required via interface '%s' %s", typeOfType, objectType.getName(), lineCol(objectType), interfaceFieldDef.getName(), interfaceTypeDef.getName(), lineCol(interfaceTypeDef))); } }
private void checkFieldsDirectives(List<GraphQLError> errors, TypeDefinitionRegistry typeRegistry, List<FieldDefinition> fieldDefinitions) { fieldDefinitions.forEach(definition -> { checkDirectives(FIELD_DEFINITION, errors, typeRegistry, definition, definition.getName(), definition.getDirectives()); // // and check its arguments definition.getInputValueDefinitions().forEach(arg -> checkDirectives(ARGUMENT_DEFINITION, errors, typeRegistry, arg, arg.getName(), arg.getDirectives())); }); }
FieldDefinition objectFieldDef = objectFields.get(interfaceFieldDef.getName()); if (objectFieldDef == null) { errors.add(new MissingInterfaceFieldError(typeOfType, objectTypeDef, interfaceTypeDef, interfaceFieldDef));
private Builder(FieldDefinition existing) { this.sourceLocation = existing.getSourceLocation(); this.name = existing.getName(); this.comments = existing.getComments(); this.type = existing.getType(); this.description = existing.getDescription(); this.inputValueDefinitions = existing.getInputValueDefinitions(); this.directives = existing.getDirectives(); this.ignoredChars = existing.getIgnoredChars(); }
private NodePrinter<FieldDefinition> fieldDefinition() { final String argSep = compactMode ? "," : ", "; return (out, node) -> { out.printf("%s", comments(node)); String args; if (hasComments(node.getInputValueDefinitions()) && !compactMode) { args = join(node.getInputValueDefinitions(), "\n"); out.printf("%s", node.getName() + wrap("(\n", args, "\n)") + ": " + spaced( type(node.getType()), directives(node.getDirectives()) ) ); } else { args = join(node.getInputValueDefinitions(), argSep); out.printf("%s", node.getName() + wrap("(", args, ")") + ": " + spaced( type(node.getType()), directives(node.getDirectives()) ) ); } }; }
.typeName(oldDef.getName()) .typeKind(getTypeKind(oldDef)) .fieldName(oldField.getName()) .reasonMsg("The new API has less arguments on field '%s' of type '%s' than the old API", mkDotName(oldDef.getName(), oldField.getName()), oldDef.getName()) .build()); return; .typeName(oldDef.getName()) .typeKind(getTypeKind(oldDef)) .fieldName(oldField.getName()) .reasonMsg("\tExamining field argument '%s' ...", mkDotName(oldDef.getName(), oldField.getName(), argName)) .build()); .typeName(oldDef.getName()) .typeKind(getTypeKind(oldDef)) .fieldName(oldField.getName()) .components(argName) .reasonMsg("The new API is missing the field argument '%s'", mkDotName(oldDef.getName(), oldField.getName(), argName)) .build()); } else { .typeName(oldDef.getName()) .typeKind(getTypeKind(oldDef)) .fieldName(oldField.getName()) .components(newArg.getName()) .reasonMsg("The new API has made the new argument '%s' on field '%s' non null and hence more strict for old consumers", newArg.getName(), mkDotName(oldDef.getName(), oldField.getName())) .build());
.typeName(oldDef.getName()) .typeKind(getTypeKind(oldDef)) .fieldName(oldField.getName()) .components(getAstDesc(oldArgType), getAstDesc(newArgType)) .reasonMsg("The new API has changed field '%s' argument '%s' from type '%s' to '%s'", mkDotName(oldDef.getName(), oldField.getName()), oldArg.getName(), getAstDesc(oldArgType), getAstDesc(newArgType)) .build()); } else { .typeName(oldDef.getName()) .typeKind(getTypeKind(oldDef)) .fieldName(oldField.getName()) .components(oldArg.getName()) .reasonMsg("The new API has changed default value types on argument named '%s' on field '%s' of type '%s", oldArg.getName(), mkDotName(oldDef.getName(), oldField.getName()), oldDef.getName()) .build()); .typeName(oldDef.getName()) .typeKind(getTypeKind(oldDef)) .fieldName(oldField.getName()) .components(oldArg.getName()) .reasonMsg("The new API has changed default value on argument named '%s' on field '%s' of type '%s", oldArg.getName(), mkDotName(oldDef.getName(), oldField.getName()), oldDef.getName()) .build());
private DataFetcherFactory buildDataFetcherFactory(BuildContext buildCtx, TypeDefinition parentType, FieldDefinition fieldDef, GraphQLOutputType fieldType, List<GraphQLDirective> directives) { String fieldName = fieldDef.getName(); String parentTypeName = parentType.getName(); TypeDefinitionRegistry typeRegistry = buildCtx.getTypeRegistry();
private void checkField(DiffCtx ctx, TypeDefinition old, FieldDefinition oldField, FieldDefinition newField) { Type oldFieldType = oldField.getType(); Type newFieldType = newField.getType(); DiffCategory category = checkTypeWithNonNullAndList(oldFieldType, newFieldType); if (category != null) { ctx.report(DiffEvent.apiBreakage() .category(category) .typeName(old.getName()) .typeKind(getTypeKind(old)) .fieldName(oldField.getName()) .components(getAstDesc(oldFieldType), getAstDesc(newFieldType)) .reasonMsg("The new API has changed field '%s' from type '%s' to '%s'", mkDotName(old.getName(), oldField.getName()), getAstDesc(oldFieldType), getAstDesc(newFieldType)) .build()); } checkFieldArguments(ctx, old, oldField, oldField.getInputValueDefinitions(), newField.getInputValueDefinitions()); checkDirectives(ctx, old, oldField.getDirectives(), newField.getDirectives()); // // and down we go again recursively via fields // checkType(ctx, oldFieldType, newFieldType); }
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())); }