io.leangen.graphql.annotations.GraphQLArgument Java Examples

@GraphQLQuery(name = "users")
public List<User<String>> getUsersById(@GraphQLArgument(name = "id") @GraphQLId Integer id) {
    User<String> user = new User<>();
    user.id = id;
    user.name = "Tatko";
    user.uuid = UUID.randomUUID();
    user.registrationDate = new Date();
    user.addresses = addresses;
    User<String> user2 = new User<>();
    user2.id = id + 1;
    user2.name = "Tzar";
    user2.uuid = UUID.randomUUID();
    user2.registrationDate = new Date();
    user2.addresses = addresses;
    return Arrays.asList(user, user2);
}
 

protected String getArgumentName(Parameter parameter, AnnotatedType parameterType, ArgumentBuilderParams builderParams) {
    if (Optional.ofNullable(parameterType.getAnnotation(GraphQLId.class)).filter(GraphQLId::relayId).isPresent()) {
        return GraphQLId.RELAY_ID_FIELD_NAME;
    }
    GraphQLArgument meta = parameter.getAnnotation(GraphQLArgument.class);
    if (meta != null && !meta.name().isEmpty()) {
        return builderParams.getEnvironment().messageBundle.interpolate(meta.name());
    } else {
        if (!parameter.isNamePresent() && builderParams.getInclusionStrategy().includeArgumentForMapping(parameter, parameterType, builderParams.getDeclaringType())) {
            log.warn("No explicit argument name given and the parameter name lost in compilation: "
                    + parameter.getDeclaringExecutable().toGenericString() + "#" + parameter.toString()
                    + ". For details and possible solutions see " + Urls.Errors.MISSING_ARGUMENT_NAME);
        }
        return parameter.getName();
    }
}
 

@Batched
@GraphQLQuery
public List<Education> educations(@GraphQLArgument(name = "users") @GraphQLContext List<SimpleUser> users, @GraphQLRootContext AtomicBoolean flag) {
    assertEquals(3, users.size());
    flag.getAndSet(true);
    return users.stream()
            .map(u -> u.getEducation(2000 + u.getFullName().charAt(0)))
            .collect(Collectors.toList());
}
 

@GraphQLMutation
public boolean deleteToDo(@GraphQLNonNull @GraphQLArgument(name = "id") String id) {
    ToDo toDo = toDoRepository.findById(id);
    if (toDo != null) {
        toDoRepository.deleteById(id);
        return true;
    } else {
        return false;
    }
}
 

protected Object defaultValue(Parameter parameter, AnnotatedType parameterType, GlobalEnvironment environment) {

        GraphQLArgument meta = parameter.getAnnotation(GraphQLArgument.class);
        if (meta == null) return null;
        try {
            return defaultValueProvider(meta.defaultValueProvider(), environment)
                    .getDefaultValue(parameter, environment.getMappableInputType(parameterType), ReservedStrings.decode(environment.messageBundle.interpolate(meta.defaultValue())));
        } catch (ReflectiveOperationException e) {
            throw new IllegalArgumentException(
                    meta.defaultValueProvider().getName() + " must expose a public default constructor, or a constructor accepting " + GlobalEnvironment.class.getName(), e);
        }
    }
 

@GraphQLQuery(name = "extended")
public ExtendedPage<Book> getExtended(@GraphQLArgument(name = "first") int first, @GraphQLArgument(name = "after") String after) {
    List<Book> books = new ArrayList<>();
    books.add(new Book("Tesseract", "x123"));
    long count = 100L;
    long offset = Long.parseLong(after);
    return PageFactory.createOffsetBasedPage(books, count, offset, (edges, info) -> new ExtendedPage<>(edges, info, count));
}
 

@GraphQLQuery(name = "repo")
public List<Stream<GenericRepo>> getRepo(@GraphQLArgument(name = "id") int id) {
    if (id % 2 == 0) {
        return Collections.singletonList(Stream.of(new SessionRepo<>(new Street("Baker street", 1))));
    } else {
        return Collections.singletonList(Stream.of(new SessionRepo<>(new Education("Alma Mater", 1600, 1604))));
    }
}
 

@GraphQLMutation
public boolean completeToDo(@GraphQLNonNull @GraphQLArgument(name = "id") String id) {
    ToDo toDo = toDoRepository.findById(id);
    if (toDo != null) {
        toDo.setCompleted(true);
        toDoRepository.save(toDo);
        return true;
    } else {
        return false;
    }
}
 

@GraphQLQuery(name = "extended")
public ExtendedConnection<ExtendedEdge<Book>> getExtended(@GraphQLArgument(name = "first") int first, @GraphQLArgument(name = "after") String after) {
    List<Book> books = new ArrayList<>();
    books.add(new Book("Tesseract", "x123"));
    long count = 100L;
    long offset = Long.parseLong(after);
    Iterator<ExtendedEdge.COLOR> colors = Arrays.asList(ExtendedEdge.COLOR.WHITE, ExtendedEdge.COLOR.BLACK).iterator();
    return PageFactory.createOffsetBasedConnection(books, count, offset,
            (node, cursor) -> new ExtendedEdge<>(node, cursor, colors.next()), (edges, info) -> new ExtendedConnection<>(edges, info, count));
}
 

@GraphQLQuery(name = "usersArr")
@SuppressWarnings("unchecked")
public User<String>[] getUsersByAnyEducationArray(@GraphQLArgument(name = "educations") T[] educations) {
    List<User<String>> users = getUsersById(1);
    return users.toArray(new User[0]);
}
 

@GraphQLMutation
public ToDo createToDo(@GraphQLNonNull @GraphQLArgument(name = "title") String title) {
    ToDo toDo = new ToDo(title);
    return toDoRepository.save(toDo);
}
 

@GraphQLQuery
public AnnotatedId other(@GraphQLArgument(name = "id") AnnotatedId id) {
    return id;
}
 

@GraphQLQuery
public Parent<String> test(@GraphQLArgument(name = "container") Parent<String> container) {
    return container;
}
 

@GraphQLQuery(name = "pets")
public Page<Pet> findPets(@GraphQLArgument(name = "first") int first, @GraphQLArgument(name = "after") String after) {
    return PageFactory.createPage(Collections.emptyList(), PageFactory.offsetBasedCursorProvider(0L), false, false);
}
 

@GraphQLMutation
@GraphQLComplexity("2 + childScore")
public @GraphQLNonNull List<@GraphQLNonNull Pet> addPet(@GraphQLArgument(name = "pet") Pet pet) {
    return Collections.singletonList(pet);
}
 

@GraphQLQuery(name = ECHO)
public @GraphQLScalar Street echoArgument(@GraphQLArgument(name = "user") @GraphQLScalar Street street) {
    return street;
}
 

@GraphQLMutation(name = "upMe")
public Map<String, String> getUpdateCurrentUser(@GraphQLArgument(name = "updates") Map<String, String> updates) {
    return updates;
}
 

@GraphQLQuery(name = "users")
public List<User<String>> getUserByUuid(@GraphQLArgument(name = "uuid") UUID uuid) {
    return getUsersById(1);
}
 

@GraphQLMutation(name = "updateUsername")
public User<String> updateUsername(@GraphQLContext User<String> user, @GraphQLArgument(name = "username") String username) {
    user.name = username;
    return user;
}
 

@GraphQLQuery(name = "usersByDate")
@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
public List<User<String>> getUsersByDate(@GraphQLArgument(name = "regDate") Optional<Date> date) {
    return getUsersById(1);
}
 

@GraphQLQuery(name = "users")
@GraphQLComplexity("2 * childScore")
@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
public List<User<String>> getUsersByRegDate(@GraphQLArgument(name = "regDate") Optional<Date> date) {
    return getUsersById(1);
}
 

@GraphQLQuery(name = "users")
public List<User<String>> getUsersByAnyEducation(@GraphQLArgument(name = "educations") List<? super T> educations) {
    return getUsersById(1);
}
 

@GraphQLQuery(name = "users")
public List<User<String>> getUsersByEducation(@GraphQLArgument(name = "education") Education education) {
    return getUsersById(1);
}
 

@GraphQLMutation
public void addItems(@GraphQLArgument(name = "items") Set<T> items) {
    items.forEach(item -> itemsByName.putIfAbsent(item.toString(), item));
}
 

@GraphQLMutation
public void addItem(@GraphQLArgument(name = "name") String name, @GraphQLArgument(name = "item") T item) {
    itemsByName.putIfAbsent(name, item);
}
 

@GraphQLQuery
public T contains(@GraphQLArgument(name = "item") T item) {
    return itemsByName.containsValue(item) ? item : null;
}
 

@GraphQLQuery(name = "springPageComponent_users")
public Page<User> users(@GraphQLArgument(name = "first") int first, @GraphQLArgument(name = "after") String after) {
    return new PageImpl<>(users.subList(0, first), PageRequest.of(0, first), users.size());
}
 

@GraphQLQuery(name = "find")
public Auto findDeep(@GraphQLArgument(name = "one") boolean one) {
    return one ? new One() : new Two();
}
 

@GraphQLQuery(name = "find")
public Manual findFlat(@GraphQLArgument(name = "one") boolean one) {
    return one ? new One() : new Two();
}
 

@GraphQLQuery(name = "books")
public RelayTest.Book[] getBooks(@GraphQLArgument(name = "after") LocalDate after) {
    return new RelayTest.Book[] {new RelayTest.Book("Tesseract", "x123")};
}