improvement: add unrelated exists expressions

Author: zachdaniel

documentation/topics/reference/expressions.md

@@ -96,7 +96,7 @@ For elixir-backed data layers, they will be a function or an MFA that will be ca
 
 ## Sub-expressions
 
-- `exists/2` | `exists(foo.bar, name == "fred")` takes an expression scoped to the destination resource, and checks if any related entry matches. See the section on `exists` below.
+- `exists/2` | `exists(foo.bar, name == "fred")` takes an expression scoped to the destination resource, and checks if any related entry matches. Can also be used with resource modules for unrelated exists: `exists(SomeResource, name == "fred")`. See the section on `exists` below.
 - `path.exists/2` | Same as `exists` but the source of the relationship is itself a nested relationship. See the section on `exists` below.
 - `parent/1` | Allows an expression scoped to a resource to refer to the "outer" context. Used in relationship filters and `exists`
 
@@ -153,11 +153,12 @@ calculate :latest_report, :string,
     ]
   ))
 
-# Complex calculation with multiple unrelated aggregates
+# Complex calculation with multiple unrelated aggregates and exists
 calculate :stats, :map, expr(%{
   profile_count: count(Profile, filter: expr(name == parent(name))),
   total_score: sum(Report, field: :score, query: [filter: expr(author_name == parent(name))]),
-  has_active_profile: exists(Profile, filter: expr(active == true and name == parent(name)))
+  has_active_profile: exists(Profile, active == true and name == parent(name)),
+  has_recent_reports: exists(Report, author_name == parent(name) and inserted_at > ago(1, :week))
 })
 ```
 
@@ -268,6 +269,28 @@ Ash.Query.filter(Post, author.exists(roles, name == :admin) and author.active)
 
 While the above is not common, it can be useful in some specific circumstances, and is used under the hood by the policy authorizer when combining the filters of various resources to create a single filter.
 
+### Unrelated Exists
+
+Sometimes you want to check for the existence of records in any resource, not just through relationships. Unrelated exists allows you to query any resource directly:
+
+```elixir
+# Check if there are any profiles with the same name as the user
+Ash.Query.filter(User, exists(Profile, name == parent(name)))
+
+# Check if user has reports (without needing a relationship)
+Ash.Query.filter(User, exists(Report, author_name == parent(name)))
+
+# Check existence with complex conditions
+Ash.Query.filter(User, exists(Profile, active == true and age > 25))
+
+# Combine with other filters
+Ash.Query.filter(User, 
+  active == true and exists(Profile, name == parent(name))
+)
+```
+
+The `parent/1` function allows you to reference fields from the source resource within the exists expression. Authorization is automatically applied to unrelated exists expressions using the target resource's primary read action.
+
 ## Portability
 
 Ash expressions being portable is more important than it sounds. For example, if you were using AshPostgres and had the following calculation, which is an expression capable of being run in elixir or translated to SQL:

lib/ash/actions/read/read.ex

@@ -4686,16 +4686,61 @@ defmodule Ash.Actions.Read do
         {:ok,
          filter
          |> Ash.Filter.map(fn
-           %Ash.Query.Exists{at_path: at_path, path: exists_path, expr: exists_expr} = exists ->
-             {:ok, new_expr} =
-               do_filter_with_related(
-                 resource,
-                 exists_expr,
-                 path_filters,
-                 prefix ++ at_path ++ exists_path
-               )
-
-             {:halt, %{exists | expr: new_expr}}
+           %Ash.Query.Exists{
+             at_path: at_path,
+             path: exists_path,
+             expr: exists_expr,
+             unrelated?: unrelated?,
+             resource: unrelated_resource
+           } = exists ->
+             if unrelated? do
+               primary_read_action = Ash.Resource.Info.primary_action!(unrelated_resource, :read)
+               filter_key = {:unrelated_exists, unrelated_resource, primary_read_action.name}
+
+               case Map.get(path_filters, filter_key) do
+                 nil ->
+                   {:ok, new_expr} =
+                     do_filter_with_related(
+                       unrelated_resource,
+                       exists_expr,
+                       path_filters,
+                       []
+                     )
+
+                   {:halt, %{exists | expr: new_expr}}
+
+                 %Ash.Filter{expression: false} ->
+                   {:halt, false}
+
+                 auth_filter ->
+                   {:ok, new_expr} =
+                     do_filter_with_related(
+                       unrelated_resource,
+                       exists_expr,
+                       path_filters,
+                       []
+                     )
+
+                   combined_expr =
+                     Ash.Query.BooleanExpression.optimized_new(
+                       :and,
+                       new_expr,
+                       auth_filter.expression
+                     )
+
+                   {:halt, %{exists | expr: combined_expr}}
+               end
+             else
+               {:ok, new_expr} =
+                 do_filter_with_related(
+                   resource,
+                   exists_expr,
+                   path_filters,
+                   prefix ++ at_path ++ exists_path
+                 )
+
+               {:halt, %{exists | expr: new_expr}}
+             end
 
            other ->
              other

lib/ash/data_layer/data_layer.ex

@@ -74,6 +74,7 @@ defmodule Ash.DataLayer do
           | {:combine, combination_type}
           | {:atomic, :update}
           | {:atomic, :upsert}
+          | {:exists, :unrelated}
           | {:lateral_join, list(Ash.Resource.t())}
           | {:join, Ash.Resource.t()}
           | {:aggregate, :unrelated}

lib/ash/data_layer/ets/ets.ex

@@ -201,6 +201,7 @@ defmodule Ash.DataLayer.Ets do
   def can?(_, {:aggregate, :avg}), do: true
   def can?(_, {:aggregate, :exists}), do: true
   def can?(_, {:aggregate, :unrelated}), do: true
+  def can?(_, {:exists, :unrelated}), do: true
   def can?(_, :changeset_filter), do: true
   def can?(_, :update_query), do: true
   def can?(_, :destroy_query), do: true

lib/ash/data_layer/mnesia/mnesia.ex

@@ -92,7 +92,6 @@ defmodule Ash.DataLayer.Mnesia do
   def can?(_, :sort), do: true
   def can?(_, :filter), do: true
   def can?(_, {:filter_relationship, _}), do: true
-  def can?(_, {:query_aggregate, :count}), do: true
   def can?(_, :expression_calculation), do: true
   def can?(_, :expression_calculation_sort), do: true
   def can?(_, :limit), do: true
@@ -111,6 +110,8 @@ defmodule Ash.DataLayer.Mnesia do
   def can?(_, {:aggregate, :min}), do: true
   def can?(_, {:aggregate, :avg}), do: true
   def can?(_, {:aggregate, :exists}), do: true
+  def can?(_, {:aggregate, :unrelated}), do: true
+  def can?(_, {:exists, :unrelated}), do: true
   def can?(resource, {:query_aggregate, kind}), do: can?(resource, {:aggregate, kind})
 
   case Application.compile_env(:ash, :no_join_mnesia_ets) || false do

lib/ash/expr/expr.ex

@@ -721,7 +721,7 @@ defmodule Ash.Expr do
       when is_atom(op) and op in @operator_symbols do
     args = Enum.map(args, &do_expr(&1, false))
 
-    if op == :== do
+    if op in [:==, :!=, :>, :<, :>=, :<=] do
       soft_escape(
         quote do
           args = unquote(args)
@@ -765,6 +765,80 @@ defmodule Ash.Expr do
     )
   end
 
+  def do_expr({:exists, _, [{:__aliases__, _, _parts} = alias_ast, original_expr]}, escape?) do
+    processed_expr = do_expr(original_expr, false)
+
+    soft_escape(
+      quote do
+        %Ash.Query.Exists{
+          path: [],
+          resource: Macro.escape(unquote(alias_ast)),
+          expr: unquote(processed_expr),
+          at_path: [],
+          unrelated?: true
+        }
+      end,
+      escape?
+    )
+  end
+
+  def do_expr({:exists, _, [{:__aliases__, _, _parts} = alias_ast]}, escape?) do
+    soft_escape(
+      quote do
+        %Ash.Query.Exists{
+          path: [],
+          resource: Macro.escape(unquote(alias_ast)),
+          expr: true,
+          at_path: [],
+          unrelated?: true
+        }
+      end,
+      escape?
+    )
+  end
+
+  def do_expr({:exists, _, [module_atom, original_expr]}, escape?) when is_atom(module_atom) do
+    module_string = Atom.to_string(module_atom)
+
+    if String.match?(module_string, ~r/^[A-Z].*/) do
+      processed_expr = do_expr(original_expr, false)
+
+      soft_escape(
+        quote do
+          %Ash.Query.Exists{
+            path: [],
+            resource: unquote(module_atom),
+            expr: unquote(processed_expr),
+            at_path: [],
+            unrelated?: true
+          }
+        end,
+        escape?
+      )
+    else
+      expr_with_at_path(module_atom, [], original_expr, Ash.Query.Exists, escape?)
+    end
+  end
+
+  def do_expr({:exists, _, [module_atom]}, escape?) when is_atom(module_atom) do
+    module_string = Atom.to_string(module_atom)
+
+    if String.match?(module_string, ~r/^[A-Z].*/) do
+      soft_escape(
+        %Ash.Query.Exists{
+          path: [],
+          resource: module_atom,
+          expr: true,
+          at_path: [],
+          unrelated?: true
+        },
+        escape?
+      )
+    else
+      expr_with_at_path(module_atom, [], true, Ash.Query.Exists, escape?)
+    end
+  end
+
   def do_expr({:exists, _, [path, original_expr]}, escape?) do
     expr_with_at_path(path, [], original_expr, Ash.Query.Exists, escape?)
   end