graphqlAsync() - Code Metrics - Inspection of "Adds support for asynchronous executions via Promi..." - digiaonline/graphql-php - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#345)

unknown
created 2019-05-20 03:17 UTC
graphqlAsync() A

↳ Parent: Project
Complexity

Conditions	2
Paths	2
Size

Total Lines	27
Code Lines	13
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	2
eloc	13
nc	2
nop	8
dl	0
loc	27
rs	9.8333
c	0
b	0
f	0
How to fix Many Parameters

<?php

namespace Digia\GraphQL;

use Digia\GraphQL\Error\Handler\CallableMiddleware;
use Digia\GraphQL\Error\Handler\ErrorHandler;
use Digia\GraphQL\Error\Handler\ErrorHandlerInterface;
use Digia\GraphQL\Error\InvariantException;
use Digia\GraphQL\Execution\ExecutionResult;
use Digia\GraphQL\Language\Node\DocumentNode;
use Digia\GraphQL\Language\Node\NodeInterface;
use Digia\GraphQL\Language\Node\TypeNodeInterface;
use Digia\GraphQL\Language\Node\ValueNodeInterface;
use Digia\GraphQL\Language\Source;
use Digia\GraphQL\Language\StringSourceBuilder;
use Digia\GraphQL\Language\SyntaxErrorException;
use Digia\GraphQL\Schema\Resolver\ResolverRegistryInterface;
use Digia\GraphQL\Schema\Schema;
use Digia\GraphQL\Schema\Validation\SchemaValidationException;
use Digia\GraphQL\Validation\ValidationException;
use React\Promise\PromiseInterface;

/**
 * @param string|Source                   $source
 * @param array|ResolverRegistryInterface $resolverRegistry
 * @param array                           $options
 * @return Schema
 * @throws InvariantException
 */
function buildSchema($source, $resolverRegistry = [], array $options = []): Schema
{
    if (\is_string($source)) {
        $source = (new StringSourceBuilder($source))->build();
    }

    return GraphQL::buildSchema($source, $resolverRegistry, $options);
}

/**
 * @param Schema                          $schema
 * @param string|Source                   $source
 * @param array|ResolverRegistryInterface $resolverRegistry
 * @param array                           $options
 * @return Schema
 * @throws InvariantException
 */
function extendSchema(Schema $schema, $source, $resolverRegistry = [], array $options = []): Schema
{
    if (\is_string($source)) {
        $source = (new StringSourceBuilder($source))->build();
    }

    return GraphQL::extendSchema($schema, $source, $resolverRegistry, $options);
}

/**
 * @param Schema $schema
 * @return SchemaValidationException[]
 */
function validateSchema(Schema $schema): array
{
    return GraphQL::validateSchema($schema);
}

/**
 * @param string|Source $source
 * @param array         $options
 * @return DocumentNode
 * @throws InvariantException
 * @throws SyntaxErrorException
 */
function parse($source, array $options = []): DocumentNode
{
    if (\is_string($source)) {
        $source = (new StringSourceBuilder($source))->build();
    }

    return GraphQL::parse($source, $options);
}

/**
 * @param string|Source $source
 * @param array         $options
 * @return ValueNodeInterface
 * @throws InvariantException
 * @throws SyntaxErrorException
 */
function parseValue($source, array $options = []): ValueNodeInterface
{
    if (\is_string($source)) {
        $source = (new StringSourceBuilder($source))->build();
    }

    return GraphQL::parseValue($source, $options);
}

/**
 * @param string|Source $source
 * @param array         $options
 * @return TypeNodeInterface
 * @throws InvariantException
 * @throws SyntaxErrorException
 */
function parseType($source, array $options = []): TypeNodeInterface
{
    if (\is_string($source)) {
        $source = (new StringSourceBuilder($source))->build();
    }

    return GraphQL::parseType($source, $options);
}

/**
 * @param Schema       $schema
 * @param DocumentNode $document
 * @return array|ValidationException[]
 */
function validate(Schema $schema, DocumentNode $document): array
{
    return GraphQL::validate($schema, $document);
}

/**
 * @param Schema                     $schema
 * @param DocumentNode               $document
 * @param mixed|null                 $rootValue
 * @param mixed|null                 $contextValue
 * @param array                      $variableValues
 * @param mixed|null                 $operationName
 * @param callable|null              $fieldResolver
 * @param ErrorHandlerInterface|null $errorHandler
 * @return ExecutionResult
 */
function execute(
    Schema $schema,
    DocumentNode $document,
    $rootValue = null,
    $contextValue = null,
    array $variableValues = [],
    $operationName = null,
    callable $fieldResolver = null,
    $errorHandler = null
): ExecutionResult {
    return GraphQL::execute(
        $schema,
        $document,
        $rootValue,
        $contextValue,
        $variableValues,
        $operationName,
        $fieldResolver,
        $errorHandler
    );
}

/**
 * @param Schema                     $schema
 * @param DocumentNode               $document
 * @param mixed|null                 $rootValue
 * @param mixed|null                 $contextValue
 * @param array                      $variableValues
 * @param mixed|null                 $operationName
 * @param callable|null              $fieldResolver
 * @param ErrorHandlerInterface|null $errorHandler
 * @return PromiseInterface<ExecutionResult>
 */
function promiseExecute(
    Schema $schema,
    DocumentNode $document,
    $rootValue = null,
    $contextValue = null,
    array $variableValues = [],
    $operationName = null,
    callable $fieldResolver = null,
    $errorHandler = null
): PromiseInterface {
    return GraphQL::promiseExecute(
        $schema,
        $document,
        $rootValue,
        $contextValue,
        $variableValues,
        $operationName,
        $fieldResolver,
        $errorHandler
    );
}

/**
 * @param NodeInterface $node
 * @return string
 */
function printNode(NodeInterface $node): string
{
    return GraphQL::print($node);
}

/**
 * @param Schema                              $schema
 * @param string                              $source
 * @param mixed                               $rootValue
 * @param mixed                               $contextValue
 * @param array                               $variableValues
 * @param string|null                         $operationName
 * @param callable|null                       $fieldResolver
 * @param ErrorHandlerInterface|callable|null $errorHandler
 * @return array
 * @throws InvariantException
 * @throws SyntaxErrorException
 */
function graphql(
    Schema $schema,
    string $source,
    $rootValue = null,
    $contextValue = null,
    array $variableValues = [],
    ?string $operationName = null,
    ?callable $fieldResolver = null,
    $errorHandler = null
): array {
    if (\is_callable($errorHandler)) {
        $errorHandler = new ErrorHandler([new CallableMiddleware($errorHandler)]);
        $errorHandler = new ErrorHandler([new CallableMiddleware(/** @scrutinizer ignore-type */ $errorHandler)]);
    }

    $result = GraphQL::process(
        $schema,
        $source,
        $rootValue,
        $contextValue,
        $variableValues,
        $operationName,
        $fieldResolver,
        $errorHandler
        /** @scrutinizer ignore-type */ $errorHandler
    );

    return $result->toArray();
}

/**
 * @param Schema                              $schema
 * @param string                              $source
 * @param mixed                               $rootValue
 * @param mixed                               $contextValue
 * @param array                               $variableValues
 * @param string|null                         $operationName
 * @param callable|null                       $fieldResolver
 * @param ErrorHandlerInterface|callable|null $errorHandler
 * @return PromiseInterface<array>
 * @throws InvariantException
 * @throws SyntaxErrorException
 */
function graphqlAsync(
    Schema $schema,
    string $source,
    $rootValue = null,
    $contextValue = null,
    array $variableValues = [],
    ?string $operationName = null,
    ?callable $fieldResolver = null,
    $errorHandler = null
): PromiseInterface {
    if (\is_callable($errorHandler)) {
        $errorHandler = new ErrorHandler([new CallableMiddleware($errorHandler)]);
        $errorHandler = new ErrorHandler([new CallableMiddleware(/** @scrutinizer ignore-type */ $errorHandler)]);
    }

    $result = GraphQL::processAsync(
        $schema,
        $source,
        $rootValue,
        $contextValue,
        $variableValues,
        $operationName,
        $fieldResolver,
        $errorHandler
        /** @scrutinizer ignore-type */ $errorHandler
    );

    return $result->then(function (ExecutionResult $result) {
        return $result->toArray();
    });
}

digiaonline / graphql-php

Pull Request — master (#345)

graphqlAsync() A

Complexity

Size

Duplication

Importance

How to fix Many Parameters

Many Parameters

Duplication Side-by-Side

Filter issues like
