Merge pull request #11 from kettasoft/refactor/engines-clause-refactor

Refactor Engines to rely on ClauseFactory/Clause

Author: kettasoft

config/filterable.php

@@ -214,6 +214,16 @@
             */
             'strict' => true,
 
+            /*
+            |--------------------------------------------------------------------------
+            | Egnore empty values
+            |--------------------------------------------------------------------------
+            |
+            | If 'true' filters with null or empty string values will be ignored.
+            |
+            */
+            'ignore_empty_values' => false,
+
             /*
             |--------------------------------------------------------------------------
             | Allowed Fields

src/Engines/Expression.php

@@ -2,17 +2,20 @@
 
 namespace Kettasoft\Filterable\Engines;
 
+use Kettasoft\Filterable\Support\Payload;
 use Kettasoft\Filterable\Traits\FieldNormalizer;
 use Illuminate\Contracts\Database\Eloquent\Builder;
 use Kettasoft\Filterable\Engines\Foundation\Clause;
 use Kettasoft\Filterable\Engines\Foundation\Engine;
 use Kettasoft\Filterable\Support\ConditionNormalizer;
 use Kettasoft\Filterable\Support\ValidateTableColumns;
 use Kettasoft\Filterable\Engines\Foundation\ClauseApplier;
+use Kettasoft\Filterable\Engines\Foundation\ClauseFactory;
 use Kettasoft\Filterable\Engines\Foundation\Enums\Operators;
 use Kettasoft\Filterable\Engines\Foundation\Appliers\Applier;
 use Kettasoft\Filterable\Exceptions\InvalidOperatorException;
 use Kettasoft\Filterable\Exceptions\NotAllowedFieldException;
+use Kettasoft\Filterable\Engines\Foundation\Parsers\Dissector;
 
 class Expression extends Engine
 {
@@ -36,20 +39,16 @@ public function execute(Builder $builder)
       // Normalize the condition to [ operator => value ].
       $condition = ConditionNormalizer::normalize($condition, $this->defaultOperator());
 
-      $clause = Clause::make($this->getResources(), $field, $condition)->strict($this->isStrict());
+      $dissector = Dissector::parse($condition, $this->defaultOperator());
 
-      if (! $clause->isAllowedField() && ! $clause->isRelational()) {
-        if ($this->isStrict()) {
-          throw new NotAllowedFieldException($field);
-        }
+      $clause = (new ClauseFactory($this))->make(
+        new Payload($field, $dissector->operator, $dissector->value, null)
+      );
 
+      if (! $clause->validated) {
         continue; // skip disallowed field
       }
 
-      if ($clause->isEmptyValue() && config('filterable.engines.expression.egnore_empty_values', false)) {
-        continue;
-      }
-
       return Applier::apply(new ClauseApplier($clause), $builder);
     }
 
@@ -94,6 +93,11 @@ public function defaultOperator(): string
     return config('filterable.engines.expression.default_operator', 'eq');
   }
 
+  public function isIgnoredEmptyValuesFromConfig(): bool
+  {
+    return config('filterable.engines.expression.ignore_empty_values', false);
+  }
+
   /**
    * Get engine name.
    * @return string

src/Engines/Foundation/Clause.php

@@ -6,20 +6,11 @@
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Contracts\Support\Jsonable;
 use Illuminate\Contracts\Support\Arrayable;
-use Kettasoft\Filterable\Foundation\Resources;
-use Kettasoft\Filterable\Engines\Foundation\Mapper;
-use Kettasoft\Filterable\Support\ValidateTableColumns;
 use Kettasoft\Filterable\Engines\Foundation\Parsers\Dissector;
-use Kettasoft\Filterable\Engines\Foundation\Mappers\OperatorMapper;
 use Kettasoft\Filterable\Engines\Foundation\Resolvers\RelationResolver;
 
 class Clause implements Arrayable, Jsonable
 {
-  /**
-   * Current registered engine.
-   * @var Resources
-   */
-  public Resources $resources;
 
   /**
    * Original field.
@@ -40,43 +31,33 @@ class Clause implements Arrayable, Jsonable
   public readonly string|null $value;
 
   /**
-   * Dissector instance.
-   * @var Dissector
-   */
-  public readonly Dissector $dissector;
-
-  /**
-   * Strict mode.
+   * Check if the clause is validated.
    * @var bool
    */
-  protected bool $strict = false;
+  public bool $validated = false;
 
   /**
    * Clause constructor.
    * @param \Kettasoft\Filterable\Foundation\Resources $resources
    * @param mixed $field
    * @param mixed $dissector
    */
-  public function __construct(Resources $resources, $field, $dissector)
+  public function __construct($field, $operator, $value)
   {
-    $this->resources = $resources;
     $this->field = $field;
-    $this->dissector = Dissector::parse($dissector, 'eq');
-
-    $this->operator = $this->dissector->operator;
-    $this->value = $this->dissector->value;
+    $this->operator = $operator;
+    $this->value = $value;
   }
 
   /**
    * Create Dissector instance.
-   * @param \Kettasoft\Filterable\Foundation\Resources $resources
    * @param mixed $field
    * @param mixed $dissector
    * @return Clause
    */
-  public static function make(Resources $resources, $field, $dissector)
+  public static function make($field, $operator, $value)
   {
-    return new self($resources, $field, $dissector);
+    return new self($field, $operator, $value);
   }
 
   /**
@@ -87,9 +68,10 @@ public function isRelational(): bool
     return is_string($this->field) && str_contains($this->field, '.');
   }
 
-  public function isEmptyValue(): bool
+  public function setStatus(bool $status)
   {
-    return empty($this->value) || is_null($this->value);
+    $this->validated = $status;
+    return $this;
   }
 
   /**
@@ -105,73 +87,22 @@ public function getOriginalField()
    */
   public function getValue()
   {
-    $sanitizers = $this->resources->sanitizers;
-
-    $value = $this->getOriginalValue();
-
-    if (count($sanitizers)) {
-      foreach ($sanitizers as $sanitizer) {
-        $value = $sanitizer->handle($this->getOriginalField(), $value);
-      }
-    }
-
-    return $value;
+    return $this->value;
   }
 
-  /**
-   * @inheritDoc
-   */
-  public function getOriginalValue()
+  public function relation($bag)
   {
-    return $this->dissector->value;
+    $instance = new RelationResolver($bag, $this->field);
+    return $instance;
   }
 
-  /**
-   * @inheritDoc
-   */
-  public function getOperator()
+  public function apply(Builder $builder)
   {
-    $instance = $this->resources->operators;
-
-    return Mapper::run(
-      OperatorMapper::init($instance, $this->strict),
-      $this->operator
+    return $builder->where(
+      $this->field,
+      $this->operator,
+      $this->value
     );
-    // return $instance->get($this->operator, $instance->get($instance->default));
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public function getDatabaseColumnName()
-  {
-    return $this->resources->fieldMap->get($this->field, $this->field);
-  }
-
-  /**
-   * Check if the field is allowed.
-   * @return bool
-   */
-  public function isAllowedField(): bool
-  {
-    return $this->resources->fields->has($this->field);
-  }
-
-  public function validateTableColumn()
-  {
-    // return ValidateTableColumns::validate($this->engine->getContext()->getBuilder(), $this->getDatabaseColumnName());
-  }
-
-  public function strict($enable = true): self
-  {
-    $this->strict = $enable;
-    return $this;
-  }
-
-  public function relation($bag)
-  {
-    $instance = new RelationResolver($bag, $this->field);
-    return $instance;
   }
 
   /**
@@ -180,9 +111,9 @@ public function relation($bag)
   public function toArray(): array
   {
     return [
-      'field' => $this->getDatabaseColumnName(),
-      'operator' => $this->getOperator(),
-      'value' => $this->getValue()
+      'field' => $this->field,
+      'operator' => $this->operator,
+      'value' => $this->value
     ];
   }
 

src/Engines/Foundation/ClauseApplier.php

@@ -20,9 +20,9 @@ public function __construct(protected Clause $clause) {}
    */
   public function apply(Builder $builder): Builder
   {
-    if (! $this->clause->isAllowedField() && ! $this->clause->isRelational()) {
-      return $builder;
-    }
+    // if ($this->clause->isRelational()) {
+    //   return $builder;
+    // }
 
     if ($this->clause->isRelational()) {
       return $this->applyRelational($builder);
@@ -38,11 +38,7 @@ public function apply(Builder $builder): Builder
    */
   protected function applyDirect(Builder $builder)
   {
-    return $builder->where(
-      $this->clause->getDatabaseColumnName(),
-      $this->clause->getOperator(),
-      $this->clause->getValue()
-    );
+    return $builder->where($this->clause->field, $this->clause->operator, $this->clause->value);
   }
 
   /**
@@ -52,9 +48,10 @@ protected function applyDirect(Builder $builder)
    */
   protected function applyRelational(Builder $builder)
   {
-    return $this->clause->relation($this->clause->resources->relations)->resolve(
-      $builder,
-      $this->clause
-    );
+    [$relation, $field] = explode('.', $this->clause->field, 2);
+
+    return $builder->whereHas($relation, function ($query) use ($field) {
+      $query->where($field, $this->clause->operator, $this->clause->value);
+    });
   }
 }