private void checkFieldArguments()

in src/main/com/intellij/lang/jsgraphql/types/schema/diff/SchemaDiff.java [612:684]
64 lines of code
7 McCabe index (conditional complexity)

  private void checkFieldArguments(DiffCtx ctx,
                                   TypeDefinition oldDef,
                                   FieldDefinition oldField,
                                   List<InputValueDefinition> oldInputValueDefinitions,
                                   List<InputValueDefinition> newInputValueDefinitions) {
    Map<String, InputValueDefinition> oldArgsMap = sortedMap(oldInputValueDefinitions,
                                                             InputValueDefinition::getName);
    Map<String, InputValueDefinition> newArgMap = sortedMap(newInputValueDefinitions,
                                                            InputValueDefinition::getName);

    if (oldArgsMap.size() > newArgMap.size()) {
      ctx.report(DiffEvent.apiBreakage()
                   .category(DiffCategory.MISSING)
                   .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;
    }

    for (Map.Entry<String, InputValueDefinition> entry : oldArgsMap.entrySet()) {

      String argName = entry.getKey();
      ctx.report(DiffEvent.apiInfo()
                   .typeName(oldDef.getName())
                   .typeKind(getTypeKind(oldDef))
                   .fieldName(oldField.getName())
                   .reasonMsg("\tExamining field argument '%s' ...",
                              mkDotName(oldDef.getName(), oldField.getName(), argName))
                   .build());


      InputValueDefinition newArg = newArgMap.get(argName);
      if (newArg == null) {
        ctx.report(DiffEvent.apiBreakage()
                     .category(DiffCategory.MISSING)
                     .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 {
        checkFieldArg(ctx, oldDef, oldField, entry.getValue(), newArg);
      }
    }

    // check new fields are not mandatory
    for (Map.Entry<String, InputValueDefinition> entry : newArgMap.entrySet()) {
      InputValueDefinition newArg = entry.getValue();
      Optional<InputValueDefinition> oldArg = Optional.ofNullable(oldArgsMap.get(newArg.getName()));

      if (oldArg.isEmpty()) {
        // new args MUST not be mandatory
        if (typeInfo(newArg.getType()).isNonNull()) {
          ctx.report(DiffEvent.apiBreakage()
                       .category(DiffCategory.STRICTER)
                       .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());
        }
      }
    }
  }