- Fixed DBExprFilter: validator and validationResultHandler are only taken into account if key exists

rkrx · rkrx · commit 8ee3daba6f53 · 2021-07-21T16:49:51.000+02:00
- Limit and Offset can now take a parameter of Type OptionalValue, which can make both optional
diff --git a/composer.json b/composer.json
@@ -15,7 +15,7 @@
 		"psr/log": "~1"
 	},
 	"require-dev": {
-		"phpunit/phpunit": "~6",
+		"phpunit/phpunit": ">= 6.0",
 		"phpstan/phpstan": "*@stable"
 	},
 	"autoload": {
diff --git a/src/Builder/Expr/DBExprFilter.php b/src/Builder/Expr/DBExprFilter.php
@@ -1,11 +1,14 @@
 <?php
 namespace Kir\MySQL\Builder\Expr;
 
+use Kir\MySQL\Builder\Helpers\RecursiveStructureAccess;
 use RuntimeException;
 
 class DBExprFilter implements OptionalExpression {
 	/** @var mixed */
 	private $expression;
+	/** @var bool */
+	private $hasValue;
 	/** @var mixed */
 	private $value;
 	/** @var string[] */
@@ -24,21 +27,18 @@ class DBExprFilter implements OptionalExpression {
 	 */
 	public function __construct($expression, array $data, $keyPath, $validator = null, $validationResultHandler = null) {
 		$this->expression = $expression;
-		$this->value = $data;
 		$this->keyPath = $this->buildKey($keyPath);
-		$this->value = $this->recursiveGet($data, $this->keyPath, null);
+		$this->hasValue = RecursiveStructureAccess::recursiveHas($data, $this->keyPath);
+		$this->value = RecursiveStructureAccess::recursiveGet($data, $this->keyPath, null);
 		if($validator === null) {
-			$validator = function ($data) {
-				if(is_array($data)) {
-					return $this->isValidArray($data);
-				}
-				return (string) $data !== '';
+			$validator = function() {
+				return true;
 			};
 		}
+		$this->validator = $validator;
 		if($validationResultHandler === null) {
 			$validationResultHandler = static function () {};
 		}
-		$this->validator = $validator;
 		$this->validationResultHandler = $validationResultHandler;
 	}
 
@@ -53,6 +53,9 @@ public function getExpression() {
 	 * @return bool
 	 */
 	public function isValid() {
+		if(!$this->hasValue) {
+			return false;
+		}
 		$result = call_user_func($this->validator, $this->value);
 		call_user_func($this->validationResultHandler, $result, [
 			'value' => $this->value,
@@ -95,25 +98,4 @@ private function isValidArray(array $array) {
 		});
 		return count($data) > 0;
 	}
-
-	/**
-	 * @param array $array
-	 * @param array $path
-	 * @param mixed $default
-	 * @return array
-	 */
-	private function recursiveGet($array, $path, $default) {
-		$count = count($path);
-		if (!$count) {
-			return $default;
-		}
-		foreach($path as $idxValue) {
-			$part = $idxValue;
-			if(!array_key_exists($part, $array)) {
-				return $default;
-			}
-			$array = $array[$part];
-		}
-		return $array;
-	}
 }
diff --git a/src/Builder/Expr/RequiredDBFilterMap.php b/src/Builder/Expr/RequiredDBFilterMap.php
@@ -1,6 +1,8 @@
 <?php
 namespace Kir\MySQL\Builder\Expr;
 
+use Kir\MySQL\Builder\Helpers\RecursiveStructureAccess;
+
 class RequiredDBFilterMap {
 	/** @var array */
 	private $map;
@@ -34,10 +36,9 @@ protected function getMap(): array {
 	 * @return DBExprFilter
 	 */
 	public function __invoke($expression, $keyPath, $validator = null) {
-		return new DBExprFilter($expression, $this->map, $keyPath, $validator, static function ($result, array $data) {
-			if(!$result) {
-				throw new RequiredValueNotFoundException(sprintf("Required value %s not found", $data['key']));
-			}
-		});
+		if(!RecursiveStructureAccess::recursiveHas($this->map, $keyPath)) {
+			throw new RequiredValueNotFoundException(sprintf("Required value %s not found", json_encode($keyPath, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE)));
+		}
+		return new DBExprFilter($expression, $this->map, $keyPath, $validator);
 	}
 }
diff --git a/src/Builder/Helpers/RecursiveStructureAccess.php b/src/Builder/Helpers/RecursiveStructureAccess.php
@@ -0,0 +1,87 @@
+<?php
+
+namespace Kir\MySQL\Builder\Helpers;
+
+use ArrayObject;
+
+class RecursiveStructureAccess {
+	/**
+	 * @param object|array<string, mixed> $structure
+	 * @param string|array<int, string> $path
+	 * @return bool
+	 */
+	public static function recursiveHas($structure, $path): bool {
+		$arrayPath = self::getArrayPath($path);
+		return self::_recursiveHas($structure, $arrayPath);
+	}
+
+	/**
+	 * @param object|array<string, mixed> $structure
+	 * @param string|array<int, string> $path
+	 * @param mixed $default
+	 * @return mixed
+	 */
+	public static function recursiveGet($structure, $path, $default) {
+		$arrayPath = self::getArrayPath($path);
+		$data = self::ensureArrayIsArray($structure);
+		$count = count($arrayPath ?? []);
+		if (!$count) {
+			return $default;
+		}
+		foreach($arrayPath as $idxValue) {
+			$part = $idxValue;
+			if(!array_key_exists($part, $data)) {
+				return $default;
+			}
+			$data = $data[$part];
+		}
+		return $data;
+	}
+
+	/**
+	 * @param mixed $structure
+	 * @param array<int, string> $path
+	 * @return bool
+	 */
+	private static function _recursiveHas($structure, array $path): bool {
+		$data = self::ensureArrayIsArray($structure);
+		if($data === null) {
+			return false;
+		}
+		if(!count($path)) {
+			return false;
+		}
+		$key = array_shift($path);
+		if(count($path)) {
+			return self::_recursiveHas($data[$key] ?? null, $path);
+		}
+		return array_key_exists($key, $data);
+	}
+
+	/**
+	 * @param string|array<int, string> $path
+	 * @return array<int, string>
+	 */
+	private static function getArrayPath($path): array {
+		if(is_array($path)) {
+			return $path;
+		}
+		return preg_split('{(?<!\\x5C)(?:\\x5C\\x5C)*\\.}', $path);
+	}
+
+	/**
+	 * @param mixed $array
+	 */
+	private static function ensureArrayIsArray($array): ?array {
+		if($array instanceof ArrayObject) {
+			return $array->getArrayCopy();
+		}
+		if(is_object($array)) {
+			return (array) $array;
+		}
+		if(is_array($array)) {
+			return $array;
+		}
+		return null;
+	}
+}
diff --git a/src/Builder/InvalidValueException.php b/src/Builder/InvalidValueException.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace Kir\MySQL\Builder;
+
+class InvalidValueException extends Exception {
+
+}
diff --git a/src/Builder/Traits/LimitBuilder.php b/src/Builder/Traits/LimitBuilder.php
@@ -1,19 +1,25 @@
 <?php
 namespace Kir\MySQL\Builder\Traits;
 
+use Kir\MySQL\Builder\InvalidValueException;
+use Kir\MySQL\Builder\Value\OptionalValue;
+
 trait LimitBuilder {
-	/** @var int|null */
+	/** @var null|int|OptionalValue */
 	private $limit;
 
 	/**
-	 * @return int|null
+	 * @return null|int
 	 */
 	protected function getLimit() {
+		if($this->limit instanceof OptionalValue) {
+			return $this->limit->getValue();
+		}
 		return $this->limit;
 	}
 
 	/**
-	 * @param int|null $limit
+	 * @param null|int|OptionalValue $limit
 	 * @return $this
 	 */
 	public function limit($limit) {
@@ -27,11 +33,19 @@ public function limit($limit) {
 	 * @return string
 	 */
 	protected function buildLimit($query, $offset = null) {
-		$limit = $this->limit;
+		$limit = $this->getLimit();
 		if($limit === null && $offset !== null) {
 			$limit = '18446744073709551615';
 		}
-		if($limit !== null) {
+		if($this->limit instanceof OptionalValue) {
+			if($this->limit->isValid()) {
+				$value = $this->limit->getValue();
+				if(!preg_match('{\\d+}', $value)) {
+					throw new InvalidValueException('Value for LIMIT has to be a number');
+				}
+				$query .= "LIMIT\n\t{$this->limit->getValue()}\n";
+			}
+		} elseif($limit !== null) {
 			$query .= "LIMIT\n\t{$limit}\n";
 		}
 		return $query;
diff --git a/src/Builder/Traits/OffsetBuilder.php b/src/Builder/Traits/OffsetBuilder.php
@@ -1,22 +1,28 @@
 <?php
 namespace Kir\MySQL\Builder\Traits;
 
+use Kir\MySQL\Builder\InvalidValueException;
+use Kir\MySQL\Builder\Value\OptionalValue;
+
 trait OffsetBuilder {
-	/** @var int */
-	private $offset;
+	/** @var null|int|OptionalValue */
+	private $offset = null;
 
 	/**
-	 * @return int
+	 * @return null|int
 	 */
 	protected function getOffset() {
+		if($this->offset instanceof OptionalValue) {
+			return $this->offset->getValue();
+		}
 		return $this->offset;
 	}
 
 	/**
-	 * @param int $offset
+	 * @param null|int|OptionalValue $offset
 	 * @return $this
 	 */
-	public function offset($offset) {
+	public function offset($offset = 0) {
 		$this->offset = $offset;
 		return $this;
 	}
@@ -25,8 +31,17 @@ public function offset($offset) {
 	 * @param string $query
 	 * @return string
 	 */
-	protected function buildOffset($query) {
-		if($this->offset !== null) {
+	protected function buildOffset(string $query): string {
+		$offset = $this->getOffset();
+		if($this->offset instanceof OptionalValue) {
+			if($this->offset->isValid()) {
+				$value = $this->offset->getValue();
+				if(!preg_match('{\\d+}', $value)) {
+					throw new InvalidValueException('Value for OFFSET has to be a number');
+				}
+				$query .= "OFFSET\n\t{$this->offset->getValue()}\n";
+			}
+		} elseif($offset !== null) {
 			$query .= "OFFSET\n\t{$this->offset}\n";
 		}
 		return $query;
diff --git a/src/Builder/Value/DBOptionalValue.php b/src/Builder/Value/DBOptionalValue.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace Kir\MySQL\Builder\Value;
+
+use Kir\MySQL\Builder\Helpers\RecursiveStructureAccess;
+
+class DBOptionalValue implements OptionalValue {
+	private $data;
+	/** @var string|string[] */
+	private $path;
+	/** @var callable|null */
+	private $validator;
+
+	/**
+	 * @param object|array<string, mixed>
+	 * @param string|string[] $path
+	 * @param null|callable(): bool $validator
+	 */
+	public function __construct($data, $path, $validator = null) {
+		$this->data = $data;
+		$this->path = $path;
+		$this->validator = $validator;
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function isValid(): bool {
+		if(!RecursiveStructureAccess::recursiveHas($this->data, $this->path)) {
+			return false;
+		}
+		if($this->validator !== null) {
+			$value = $this->getValue();
+			return call_user_func($this->validator, $value);
+		}
+		return true;
+	}
+
+	/**
+	 * @return mixed|null
+	 */
+	public function getValue() {
+		return RecursiveStructureAccess::recursiveGet($this->data, $this->path, null);
+	}
+}
diff --git a/src/Builder/Value/OptionalValue.php b/src/Builder/Value/OptionalValue.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Kir\MySQL\Builder\Value;
+
+interface OptionalValue {
+	/**
+	 * @return bool If true, the Value is present
+	 */
+	public function isValid(): bool;
+
+	/**
+	 * @return mixed
+	 */
+	public function getValue();
+}
diff --git a/tests/Builder/Helpers/RecursiveStructureAccessTest.php b/tests/Builder/Helpers/RecursiveStructureAccessTest.php
diff --git a/tests/Builder/SelectTest.php b/tests/Builder/SelectTest.php

-Original file line number
+Diff line change
@@ @@ -0,0 +1,7 @@ @@
 +<?php
++
 +namespace Kir\MySQL\Builder;
++
 +class InvalidValueException extends Exception {
++
 +}