where field exists alias

Author: pdphilip

src/Eloquent/Docs/ModelDocs.php

@@ -83,10 +83,14 @@
  * @method static $this orWhereNestedObject($column, $query, $filterInnerHits = false, $options = [])
  * @method static $this orWhereNotNestedObject($column, $query, $filterInnerHits = false, $options = [])
  *-----------------------------------
- * @method static $this whereTermExists($column, $boolean = 'and', $not = false)
- * @method static $this whereNotTermExists($column)
- * @method static $this orWhereTermExists($column)
- * @method static $this orWhereNotTermsExists($column)
+ * @method static $this whereFieldExists($column, $boolean = 'and', $not = false)
+ * @method static $this whereFieldDoesntExist($column)
+ * @method static $this orWhereFieldExists($column)
+ * @method static $this orWhereFieldDoesntExist($column)
+ * @method static $this whereTermExists($column, $boolean = 'and', $not = false) @deprecated use whereFieldExists
+ * @method static $this whereNotTermExists($column) @deprecated use whereFieldDoesntExist
+ * @method static $this orWhereTermExists($column) @deprecated use orWhereFieldExists
+ * @method static $this orWhereNotTermsExists($column) @deprecated use orWhereFieldDoesntExist
  *-----------------------------------
  * @method static $this whereRaw($dsl, $bindings = [], $boolean = 'and', $options = [])
  *===========================================

src/Query/Concerns/BuildsFieldQueries.php

@@ -81,11 +81,19 @@ public function orWhereNotExact($column, $value, $options = []): self
     }
 
     // ----------------------------------------------------------------------
-    // Term Exists Query - check if a field has an indexed value
+    // Exists Query - check if a field has an indexed value
     // https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-exists-query.html
+    //
+    // Named whereFieldExists (not whereExists) to avoid colliding with
+    // Laravel's base Builder::whereExists(Closure $callback) — the SQL
+    // EXISTS subquery clause, which has entirely different semantics.
+    //
+    // Works on top-level fields and on nested-mapped fields: the compiler
+    // auto-wraps the exists clause in a nested query when the field's path
+    // is mapped as nested.
     // ----------------------------------------------------------------------
 
-    public function whereTermExists($column, $boolean = 'and', $not = false): self
+    public function whereFieldExists($column, $boolean = 'and', $not = false): self
     {
         $this->wheres[] = [
             'type' => 'Basic',
@@ -99,19 +107,52 @@ public function whereTermExists($column, $boolean = 'and', $not = false): self
         return $this;
     }
 
-    public function whereNotTermExists($column)
+    public function whereFieldDoesntExist($column): self
+    {
+        return $this->whereFieldExists($column, 'and', true);
+    }
+
+    public function orWhereFieldExists($column): self
+    {
+        return $this->whereFieldExists($column, 'or', false);
+    }
+
+    public function orWhereFieldDoesntExist($column): self
+    {
+        return $this->whereFieldExists($column, 'or', true);
+    }
+
+    /**
+     * @deprecated Use whereFieldExists() instead. Will be removed in v6.
+     */
+    public function whereTermExists($column, $boolean = 'and', $not = false): self
+    {
+        return $this->whereFieldExists($column, $boolean, $not);
+    }
+
+    /**
+     * @deprecated Use whereFieldDoesntExist() instead. Will be removed in v6.
+     */
+    public function whereNotTermExists($column): self
     {
-        return $this->whereTermExists($column, 'and', true);
+        return $this->whereFieldExists($column, 'and', true);
     }
 
-    public function orWhereTermExists($column)
+    /**
+     * @deprecated Use orWhereFieldExists() instead. Will be removed in v6.
+     */
+    public function orWhereTermExists($column): self
     {
-        return $this->whereTermExists($column, 'or', false);
+        return $this->whereFieldExists($column, 'or', false);
     }
 
-    public function orWhereNotTermsExists($column)
+    /**
+     * @deprecated Use orWhereFieldDoesntExist() instead. Will be removed in v6.
+     *             Note: the original method name had a typo ("Terms" plural).
+     */
+    public function orWhereNotTermsExists($column): self
     {
-        return $this->whereTermExists($column, 'or', true);
+        return $this->whereFieldExists($column, 'or', true);
     }
 
     // ----------------------------------------------------------------------

src/Query/Grammar/Concerns/CompilesWheres.php

@@ -118,6 +118,16 @@ protected function compileWhereBasic(Builder $builder, array $where): array
 
         if (is_null($value) || $where['operator'] == 'exists') {
             $query = DslFactory::exists($field, $options);
+
+            // Auto-wrap in nested when the field lives under a nested path
+            // and we're not already inside a parent-field (nested closure) context.
+            $insideNestedContext = ! empty($builder->options()->get('parentField'));
+            if (! $insideNestedContext) {
+                $nestedPath = $this->getNestedPath($field, $builder);
+                if ($nestedPath) {
+                    $query = DslFactory::nested($nestedPath, ['query' => $query]);
+                }
+            }
         } elseif (in_array($where['operator'], ['like', 'not like'])) {
             $field = $this->getIndexableField($field, $builder);
             $wildcardValue = str_replace('%', '*', $value);

tests/QueryElasticsearchSpecificTest.php

@@ -192,6 +192,66 @@
     Post::whereNestedObject('comments', 12345);
 })->throws(\PDPhilip\Elasticsearch\Exceptions\BuilderException::class);
 
+it('whereFieldExists matches users with the field set', function () {
+    expect(User::whereFieldExists('title')->count())->toBe(8);
+});
+
+it('whereFieldDoesntExist matches users with the field missing', function () {
+    expect(User::whereFieldDoesntExist('title')->count())->toBe(1);
+});
+
+it('whereFieldExists is parity with deprecated whereTermExists', function () {
+    $new = User::whereFieldExists('title')->get()->pluck('name')->sort()->values()->all();
+    $old = User::whereTermExists('title')->get()->pluck('name')->sort()->values()->all();
+    expect($new)->toBe($old);
+});
+
+it('whereFieldExists auto-wraps in nested for nested-mapped fields', function () {
+    $dsl = Post::whereFieldExists('comments.country')->toDsl();
+
+    $clause = $dsl['body']['query'];
+    expect($clause)->toHaveKey('nested')
+        ->and($clause['nested']['path'])->toBe('comments')
+        ->and($clause['nested']['query'])->toBe(['exists' => ['field' => 'comments.country']]);
+});
+
+it('whereFieldExists returns posts when nested field exists', function () {
+    expect(Post::whereFieldExists('comments.country')->count())->toBe(4);
+});
+
+it('whereFieldExists does not wrap when already inside a nested closure', function () {
+    $dsl = Post::whereNestedObject('comments', function ($q) {
+        $q->whereFieldExists('country');
+    })->toDsl();
+
+    $nested = $dsl['body']['query']['nested'];
+    expect($nested['path'])->toBe('comments')
+        ->and($nested['query'])->toBe(['exists' => ['field' => 'comments.country']]);
+});
+
+it('whereFieldExists leaves top-level fields unwrapped', function () {
+    $dsl = Post::whereFieldExists('title')->toDsl();
+    expect($dsl['body']['query'])->toBe(['exists' => ['field' => 'title']]);
+});
+
+it('whereNotNull on a nested field auto-wraps in nested', function () {
+    $dsl = Post::whereNotNull('comments.country')->toDsl();
+
+    $clause = $dsl['body']['query'];
+    expect($clause)->toHaveKey('nested')
+        ->and($clause['nested']['path'])->toBe('comments')
+        ->and($clause['nested']['query'])->toBe(['exists' => ['field' => 'comments.country']]);
+});
+
+it('whereNull on a nested field wraps nested inside must_not', function () {
+    $dsl = Post::whereNull('comments.country')->toDsl();
+
+    $mustNot = $dsl['body']['query']['bool']['must_not'][0];
+    expect($mustNot)->toHaveKey('nested')
+        ->and($mustNot['nested']['path'])->toBe('comments')
+        ->and($mustNot['nested']['query'])->toBe(['exists' => ['field' => 'comments.country']]);
+});
+
 it('can search with field boosting', function () {
     $users = User::search('John', 'best_fields', ['name' => 5, 'description' => 1])->get();
     expect($users)->toHaveCount(2)