fun baseExecute()

in graphql-dgs/src/main/kotlin/com/netflix/graphql/dgs/internal/BaseDgsQueryExecutor.kt [70:172]
94 lines of code
7 McCabe index (conditional complexity)

    fun baseExecute(
        @Language("graphql") query: String?,
        variables: Map<String, Any>?,
        extensions: Map<String, Any>?,
        operationName: String?,
        dgsContext: DgsContext,
        graphQLSchema: GraphQLSchema,
        dataLoaderProvider: DgsDataLoaderProvider,
        instrumentation: Instrumentation?,
        queryExecutionStrategy: ExecutionStrategy,
        mutationExecutionStrategy: ExecutionStrategy,
        idProvider: Optional<ExecutionIdProvider>,
        preparsedDocumentProvider: PreparsedDocumentProvider?,
    ): CompletableFuture<ExecutionResult> {
        val inputVariables = variables ?: emptyMap()

        if (!StringUtils.hasText(query)) {
            return CompletableFuture.completedFuture(
                DgsExecutionResult
                    .builder()
                    .status(HttpStatus.BAD_REQUEST)
                    .executionResult(
                        ExecutionResult
                            .newExecutionResult()
                            .addError(DgsBadRequestException.NULL_OR_EMPTY_QUERY_EXCEPTION.toGraphQlError())
                            .build(),
                    ).build(),
            )
        }

        val graphQLBuilder =
            GraphQL
                .newGraphQL(graphQLSchema)
                .queryExecutionStrategy(queryExecutionStrategy)
                .mutationExecutionStrategy(mutationExecutionStrategy)

        preparsedDocumentProvider?.let { graphQLBuilder.preparsedDocumentProvider(it) }
        instrumentation?.let { graphQLBuilder.instrumentation(it) }
        idProvider.ifPresent { graphQLBuilder.executionIdProvider(it) }

        val graphQL: GraphQL = graphQLBuilder.build()

        lateinit var executionInput: ExecutionInput
        val dataLoaderRegistry = dataLoaderProvider.buildRegistryWithContextSupplier { executionInput.graphQLContext }

        @Suppress("DEPRECATION")
        executionInput =
            ExecutionInput
                .newExecutionInput()
                .query(query)
                .operationName(operationName)
                .variables(inputVariables)
                .dataLoaderRegistry(dataLoaderRegistry)
                .context(dgsContext)
                .graphQLContext(dgsContext)
                .extensions(extensions.orEmpty())
                .build()

        return try {
            val future = graphQL.executeAsync(executionInput)

            if (dataLoaderRegistry is AutoCloseable) {
                future.whenComplete { _, _ -> dataLoaderRegistry.close() }
            }

            future.exceptionally { exc ->
                val cause =
                    if (exc is CompletionException) {
                        exc.cause
                    } else {
                        exc
                    }
                if (cause is GraphQLError) {
                    DgsExecutionResult
                        .builder()
                        .status(HttpStatus.BAD_REQUEST)
                        .executionResult(ExecutionResult.newExecutionResult().addError(cause).build())
                        .build()
                } else {
                    logger.error("Encountered an exception while handling query {}", query, cause)
                    DgsExecutionResult
                        .builder()
                        .status(HttpStatus.INTERNAL_SERVER_ERROR)
                        .executionResult(
                            ExecutionResult
                                .newExecutionResult()
                                .addError(
                                    TypedGraphQLError.newInternalErrorBuilder().build(),
                                ).build(),
                        ).build()
                }
            }
        } catch (e: Exception) {
            logger.error("Encountered an exception while handling query {}", query, e)
            val executionResult = ExecutionResult.newExecutionResult()
            if (e is GraphQLError) {
                executionResult.addError(e)
            } else {
                executionResult.addError(TypedGraphQLError.newInternalErrorBuilder().build())
            }
            CompletableFuture.completedFuture(executionResult.build())
        }
    }