graphql.language.InputValueDefinition Java Examples

private Type getType( Node def )
{
  if( def instanceof VariableDefinition )
  {
    return ((VariableDefinition)def).getType();
  }
  if( def instanceof InputValueDefinition )
  {
    return ((InputValueDefinition)def).getType();
  }
  if( def instanceof FieldDefinition )
  {
    return ((FieldDefinition)def).getType();
  }
  throw new IllegalStateException();
}
 

private void addInnerInputType( InputObjectTypeDefinition type, SrcLinkedClass enclosingType )
{
  String identifier = makeIdentifier( type.getName(), false );
  String fqn = getFqn() + '.' + identifier;
  SrcLinkedClass srcClass = new SrcLinkedClass( fqn, enclosingType, Interface )
    .addInterface( IJsonBindingsBacked.class.getSimpleName() )
    .addAnnotation( new SrcAnnotationExpression( Structural.class.getSimpleName() )
      .addArgument( "factoryClass", Class.class, identifier + ".ProxyFactory.class" ) )
    .modifiers( Modifier.PUBLIC );
  addUnionInterfaces( type, srcClass );
  addActualNameAnnotation( srcClass, type.getName(), false );
  addSourcePositionAnnotation( srcClass, type, srcClass );
  addProxyFactory( srcClass );
  addBuilder( srcClass, type );
  addCreateMethod( srcClass, type );
  addBuilderMethod( srcClass, type );
  List<InputValueDefinition> inputValueDefinitions = type.getInputValueDefinitions();
  for( InputValueDefinition member: inputValueDefinitions )
  {
    addMember( srcClass, member, name -> inputValueDefinitions.stream().anyMatch( f -> f.getName().equals( name ) ) );
  }
  addInputExtensions( type, srcClass );
  enclosingType.addInnerClass( srcClass );
}
 

private void addInputExtensions( InputObjectTypeDefinition type, SrcLinkedClass srcClass )
{
  List<InputValueDefinition> baseInputValueDefinitions = type.getInputValueDefinitions();
  List<InputObjectTypeExtensionDefinition> inputExtensions = _registry.inputObjectTypeExtensions().get( type.getName() );
  if( inputExtensions != null )
  {
    for( InputObjectTypeExtensionDefinition ext: inputExtensions )
    {
      List<InputValueDefinition> extInputValueDefinitions = ext.getInputValueDefinitions();
      for( InputValueDefinition member: extInputValueDefinitions )
      {
        addMember( srcClass, member,
          name ->
            baseInputValueDefinitions.stream().anyMatch( f -> f.getName().equals( name ) ) ||
            extInputValueDefinitions.stream().anyMatch( f -> f.getName().equals( name ) )
        );
      }
    }
  }
}
 

private List<FieldDefinition> createFields(List<Map<String, Object>> fields) {
    List<FieldDefinition> result = new ArrayList<>();
    for (Map<String, Object> field : fields) {
        List<Map<String, Object>> args = (List<Map<String, Object>>) field.get("args");
        List<InputValueDefinition> inputValueDefinitions = createInputValueDefinitions(args);
        FieldDefinition fieldDefinition = FieldDefinition.newFieldDefinition()
                .name((String) field.get("name"))
                .description(getDescription(field))
                .type(createTypeIndirection((Map<String, Object>) field.get("type")))
                .inputValueDefinitions(inputValueDefinitions)
                .directives(createDeprecatedDirective(field))
                .build();
        result.add(fieldDefinition);
    }
    return result;
}
 

@SuppressWarnings("unchecked")
private List<InputValueDefinition> createInputValueDefinitions(List<Map<String, Object>> args) {
    List<InputValueDefinition> result = new ArrayList<>();
    for (Map<String, Object> arg : args) {
        Type argType = createTypeIndirection((Map<String, Object>) arg.get("type"));
        String valueLiteral = (String) arg.get("defaultValue");
        Value defaultValue = valueLiteral != null ? AstValueHelper.valueFromAst(valueLiteral) : null;
        InputValueDefinition inputValueDefinition = InputValueDefinition.newInputValueDefinition()
                .name((String) arg.get("name"))
                .type(argType)
                .description(getDescription(arg))
                .defaultValue(defaultValue)
                .build();
        result.add(inputValueDefinition);
    }
    return result;
}
 

private List<Field> getFields(InputObjectTypeDefinition def) {
    List<Field> fields = new ArrayList<Field>();
    for ( InputValueDefinition fieldDef : def.getInputValueDefinitions() ) {
        Field field = new Field(fieldDef.getName(), toJavaTypeName(fieldDef.getType()));
        field.graphQLType = toGraphQLType(fieldDef.getType());
        field.defaultValue = toJavaValue(fieldDef.getDefaultValue());
        fields.add(field);
    }
    return fields;
}
 

private List<Arg> toArgs(List<InputValueDefinition> defs) {
    List<Arg> result = new ArrayList<>();
    for ( InputValueDefinition def : defs ) {
        Arg arg = new Arg(def.getName(), toJavaTypeName(def.getType()));
        arg.graphQLType = toGraphQLType(def.getType());
        arg.defaultValue = toJavaValue(def.getDefaultValue());
        result.add(arg);
    }
    return result;
}
 

private void addMember( SrcLinkedClass srcClass, InputValueDefinition member, Predicate<String> duplicateChecker )
{
  Type type = member.getType();
  String name = makeIdentifier( member.getName(), false );
  addMember( srcClass, member, type, name, duplicateChecker );
}
 

private void addImports(Collection<String> imports, InputObjectTypeDefinition def) {
    for ( InputValueDefinition fieldDef : def.getInputValueDefinitions() ) {
        addImports(imports, fieldDef.getType());
    }
}