PHP code example of hmennen90 / laravel-graphql

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

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

    

hmennen90 / laravel-graphql example snippets

namespace App\GraphQL;

use App\Models\User;
use Hmennen90\GraphQL\Contracts\ProvidesSchema;
use Hmennen90\GraphQL\Engine\Schema\Schema;
use Hmennen90\GraphQL\Engine\Schema\SchemaConfig;
use Hmennen90\GraphQL\Engine\Type\Definition\Argument;
use Hmennen90\GraphQL\Engine\Type\Definition\FieldDefinition;
use Hmennen90\GraphQL\Engine\Type\Definition\ObjectType;
use Hmennen90\GraphQL\Engine\Type\Definition\Type;

final class AppSchema implements ProvidesSchema
{
    public function schema(): Schema
    {
        $user = new ObjectType('User', [
            FieldDefinition::make('id', Type::nonNull(Type::id())),
            FieldDefinition::make('name', Type::string()),
            FieldDefinition::make('email', Type::string()),
        ]);

        $query = new ObjectType('Query', [
            FieldDefinition::make(
                'user',
                $user,
                args: [Argument::make('id', Type::nonNull(Type::id()))],
                resolve: fn ($root, array $args) => User::find($args['id']),
            ),
        ]);

        return new Schema(new SchemaConfig(query: $query));
    }
}

'schema' => [
    'factory' => App\GraphQL\AppSchema::class,
],

use Hmennen90\GraphQL\Engine\Type\Definition\{Argument, EnumType, EnumValueDefinition,
    FieldDefinition, InterfaceType, ObjectType, Type, UnionType};

$status = new EnumType('Status', [
    new EnumValueDefinition('ACTIVE'),
    new EnumValueDefinition('ARCHIVED', deprecationReason: 'Use ACTIVE'),
]);

$user = new ObjectType('User', [
    FieldDefinition::make('id', Type::nonNull(Type::id())),
    FieldDefinition::make('name', Type::string()),
    FieldDefinition::make('status', Type::nonNull($status)),
    // Lists & non-null wrappers:
    FieldDefinition::make('tags', Type::listOf(Type::nonNull(Type::string()))),
]);

$node = null;
$node = new ObjectType('Node', fn (): array => [
    FieldDefinition::make('id', Type::nonNull(Type::id())),
    FieldDefinition::make('parent', $node),
]);

use Hmennen90\GraphQL\Engine\Building\SchemaFirst\SchemaBuilder;

$sdl = <<<'GRAPHQL'
type Query {
  user(id: ID!): User
}

type User {
  id: ID!
  name: String
}
GRAPHQL;

$schema = SchemaBuilder::fromSdl($sdl, resolvers: [
    'Query' => [
        'user' => fn ($root, array $args) => User::find($args['id']),
    ],
]);

use Hmennen90\GraphQL\Engine\Building\CodeFirst\Attributes\GraphQLField;
use Hmennen90\GraphQL\Engine\Building\CodeFirst\Attributes\GraphQLType;
use Hmennen90\GraphQL\Engine\Building\CodeFirst\AttributeSchemaBuilder;
use Hmennen90\GraphQL\Engine\Schema\Schema;
use Hmennen90\GraphQL\Engine\Schema\SchemaConfig;

#[GraphQLType(name: 'Query')]
final class QueryType
{
    #[GraphQLField(type: 'String!')]
    public function hello(): string
    {
        return 'world';
    }

    #[GraphQLField(type: '[User!]!')]
    public function users(): array
    {
        return User::all()->all();
    }
}

$types = (new AttributeSchemaBuilder())->build([QueryType::class]);
$schema = new Schema(new SchemaConfig(query: $types['Query']));

use Hmennen90\GraphQL\Attributes\{All, Paginate, Guard};

#[GraphQLType(name: 'Query')]
final class QueryType
{
    #[GraphQLField(type: '[User!]!')]
    #[All(model: User::class)]
    public function users(): array { return []; }

    #[GraphQLField(type: '[Post!]!')]
    #[Paginate(type: 'CONNECTION')]
    #[Guard]
    public function posts(): array { return []; }
}

use Hmennen90\GraphQL\Federation\Federation;

$subgraph = Federation::subgraph($schema, [
    'User' => [
        'model'   => \App\Models\User::class,
        'resolve' => fn (array $ref) => \App\Models\User::find($ref['id']),
    ],
]);

use Hmennen90\GraphQL\Generation\ModelTypeGenerator;
use Hmennen90\GraphQL\Generation\ValidationInputGenerator;
use Hmennen90\GraphQL\Generation\ResponseTypeGenerator;

// 1. Object type from an Eloquent model (primary key, fillable, casts, timestamps)
$userType = (new ModelTypeGenerator())->fromModel(\App\Models\User::class);
//   -> type User { id: ID!  name: String  active: Boolean  meta: JSON  created_at: String ... }

// 2. Input type from a FormRequest's validation rules ("e shape
$sample = (new \App\Http\Resources\UserResource($user))->toArray(request());
$userResourceType = (new ResponseTypeGenerator())->fromArray($sample, 'UserResource');

use Hmennen90\GraphQL\Engine\Schema\Schema;
use Hmennen90\GraphQL\Engine\Schema\SchemaConfig;
use Hmennen90\GraphQL\Engine\Type\Definition\{Argument, FieldDefinition, ObjectType, Type};

$query = new ObjectType('Query', [
    FieldDefinition::make('user', $userType,
        args: [Argument::make('id', Type::nonNull(Type::id()))],
        resolve: fn ($root, array $args) => \App\Models\User::find($args['id'])),
]);

$mutation = new ObjectType('Mutation', [
    FieldDefinition::make('createUser', $userType,
        args: [Argument::make('input', Type::nonNull($createUserInput))],
        resolve: fn ($root, array $args) => \App\Models\User::create($args['input'])),
]);

$schema = new Schema(new SchemaConfig(query: $query, mutation: $mutation, types: [$userResourceType]));

use Hmennen90\GraphQL\Engine\Executor\Executor;
use Hmennen90\GraphQL\Engine\Language\Parser;

$result = Executor::execute($schema, Parser::parse('{ user(id: "1") { id name } }'));

$result->toArray(); // ['data' => ['user' => ['id' => '1', 'name' => 'Ada']]]

use Hmennen90\GraphQL\Engine\Validation\DocumentValidator;

$errors = DocumentValidator::validate($schema, Parser::parse($query), [
    'maxDepth' => 10,
    'maxComplexity' => 100,
]);

use Hmennen90\GraphQL\Facades\GraphQL;

$result = GraphQL::execute('{ user(id: "1") { name } }');
$schema = GraphQL::schema();

use Hmennen90\GraphQL\Execution\Context;

FieldDefinition::make('secret', Type::string(), resolve: function ($root, array $args, $context) {
    if ($context instanceof Context) {
        $context->authorize('view-secret'); // throws AuthorizationError on deny
    }

    return 'classified';
});

use Hmennen90\GraphQL\Directives\CanDirective;

$schema = SchemaBuilder::fromSdl(<<<'GRAPHQL'
    directive @can(ability: String!) on FIELD_DEFINITION
    type Query {
      secret: String @can(ability: "view-secret")
    }
GRAPHQL, resolvers: [/* ... */], schemaDirectives: ['can' => new CanDirective()]);

FieldDefinition::make('register', $user, args: [
    Argument::make('email', Type::nonNull(Type::string())),
], resolve: function ($root, array $args) {
    validator($args, ['email' => '

use Hmennen90\GraphQL\Support\UploadType;

$upload = UploadType::make();

FieldDefinition::make('import', Type::string(), args: [
    Argument::make('file', Type::nonNull($upload)),
], resolve: fn ($root, array $args) => $args['file']->getClientOriginalName());

// config/graphql.php
'persisted_queries' => ['enabled' => true],

// config/graphql.php
'cache_control' => ['enabled' => true],

// config/graphql.php
'subscriptions' => ['enabled' => true],

use Hmennen90\GraphQL\Subscriptions\SubscriptionManager;

app(SubscriptionManager::class)->broadcast('postAdded', $post);

use Hmennen90\GraphQL\Engine\Executor\DataLoader;

$companies = new DataLoader(function (array $ids) {
    $byId = Company::findMany($ids)->keyBy('id');

    // must return one value per key, in the same order as $ids
    return array_map(fn ($id) => $byId->get($id), $ids);
});

FieldDefinition::make('company', $companyType,
    resolve: fn (array $user) => $companies->load($user['company_id']));

// config/graphql.php
'security' => [
    'max_depth' => 15,
    'max_complexity' => 200,
],

use Closure;
use Hmennen90\GraphQL\Engine\Executor\{DirectiveMiddleware, ResolveInfo};
use Hmennen90\GraphQL\Engine\Language\AST\DirectiveNode;

final class UpperDirective implements DirectiveMiddleware
{
    public function handle(DirectiveNode $node, ResolveInfo $info, Closure $resolve): mixed
    {
        $value = $resolve();

        return is_string($value) ? strtoupper($value) : $value;
    }
}

// register on the schema:
new SchemaConfig(query: $query, directiveMiddleware: ['upper' => new UpperDirective()]);

use Hmennen90\GraphQL\Support\Relay\Relay;

$connection = Relay::connectionType($userType);

FieldDefinition::make('users', $connection, args: [
    Argument::make('first', Type::int()),
    Argument::make('after', Type::string()),
], resolve: fn ($root, array $args) => Relay::connectionFromArray(User::all()->all(), $args));

bash
php artisan vendor:publish --tag=graphql-config

bash
php artisan graphql:subscriptions:serve --port=9501

bash
composer bench   # php benchmarks/run.php