Automate filter input type creation (#2861)

Developers currently need to manually specify input types in our GraphQL
schema file, requiring field names and column mappings to be duplicated.
While it's merely a nuisance at the moment, this approach will be
completely inadequate once we introduce the ability to filter by
relationship existence. This PR cleans up the developer experience by
automatically generating filter input types and guessing the input type
needed for a filter directive in most cases. That means all developers
need to do is add `@filterable` and `@filter` directives to fields and
everything just works. Pretty neat!

An additional benefit of autogenerating everything is that validation
can be added automatically as well. That means that users will now see a
validation error when trying to create an invalid filter like this:
```graphql
filters: {
    eq: {
        id: "123",
        name: "foo",
    },
}
```
This validation improvement resolves the issues remaining after
#2860.

Author: williamjallen

app/GraphQL/Directives/FilterDirective.php

@@ -16,6 +16,7 @@
 use Illuminate\Database\Eloquent\Relations\Relation;
 use Illuminate\Database\Query\Builder;
 use Illuminate\Database\Query\Builder as QueryBuilder;
+use Illuminate\Support\Str;
 use InvalidArgumentException;
 use JsonException;
 use Nuwave\Lighthouse\Schema\AST\ASTHelper;
@@ -31,7 +32,7 @@ public static function definition(): string
         return /* @lang GraphQL */ <<<'GRAPHQL'
                 directive @filter(
                     "Input type to filter on.  This should be of the form: <...>FilterInput"
-                    inputType: String!
+                    inputType: String
                 ) on ARGUMENT_DEFINITION
             GRAPHQL;
     }
@@ -49,7 +50,9 @@ public function manipulateArgDefinition(
         $multiFilterName = ASTHelper::qualifiedArgType($argDefinition, $parentField, $parentType) . 'MultiFilterInput';
         $argDefinition->type = Parser::namedType($multiFilterName);
 
-        $documentAST->setTypeDefinition($this->createMultiFilterInput($multiFilterName, $this->directiveArgValue('inputType')));
+        $defaultFilterType = Str::replaceEnd('Connection', '', $parentField->type->type->name->value) . 'FilterInput';
+        $inputType = $this->directiveArgValue('inputType', $defaultFilterType);
+        $documentAST->setTypeDefinition($this->createMultiFilterInput($multiFilterName, $inputType));
     }
 
     /**

app/GraphQL/Directives/FilterableDirective.php

@@ -0,0 +1,86 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\GraphQL\Directives;
+
+use GraphQL\Error\SyntaxError;
+use GraphQL\Language\AST\FieldDefinitionNode;
+use GraphQL\Language\AST\InterfaceTypeDefinitionNode;
+use GraphQL\Language\AST\ObjectTypeDefinitionNode;
+use GraphQL\Language\Parser;
+use JsonException;
+use Nuwave\Lighthouse\Schema\AST\DocumentAST;
+use Nuwave\Lighthouse\Schema\Directives\BaseDirective;
+use Nuwave\Lighthouse\Support\Contracts\FieldManipulator;
+
+final class FilterableDirective extends BaseDirective implements FieldManipulator
+{
+    public static function definition(): string
+    {
+        return /* @lang GraphQL */ <<<'GRAPHQL'
+                directive @filterable on FIELD_DEFINITION
+            GRAPHQL;
+    }
+
+    /**
+     * @throws JsonException
+     * @throws SyntaxError
+     */
+    public function manipulateFieldDefinition(
+        DocumentAST &$documentAST,
+        FieldDefinitionNode &$fieldDefinition,
+        ObjectTypeDefinitionNode|InterfaceTypeDefinitionNode &$parentType,
+    ): void {
+        $typeName = $parentType->name->value . 'FilterInput';
+
+        // We only have to do this once per type, even though this is called once per filterable directive
+        if (!array_key_exists($typeName, $documentAST->types)) {
+            $inputTypeString = "input {$typeName} {" . PHP_EOL;
+
+            $allFieldNames = [];
+            foreach ($parentType->fields as $field) {
+                $allFieldNames[] = $field->name->value;
+            }
+
+            $filterableFields = [];
+            foreach ($parentType->fields as $field) {
+                foreach ($field->directives as $directive) {
+                    if ($directive->name->value === 'filterable') {
+                        $filterableFields[] = $field;
+                        break;
+                    }
+                }
+            }
+
+            foreach ($filterableFields as $field) {
+                $name = $field->name->value;
+                $type = $field->type->name->value ?? $field->type->type->name->value;
+                $description = $field->description?->value;
+
+                // Only allow one field at a time.
+                $fieldsToExclude = array_filter($allFieldNames, fn ($value): bool => $value !== $name);
+                $validationDirective = '@rules(apply: ["prohibits:' . implode(',', $fieldsToExclude) . '"])';
+
+                // The @rename directive is commonly used, so we handle it explicitly.  In the future, we may
+                // want a more generalized approach which applies any directives which are also valid input directives.
+                $renameDirective = '';
+                foreach ($field->directives as $directive) {
+                    if ($directive->name->value === 'rename') {
+                        $renameDirective = '@rename(attribute: "' . $directive->arguments[0]->value->value . '")';
+                        break;
+                    }
+                }
+
+                if ($description !== null) {
+                    $inputTypeString .= '"""' . PHP_EOL . $description . PHP_EOL . '"""' . PHP_EOL;
+                }
+                $inputTypeString .= "{$name}: $type $validationDirective $renameDirective" . PHP_EOL;
+            }
+
+            $inputTypeString .= '}';
+
+            $documentAST->setTypeDefinition(Parser::inputObjectTypeDefinition($inputTypeString));
+        }
+    }
+}