getting started in graphql-php: how to add resolver functions to schema from .graphql file?

This approach works without instantiating a Server. In my case, I already have a server and can read HTTP data, all I needed was to read the GraphQL schema and run the query. First I read the schema from a file:

        $schemaContent = // file_get_contents or whatever works for you

        $schemaDocument = GraphQLLanguageParser::parse($schemaContent);
        $schemaBuilder = new GraphQLUtilsBuildSchema($schemaDocument);
        $schema = $schemaBuilder->buildSchema();

Then I execute the query passing a custom field resolver:

        $fieldResolver = function() {
            return call_user_func_array([$this, 'defaultFieldResolver'], func_get_args());
        };

        $result = GraphQLGraphQL::executeQuery(
            $schema,
            $query,        // this was grabbed from the HTTP post data
            null,
            $appContext,   // custom context
            $variables,    // this was grabbed from the HTTP post data
            null,
            $fieldResolver // HERE, custom field resolver
        );

The field resolver looks like this:

private static function defaultFieldResolver(
    $source,
    $args,
    $context,
    GraphQLTypeDefinitionResolveInfo $info
) {
    $fieldName = $info->fieldName;
    $parentType = $info->parentType->name;

    if ($source === NULL) {
        // this is the root value, return value depending on $fieldName
        // ...
    } else {
        // Depending on field type ($parentType), I call different field resolvers.
        // Since our system is big, we implemented a bootstrapping mechanism
        // so modules can register field resolvers in this class depending on field type
        // ...

        // If no field resolver was defined for this $parentType,
        // we just rely on the default field resolver provided by graphql-php (copy/paste).
        $fieldName = $info->fieldName;
        $property = null;

        if (is_array($source) || $source instanceof ArrayAccess) {
            if (isset($source[$fieldName])) {
                $property = $source[$fieldName];
            }
        } else if (is_object($source)) {
            if (isset($source->{$fieldName})) {
                $property = $source->{$fieldName};
            }
        }

        return $property instanceof Closure
            ? $property($source, $args, $context)
            : $property;
    }
}

I’m using root value for this:

<?php

require("vendor/autoload.php") ;
require("exemplo-graphql.php");
require("Usuario.php");

use GraphQLGraphQL;
use GraphQLTypeSchema;
use GraphQLUtilsBuildSchema;

$query = $_REQUEST['query'];

$typeConfigDecorator = function($typeConfig, $typeDefinitionNode) {
    $name = $typeConfig['name'];
    // ... add missing options to $typeConfig based on type $name
    return $typeConfig;
};

$contents = file_get_contents('schema.graphql');
$schema = BuildSchema::build($contents, $typeConfigDecorator);

// $rawInput = file_get_contents('php://input');
$input = json_decode($query, true);
$query = $input['query'];
$variableValues = isset($input['variables']) ? $input['variables'] : null;

try {
    // $rootValue = ['prefix' => 'You said: '];
    $rootValue = [
        'usuario' => function($root, $args, $context, $info) {
            $usuario = new Usuario();
            $usuario->setNome("aqui tem um teste");
            $usuario->setEmail("aqui tem um email");
            return $usuario;
        },
        'echo' => function($root, $args, $context, $info) {
            return "aqui tem um echooo";
        },
        'adicionarUsuario' => function ($root, $args, $context, $info) {
            $usuario = new Usuario();
            $usuario->setNome("aqui tem um teste");
            $usuario->setEmail("aqui tem um email");
            return $usuario;
        }
    ];

    $result = GraphQL::executeQuery($schema, $query, $rootValue, null,
        $variableValues);

    if ($result->errors) {
        $output = [
            'errors' => [
                [
                    'message' => $result->errors
                ]
            ]
    ];
    } else {
        $output = $result->toArray();
    }
} catch (Exception $e) {
    $output = [
        'errors' => [
            [
                'message' => $e->getMessage()
            ]
        ]
    ];
} 

header('Content-Type: application/json');
echo json_encode($output);

By default, schema which was created by using BuildSchema::build() was created without any resolvers. So we need to define our custom resolvers as follows:

$contents = file_get_contents($this->projectDir.'/config/schema.graphql');
$typeConfigDecorator = function($typeConfig, $typeDefinitionNode) {
    $name = $typeConfig['name'];
    if ($name === 'Query') {
       $typeConfig['resolveField'] =
           function ($source, $args, $context, ResolveInfo $info) {
               if ($info->fieldDefinition->name == 'login') {
                   if ($args['userName'] === 'test' && $args['password'] === '1234') {
                       return "Valid User.";
                   } else {
                       return "Invalid User";
                   }
               } elseif ($info->fieldDefinition->name == 'validateUser') {
                   if ($args['age'] < 18) {
                       return ['userId' => $args['userId'], 'category' => 'Not eligible for voting'];
                    } 
                    }
                }
                }
            ;
        }
        return $typeConfig;
    };
$schema = BuildSchema::build($contents, $typeConfigDecorator);

The above example I have added resolvers for my two queries namely ‘login’ and ‘validateUser.’

No need to define any root values and defaultFieldResolver. Our custom resolvers are enough.