Configuration Avancée

Ce guide présente les options de configuration avancées de GraphQL AutoGen pour personnaliser complètement votre API GraphQL.

Configuration par Propriétés

GraphQL AutoGen offre de nombreuses options de configuration via les propriétés Spring Boot dans votre fichier application.properties ou application.yml.

application.properties

# Configuration globale
graphql.autogen.enabled=true
graphql.autogen.base-package=com.example
graphql.autogen.schema-name=MySchema

# Options de génération
graphql.autogen.include-nullability-info=true
graphql.autogen.add-introspection-fields=true
graphql.autogen.include-schema-definition=true

# Comportement des scanners
graphql.autogen.scan-entities=true
graphql.autogen.scan-controllers=true
graphql.autogen.scan-services=false

# DataLoaders
graphql.autogen.enable-dataloaders=true
graphql.autogen.dataloader-batch-size=100
graphql.autogen.dataloader-timeout=2000

Vous pouvez également utiliser la syntaxe YAML :

application.yml

graphql:
  autogen:
    enabled: true
    base-package: com.example
    schema-name: MySchema
    include-nullability-info: true
    add-introspection-fields: true
    include-schema-definition: true
    scan-entities: true
    scan-controllers: true
    scan-services: false
    enable-dataloaders: true
    dataloader-batch-size: 100
    dataloader-timeout: 2000

Configuration Programmatique

Pour une configuration plus avancée, vous pouvez créer un bean de configuration personnalisé :

GraphQLAutoGenConfig.java

@Configuration
public class GraphQLAutoGenConfig {

    @Bean
    public GraphQLAutoGenConfigurer graphqlAutoGenConfigurer() {
        return new GraphQLAutoGenConfigurer()
            .setBasePackage("com.example")
            .setSchemaName("MySchema")
            .setIncludeNullabilityInfo(true)
            .setAddIntrospectionFields(true)
            .setIncludeSchemaDefinition(true)
            .setScanEntities(true)
            .setScanControllers(true)
            .setScanServices(false)
            .setEnableDataLoaders(true)
            .setDataLoaderBatchSize(100)
            .setDataLoaderTimeout(Duration.ofMillis(2000));
    }
}

Personnalisation des Resolvers

Resolvers personnalisés

Vous pouvez créer vos propres resolvers GraphQL :

ProductResolver.java

@Component
public class ProductResolver implements GraphQLResolver {

    private final CategoryRepository categoryRepository;

    public ProductResolver(CategoryRepository categoryRepository) {
        this.categoryRepository = categoryRepository;
    }

    @GraphQLField
    public Category category(Product product, DataFetchingEnvironment env) {
        // Logique personnalisée pour résoudre la catégorie d'un produit
        return categoryRepository.findById(product.getCategoryId()).orElse(null);
    }
}

Resolvers avec DataLoader

Création d'un DataLoader personnalisé pour optimiser les requêtes :

CategoryBatchLoader.java

@Component
public class CategoryBatchLoader implements BatchLoader {

    private final CategoryRepository categoryRepository;

    public CategoryBatchLoader(CategoryRepository categoryRepository) {
        this.categoryRepository = categoryRepository;
    }

    @Override
    public CompletionStage> load(List categoryIds) {
        return CompletableFuture.supplyAsync(() -> {
            List categories = categoryRepository.findAllById(categoryIds);
            Map categoryMap = categories.stream()
                    .collect(Collectors.toMap(Category::getId, Function.identity()));

            return categoryIds.stream()
                    .map(id -> categoryMap.getOrDefault(id, null))
                    .collect(Collectors.toList());
        });
    }
}

Intégration avec Spring Security

Configurer la sécurité pour vos requêtes GraphQL :

GraphQLSecurityConfig.java

@Configuration
@EnableWebSecurity
public class GraphQLSecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        return http
            .csrf(csrf -> csrf.disable())
            .authorizeHttpRequests(auth -> {
                auth.requestMatchers("/graphql").permitAll();
                auth.requestMatchers("/graphiql").hasRole("ADMIN");
                auth.anyRequest().authenticated();
            })
            .oauth2ResourceServer(OAuth2ResourceServerConfigurer::jwt)
            .build();
    }

    @Bean
    public GraphQLDirectiveWiringCustomizer directiveWiringCustomizer() {
        return wiringCustomizer -> {
            // Ajouter la directive @auth pour sécuriser les champs
            wiringCustomizer.setDirectiveWiringFactory(new AuthDirectiveWiring());
        };
    }
}

Personnalisation du Moteur GraphQL

Vous pouvez également personnaliser le moteur GraphQL sous-jacent :

CustomGraphQLEngineConfig.java

@Configuration
public class CustomGraphQLEngineConfig {

    @Bean
    public GraphQL graphQL(GraphQLSchema schema) {
        return GraphQL.newGraphQL(schema)
            .queryExecutionStrategy(new AsyncExecutionStrategy())
            .mutationExecutionStrategy(new AsyncSerialExecutionStrategy())
            .subscriptionExecutionStrategy(new SubscriptionExecutionStrategy())
            .instrumentation(new RequestLoggingInstrumentation())
            .build();
    }

    @Bean
    public GraphQLSchemaCustomizer schemaCustomizer() {
        return schema -> {
            // Personnaliser le schéma avant qu'il soit construit
            return SchemaTransformer.transformSchema(schema);
        };
    }
}

Pour optimiser les performances de votre API GraphQL, consultez notre guide d'optimisation des performances.

Documentation