Строим взаимодействие систем на PHP с помощью GraphQL

			<?php
require_once realpath('../vendor/autoload.php');
use GraphQLTypeSchema;
use NLMKGraphQLAppTypeTypes;
try {
    $rawInput = file_get_contents('php://input');
    $input = json_decode($rawInput, true);
    $query = $input['query'];
  //формируем схему
    $schema = new Schema([
        'query' => Types::query() //определили класс для query запросов
    ]);
  //Выполняем сформированный запрос $query к нашей схеме $schema через GraphQL
  $result = GraphQL::executeQuery($schema, $query);
    $arException = $result->toArray()['errors'] ?: [];
} catch (Throwable $e) {
    $result = [
        'error' => [
            'message' => $e->getMessage()
        ]
    ];
    $arException = [
        'message' => $e->getMessage(),
        'code' => $e->getCode(),
        'file' => $e->getFile(),
        'line' => $e->getLine(),
        'trace' => $e->getTraceAsString(),
    ];
}
header('Content-Type: application/json; charset=UTF-8');
echo json_encode($result);
		

			<?php
//файл AppTypeQueryType.php
namespace NLMKGraphQLAppType;
use GraphQLTypeDefinitionObjectType;
use NLMKGraphQLAppEntityNews;
/**
 * Class QueryType
 *
 * Тип Query для GraphQL
 *
 * @package NLMKGraphQLAppType
 */
class QueryType extends ObjectType
{
    /**
     * QueryType constructor.
     */
    public function __construct()
    {
        $config = [
            'fields' => function () {
                return [
                    'news' => [
                        'type' => Types::listOf(Types::news()), // новый тип - новость, возвращаем в виде списка
                        'args' => [
                            'id' => Types::int(), //аргумент для отбора элементов из БД
                        ],
                        'resolve' => function ($root, $args, $context, $info) {
                            return News::get($args); //Реализуем класс сущности "Новость" и метод для получения данных из таблицы "news"
                        }
                    ]
                ];
            }
        ];
        parent::__construct($config);
    }
}
		

			<?php
//файл AppTypeNewsType.php
namespace NLMKGraphQLAppType;
use GraphQLTypeDefinitionObjectType;
/**
 * Class NewsType
 *
 * Тип News для GraphQL
 *
 * @package NLMKGraphQLAppType
 */
class NewsType extends ObjectType
{
    /**
     * NewsType constructor.
     */
    public function __construct()
    {
        $config = [ //описываем допустимые поля запроса для нового типа данных news
            'fields' => function () {
                return [
                    'id' => [
                        'type' => Types::int(),
                    ],
                    'name' => [
                        'type' => Types::string(),
                    ],
                    'text' => [
                        'type' => Types::string(),
                    ],
                    'create_date' => [
                        'type' => Types::string(),
                    ],
                    'rubric' => [
                        'type' => Types::int(),
                    ],
                    'publish_date' => [
                        'type' => Types::string(),
                    ],
                    'preview_text' => [
                        'type' => Types::string(),
                    ],
                    'author' => [
                        'type' => Types::int(),
                    ],
                ];
            }
        ];
        parent::__construct($config);
    }
}
		

			<?php
//файл AppEntityNews.php
namespace NLMKGraphQLAppEntity;
use NLMKGraphQLAppDBConnectDB;
/**
 * Класс для работы с сущностью Новость
 *
 * Class News
 * @package NLMKGraphQLAppEntity
 */
class News
{
    /**
     * Запрос на получение значений из таблицы news
     * с фильтром по id
     *
     * @param $args
     * @return mixed
     */
    public static function get($args)
    {
        $DB = new ConnectDB();
        return $DB->query("SELECT * from news WHERE id = {$args['id']}");
    }
}
		

			<?php
//файл AppTypeQueryType.php
namespace NLMKGraphQLAppType;
use GraphQLTypeDefinitionObjectType;
use NLMKGraphQLAppEntityNews;
use NLMKGraphQLAppEntityRubric;
/**
 * Class QueryType
 *
 * Тип Query для GraphQL
 *
 * @package NLMKGraphQLAppType
 */
class QueryType extends ObjectType
{
    /**
     * QueryType constructor.
     */
    public function __construct()
    {
        $config = [
            'fields' => function () {
                return [
                    'news' => [
                        'type' => Types::listOf(Types::news()),
                        'args' => [
                            'id' => Types::int(),
                        ],
                        'resolve' => function ($root, $args, $context, $info) {
                            return News::get($args);
                        }
                    ],
                    'rubric' => [ //Добавили еще один запрос
                        'type' => Types::rubric(), // Создаем новый составной тип данных - рубрика
                        'args' => [
                            'id' => Types::int(), // Добавили аргумент, по которому мы можем получить рубрику
                        ],
                        'resolve' => function ($root, $args, $context, $info) {
                            return Rubric::get($args); // Добавляем метод get для получения результата запроса
                        }
                    ]
                ];
            }
        ];
        parent::__construct($config);
    }
}
		

			<?php
//файл AppTypeTypes.php
namespace NLMKGraphQLAppType;
use GraphQLTypeDefinitionType;
class Types extends Type
{
    private static $query;
    private static $news;
    private static $rubric;
    public static function query()
    {
        return self::$query ?: (self::$query = new QueryType());
    }
    public static function news()
    {
        return self::$news ?: (self::$news = new NewsType());
    }
    public static function rubric() // Зарегистрировали новый тип
    {
        return self::$rubric ?: (self::$rubric = new RubricType()); // new RubricType() - необходимо описать поля этого типа
    }
}
		

			<?php
//файл AppTypeRubricType.php
namespace NLMKGraphQLAppType;
use GraphQLTypeDefinitionObjectType;
/**
 * Class RubricType
 *
 * Тип Rubric для GraphQL
 *
 * @package NLMKGraphQLAppType
 */
class RubricType extends ObjectType
{
    /**
     * RubricType constructor.
     */
    public function __construct()
    {
        $config = [
            'fields' => function () {
                return [ //описали поля таблицы и указали их типы
                    'id' => [
                        'type' => Types::int(),
                    ],
                    'name' => [
                        'type' => Types::string(),
                    ],
                    'code' => [
                        'type' => Types::string(),
                    ],
                ];
            }
        ];
        parent::__construct($config);
    }
}
		

			<?php
//файл AppEntityRubric.php
namespace NLMKGraphQLAppType;
use NLMKGraphQLAppDBConnectDB;
class Rubric
{
    /**
     * Метод возвращает результат из таблицы рубрик
     *
     * @param $args
     * @return mixed
     */
    public static function get($args)
    {
        $DB = new ConnectDB();
        return $DB->query("SELECT * from rubrics WHERE id = {$args['id']}")[0];
    }
}
		

			<?php
//файл AppTypeNewsType.php
namespace NLMKGraphQLAppType;
use GraphQLTypeDefinitionObjectType;
use NLMKGraphQLAppEntityRubric;
/**
 * Class NewsType
 *
 * Тип News для GraphQL
 *
 * @package NLMKGraphQLAppType
 */
class NewsType extends ObjectType
{
    /**
     * NewsType constructor.
     */
    public function __construct()
    {
        $config = [
            'fields' => function () {
                return [
                    'id' => [
                        'type' => Types::int(),
                    ],
                    'name' => [
                        'type' => Types::string(),
                    ],
                    'text' => [
                        'type' => Types::string(),
                    ],
                    'create_date' => [
                        'type' => Types::string(),
                    ],
                    'rubric' => [  //описали вложенный запрос на получение рубрики новости
                        'type' => Types::rubric(),
                        'resolve' => function ($root, $args, $context, $info) {
                            //передаем в метод параметры для отбора рубрик по родительским возвращаемым полям, согласно нашей схеме БД
                            return Rubric::get(['id' => $root['rubric']]);
                        }
                    ],
                    'publish_date' => [
                        'type' => Types::string(),
                    ],
                    'preview_text' => [
                        'type' => Types::string(),
                    ],
                    'author' => [
                        'type' => Types::int(),
                    ],
                ];
            }
        ];
        parent::__construct($config);
    }
}
		

			//файл graphqlindex.php
try {
    $rawInput = file_get_contents('php://input');
    $input = json_decode($rawInput, true);
    $query = $input['query'];
    $schema = new Schema([
        'query' => Types::query(),
        'mutation' => Types::mutation() // добавим возможность обрабатывать запросы на изменение
    ]);
    $result = GraphQL::executeQuery($schema, $query);
    $arException = $result->toArray()['errors'] ?: [];
} catch (Throwable $e) {
		

			//файл AppTypeTypes.php

private static $mutation;
public static function mutation() //Зарегистрировали новый тип данных
{
     return self::$mutation ?: (self::$mutation = new MutationType());
}
		

			<?php
//файл AppTypeMutationType.php
namespace NLMKGraphQLAppType;
use GraphQLTypeDefinitionObjectType;
use NLMKGraphQLAppEntityComments;

/**
 * Class MutationType
 *
 * Тип Mutation для GraphQL
 *
 * @package NLMKGraphQLAppType
 */
class MutationType extends ObjectType
{
    /**
     * MutationType constructor.
     */
    public function __construct()
    {
        $config = [
            'fields' => function () {
                return [
                    'add_comment' => [
                        'type' => Types::comments(), //необходимо зарегистрировать тип и описать поля
                        'args' => [
                            'news_id' => Types::int(),
                            'text' => Types::string(),
                            'author' => Types::int(),
                            'date_create' => Types::string(),
                        ],
                        'resolve' => function ($root, $args, $context, $info) {
                            return Comments::set($args); // Реализуем метод Comments::set для добавления комментария
                        }
                    ]
                ];
            }
        ];
        parent::__construct($config);
    }
}
		

			//файл AppTypeTypes.php
private static $comment;
public static function comments()
{
    return self::$comment ?: (self::$comment = new CommentType());
}
		

			<?php
//файл AppTypeCommentType.php
namespace NLMKGraphQLAppType;
use GraphQLTypeDefinitionObjectType;
/**
 * Class CommentType
 *
 * Тип comment для GraphQL
 *
 * @package NLMKGraphQLAppType
 */
class CommentType extends ObjectType
{
    /**
     * CommentType constructor.
     */
    public function __construct()
    {
        $config = [
            'fields' => function () {
                return [
                    'id' => [
                        'type' => Types::int(),
                    ],
                    'text' => [
                        'type' => Types::string(),
                    ],
                    'date_create' => [
                        'type' => Types::string(),
                    ],
                    'source_id' => [
                        'type' => Types::int(),
                    ],
                    'author' => [
                        'type' => Types::int(),
                    ]
                ];
            }
        ];
        parent::__construct($config);
    }
}
		

			<?php
//файл AppEntityComments.php
namespace NLMKGraphQLAppEntity;
use NLMKGraphQLAppDBConnectDB;
/**
 * Class Comments
 * @package NLMKGraphQLAppEntity
 */
class Comments
{
    /**
     * @param $args
     * @return mixed
     */
    public static function set($args)
    {
        $DB = new ConnectDB();
        $newCommentID = $DB->query("INSERT INTO comments (TEXT, AUTHOR, DATE_CREATE, SOURCE_ID) VALUES
            ('{$args['text']}', {$args['author']}, '{$args['date_create']}', {$args['news_id']})", false, true); //добавили новый комментарий и вернули его ID
        return $DB->query("SELECT * from comments WHERE id = {$newCommentID}")[0]; //возвращаем поля добавленного комментария
    }
}
		

			<?php
//файл AppTypeCommentInputType.php
namespace NLMKGraphQLAppType;
use GraphQLTypeDefinitionInputObjectType;
/**
 * Класс для входящих аргументов сущности "Комментарий"
 *
 * Class CommentInputType
 * @package NLMKGraphQLAppType
 */
class CommentInputType extends InputObjectType
{
    /**
     * CommentInputType constructor.
     */
    public function __construct()
    {
        $config = [
            'description' => 'Добавление комментария',
            'fields' => function() {
                return [
                    'news_id' => [
                        'type' => Types::int(),
                        'description' => 'ID новости' //ключи "description" можно не добавлять
                    ],
                    'text' => [
                        'type' => Types::string(),
                        'description' => 'Комментарий пользователя'
                    ],
                    'author' => [
                        'type' => Types::int(),
                        'description' => 'ID пользователя'
                    ],
                    'date_create' => [
                        'type' => Types::string(),
                        'description' => 'Datetime добавления комментария'
                    ]
                ];
            }
        ];
        parent::__construct($config);
    }
}
		

			<?php
//файл AppTypeTypes.php
private static $commentInput;
public static function commentInput() //Зарегистрировали новый тип вида Input
{
    return self::$commentInput ?: (self::$commentInput = new CommentInputType());
}
		

			<?php
//файл AppTypeMutationType.php
namespace NLMKGraphQLAppType;
use GraphQLTypeDefinitionObjectType;
use NLMKGraphQLAppEntityComments;
/**
 * Class MutationType
 *
 * Тип Mutation для GraphQL
 *
 * @package NLMKGraphQLAppType
 */
class MutationType extends ObjectType
{
    /**
     * MutationType constructor.
     */
    public function __construct()
    {
        $config = [
            'fields' => function () {
                return [
                    'add_comment' => [
                        'type' => Types::comments(),
                        'args' => [
                            'comment' => Types::commentInput() //Добавили тип вида Input
                        ],
                        'resolve' => function ($root, $args, $context, $info) {
                            return Comments::set($args['comment']); //передали аргументы
                        }
                    ]
                ];
            }
        ];
        parent::__construct($config);
    }
}