Examples with GraphQLAppliedDirective graphql.schema.GraphQLAppliedDirective used on opensource projects

Example 6 with GraphQLAppliedDirective

use of graphql.schema.GraphQLAppliedDirective in project graphql-java by graphql-java.

the class Anonymizer method anonymizeSchemaAndQueries.

public static AnonymizeResult anonymizeSchemaAndQueries(GraphQLSchema schema, List<String> queries, Map<String, Object> variables) {
    assertNotNull(queries, () -> "queries can't be null");
    AtomicInteger defaultStringValueCounter = new AtomicInteger(1);
    AtomicInteger defaultIntValueCounter = new AtomicInteger(1);
    Map<GraphQLNamedSchemaElement, String> newNameMap = recordNewNamesForSchema(schema);
    // stores a reverse index of anonymized argument name to argument instance
    // this is to handle cases where the fields on implementing types MUST have the same exact argument and default
    // value definitions as the fields on the implemented interface. (argument default values must match exactly)
    Map<String, GraphQLArgument> renamedArgumentsMap = new HashMap<>();
    SchemaTransformer schemaTransformer = new SchemaTransformer();
    GraphQLSchema newSchema = schemaTransformer.transform(schema, new GraphQLTypeVisitorStub() {

        @Override
        public TraversalControl visitGraphQLTypeReference(GraphQLTypeReference graphQLTypeReference, TraverserContext<GraphQLSchemaElement> context) {
            GraphQLNamedSchemaElement type = (GraphQLNamedSchemaElement) schema.getType(graphQLTypeReference.getName());
            String newName = newNameMap.get(type);
            GraphQLTypeReference newReference = GraphQLTypeReference.typeRef(newName);
            return changeNode(context, newReference);
        }

        @Override
        public TraversalControl visitGraphQLArgument(GraphQLArgument graphQLArgument, TraverserContext<GraphQLSchemaElement> context) {
            String newName = assertNotNull(newNameMap.get(graphQLArgument));
            if (context.getParentNode() instanceof GraphQLFieldDefinition) {
                // arguments on field definitions must be identical across implementing types and interfaces.
                if (renamedArgumentsMap.containsKey(newName)) {
                    return changeNode(context, renamedArgumentsMap.get(newName).transform(b -> {
                    }));
                }
            }
            GraphQLArgument newElement = graphQLArgument.transform(builder -> {
                builder.name(newName).description(null).definition(null);
                if (graphQLArgument.hasSetDefaultValue()) {
                    Value<?> defaultValueLiteral = ValuesResolver.valueToLiteral(graphQLArgument.getArgumentDefaultValue(), graphQLArgument.getType());
                    builder.defaultValueLiteral(replaceValue(defaultValueLiteral, graphQLArgument.getType(), newNameMap, defaultStringValueCounter, defaultIntValueCounter));
                }
                if (graphQLArgument.hasSetValue()) {
                    Value<?> valueLiteral = ValuesResolver.valueToLiteral(graphQLArgument.getArgumentValue(), graphQLArgument.getType());
                    builder.valueLiteral(replaceValue(valueLiteral, graphQLArgument.getType(), newNameMap, defaultStringValueCounter, defaultIntValueCounter));
                }
            });
            renamedArgumentsMap.put(newName, newElement);
            return changeNode(context, newElement);
        }

        @Override
        public TraversalControl visitGraphQLAppliedDirectiveArgument(GraphQLAppliedDirectiveArgument graphQLArgument, TraverserContext<GraphQLSchemaElement> context) {
            String newName = assertNotNull(newNameMap.get(graphQLArgument));
            GraphQLAppliedDirectiveArgument newElement = graphQLArgument.transform(builder -> {
                builder.name(newName).description(null).definition(null);
                if (graphQLArgument.hasSetValue()) {
                    Value<?> valueLiteral = ValuesResolver.valueToLiteral(graphQLArgument.getArgumentValue(), graphQLArgument.getType());
                    builder.valueLiteral(replaceValue(valueLiteral, graphQLArgument.getType(), newNameMap, defaultStringValueCounter, defaultIntValueCounter));
                }
            });
            return changeNode(context, newElement);
        }

        @Override
        public TraversalControl visitGraphQLInterfaceType(GraphQLInterfaceType graphQLInterfaceType, TraverserContext<GraphQLSchemaElement> context) {
            if (Introspection.isIntrospectionTypes(graphQLInterfaceType)) {
                return TraversalControl.ABORT;
            }
            String newName = assertNotNull(newNameMap.get(graphQLInterfaceType));
            GraphQLInterfaceType newElement = graphQLInterfaceType.transform(builder -> {
                builder.name(newName).description(null).definition(null);
            });
            GraphQLCodeRegistry.Builder codeRegistry = assertNotNull(context.getVarFromParents(GraphQLCodeRegistry.Builder.class));
            TypeResolver typeResolver = codeRegistry.getTypeResolver(graphQLInterfaceType);
            codeRegistry.typeResolver(newName, typeResolver);
            return changeNode(context, newElement);
        }

        @Override
        public TraversalControl visitGraphQLEnumType(GraphQLEnumType graphQLEnumType, TraverserContext<GraphQLSchemaElement> context) {
            if (Introspection.isIntrospectionTypes(graphQLEnumType)) {
                return TraversalControl.ABORT;
            }
            String newName = assertNotNull(newNameMap.get(graphQLEnumType));
            GraphQLEnumType newElement = graphQLEnumType.transform(builder -> {
                builder.name(newName).description(null).definition(null);
            });
            return changeNode(context, newElement);
        }

        @Override
        public TraversalControl visitGraphQLEnumValueDefinition(GraphQLEnumValueDefinition enumValueDefinition, TraverserContext<GraphQLSchemaElement> context) {
            String newName = assertNotNull(newNameMap.get(enumValueDefinition));
            GraphQLEnumValueDefinition newElement = enumValueDefinition.transform(builder -> {
                builder.name(newName).description(null).definition(null);
            });
            return changeNode(context, newElement);
        }

        @Override
        public TraversalControl visitGraphQLFieldDefinition(GraphQLFieldDefinition graphQLFieldDefinition, TraverserContext<GraphQLSchemaElement> context) {
            String newName = assertNotNull(newNameMap.get(graphQLFieldDefinition));
            GraphQLFieldDefinition newElement = graphQLFieldDefinition.transform(builder -> {
                builder.name(newName).description(null).definition(null);
            });
            return changeNode(context, newElement);
        }

        @Override
        public TraversalControl visitGraphQLDirective(GraphQLDirective graphQLDirective, TraverserContext<GraphQLSchemaElement> context) {
            if (Directives.DEPRECATED_DIRECTIVE_DEFINITION.getName().equals(graphQLDirective.getName())) {
                GraphQLArgument reason = newArgument().name("reason").type(Scalars.GraphQLString).clearValue().build();
                GraphQLDirective newElement = graphQLDirective.transform(builder -> {
                    builder.description(null).argument(reason);
                });
                changeNode(context, newElement);
                return TraversalControl.ABORT;
            }
            if (DirectiveInfo.isGraphqlSpecifiedDirective(graphQLDirective.getName())) {
                return TraversalControl.ABORT;
            }
            String newName = assertNotNull(newNameMap.get(graphQLDirective));
            GraphQLDirective newElement = graphQLDirective.transform(builder -> {
                builder.name(newName).description(null).definition(null);
            });
            return changeNode(context, newElement);
        }

        @Override
        public TraversalControl visitGraphQLAppliedDirective(GraphQLAppliedDirective graphQLDirective, TraverserContext<GraphQLSchemaElement> context) {
            if (Directives.DEPRECATED_DIRECTIVE_DEFINITION.getName().equals(graphQLDirective.getName())) {
                GraphQLAppliedDirectiveArgument reason = GraphQLAppliedDirectiveArgument.newArgument().name("reason").type(Scalars.GraphQLString).clearValue().build();
                GraphQLAppliedDirective newElement = graphQLDirective.transform(builder -> {
                    builder.description(null).argument(reason);
                });
                changeNode(context, newElement);
                return TraversalControl.ABORT;
            }
            if (DirectiveInfo.isGraphqlSpecifiedDirective(graphQLDirective.getName())) {
                return TraversalControl.ABORT;
            }
            String newName = assertNotNull(newNameMap.get(graphQLDirective));
            GraphQLAppliedDirective newElement = graphQLDirective.transform(builder -> {
                builder.name(newName).description(null).definition(null);
            });
            return changeNode(context, newElement);
        }

        @Override
        public TraversalControl visitGraphQLInputObjectField(GraphQLInputObjectField graphQLInputObjectField, TraverserContext<GraphQLSchemaElement> context) {
            String newName = assertNotNull(newNameMap.get(graphQLInputObjectField));
            Value<?> defaultValue = null;
            if (graphQLInputObjectField.hasSetDefaultValue()) {
                defaultValue = ValuesResolver.valueToLiteral(graphQLInputObjectField.getInputFieldDefaultValue(), graphQLInputObjectField.getType());
                defaultValue = replaceValue(defaultValue, graphQLInputObjectField.getType(), newNameMap, defaultStringValueCounter, defaultIntValueCounter);
            }
            Value<?> finalDefaultValue = defaultValue;
            GraphQLInputObjectField newElement = graphQLInputObjectField.transform(builder -> {
                builder.name(newName);
                if (finalDefaultValue != null) {
                    builder.defaultValueLiteral(finalDefaultValue);
                }
                builder.description(null);
                builder.definition(null);
            });
            return changeNode(context, newElement);
        }

        @Override
        public TraversalControl visitGraphQLInputObjectType(GraphQLInputObjectType graphQLInputObjectType, TraverserContext<GraphQLSchemaElement> context) {
            if (Introspection.isIntrospectionTypes(graphQLInputObjectType)) {
                return TraversalControl.ABORT;
            }
            String newName = assertNotNull(newNameMap.get(graphQLInputObjectType));
            GraphQLInputObjectType newElement = graphQLInputObjectType.transform(builder -> {
                builder.name(newName).description(null).definition(null);
            });
            return changeNode(context, newElement);
        }

        @Override
        public TraversalControl visitGraphQLObjectType(GraphQLObjectType graphQLObjectType, TraverserContext<GraphQLSchemaElement> context) {
            if (Introspection.isIntrospectionTypes(graphQLObjectType)) {
                return TraversalControl.ABORT;
            }
            String newName = assertNotNull(newNameMap.get(graphQLObjectType));
            GraphQLObjectType newElement = graphQLObjectType.transform(builder -> {
                builder.name(newName).description(null).definition(null);
            });
            return changeNode(context, newElement);
        }

        @Override
        public TraversalControl visitGraphQLScalarType(GraphQLScalarType graphQLScalarType, TraverserContext<GraphQLSchemaElement> context) {
            if (ScalarInfo.isGraphqlSpecifiedScalar(graphQLScalarType)) {
                return TraversalControl.ABORT;
            }
            String newName = assertNotNull(newNameMap.get(graphQLScalarType));
            GraphQLScalarType newElement = graphQLScalarType.transform(builder -> {
                builder.name(newName).description(null).definition(null);
            });
            return changeNode(context, newElement);
        }

        @Override
        public TraversalControl visitGraphQLUnionType(GraphQLUnionType graphQLUnionType, TraverserContext<GraphQLSchemaElement> context) {
            if (Introspection.isIntrospectionTypes(graphQLUnionType)) {
                return TraversalControl.ABORT;
            }
            String newName = assertNotNull(newNameMap.get(graphQLUnionType));
            GraphQLUnionType newElement = graphQLUnionType.transform(builder -> {
                builder.name(newName).description(null).definition(null);
            });
            GraphQLCodeRegistry.Builder codeRegistry = assertNotNull(context.getVarFromParents(GraphQLCodeRegistry.Builder.class));
            TypeResolver typeResolver = codeRegistry.getTypeResolver(graphQLUnionType);
            codeRegistry.typeResolver(newName, typeResolver);
            return changeNode(context, newElement);
        }
    });
    List<String> newQueries = new ArrayList<>();
    for (String query : queries) {
        String newQuery = rewriteQuery(query, schema, newNameMap, variables);
        newQueries.add(newQuery);
    }
    AnonymizeResult result = new AnonymizeResult(newSchema, newQueries);
    return result;
}

Example 7 with GraphQLAppliedDirective

use of graphql.schema.GraphQLAppliedDirective in project graphql-java by graphql-java.

the class Anonymizer method recordNewNamesForSchema.

public static Map<GraphQLNamedSchemaElement, String> recordNewNamesForSchema(GraphQLSchema schema) {
    AtomicInteger objectCounter = new AtomicInteger(1);
    AtomicInteger inputObjectCounter = new AtomicInteger(1);
    AtomicInteger inputObjectFieldCounter = new AtomicInteger(1);
    AtomicInteger fieldCounter = new AtomicInteger(1);
    AtomicInteger scalarCounter = new AtomicInteger(1);
    AtomicInteger directiveCounter = new AtomicInteger(1);
    AtomicInteger argumentCounter = new AtomicInteger(1);
    AtomicInteger interfaceCounter = new AtomicInteger(1);
    AtomicInteger unionCounter = new AtomicInteger(1);
    AtomicInteger enumCounter = new AtomicInteger(1);
    AtomicInteger enumValueCounter = new AtomicInteger(1);
    Map<GraphQLNamedSchemaElement, String> newNameMap = new LinkedHashMap<>();
    Map<String, String> directivesOriginalToNewNameMap = new HashMap<>();
    // DirectiveName.argumentName -> newArgumentName
    Map<String, String> seenArgumentsOnDirectivesMap = new HashMap<>();
    Map<String, List<GraphQLImplementingType>> interfaceToImplementations = new SchemaUtil().groupImplementationsForInterfacesAndObjects(schema);
    Consumer<GraphQLNamedSchemaElement> recordDirectiveName = (graphQLDirective) -> {
        String directiveName = graphQLDirective.getName();
        if (directivesOriginalToNewNameMap.containsKey(directiveName)) {
            newNameMap.put(graphQLDirective, directivesOriginalToNewNameMap.get(directiveName));
            return;
        }
        String newName = "Directive" + directiveCounter.getAndIncrement();
        newNameMap.put(graphQLDirective, newName);
        directivesOriginalToNewNameMap.put(directiveName, newName);
    };
    BiConsumer<GraphQLNamedSchemaElement, String> recordDirectiveArgumentName = (graphQLArgument, directiveArgumentKey) -> {
        if (seenArgumentsOnDirectivesMap.containsKey(directiveArgumentKey)) {
            newNameMap.put(graphQLArgument, seenArgumentsOnDirectivesMap.get(directiveArgumentKey));
            return;
        }
        String newName = "argument" + argumentCounter.getAndIncrement();
        newNameMap.put(graphQLArgument, newName);
        seenArgumentsOnDirectivesMap.put(directiveArgumentKey, newName);
    };
    GraphQLTypeVisitor visitor = new GraphQLTypeVisitorStub() {

        @Override
        public TraversalControl visitGraphQLArgument(GraphQLArgument graphQLArgument, TraverserContext<GraphQLSchemaElement> context) {
            String curName = graphQLArgument.getName();
            GraphQLSchemaElement parentNode = context.getParentNode();
            if (parentNode instanceof GraphQLDirective) {
                // if we already went over the argument for this directive name, no need to add new names
                String directiveArgumentKey = ((GraphQLDirective) parentNode).getName() + graphQLArgument.getName();
                recordDirectiveArgumentName.accept(graphQLArgument, directiveArgumentKey);
                return CONTINUE;
            }
            if (!(parentNode instanceof GraphQLFieldDefinition)) {
                String newName = "argument" + argumentCounter.getAndIncrement();
                newNameMap.put(graphQLArgument, newName);
                return CONTINUE;
            }
            GraphQLFieldDefinition fieldDefinition = (GraphQLFieldDefinition) parentNode;
            String fieldName = fieldDefinition.getName();
            GraphQLImplementingType implementingType = (GraphQLImplementingType) context.getParentContext().getParentNode();
            Set<GraphQLFieldDefinition> matchingInterfaceFieldDefinitions = getSameFields(fieldName, implementingType.getName(), interfaceToImplementations, schema);
            String newName;
            if (matchingInterfaceFieldDefinitions.size() == 0) {
                newName = "argument" + argumentCounter.getAndIncrement();
            } else {
                List<GraphQLArgument> matchingArgumentDefinitions = getMatchingArgumentDefinitions(curName, matchingInterfaceFieldDefinitions);
                if (matchingArgumentDefinitions.size() == 0) {
                    newName = "argument" + argumentCounter.getAndIncrement();
                } else {
                    if (newNameMap.containsKey(matchingArgumentDefinitions.get(0))) {
                        newName = newNameMap.get(matchingArgumentDefinitions.get(0));
                    } else {
                        newName = "argument" + argumentCounter.getAndIncrement();
                        for (GraphQLArgument argument : matchingArgumentDefinitions) {
                            newNameMap.put(argument, newName);
                        }
                    }
                }
            }
            newNameMap.put(graphQLArgument, newName);
            return CONTINUE;
        }

        @Override
        public TraversalControl visitGraphQLAppliedDirectiveArgument(GraphQLAppliedDirectiveArgument graphQLArgument, TraverserContext<GraphQLSchemaElement> context) {
            GraphQLSchemaElement parentNode = context.getParentNode();
            if (parentNode instanceof GraphQLAppliedDirective) {
                // if we already went over the argument for this directive name, no need to add new names
                String directiveArgumentKey = ((GraphQLAppliedDirective) parentNode).getName() + graphQLArgument.getName();
                recordDirectiveArgumentName.accept(graphQLArgument, directiveArgumentKey);
            }
            return CONTINUE;
        }

        @Override
        public TraversalControl visitGraphQLDirective(GraphQLDirective graphQLDirective, TraverserContext<GraphQLSchemaElement> context) {
            if (DirectiveInfo.isGraphqlSpecifiedDirective(graphQLDirective)) {
                return TraversalControl.ABORT;
            }
            recordDirectiveName.accept(graphQLDirective);
            return CONTINUE;
        }

        @Override
        public TraversalControl visitGraphQLAppliedDirective(GraphQLAppliedDirective graphQLAppliedDirective, TraverserContext<GraphQLSchemaElement> context) {
            if (DirectiveInfo.isGraphqlSpecifiedDirective(graphQLAppliedDirective.getName())) {
                return TraversalControl.ABORT;
            }
            recordDirectiveName.accept(graphQLAppliedDirective);
            return CONTINUE;
        }

        @Override
        public TraversalControl visitGraphQLInterfaceType(GraphQLInterfaceType graphQLInterfaceType, TraverserContext<GraphQLSchemaElement> context) {
            if (Introspection.isIntrospectionTypes(graphQLInterfaceType)) {
                return TraversalControl.ABORT;
            }
            String newName = "Interface" + interfaceCounter.getAndIncrement();
            newNameMap.put(graphQLInterfaceType, newName);
            return CONTINUE;
        }

        @Override
        public TraversalControl visitGraphQLEnumType(GraphQLEnumType graphQLEnumType, TraverserContext<GraphQLSchemaElement> context) {
            if (Introspection.isIntrospectionTypes(graphQLEnumType)) {
                return TraversalControl.ABORT;
            }
            String newName = "Enum" + enumCounter.getAndIncrement();
            newNameMap.put(graphQLEnumType, newName);
            return CONTINUE;
        }

        @Override
        public TraversalControl visitGraphQLEnumValueDefinition(GraphQLEnumValueDefinition enumValueDefinition, TraverserContext<GraphQLSchemaElement> context) {
            String newName = "EnumValue" + enumValueCounter.getAndIncrement();
            newNameMap.put(enumValueDefinition, newName);
            return CONTINUE;
        }

        @Override
        public TraversalControl visitGraphQLFieldDefinition(GraphQLFieldDefinition graphQLFieldDefinition, TraverserContext<GraphQLSchemaElement> context) {
            String fieldName = graphQLFieldDefinition.getName();
            GraphQLImplementingType parentNode = (GraphQLImplementingType) context.getParentNode();
            Set<GraphQLFieldDefinition> sameFields = getSameFields(fieldName, parentNode.getName(), interfaceToImplementations, schema);
            String newName;
            if (sameFields.size() == 0) {
                newName = "field" + fieldCounter.getAndIncrement();
            } else {
                if (newNameMap.containsKey(sameFields.iterator().next())) {
                    newName = newNameMap.get(sameFields.iterator().next());
                } else {
                    newName = "field" + fieldCounter.getAndIncrement();
                    for (GraphQLFieldDefinition fieldDefinition : sameFields) {
                        newNameMap.put(fieldDefinition, newName);
                    }
                }
            }
            newNameMap.put(graphQLFieldDefinition, newName);
            return CONTINUE;
        }

        @Override
        public TraversalControl visitGraphQLInputObjectField(GraphQLInputObjectField graphQLInputObjectField, TraverserContext<GraphQLSchemaElement> context) {
            String newName = "inputField" + inputObjectFieldCounter.getAndIncrement();
            newNameMap.put(graphQLInputObjectField, newName);
            return CONTINUE;
        }

        @Override
        public TraversalControl visitGraphQLInputObjectType(GraphQLInputObjectType graphQLInputObjectType, TraverserContext<GraphQLSchemaElement> context) {
            if (Introspection.isIntrospectionTypes(graphQLInputObjectType)) {
                return TraversalControl.ABORT;
            }
            String newName = "InputObject" + inputObjectCounter.getAndIncrement();
            newNameMap.put(graphQLInputObjectType, newName);
            return CONTINUE;
        }

        @Override
        public TraversalControl visitGraphQLObjectType(GraphQLObjectType graphQLObjectType, TraverserContext<GraphQLSchemaElement> context) {
            if (Introspection.isIntrospectionTypes(graphQLObjectType)) {
                return TraversalControl.ABORT;
            }
            String newName = "Object" + objectCounter.getAndIncrement();
            newNameMap.put(graphQLObjectType, newName);
            return CONTINUE;
        }

        @Override
        public TraversalControl visitGraphQLScalarType(GraphQLScalarType graphQLScalarType, TraverserContext<GraphQLSchemaElement> context) {
            if (ScalarInfo.isGraphqlSpecifiedScalar(graphQLScalarType)) {
                return TraversalControl.ABORT;
            }
            String newName = "Scalar" + scalarCounter.getAndIncrement();
            newNameMap.put(graphQLScalarType, newName);
            return CONTINUE;
        }

        @Override
        public TraversalControl visitGraphQLUnionType(GraphQLUnionType graphQLUnionType, TraverserContext<GraphQLSchemaElement> context) {
            if (Introspection.isIntrospectionTypes(graphQLUnionType)) {
                return TraversalControl.ABORT;
            }
            String newName = "Union" + unionCounter.getAndIncrement();
            newNameMap.put(graphQLUnionType, newName);
            return CONTINUE;
        }
    };
    SchemaTransformer.transformSchema(schema, visitor);
    return newNameMap;
}

Example 8 with GraphQLAppliedDirective

use of graphql.schema.GraphQLAppliedDirective in project graphql-java by graphql-java.

the class SchemaGeneratorHelper method buildScalar.

GraphQLScalarType buildScalar(BuildContext buildCtx, ScalarTypeDefinition typeDefinition) {
    TypeDefinitionRegistry typeRegistry = buildCtx.getTypeRegistry();
    RuntimeWiring runtimeWiring = buildCtx.getWiring();
    WiringFactory wiringFactory = runtimeWiring.getWiringFactory();
    List<ScalarTypeExtensionDefinition> extensions = scalarTypeExtensions(typeDefinition, buildCtx);
    ScalarWiringEnvironment environment = new ScalarWiringEnvironment(typeRegistry, typeDefinition, extensions);
    GraphQLScalarType scalar;
    if (wiringFactory.providesScalar(environment)) {
        scalar = wiringFactory.getScalar(environment);
    } else {
        scalar = buildCtx.getWiring().getScalars().get(typeDefinition.getName());
    }
    if (!ScalarInfo.isGraphqlSpecifiedScalar(scalar)) {
        String description = getScalarDesc(scalar, typeDefinition);
        Pair<List<GraphQLDirective>, List<GraphQLAppliedDirective>> appliedDirectives = buildAppliedDirectives(buildCtx, inputTypeFactory(buildCtx), typeDefinition.getDirectives(), directivesOf(extensions), SCALAR, buildCtx.getDirectives(), buildCtx.getComparatorRegistry());
        scalar = scalar.transform(builder -> {
            builder.description(description).definition(buildCtx.isCaptureAstDefinitions() ? typeDefinition : null).comparatorRegistry(buildCtx.getComparatorRegistry()).specifiedByUrl(getSpecifiedByUrl(typeDefinition, extensions));
            buildAppliedDirectives(buildCtx, builder, appliedDirectives);
        });
    }
    return directivesObserve(buildCtx, scalar);
}

Example 9 with GraphQLAppliedDirective

use of graphql.schema.GraphQLAppliedDirective in project graphql-java by graphql-java.

the class SchemaPrinter method directiveString.

private String directiveString(GraphQLAppliedDirective directive) {
    if (!options.getIncludeSchemaElement().test(directive)) {
        return "";
    }
    if (!options.getIncludeDirective().test(directive.getName())) {
        // @deprecated is special - we always print it if something is deprecated
        if (!isDeprecatedDirective(directive)) {
            return "";
        }
    }
    StringBuilder sb = new StringBuilder();
    sb.append("@").append(directive.getName());
    Comparator<? super GraphQLSchemaElement> comparator = getComparator(GraphQLAppliedDirective.class, GraphQLAppliedDirectiveArgument.class);
    List<GraphQLAppliedDirectiveArgument> args = directive.getArguments();
    args = args.stream().filter(arg -> arg.getArgumentValue().isSet()).sorted(comparator).collect(toList());
    if (!args.isEmpty()) {
        sb.append("(");
        for (int i = 0; i < args.size(); i++) {
            GraphQLAppliedDirectiveArgument arg = args.get(i);
            String argValue = null;
            if (arg.hasSetValue()) {
                argValue = printAst(arg.getArgumentValue(), arg.getType());
            }
            if (!isNullOrEmpty(argValue)) {
                sb.append(arg.getName());
                sb.append(" : ");
                sb.append(argValue);
                if (i < args.size() - 1) {
                    sb.append(", ");
                }
            }
        }
        sb.append(")");
    }
    return sb.toString();
}

Example 10 with GraphQLAppliedDirective

use of graphql.schema.GraphQLAppliedDirective in project graphql-java by graphql-java.

the class SchemaGeneratorHelper method buildEnumType.

GraphQLEnumType buildEnumType(BuildContext buildCtx, EnumTypeDefinition typeDefinition) {
    GraphQLEnumType.Builder builder = GraphQLEnumType.newEnum();
    builder.definition(buildCtx.isCaptureAstDefinitions() ? typeDefinition : null);
    builder.name(typeDefinition.getName());
    builder.description(buildDescription(buildCtx, typeDefinition, typeDefinition.getDescription()));
    builder.comparatorRegistry(buildCtx.getComparatorRegistry());
    List<EnumTypeExtensionDefinition> extensions = enumTypeExtensions(typeDefinition, buildCtx);
    builder.extensionDefinitions(buildCtx.isCaptureAstDefinitions() ? extensions : emptyList());
    EnumValuesProvider enumValuesProvider = buildCtx.getWiring().getEnumValuesProviders().get(typeDefinition.getName());
    typeDefinition.getEnumValueDefinitions().forEach(evd -> {
        GraphQLEnumValueDefinition enumValueDefinition = buildEnumValue(buildCtx, typeDefinition, enumValuesProvider, evd);
        builder.value(enumValueDefinition);
    });
    extensions.forEach(extension -> extension.getEnumValueDefinitions().forEach(evd -> {
        GraphQLEnumValueDefinition enumValueDefinition = buildEnumValue(buildCtx, typeDefinition, enumValuesProvider, evd);
        if (!builder.hasValue(enumValueDefinition.getName())) {
            builder.value(enumValueDefinition);
        }
    }));
    Pair<List<GraphQLDirective>, List<GraphQLAppliedDirective>> appliedDirectives = buildAppliedDirectives(buildCtx, inputTypeFactory(buildCtx), typeDefinition.getDirectives(), directivesOf(extensions), ENUM, buildCtx.getDirectives(), buildCtx.getComparatorRegistry());
    buildAppliedDirectives(buildCtx, builder, appliedDirectives);
    return directivesObserve(buildCtx, builder.build());
}