PHP code example of wedrix / watchtower

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

wedrix / watchtower example snippets

declare(strict_types=1);

use function Wedrix\Watchtower\Console;

$console = Console(
    entityManager: $entityManager,
    schemaFileDirectory: __DIR__.'/resources/graphql',
    schemaFileName: 'schema.graphql',
    pluginsDirectory: __DIR__.'/resources/graphql/plugins',
    scalarTypeDefinitionsDirectory: __DIR__.'/resources/graphql/scalar_type_definitions',
    cacheDirectory: __DIR__.'/var/cache',
);

match ($argv[1] ?? null) {
    'schema:generate' => $console->generateSchema(),
    'schema:update' => $console->updateSchema(),
    'cache:generate' => $console->generateCache(),
    default => fwrite(STDERR, "Usage: schema:generate | schema:update | cache:generate\n"),
};

declare(strict_types=1);

use GraphQL\Error\DebugFlag;

use function Wedrix\Watchtower\Executor;

$executor = Executor(
    entityManager: $entityManager,
    schemaFile: __DIR__.'/resources/graphql/schema.graphql',
    pluginsDirectory: __DIR__.'/resources/graphql/plugins',
    scalarTypeDefinitionsDirectory: __DIR__.'/resources/graphql/scalar_type_definitions',
    cacheDirectory: __DIR__.'/var/cache',
    optimize: false,
);

$input = json_decode(file_get_contents('php://input') ?: '{}', true, 512, JSON_THROW_ON_ERROR);

$result = $executor->executeQuery(
    source: $input['query'] ?? '',
    rootValue: [],
    contextValue: [
        'request' => $request,
        'currentUser' => $currentUser,
    ],
    variableValues: $input['variables'] ?? null,
    operationName: $input['operationName'] ?? null,
    validationRules: null,
);

header('Content-Type: application/json; charset=utf-8');
echo json_encode(
    $result->toArray(DebugFlag::INCLUDE_DEBUG_MESSAGE),
    JSON_THROW_ON_ERROR,
);

return [
    [
        '__typename' => 'BookSearchResult',
        'id' => '1',
        'title' => 'GraphQL Basics',
    ],
];

$cursor = base64_encode(json_encode([
    'title' => 'GraphQL Basics',
    'id' => 123,
], JSON_THROW_ON_ERROR));

$console->addFilterPlugin('Book', 'ids');
$console->addOrderingPlugin('Book', 'titleAsc');
$console->addSelectorPlugin('Book', 'summary');
$console->addResolverPlugin('Book', 'externalRating');
$console->addSearchResolverPlugin('Book');
$console->addNodeAuthorizorPlugin('Book');
$console->addRootNodeAuthorizorPlugin();
$console->addProjectionPlugin('Book');
$console->addConstraintPlugin('Book');
$console->addRootConstraintPlugin();
$console->addMutationPlugin('createBook');
$console->addSubscriptionPlugin('bookCreated');
$console->addResultAuthorizorPlugin('Book', false);
$console->addRootResultAuthorizorPlugin();

declare(strict_types=1);

namespace Wedrix\Watchtower\FilterPlugin;

use Wedrix\Watchtower\Resolver\Node;
use Wedrix\Watchtower\Resolver\QueryBuilder;

function apply_books_ids_filter(
    QueryBuilder $queryBuilder,
    Node $node
): void {
    $ids = $node->args()['queryParams']['filters']['ids'] ?? null;

    if ($ids === null || $ids === []) {
        return;
    }

    $rootAlias = $queryBuilder->rootAlias();
    $idsParameter = $queryBuilder->parameterName('ids');

    $queryBuilder
        ->andWhere("$rootAlias.id IN (:$idsParameter)")
        ->setParameter($idsParameter, $ids);
}

$rootAlias = $queryBuilder->rootAlias();
$authorJoin = "$rootAlias.author";
$authorAlias = $queryBuilder->joinAlias(
    $authorJoin,
    'bookAuthor'
);
$queryBuilder->joinOnce($authorJoin, $authorAlias);

$queryBuilder->andWhere("LOWER($authorAlias.name) LIKE :authorName");

$businessJoin = "$rootAlias.business";
$businessAlias = $queryBuilder->joinAlias(
    $businessJoin,
    'listingBusiness'
);
$queryBuilder->joinOnce($businessJoin, $businessAlias);

$sellerJoin = "$businessAlias.seller";
$sellerAlias = $queryBuilder->joinAlias(
    $sellerJoin,
    'listingBusinessSeller'
);
$queryBuilder->joinOnce($sellerJoin, $sellerAlias);

declare(strict_types=1);

namespace Wedrix\Watchtower\OrderingPlugin;

use Doctrine\DBAL\ParameterType;
use Wedrix\Watchtower\Resolver\Node;
use Wedrix\Watchtower\Resolver\QueryBuilder;

function apply_books_title_asc_ordering(
    QueryBuilder $queryBuilder,
    Node $node
): void {
    $rootAlias = $queryBuilder->rootAlias();
    $titleAlias = $queryBuilder->selectAlias('titleOrder');
    $idAlias = $queryBuilder->selectAlias('idOrder');

    $queryBuilder
        ->addSelect("LOWER($rootAlias.title) AS HIDDEN $titleAlias")
        ->addSelect("$rootAlias.id AS HIDDEN $idAlias")
        ->addOrderBy($titleAlias, 'ASC')
        ->addOrderBy($idAlias, 'ASC');

    $queryBuilder->registerCursorOrdering('title', "LOWER($rootAlias.title)", 'ASC', ParameterType::STRING);
    $queryBuilder->registerCursorOrdering('id', "$rootAlias.id", 'ASC', ParameterType::INTEGER);
}

function apply_book_summary_selector(
    QueryBuilder $queryBuilder,
    Node $node
): void {
    $rootAlias = $queryBuilder->rootAlias();

    $queryBuilder->addSelect("CONCAT($rootAlias.title, ' #', $rootAlias.id) AS summary");
}

function resolve_book_external_rating_field(Node $node): mixed
{
    return $node->context()['ratings']->forBook($node->root()['id']);
}

use function Wedrix\Watchtower\Resolver\EntityManager;
use function Wedrix\Watchtower\Resolver\HydrationQuery;

function resolve_books_search(Node $node): mixed
{
    $ids = $node->context()['search']->bookIds(
        (string) ($node->args()['queryParams']['search'] ?? ''),
    );

    if ($ids === []) {
        return [];
    }

    $query = HydrationQuery(
        node: $node,
        entityManager: EntityManager($node->context()['entityManager']),
        plugins: $node->context()['watchtowerPlugins']
    );

    if (! $query->isWorkable()) {
        return [];
    }

    $queryBuilder = $query->builder();
    $rootAlias = $queryBuilder->rootAlias();

    $rows = $queryBuilder
        ->andWhere("$rootAlias.id IN (:searchIds)")
        ->setParameter('searchIds', $ids)
        ->getQuery()
        ->getArrayResult();

    $rowsById = array_column($rows, null, 'id');

    return array_values(array_filter(array_map(
        static fn ($id) => $rowsById[$id] ?? null,
        $ids
    )));
}

function call_create_book_mutation(Node $node): mixed
{
    $book = $node->context()['bookService']->create($node->args()['input']);

    return [
        'id' => $book->id(),
        'title' => $book->title(),
    ];
}

function apply_book_constraint(QueryBuilder $queryBuilder, Node $node): void
{
    $rootAlias = $queryBuilder->rootAlias();
    $tenantIdParameter = $queryBuilder->parameterName('tenantId');

    $queryBuilder
        ->andWhere("$rootAlias.tenant = :$tenantIdParameter")
        ->setParameter($tenantIdParameter, $node->context()['tenantId']);
}

function authorize_book_node(Node $node): void
{
    if (
        $node->isACollection()
        && $node->context()['currentUser']->isGuest()
        && (($node->args()['queryParams']['filters']['public'] ?? null) !== true)
    ) {
        throw new \RuntimeException('A public-only filter is 

function project_book(QueryBuilder $queryBuilder, Node $node): void
{
    $rootAlias = $queryBuilder->rootAlias();
    $queryBuilder->addSelect("$rootAlias.public AS authorizationPublic");
}

function authorize_book_result(Result $result, Node $node): void
{
    if (! $node->context()['currentUser']->canViewBooks()) {
        throw new \RuntimeException('Unauthorized.');
    }
}

$console->addScalarTypeDefinition('Money');

declare(strict_types=1);

namespace Wedrix\Watchtower\MoneyTypeDefinition;

use GraphQL\Language\AST\Node;
use GraphQL\Language\AST\StringValueNode;

function serialize(mixed $value): string
{
    return (string) $value;
}

function parseValue(string $value): mixed
{
    return $value;
}

function parseLiteral(Node $value, ?array $variables = null): mixed
{
    if (! $value instanceof StringValueNode) {
        throw new \InvalidArgumentException('Money must be a string.');
    }

    return parseValue($value->value);
}

$executor = Executor(
    entityManager: $entityManager,
    schemaFile: __DIR__.'/resources/graphql/schema.graphql',
    pluginsDirectory: __DIR__.'/resources/graphql/plugins',
    scalarTypeDefinitionsDirectory: __DIR__.'/resources/graphql/scalar_type_definitions',
    cacheDirectory: __DIR__.'/var/cache',
    optimize: true,
);

bash
php bin/watchtower schema:generate

bash
php bin/watchtower cache:generate