Fully implement Regex scalar and tests

Author: spawnia

README.md

@@ -17,3 +17,38 @@ A collection of custom scalar types for usage with https://github.com/webonyx/gr
 
 You can use the provided Scalars just like any other type in your schema definition.
 Check [SchemaUsageTest](tests/SchemaUsageTest.php) for an example. 
+
+### The Regex Scalar
+
+The `Regex` class allows you to define a custom scalar that validates that the given
+value matches a regular expression.
+
+The quickest way to define a custom scalar is the `make` factory method. Just provide
+a name and a regular expression and you will receive a ready-to-use custom regex scalar.
+
+```php
+<?php
+
+use MLL\GraphQLScalars\Regex;
+
+$hexValue = Regex::make('HexValue', '/^#?([a-f0-9]{6}|[a-f0-9]{3})$/');
+
+$hexValue instanceof \GraphQL\Type\Definition\ScalarType; // true
+```
+
+You may also define your regex scalar as a class.
+
+```php
+<?php
+
+use MLL\GraphQLScalars\Regex;
+
+// The name is implicitly set through the class name here
+class HexValue extends Regex
+{
+    protected function regex() : string
+    {
+        return '/^#?([a-f0-9]{6}|[a-f0-9]{3})$/';
+    }
+}
+```

composer.json

@@ -1,15 +1,17 @@
 {
   "name": "mll-lab/graphql-php-scalars",
   "description": "A collection of custom scalar types for usage with https://github.com/webonyx/graphql-php",
-  "license": "MIT",
+  "type": "library",
   "keywords": ["graphql", "php"],
+  "license": "MIT",
   "authors": [
     {
       "name": "Benedikt Franke",
       "email": "[email protected]"
     }
   ],
   "require": {
+    "php": ">=7.0",
     "webonyx/graphql-php": "^0.12.6",
     "spatie/regex": "^1.3"
   },
@@ -24,6 +26,11 @@
       "MLL\\GraphQLScalars\\": "src"
     }
   },
+  "autoload-dev": {
+    "psr-4": {
+      "Tests\\": "tests/"
+    }
+  },
   "scripts": {
     "test": "phpunit"
   }

src/Regex.php

@@ -4,26 +4,66 @@
 
 namespace MLL\GraphQLScalars;
 
+use GraphQL\Error\Error;
 use GraphQL\Error\InvariantViolation;
 use GraphQL\Language\AST\Node;
+use GraphQL\Language\AST\StringValueNode;
 use GraphQL\Type\Definition\ScalarType;
+use GraphQL\Utils\Utils;
 use Spatie\Regex\Regex as RegexValidator;
 
 abstract class Regex extends ScalarType
 {
+    /**
+     * Return the Regex that the values are validated against.
+     *
+     * @return string
+     */
+    abstract protected function regex(): string;
+    
+    /**
+     * This factory method allows you to create a Regex scalar in a one-liner.
+     *
+     * @param string $name
+     * @param string $regex
+     *
+     * @return Regex
+     */
+    public static function make(string $name, string $regex): Regex
+    {
+        $regexClass = new class() extends Regex {
+            /**
+             * Return the Regex that the values are validated against.
+             *
+             * Must be a valid
+             *
+             * @return string
+             */
+            protected function regex(): string
+            {
+                return $this->regex;
+            }
+        };
+        
+        $regexClass->name = $name;
+        $regexClass->regex = $regex;
+        
+        return $regexClass;
+    }
+    
     /**
      * Serializes an internal value to include in a response.
      *
-     * @param string $value
+     * @param mixed $value
      *
      * @return string
      */
     public function serialize($value): string
     {
         if (!canBeString($value)) {
-            $valueClass = get_class($value);
+            $safeValue = Utils::printSafe($value);
 
-            throw new InvariantViolation("The given value of class $valueClass can not be serialized.");
+            throw new InvariantViolation("The given value {$safeValue} can not be serialized.");
         }
 
         $stringValue = strval($value);
@@ -34,21 +74,34 @@ public function serialize($value): string
 
         return $stringValue;
     }
-
+    
     /**
      * Parses an externally provided value (query variable) to use as an input.
      *
      * @param mixed $value
      *
+     * @throws Error
+     *
      * @return mixed
      */
-    public function parseValue($value)
+    public function parseValue($value): string
     {
-        // TODO implement validation
+        if (!canBeString($value)) {
+            $safeValue = Utils::printSafe($value);
+        
+            throw new Error("The given value {$safeValue} can not be serialized.");
+        }
+    
+        $stringValue = strval($value);
+    
+        if(!$this->matchesRegex($stringValue)){
+            $safeValue = Utils::printSafeJson($stringValue);
+            throw new Error("The given value {$safeValue} did not match the regex {$this->regex()}");
+        }
 
         return $value;
     }
-
+    
     /**
      * Parses an externally provided literal value (hardcoded in GraphQL query) to use as an input.
      *
@@ -60,13 +113,24 @@ public function parseValue($value)
      * @param Node $valueNode
      * @param array $variables
      *
-     * @return mixed
+     * @throws Error
+     *
+     * @return string
      */
-    public function parseLiteral($valueNode, array $variables = null)
+    public function parseLiteral($valueNode, array $variables = null): string
     {
-        // TODO implement validation
-
-        return $valueNode->value;
+        if (!$valueNode instanceof StringValueNode) {
+            throw new Error("Query error: Can only parse strings got: {$valueNode->kind}", [$valueNode]);
+        }
+    
+        $value = $valueNode->value;
+        
+        if(!$this->matchesRegex($value)){
+            $safeValue = Utils::printSafeJson($value);
+            throw new Error("The given value {$safeValue} did not match the regex {$this->regex()}", [$valueNode]);
+        }
+    
+        return $value;
     }
 
     /**
@@ -81,13 +145,4 @@ protected function matchesRegex(string $value): bool
             $value
         )->hasMatch();
     }
-
-    /**
-     * Return the Regex that the values are validated against.
-     *
-     * Must be a valid
-     *
-     * @return string
-     */
-    abstract protected function regex(): string;
 }

tests/Foo.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Tests;
+
+use MLL\GraphQLScalars\Regex;
+
+class Foo extends Regex
+{
+    /**
+     * Return the Regex that the values are validated against.
+     *
+     * Must be a valid
+     *
+     * @return string
+     */
+    protected function regex(): string
+    {
+        return '/foo/';
+    }
+}