Filter object

src/Collection/Filter/Filter.php

@@ -0,0 +1,53 @@
+<?php declare(strict_types = 1);
+
+namespace Nextras\Orm\Collection\Filter;
+
+class Filter
+{
+
+ /** @var FindFilter */
+ private $find;
+
+ /** @var OrderFilter */
+ private $order;
+
+ /** @var int|null */
+ private $limitCount;
+
+ /** @var int|null */
+ private $limitOffset;
+
+ public function __construct()
+ {
+ $this->find = new FindFilter();
+ $this->order = new OrderFilter();
+ }
+
+ public function find(): FindFilter
+ {
+ return $this->find;
+ }
+
+ public function order(): OrderFilter
+ {
+ return $this->order;
+ }
+
+ public function limit(int $count, ?int $offset = null): void
+ {
+ $this->limitCount = $count;
+ $this->limitOffset = $offset;
+ }
+
+ /**
+ * @return array{int|null, int|null}
+ */
+ public function getLimit(): array
+ {
+ return [
+ $this->limitCount,
+ $this->limitOffset,
+ ];
+ }
+
+}

src/Collection/Filter/FindFilter.php

@@ -0,0 +1,179 @@
+<?php declare(strict_types = 1);
+
+namespace Nextras\Orm\Collection\Filter;
+
+use Closure;
+use Nextras\Orm\Collection\Expression\LikeExpression;
+use Nextras\Orm\Collection\Functions\IArrayFunction;
+use Nextras\Orm\Collection\Functions\IQueryBuilderFunction;
+use Nextras\Orm\Collection\ICollection;
+use function array_merge;
+use function array_unshift;
+use function count;
+
+class FindFilter
+{
+
+ /** @var array<mixed> */
+ private $conditions = [];
+
+ /** @var string */
+ private $logicalOperator;
+
+ public function __construct(string $logicalOperator = ICollection::AND)
+ {
+ $this->logicalOperator = $logicalOperator;
+ }
+
+ /**
+ * @param mixed $value
+ */
+ public function equal(string $property, $value): void
+ {
+ $this->operator('', $property, $value);
+ }
+
+ /**
+ * @param mixed $value
+ */
+ public function notEqual(string $property, $value): void
+ {
+ $this->operator('!=', $property, $value);
+ }
+
+ /**
+ * @param mixed $number
+ */
+ public function greater(string $property, $number): void
+ {
+ $this->operator('>', $property, $number);
+ }
+
+ /**
+ * @param mixed $number
+ */
+ public function greaterOrEqual(string $property, $number): void
+ {
+ $this->operator('>=', $property, $number);
+ }
+
+ /**
+ * @param mixed $number
+ */
+ public function lower(string $property, $number): void
+ {
+ $this->operator('<', $property, $number);
+ }
+
+ /**
+ * @param mixed $number
+ */
+ public function lowerOrEqual(string $property, $number): void
+ {
+ $this->operator('<=', $property, $number);
+ }
+
+ public function like(string $property, LikeExpression $expression): void
+ {
+ $this->operator('~', $property, $expression);
+ }
+
+ /**
+ * @param mixed $value
+ */
+ public function operator(string $operator, string $property, $value): void
+ {
+ $this->raw([
+ "{$property}{$operator}" => $value,
+ ]);
+ }
+
+ /**
+ * @param class-string<IArrayFunction|IQueryBuilderFunction> $function
+ * @param string|array<mixed> $expression
+ * @param mixed $values
+ */
+ public function function(string $function, $expression, ...$values): void
+ {
+ $this->raw($this->createFunction($function, $expression, ...$values));
+ }
+
+ /**
+ * @param class-string<IArrayFunction|IQueryBuilderFunction> $function
+ * @param string|array<mixed> $expression
+ * @param mixed $values
+ * @return array<mixed>
+ */
+ public function createFunction(string $function, $expression, ...$values): array
+ {
+ return array_merge([$function, $expression], $values);
+ }
+
+ /**
+ * @param array<mixed> $condition
+ */
+ public function raw(array $condition): void
+ {
+ $this->conditions[] = $condition;
+ }
+
+ /**
+ * @param Closure(FindFilter): void $conditions
+ */
+ public function and(Closure $conditions): void
+ {
+ $this->logicalOperator($conditions, ICollection::AND);
+ }
+
+ /**
+ * @param Closure(FindFilter): void $conditions
+ */
+ public function or(Closure $conditions): void
+ {
+ $this->logicalOperator($conditions, ICollection::OR);
+ }
+
+ /**
+ * @param Closure(FindFilter): void $conditions
+ */
+ private function logicalOperator(Closure $conditions, string $operator): void
+ {
+ $find = new FindFilter($operator);
+
+ $conditions($find);
+
+ $raw = $find->getConditions();
+
+ if ($raw === []) {
+ return;
+ }
+
+ $this->raw($raw);
+ }
+
+ /**
+ * @return array<mixed>
+ */
+ public function getConditions(): array
+ {
+ // No conditions, empty result
+ $count = count($this->conditions);
+ if ($count === 0) {
+ return [];
+ }
+
+ // Only condition is inner logical operator, optimize it
+ if ($count === 1) {
+ $key = $this->conditions[0][0] ?? null;
+ if ($key === ICollection::AND || $key === ICollection::OR) {
+ return $this->conditions[0];
+ }
+ }
+
+ $conditions = $this->conditions;
+ array_unshift($conditions, $this->logicalOperator);
+
+ return $conditions;
+ }
+
+}

src/Collection/Filter/OrderFilter.php

@@ -0,0 +1,61 @@
+<?php declare(strict_types = 1);
+
+namespace Nextras\Orm\Collection\Filter;
+
+use Nextras\Orm\Collection\Functions\IArrayFunction;
+use Nextras\Orm\Collection\Functions\IQueryBuilderFunction;
+use Nextras\Orm\Collection\ICollection;
+use function array_merge;
+
+class OrderFilter
+{
+
+ /** @var array<array{0:string|array<mixed>, 1:string}> */
+ private $order = [];
+
+ public function property(string $property, string $direction = ICollection::ASC): void
+ {
+ $this->raw($property, $direction);
+ }
+
+ /**
+ * @param class-string<IArrayFunction|IQueryBuilderFunction> $function
+ * @param string|array<mixed> $expression
+ * @param mixed $values
+ */
+ public function function(string $function, $expression, string $direction = ICollection::ASC, ...$values): void
+ {
+ $this->raw(
+ $this->createFunction($function, $expression, ...$values),
+ $direction,
+ );
+ }
+
+ /**
+ * @param class-string<IArrayFunction|IQueryBuilderFunction> $function
+ * @param string|array<mixed> $expression
+ * @param mixed $values
+ * @return array<mixed>
+ */
+ public function createFunction(string $function, $expression, ...$values): array
+ {
+ return array_merge([$function, $expression], $values);
+ }
+
+ /**
+ * @param string|array<mixed> $expression
+ */
+ public function raw($expression, string $direction = ICollection::ASC): void
+ {
+ $this->order[] = [$expression, $direction];
+ }
+
+ /**
+ * @return array<array{0:string|array<mixed>, 1:string}>
+ */
+ public function getOrder(): array
+ {
+ return $this->order;
+ }
+
+}

src/Repository/Repository.php

@@ -11,6 +11,8 @@
 
 
 use Nextras\Orm\Collection\ArrayCollection;
+use Nextras\Orm\Collection\Filter\Filter;
+use Nextras\Orm\Collection\Filter\FindFilter;
 use Nextras\Orm\Collection\Functions\AvgAggregateFunction;
 use Nextras\Orm\Collection\Functions\CompareEqualsFunction;
 use Nextras\Orm\Collection\Functions\CompareGreaterThanEqualsFunction;
@@ -249,6 +251,22 @@ public function getByIdChecked($id): IEntity
  }
 
 
+ public function getByFilter(FindFilter $find): ?IEntity
+ {
+ return $this->getBy($find->getConditions());
+ }
+
+
+ public function getByFilterChecked(FindFilter $find): IEntity
+ {
+ $entity = $this->getBy($find->getConditions());
+ if ($entity === null) {
+ throw new NoResultException();
+ }
+ return $entity;
+ }
+
+
  /** {@inheritdoc} */
  public function findAll(): ICollection
  {
@@ -278,6 +296,28 @@ public function findById($ids): ICollection
  }
 
 
+ /**
+ * @phpstan-return ICollection<E>
+ */
+ public function findByFilter(Filter $filter): ICollection
+ {
+ $conditions = $filter->find()->getConditions();
+ $collection = $conditions === [] ? $this->findAll() : $this->findBy($conditions);
+
+ $order = $filter->order()->getOrder();
+ foreach ($order as [$expression, $direction]) {
+ $collection = $collection->orderBy($expression, $direction);
+ }
+
+ [$limitCount, $limitOffset] = $filter->getLimit();
+ if ($limitCount !== null) {
+ $collection = $collection->limitBy($limitCount, $limitOffset);
+ }
+
+ return $collection;
+ }
+
+
  /** {@inheritdoc} */
  public function findByIds(array $ids): ICollection
  {
@@ -347,6 +387,12 @@ protected function createCollectionFunction(string $name)
  }
 
 
+ public function createFilter(): Filter
+ {
+ return new Filter();
+ }
+
+
  /** {@inheritdoc} */
  public function attach(IEntity $entity): void
  {