private String atFetchFromSupport(String fieldName, List<GraphQLDirective> directives) { // @fetch(from : "name") Optional<GraphQLArgument> from = directiveWithArg(directives, FETCH, "from"); return from.map(arg -> String.valueOf(arg.getValue())).orElse(fieldName); }
private String directiveString(GraphQLDirective directive) { StringBuilder sb = new StringBuilder(); sb.append("@").append(directive.getName()); List<GraphQLArgument> args = directive.getArguments(); args = args .stream() .sorted(Comparator.comparing(GraphQLArgument::getName)) .collect(toList()); if (!args.isEmpty()) { sb.append("("); for (int i = 0; i < args.size(); i++) { GraphQLArgument arg = args.get(i); sb.append(arg.getName()); if (arg.getValue() != null) { sb.append(" : "); sb.append(printAst(arg.getValue(), arg.getType())); } else if (arg.getDefaultValue() != null) { sb.append(" : "); sb.append(printAst(arg.getDefaultValue(), arg.getType())); } if (i < args.size() - 1) { sb.append(", "); } } sb.append(")"); } return sb.toString(); }
public Builder(GraphQLArgument existing) { this.name = existing.getName(); this.type = existing.getType(); this.value = existing.getValue(); this.defaultValue = existing.getDefaultValue(); this.description = existing.getDescription(); this.definition = existing.getDefinition(); this.directives.putAll(FpKit.getByName(existing.getDirectives(), GraphQLDirective::getName)); }
@Override public GraphQLFieldDefinition onField(SchemaDirectiveWiringEnvironment<GraphQLFieldDefinition> environment) { String targetAuthRole = (String) environment.getDirective().getArgument("role").getValue(); GraphQLFieldDefinition field = environment.getElement(); GraphQLFieldsContainer parentType = environment.getFieldsContainer(); // // build a data fetcher that first checks authorisation roles before then calling the original data fetcher // DataFetcher originalDataFetcher = environment.getCodeRegistry().getDataFetcher(parentType, field); DataFetcher authDataFetcher = new DataFetcher() { @Override public Object get(DataFetchingEnvironment dataFetchingEnvironment) throws Exception { Map<String, Object> contextMap = dataFetchingEnvironment.getContext(); AuthorisationCtx authContext = (AuthorisationCtx) contextMap.get("authContext"); if (authContext.hasRole(targetAuthRole)) { return originalDataFetcher.get(dataFetchingEnvironment); } else { return null; } } }; // // now change the field definition to have the new authorising data fetcher FieldCoordinates coordinates = FieldCoordinates.coordinates(parentType, field); environment.getCodeRegistry().dataFetcher(coordinates, authDataFetcher); return field; } }
private String atFetchFromSupport(String fieldName, List<GraphQLDirective> directives) { // @fetch(from : "name") Optional<GraphQLArgument> from = directiveWithArg(directives, FETCH, "from"); return from.map(arg -> String.valueOf(arg.getValue())).orElse(fieldName); }
public static Optional<Operation> getMappedOperation(GraphQLFieldDefinition field) { return DirectivesUtil.directiveWithArg(field.getDirectives(), MAPPED_OPERATION, OPERATION) .map(arg -> (Operation) arg.getValue()); }
public static Optional<InputField> getMappedInputField(GraphQLInputObjectField field) { return DirectivesUtil.directiveWithArg(field.getDirectives(), MAPPED_INPUT_FIELD, INPUT_FIELD) .map(arg -> (InputField) arg.getValue()); }
public static AnnotatedType getMappedType(GraphQLType type) { return DirectivesUtil.directiveWithArg(((GraphQLDirectiveContainer) type).getDirectives(), MAPPED_TYPE, TYPE) .map(arg -> (AnnotatedType) arg.getValue()) .orElseThrow(() -> new IllegalArgumentException("GraphQL type " + type.getName() + " does not have a mapped Java type")); }
public Builder(GraphQLArgument existing) { this.name = existing.getName(); this.type = existing.getType(); this.value = existing.getValue(); this.defaultValue = existing.getDefaultValue(); this.description = existing.getDescription(); this.definition = existing.getDefinition(); this.directives.putAll(FpKit.getByName(existing.getDirectives(), GraphQLDirective::getName)); }
@Test public void testDecoratedArgument_directivesAreInRegistry_directivesAreBuilt() throws Exception { // Arrange ProcessingElementsContainer processingElementsContainer = new ProcessingElementsContainer(); GraphQLDirective upperCase = newDirective().name("upperCase").argument(builder -> builder.name("myArg").type(GraphQLString).defaultValue("DefaultString")).build(); GraphQLDirective lowerCase = newDirective().name("lowerCase").build(); processingElementsContainer.getDirectiveRegistry().put("upperCase", upperCase); processingElementsContainer.getDirectiveRegistry().put("lowerCase", lowerCase); DirectivesBuilder directivesBuilder = new DirectivesBuilder(this.getClass().getMethod("forTestMethod", String.class).getParameters()[0], processingElementsContainer); // Act GraphQLDirective[] graphQLDirectives = directivesBuilder.build(); // Assert assertEquals(graphQLDirectives.length, 1); assertEquals(graphQLDirectives[0].getName(), "upperCase"); assertFalse(graphQLDirectives[0].getArguments().isEmpty()); assertEquals(graphQLDirectives[0].getArguments().get(0).getName(), "myArg"); assertEquals(graphQLDirectives[0].getArguments().get(0).getValue(), "DefaultString"); }
@Test public void testDecoratedParameterWithArguments_directivesAreInRegistry_directivesAreBuilt() throws Exception { // Arrange ProcessingElementsContainer processingElementsContainer = new ProcessingElementsContainer(); GraphQLDirective upperCase = newDirective().name("upperCase").argument(builder -> builder.name("myArg").type(GraphQLString)).build(); GraphQLDirective lowerCase = newDirective().name("lowerCase").build(); processingElementsContainer.getDirectiveRegistry().put("upperCase", upperCase); processingElementsContainer.getDirectiveRegistry().put("lowerCase", lowerCase); DirectivesBuilder directivesBuilder = new DirectivesBuilder(this.getClass().getMethod("forTestMethodParameterWithArguments", String.class).getParameters()[0], processingElementsContainer); // Act GraphQLDirective[] graphQLDirectives = directivesBuilder.build(); // Assert assertEquals(graphQLDirectives.length, 1); assertEquals(graphQLDirectives[0].getName(), "upperCase"); assertFalse(graphQLDirectives[0].getArguments().isEmpty()); assertEquals(graphQLDirectives[0].getArguments().get(0).getName(), "myArg"); assertEquals(graphQLDirectives[0].getArguments().get(0).getValue(), "This is a string"); }
@Test public void testDecoratedFieldWithArguments_moreArgumentsThanArgumentsValues_directivesAreBuilt() throws Exception { // Arrange ProcessingElementsContainer processingElementsContainer = new ProcessingElementsContainer(); GraphQLDirective upperCase = newDirective().name("upperCase").argument(builder -> builder.name("arg").type(GraphQLString)) .argument(builder -> builder.name("arg2").type(GraphQLInt).defaultValue("5")).build(); GraphQLDirective lowerCase = newDirective().name("lowerCase").build(); processingElementsContainer.getDirectiveRegistry().put("upperCase", upperCase); processingElementsContainer.getDirectiveRegistry().put("lowerCase", lowerCase); DirectivesBuilder directivesBuilder = new DirectivesBuilder(this.getClass().getField("decoratedFieldWithArguments"), processingElementsContainer); GraphQLDirective[] graphQLDirectives = directivesBuilder.build(); assertEquals(graphQLDirectives.length, 2); assertEquals(graphQLDirectives[0].getArguments().size(), 2); assertEquals(graphQLDirectives[0].getArguments().get(0).getName(), "arg"); assertEquals(graphQLDirectives[0].getArguments().get(0).getValue(), "This is a string"); assertEquals(graphQLDirectives[0].getArguments().get(1).getName(), "arg2"); assertEquals(graphQLDirectives[0].getArguments().get(1).getValue(), "5"); }
@Test public void testDecoratedField_directivesAreInRegistry_directivesAreBuilt() throws Exception { // Arrange ProcessingElementsContainer processingElementsContainer = new ProcessingElementsContainer(); GraphQLDirective upperCase = newDirective().name("upperCase").argument(builder -> builder.name("myArg").type(GraphQLString).defaultValue("DefaultString")).build(); GraphQLDirective lowerCase = newDirective().name("lowerCase").build(); processingElementsContainer.getDirectiveRegistry().put("upperCase", upperCase); processingElementsContainer.getDirectiveRegistry().put("lowerCase", lowerCase); DirectivesBuilder directivesBuilder = new DirectivesBuilder(this.getClass().getField("decoratedField"), processingElementsContainer); // Act GraphQLDirective[] graphQLDirectives = directivesBuilder.build(); // Assert assertEquals(graphQLDirectives.length, 2); assertEquals(graphQLDirectives[0].getName(), "upperCase"); assertFalse(graphQLDirectives[0].getArguments().isEmpty()); assertEquals(graphQLDirectives[0].getArguments().get(0).getName(), "myArg"); assertEquals(graphQLDirectives[0].getArguments().get(0).getValue(), "DefaultString"); assertEquals(graphQLDirectives[1].getName(), "lowerCase"); assertTrue(graphQLDirectives[1].getArguments().isEmpty()); }
@Test public void testDecoratedFieldWithArguments_directivesAreInRegistry_directivesAreBuilt() throws Exception { // Arrange ProcessingElementsContainer processingElementsContainer = new ProcessingElementsContainer(); GraphQLDirective upperCase = newDirective().name("upperCase").argument(builder -> builder.name("myArg").type(GraphQLString)).build(); GraphQLDirective lowerCase = newDirective().name("lowerCase").build(); processingElementsContainer.getDirectiveRegistry().put("upperCase", upperCase); processingElementsContainer.getDirectiveRegistry().put("lowerCase", lowerCase); DirectivesBuilder directivesBuilder = new DirectivesBuilder(this.getClass().getField("decoratedFieldWithArguments"), processingElementsContainer); // Act GraphQLDirective[] graphQLDirectives = directivesBuilder.build(); // Assert assertEquals(graphQLDirectives.length, 2); assertEquals(graphQLDirectives[0].getName(), "upperCase"); assertFalse(graphQLDirectives[0].getArguments().isEmpty()); assertEquals(graphQLDirectives[0].getArguments().get(0).getName(), "myArg"); assertEquals(graphQLDirectives[0].getArguments().get(0).getValue(), "This is a string"); assertEquals(graphQLDirectives[1].getName(), "lowerCase"); assertTrue(graphQLDirectives[1].getArguments().isEmpty()); }
@Test public void testDecoratedClassWithArguments_directivesAreInRegistry_directivesAreBuilt() throws Exception { // Arrange ProcessingElementsContainer processingElementsContainer = new ProcessingElementsContainer(); GraphQLDirective upperCase = newDirective().name("upperCase").argument(builder -> builder.name("myArg").type(GraphQLString)).build(); GraphQLDirective lowerCase = newDirective().name("lowerCase").build(); processingElementsContainer.getDirectiveRegistry().put("upperCase", upperCase); processingElementsContainer.getDirectiveRegistry().put("lowerCase", lowerCase); DirectivesBuilder directivesBuilder = new DirectivesBuilder(DecoratedClassWithArgs.class, processingElementsContainer); // Act GraphQLDirective[] graphQLDirectives = directivesBuilder.build(); // Assert assertEquals(graphQLDirectives.length, 2); assertEquals(graphQLDirectives[0].getName(), "upperCase"); assertFalse(graphQLDirectives[0].getArguments().isEmpty()); assertEquals(graphQLDirectives[0].getArguments().get(0).getName(), "myArg"); assertEquals(graphQLDirectives[0].getArguments().get(0).getValue(), "This is a string"); assertEquals(graphQLDirectives[1].getName(), "lowerCase"); assertTrue(graphQLDirectives[1].getArguments().isEmpty()); }
@Test public void testDecoratedClass_directivesAreInRegistry_directivesAreBuilt() throws Exception { // Arrange ProcessingElementsContainer processingElementsContainer = new ProcessingElementsContainer(); GraphQLDirective upperCase = newDirective().name("upperCase").argument(builder -> builder.name("myArg").type(GraphQLString).defaultValue("DefaultString")).build(); GraphQLDirective lowerCase = newDirective().name("lowerCase").build(); processingElementsContainer.getDirectiveRegistry().put("upperCase", upperCase); processingElementsContainer.getDirectiveRegistry().put("lowerCase", lowerCase); DirectivesBuilder directivesBuilder = new DirectivesBuilder(DecoratedClass.class, processingElementsContainer); // Act GraphQLDirective[] graphQLDirectives = directivesBuilder.build(); // Assert assertEquals(graphQLDirectives.length, 2); assertEquals(graphQLDirectives[0].getName(), "upperCase"); assertFalse(graphQLDirectives[0].getArguments().isEmpty()); assertEquals(graphQLDirectives[0].getArguments().get(0).getName(), "myArg"); assertEquals(graphQLDirectives[0].getArguments().get(0).getValue(), "DefaultString"); assertEquals(graphQLDirectives[1].getName(), "lowerCase"); assertTrue(graphQLDirectives[1].getArguments().isEmpty()); }
@Override public GraphQLFieldDefinition onField(AnnotationsWiringEnvironment environment) { GraphQLFieldDefinition field = (GraphQLFieldDefinition) environment.getElement(); boolean isActive = (boolean) environment.getDirective().getArgument("isActive").getValue(); DataFetcher dataFetcher = DataFetcherFactories.wrapDataFetcher(field.getDataFetcher(), (((dataFetchingEnvironment, value) -> { if (value instanceof String && isActive) { return ((String) value).toUpperCase(); } return value; }))); return field.transform(builder -> builder.dataFetcher(dataFetcher)); } }
@Override public GraphQLFieldDefinition onField(AnnotationsWiringEnvironment environment) { GraphQLFieldDefinition field = (GraphQLFieldDefinition) environment.getElement(); String suffix = (String) environment.getDirective().getArgument("suffix").getValue(); DataFetcher dataFetcher = DataFetcherFactories.wrapDataFetcher(field.getDataFetcher(), (((dataFetchingEnvironment, value) -> { if (value instanceof String) { return value + suffix; } return value; }))); return field.transform(builder -> builder.dataFetcher(dataFetcher)); } }