Update to webonyx/graphql-php 0.13 and PHP 7.1+

Author: spawnia

.travis.yml

@@ -1,7 +1,6 @@
 language: php
 
 php:
-- 7.0
 - 7.1
 - 7.2
 

README.md

@@ -64,9 +64,17 @@ use MLL\GraphQLScalars\Regex;
 // The name is implicitly set through the class name here
 class HexValue extends Regex
 {
-    public $description = 'A hexadecimal color is specified with: #RRGGBB, where RR (red), GG (green) and BB (blue) are hexadecimal integers between 00 and FF specifying the intensity of the color.';
-    
-    protected function regex() : string
+    /**
+     * The description that is used for schema introspection.
+     *
+     * @var string
+     */
+    public $description = <<<'DESCRIPTION'
+A hexadecimal color is specified with: #RRGGBB, where RR (red), GG (green) and BB (blue)
+are hexadecimal integers between 00 and FF specifying the intensity of the color.
+DESCRIPTION;
+
+    public static function regex() : string
     {
         return '/^#?([a-f0-9]{6}|[a-f0-9]{3})$/';
     }
@@ -75,7 +83,7 @@ class HexValue extends Regex
 
 ### [StringScalar](StringScalar.php)
 
-The `StringScalar` encapsulate all the boilerplate associated with creating a string-based Scalar type.
+The `StringScalar` encapsulates all the boilerplate associated with creating a string-based Scalar type.
 It does the proper string checking for you and let's you focus on the minimal logic that is specific to your use case.
 
 All you have to specify is a function that checks if the given string is valid. Use the factory method

composer.json

@@ -11,14 +11,14 @@
     }
   ],
   "require": {
-    "php": ">=7.0",
-    "webonyx/graphql-php": "^0.12.6",
+    "php": ">=7.1",
+    "webonyx/graphql-php": "^0.13",
     "spatie/regex": "^1.3",
     "egulias/email-validator": "^2.1"
   },
   "require-dev": {
     "ext-json": "*",
-    "phpunit/phpunit": "^6|^7.3",
+    "phpunit/phpunit": "^7.3",
     "psy/psysh": "^0.9.8"
   },
   "autoload": {

src/Email.php

@@ -9,7 +9,11 @@
 
 class Email extends StringScalar
 {
-    /** @var string */
+    /**
+     * The description that is used for schema introspection.
+     *
+     * @var string
+     */
     public $description = 'A RFC 5321 compliant email.';
 
     /**

src/Mixed.php

@@ -10,12 +10,16 @@
 
 class Mixed extends ScalarType
 {
-    /** @var string */
-    public $description = <<<'EOT'
+    /**
+     * The description that is used for schema introspection.
+     *
+     * @var string
+     */
+    public $description = <<<'DESCRIPTION'
 Loose type that allows any value. Be careful when passing in large Int or Float literals,
 as they may not be parsed correctly on the server side. Use String literals if you are
 dealing with really large numbers to be on the safe side.
-EOT;
+DESCRIPTION;
 
     /**
      * Serializes an internal value to include in a response.
@@ -46,16 +50,16 @@ public function parseValue($value)
     /**
      * Parses an externally provided literal value (hardcoded in GraphQL query) to use as an input.
      *
-     * In the case of an invalid node or value this method must throw an Exception
+     * In the case of an invalid node or value, this method must throw an Exception.
      *
      * @param ValueNode $valueNode
-     * @param array|null $variables
+     * @param \mixed[]|null $variables
      *
      * @throws \Exception
      *
      * @return \mixed
      */
-    public function parseLiteral($valueNode, array $variables = null)
+    public function parseLiteral($valueNode, ?array $variables = null)
     {
         return AST::valueFromASTUntyped($valueNode);
     }

src/Regex.php

@@ -20,12 +20,18 @@ abstract class Regex extends ScalarType
      * @param string|null $description A description for the type.
      * @param string $regex The regular expression that is validated against.
      *
-     * @return Regex
+     * @return static
      */
-    public static function make(string $name, string $description = null, string $regex): self
+    public static function make(string $name, ?string $description = null, string $regex): self
     {
-        $regexClass = new class() extends Regex {
-            /** @var string Is set dynamically during this class creation. */
+        $concreteRegex = new class() extends Regex {
+            /**
+             * The regex that values are validated against.
+             *
+             * Is set dynamically during this class creation.
+             *
+             * @var string
+             */
             public static $regex;
 
             /**
@@ -41,11 +47,11 @@ public static function regex(): string
             }
         };
 
-        $regexClass->name = $name;
-        $regexClass->description = $description;
-        $regexClass::$regex = $regex;
+        $concreteRegex->name = $name;
+        $concreteRegex->description = $description;
+        $concreteRegex::$regex = $regex;
 
-        return $regexClass;
+        return $concreteRegex;
     }
 
     /**
@@ -64,7 +70,7 @@ abstract public static function regex(): string;
      */
     public function serialize($value): string
     {
-        $stringValue = assertString($value, InvariantViolation::class);
+        $stringValue = coerceToString($value, InvariantViolation::class);
 
         if (!static::matchesRegex($stringValue)) {
             throw new InvariantViolation(
@@ -76,6 +82,8 @@ public function serialize($value): string
     }
 
     /**
+     * Determine if the given string matches the regex defined in this class.
+     *
      * @param string $value
      *
      * @return bool
@@ -99,7 +107,7 @@ protected static function matchesRegex(string $value): bool
      */
     public function parseValue($value): string
     {
-        $stringValue = assertString($value, Error::class);
+        $stringValue = coerceToString($value, Error::class);
 
         if (!static::matchesRegex($stringValue)) {
             throw new Error(
@@ -114,15 +122,15 @@ public function parseValue($value): string
      * Parses an externally provided literal value (hardcoded in GraphQL query) to use as an input.
      *
      * @param Node $valueNode
-     * @param array $variables
+     * @param mixed[]|null $variables
      *
      * @throws Error
      *
      * @return string
      */
-    public function parseLiteral($valueNode, array $variables = null): string
+    public function parseLiteral($valueNode, ?array $variables = null): string
     {
-        $value = assertStringLiteral($valueNode);
+        $value = extractStringFromLiteral($valueNode);
 
         if (!static::matchesRegex($value)) {
             throw new Error(
@@ -135,6 +143,8 @@ public function parseLiteral($valueNode, array $variables = null): string
     }
 
     /**
+     * Construct the error message that occurs when the given string does not match the regex.
+     *
      * @param string $value
      *
      * @return string

src/StringScalar.php

@@ -13,15 +13,17 @@
 abstract class StringScalar extends ScalarType
 {
     /**
+     * Instantiate an anonymous subclass that can be used in a schema.
+     *
      * @param string $name The name that the scalar type will have in the schema.
      * @param string|null $description A description for the type.
      * @param callable $isValid A function that returns a boolean whether a given string is valid.
      *
-     * @return StringScalar
+     * @return static
      */
-    public static function make(string $name, string $description = null, callable $isValid): self
+    public static function make(string $name, ?string $description = null, callable $isValid): self
     {
-        $instance = new class() extends StringScalar {
+        $concreteStringScalar = new class() extends StringScalar {
             /**
              * Check if the given string is a valid email.
              *
@@ -35,15 +37,15 @@ protected function isValid(string $stringValue): bool
             }
         };
 
-        $instance->name = $name;
-        $instance->description = $description;
-        $instance->isValid = $isValid;
+        $concreteStringScalar->name = $name;
+        $concreteStringScalar->description = $description;
+        $concreteStringScalar->isValid = $isValid;
 
-        return $instance;
+        return $concreteStringScalar;
     }
 
     /**
-     * Check if the given string is a valid email.
+     * Check if the given string is valid.
      *
      * @param string $stringValue
      *
@@ -54,13 +56,15 @@ abstract protected function isValid(string $stringValue): bool;
     /**
      * Serializes an internal value to include in a response.
      *
-     * @param string $value
+     * @param mixed $value
+     *
+     * @throws InvariantViolation
      *
      * @return string
      */
     public function serialize($value): string
     {
-        $stringValue = assertString($value, InvariantViolation::class);
+        $stringValue = coerceToString($value, InvariantViolation::class);
 
         if (!$this->isValid($stringValue)) {
             throw new InvariantViolation(
@@ -72,6 +76,8 @@ public function serialize($value): string
     }
 
     /**
+     * Construct an error message that occurs when an invalid string is passed.
+     *
      * @param string $stringValue
      *
      * @return string
@@ -94,7 +100,7 @@ public function invalidStringMessage(string $stringValue): string
      */
     public function parseValue($value): string
     {
-        $stringValue = assertString($value, Error::class);
+        $stringValue = coerceToString($value, Error::class);
 
         if (!$this->isValid($stringValue)) {
             throw new Error(
@@ -114,15 +120,15 @@ public function parseValue($value): string
      * }
      *
      * @param Node $valueNode
-     * @param array $variables
+     * @param mixed[]|null $variables
      *
      * @throws Error
      *
      * @return string
      */
-    public function parseLiteral($valueNode, array $variables = null): string
+    public function parseLiteral($valueNode, ?array $variables = null): string
     {
-        $stringValue = assertStringLiteral($valueNode);
+        $stringValue = extractStringFromLiteral($valueNode);
 
         if (!$this->isValid($stringValue)) {
             throw new Error(

src/utils.php

@@ -11,7 +11,7 @@
 /**
  * Check if a value can be serialized to a string.
  *
- * @param $value
+ * @param mixed $value
  *
  * @return bool
  */
@@ -23,35 +23,43 @@ function canBeString($value): bool
 }
 
 /**
- * @param $valueNode
+ * Get the underlying string from a GraphQL literal and throw if Literal is not a string.
+ *
+ * @param mixed $valueNode
  *
  * @throws Error
  *
  * @return string
  */
-function assertStringLiteral($valueNode): string
+function extractStringFromLiteral($valueNode): string
 {
     if (!$valueNode instanceof StringValueNode) {
-        throw new Error("Query error: Can only parse strings got: {$valueNode->kind}", [$valueNode]);
+        throw new Error(
+            "Query error: Can only parse strings got: {$valueNode->kind}", [$valueNode]
+        );
     }
 
     return $valueNode->value;
 }
 
 /**
- * Ensure the value is a string and throw an exception if not.
+ * Convert the value to a string and throw an exception if it is not possible.
  *
- * @param $value
+ * @param mixed $value
  * @param string $exceptionClass
  *
+ * @throws <$exceptionClass>
+ *
  * @return string
  */
-function assertString($value, string $exceptionClass): string
+function coerceToString($value, string $exceptionClass): string
 {
     if (!canBeString($value)) {
         $safeValue = Utils::printSafeJson($value);
 
-        throw new $exceptionClass("The given value {$safeValue} can not be serialized.");
+        throw new $exceptionClass(
+            "The given value {$safeValue} can not be serialized."
+        );
     }
 
     return strval($value);