open fun dgsSchemaProvider()

in graphql-dgs-spring-graphql/src/main/kotlin/com/netflix/graphql/dgs/springgraphql/autoconfig/DgsSpringGraphQLAutoConfiguration.kt [285:373]
82 lines of code
5 McCabe index (conditional complexity)

    open fun dgsSchemaProvider(
        applicationContext: ApplicationContext,
        federationResolver: Optional<DgsFederationResolver>,
        existingTypeDefinitionFactory: Optional<TypeDefinitionRegistry>,
        existingCodeRegistry: Optional<GraphQLCodeRegistry>,
        dataFetcherResultProcessors: List<DataFetcherResultProcessor>,
        dataFetcherExceptionHandler: Optional<DataFetcherExceptionHandler> = Optional.empty(),
        entityFetcherRegistry: EntityFetcherRegistry,
        defaultDataFetcherFactory: Optional<DataFetcherFactory<*>> = Optional.empty(),
        methodDataFetcherFactory: MethodDataFetcherFactory,
        fallbackTypeResolver: TypeResolver? = null,
    ): DgsSchemaProvider =
        DgsSchemaProvider(
            applicationContext = applicationContext,
            federationResolver = federationResolver,
            existingTypeDefinitionRegistry = existingTypeDefinitionFactory,
            schemaLocations = configProps.schemaLocations,
            dataFetcherResultProcessors = dataFetcherResultProcessors,
            dataFetcherExceptionHandler = dataFetcherExceptionHandler,
            entityFetcherRegistry = entityFetcherRegistry,
            defaultDataFetcherFactory = defaultDataFetcherFactory,
            methodDataFetcherFactory = methodDataFetcherFactory,
            schemaWiringValidationEnabled = configProps.schemaWiringValidationEnabled,
            enableEntityFetcherCustomScalarParsing = configProps.enableEntityFetcherCustomScalarParsing,
            fallbackTypeResolver = fallbackTypeResolver,
        )

    @Bean
    open fun graphQlSource(
        properties: GraphQlProperties,
        dgsSchemaProvider: DgsSchemaProvider,
        exceptionResolvers: ObjectProvider<DataFetcherExceptionResolver>,
        subscriptionExceptionResolvers: ObjectProvider<SubscriptionExceptionResolver>,
        instrumentations: ObjectProvider<Instrumentation>,
        wiringConfigurers: ObjectProvider<RuntimeWiringConfigurer>,
        sourceCustomizers: ObjectProvider<GraphQlSourceBuilderCustomizer>,
        reloadSchemaIndicator: ReloadSchemaIndicator,
        defaultExceptionHandler: DataFetcherExceptionHandler,
        reportConsumer: Consumer<SchemaReport>?,
    ): GraphQlSource {
        val dataFetcherExceptionResolvers: MutableList<DataFetcherExceptionResolver> =
            exceptionResolvers
                .orderedStream()
                .collect(Collectors.toList())
        dataFetcherExceptionResolvers += ExceptionHandlerResolverAdapter(defaultExceptionHandler)

        val builder =
            DgsGraphQLSourceBuilder(dgsSchemaProvider, configProps.introspection.showSdlComments)
                .exceptionResolvers(dataFetcherExceptionResolvers)
                .subscriptionExceptionResolvers(subscriptionExceptionResolvers.orderedStream().toList())
                .instrumentation(instrumentations.orderedStream().toList())

        if (properties.schema.inspection.isEnabled) {
            if (reportConsumer != null) {
                builder.inspectSchemaMappings(reportConsumer)
            } else if (LOG.isInfoEnabled) {
                builder.inspectSchemaMappings { schemaReport ->
                    val messageBuilder = StringBuilder("***Schema Report***\n")

                    val arguments =
                        schemaReport.unmappedArguments().map { entry ->
                            val (key, value) = entry
                            if (key is SelfDescribingDataFetcher) {
                                val dataFetcher =
                                    (key as DgsGraphQLSourceBuilder.DgsSelfDescribingDataFetcher).dataFetcher
                                dataFetcher.method.declaringClass.name + "." + dataFetcher.method.name + " for arguments " + value
                            } else {
                                entry.toString()
                            }
                        }

                    messageBuilder.append("Unmapped fields: ").append(schemaReport.unmappedFields()).append('\n')
                    messageBuilder.append("Unmapped registrations: ").append(schemaReport.unmappedRegistrations()).append('\n')
                    messageBuilder.append("Unmapped arguments: ").append(arguments).append('\n')
                    messageBuilder.append("Skipped types: ").append(schemaReport.skippedTypes()).append('\n')

                    LOG.info("{}", messageBuilder)
                }
            }
        }

        wiringConfigurers.orderedStream().forEach { configurer: RuntimeWiringConfigurer ->
            builder.configureRuntimeWiring(configurer)
        }
        sourceCustomizers.orderedStream().forEach { customizer: GraphQlSourceBuilderCustomizer ->
            customizer.customize(builder)
        }
        return ReloadableGraphQLSource(builder, reloadSchemaIndicator)
    }