private void checkInputFields()

in src/main/com/intellij/lang/jsgraphql/types/schema/diff/SchemaDiff.java [319:398]
68 lines of code
8 McCabe index (conditional complexity)

  private void checkInputFields(DiffCtx ctx,
                                TypeDefinition old,
                                List<InputValueDefinition> oldIVD,
                                List<InputValueDefinition> newIVD) {
    Map<String, InputValueDefinition> oldDefinitionMap = sortedMap(oldIVD, InputValueDefinition::getName);
    Map<String, InputValueDefinition> newDefinitionMap = sortedMap(newIVD, InputValueDefinition::getName);

    for (String inputFieldName : oldDefinitionMap.keySet()) {
      InputValueDefinition oldField = oldDefinitionMap.get(inputFieldName);
      Optional<InputValueDefinition> newField = Optional.ofNullable(newDefinitionMap.get(inputFieldName));

      ctx.report(DiffEvent.apiInfo()
                   .typeName(old.getName())
                   .typeKind(getTypeKind(old))
                   .fieldName(oldField.getName())
                   .reasonMsg("\tExamining input field '%s' ...", mkDotName(old.getName(), oldField.getName()))
                   .build());


      if (newField.isEmpty()) {
        DiffCategory category;
        String message;
        if (isDeprecated(oldField)) {
          category = DiffCategory.DEPRECATION_REMOVED;
          message = "The new API has removed a deprecated field '%s'";
        }
        else {
          category = DiffCategory.MISSING;
          message = "The new API is missing an input field '%s'";
        }
        ctx.report(DiffEvent.apiBreakage()
                     .category(category)
                     .typeName(old.getName())
                     .typeKind(getTypeKind(old))
                     .fieldName(oldField.getName())
                     .reasonMsg(message, mkDotName(old.getName(), oldField.getName()))
                     .build());
      }
      else {
        DiffCategory category = checkTypeWithNonNullAndList(oldField.getType(), newField.get().getType());
        if (category != null) {
          ctx.report(DiffEvent.apiBreakage()
                       .category(category)
                       .typeName(old.getName())
                       .typeKind(getTypeKind(old))
                       .fieldName(oldField.getName())
                       .components(getAstDesc(oldField.getType()), getAstDesc(newField.get().getType()))
                       .reasonMsg("The new API has changed input field '%s' from type '%s' to '%s'",
                                  oldField.getName(), getAstDesc(oldField.getType()), getAstDesc(newField.get().getType()))
                       .build());
        }

        //
        // recurse via input types
        //
        checkType(ctx, oldField.getType(), newField.get().getType());
      }
    }

    // check new fields are not mandatory
    for (String inputFieldName : newDefinitionMap.keySet()) {
      InputValueDefinition newField = newDefinitionMap.get(inputFieldName);
      Optional<InputValueDefinition> oldField = Optional.ofNullable(oldDefinitionMap.get(inputFieldName));

      if (oldField.isEmpty()) {
        // new fields MUST not be mandatory
        if (typeInfo(newField.getType()).isNonNull()) {
          ctx.report(DiffEvent.apiBreakage()
                       .category(DiffCategory.STRICTER)
                       .typeName(old.getName())
                       .typeKind(getTypeKind(old))
                       .fieldName(newField.getName())
                       .reasonMsg(
                         "The new API has made the new input field '%s' non null and hence more strict for old consumers",
                         newField.getName())
                       .build());
        }
      }
    }
  }