improvement: support "unrelated" aggregates (#2240)

* improvement: support "unrelated" aggregates

the terminology here is a bit confusing, but aggregates were originally
designed over relationships. This allows to use a Resource, instead of
a relationship.path in aggregates.

* docs: document unrelated aggregates

* chore: update usage rules w/ unrelated aggregate information

* WIP

* improvement: add unrelated exists expressions

* use `related?` instead of `unrelated?`

* add missed stuff when changing unrelated? -> related?

* fix: don't skip authorization for unrelated aggregates

* get build passing & make tests suck less

* update docs

* cleanup comments

Author: zachdaniel

documentation/dsls/DSL-Ash.Resource.md

@@ -2823,6 +2823,8 @@ Declares a named count aggregate on the resource
 
 Supports `filter`, but not `sort` (because that wouldn't affect the count)
 
+Can aggregate over relationships using a relationship path, or directly over another resource.
+
 See the [aggregates guide](/documentation/topics/resources/aggregates.md) for more.
 
 
@@ -2838,14 +2840,21 @@ end
 
 ```
 
+```
+count :matching_profiles_count, Profile do
+  filter expr(name == parent(name))
+end
+
+```
+
 
 
 ### Arguments
 
 | Name | Type | Default | Docs |
 |------|------|---------|------|
 | [`name`](#aggregates-count-name){: #aggregates-count-name .spark-required} | `atom` |  | The field to place the aggregate in |
-| [`relationship_path`](#aggregates-count-relationship_path){: #aggregates-count-relationship_path .spark-required} | `atom \| list(atom)` |  | The relationship or relationship path to use for the aggregate |
+| [`relationship_path`](#aggregates-count-relationship_path){: #aggregates-count-relationship_path .spark-required} | `list(atom) \| atom` |  | The relationship or relationship path to use for the aggregate, or a resource module for resource-based aggregates |
 ### Options
 
 | Name | Type | Default | Docs |
@@ -2935,7 +2944,7 @@ exists :has_ticket, :assigned_tickets
 | Name | Type | Default | Docs |
 |------|------|---------|------|
 | [`name`](#aggregates-exists-name){: #aggregates-exists-name .spark-required} | `atom` |  | The field to place the aggregate in |
-| [`relationship_path`](#aggregates-exists-relationship_path){: #aggregates-exists-relationship_path .spark-required} | `atom \| list(atom)` |  | The relationship or relationship path to use for the aggregate |
+| [`relationship_path`](#aggregates-exists-relationship_path){: #aggregates-exists-relationship_path .spark-required} | `list(atom) \| atom` |  | The relationship or relationship path to use for the aggregate, or a resource module for resource-based aggregates |
 ### Options
 
 | Name | Type | Default | Docs |
@@ -3027,7 +3036,7 @@ end
 | Name | Type | Default | Docs |
 |------|------|---------|------|
 | [`name`](#aggregates-first-name){: #aggregates-first-name .spark-required} | `atom` |  | The field to place the aggregate in |
-| [`relationship_path`](#aggregates-first-relationship_path){: #aggregates-first-relationship_path .spark-required} | `atom \| list(atom)` |  | The relationship or relationship path to use for the aggregate |
+| [`relationship_path`](#aggregates-first-relationship_path){: #aggregates-first-relationship_path .spark-required} | `list(atom) \| atom` |  | The relationship or relationship path to use for the aggregate, or a resource module for resource-based aggregates |
 | [`field`](#aggregates-first-field){: #aggregates-first-field } | `atom` |  | The field to aggregate. Defaults to the first field in the primary key of the resource |
 ### Options
 
@@ -3120,7 +3129,7 @@ end
 | Name | Type | Default | Docs |
 |------|------|---------|------|
 | [`name`](#aggregates-sum-name){: #aggregates-sum-name .spark-required} | `atom` |  | The field to place the aggregate in |
-| [`relationship_path`](#aggregates-sum-relationship_path){: #aggregates-sum-relationship_path .spark-required} | `atom \| list(atom)` |  | The relationship or relationship path to use for the aggregate |
+| [`relationship_path`](#aggregates-sum-relationship_path){: #aggregates-sum-relationship_path .spark-required} | `list(atom) \| atom` |  | The relationship or relationship path to use for the aggregate, or a resource module for resource-based aggregates |
 | [`field`](#aggregates-sum-field){: #aggregates-sum-field } | `atom` |  | The field to aggregate. Defaults to the first field in the primary key of the resource |
 ### Options
 
@@ -3212,7 +3221,7 @@ end
 | Name | Type | Default | Docs |
 |------|------|---------|------|
 | [`name`](#aggregates-list-name){: #aggregates-list-name .spark-required} | `atom` |  | The field to place the aggregate in |
-| [`relationship_path`](#aggregates-list-relationship_path){: #aggregates-list-relationship_path .spark-required} | `atom \| list(atom)` |  | The relationship or relationship path to use for the aggregate |
+| [`relationship_path`](#aggregates-list-relationship_path){: #aggregates-list-relationship_path .spark-required} | `list(atom) \| atom` |  | The relationship or relationship path to use for the aggregate, or a resource module for resource-based aggregates |
 | [`field`](#aggregates-list-field){: #aggregates-list-field } | `atom` |  | The field to aggregate. Defaults to the first field in the primary key of the resource |
 ### Options
 
@@ -3306,7 +3315,7 @@ end
 | Name | Type | Default | Docs |
 |------|------|---------|------|
 | [`name`](#aggregates-max-name){: #aggregates-max-name .spark-required} | `atom` |  | The field to place the aggregate in |
-| [`relationship_path`](#aggregates-max-relationship_path){: #aggregates-max-relationship_path .spark-required} | `atom \| list(atom)` |  | The relationship or relationship path to use for the aggregate |
+| [`relationship_path`](#aggregates-max-relationship_path){: #aggregates-max-relationship_path .spark-required} | `list(atom) \| atom` |  | The relationship or relationship path to use for the aggregate, or a resource module for resource-based aggregates |
 | [`field`](#aggregates-max-field){: #aggregates-max-field } | `atom` |  | The field to aggregate. Defaults to the first field in the primary key of the resource |
 ### Options
 
@@ -3397,7 +3406,7 @@ end
 | Name | Type | Default | Docs |
 |------|------|---------|------|
 | [`name`](#aggregates-min-name){: #aggregates-min-name .spark-required} | `atom` |  | The field to place the aggregate in |
-| [`relationship_path`](#aggregates-min-relationship_path){: #aggregates-min-relationship_path .spark-required} | `atom \| list(atom)` |  | The relationship or relationship path to use for the aggregate |
+| [`relationship_path`](#aggregates-min-relationship_path){: #aggregates-min-relationship_path .spark-required} | `list(atom) \| atom` |  | The relationship or relationship path to use for the aggregate, or a resource module for resource-based aggregates |
 | [`field`](#aggregates-min-field){: #aggregates-min-field } | `atom` |  | The field to aggregate. Defaults to the first field in the primary key of the resource |
 ### Options
 
@@ -3488,7 +3497,7 @@ end
 | Name | Type | Default | Docs |
 |------|------|---------|------|
 | [`name`](#aggregates-avg-name){: #aggregates-avg-name .spark-required} | `atom` |  | The field to place the aggregate in |
-| [`relationship_path`](#aggregates-avg-relationship_path){: #aggregates-avg-relationship_path .spark-required} | `atom \| list(atom)` |  | The relationship or relationship path to use for the aggregate |
+| [`relationship_path`](#aggregates-avg-relationship_path){: #aggregates-avg-relationship_path .spark-required} | `list(atom) \| atom` |  | The relationship or relationship path to use for the aggregate, or a resource module for resource-based aggregates |
 | [`field`](#aggregates-avg-field){: #aggregates-avg-field } | `atom` |  | The field to aggregate. Defaults to the first field in the primary key of the resource |
 ### Options
 
@@ -3581,7 +3590,7 @@ end
 | Name | Type | Default | Docs |
 |------|------|---------|------|
 | [`name`](#aggregates-custom-name){: #aggregates-custom-name .spark-required} | `atom` |  | The field to place the aggregate in |
-| [`relationship_path`](#aggregates-custom-relationship_path){: #aggregates-custom-relationship_path .spark-required} | `atom \| list(atom)` |  | The relationship or relationship path to use for the aggregate |
+| [`relationship_path`](#aggregates-custom-relationship_path){: #aggregates-custom-relationship_path .spark-required} | `list(atom) \| atom` |  | The relationship or relationship path to use for the aggregate, or a resource module for resource-based aggregates |
 | [`type`](#aggregates-custom-type){: #aggregates-custom-type .spark-required} | `module` |  | The type of the value returned by the aggregate |
 ### Options
 

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 directly: `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`
 
@@ -121,7 +121,11 @@ For elixir-backed data layers, they will be a function or an MFA that will be ca
 
 ## Inline Aggregates
 
-Aggregates can be referenced in-line, with their relationship path specified and any options provided that match the options given to `Ash.Query.Aggregate.new/4`. For example:
+Aggregates can be referenced in-line, with their relationship path specified and any options provided that match the options given to `Ash.Query.Aggregate.new/4`.
+
+### Relationship-based Inline Aggregates
+
+For aggregating over related data through relationships:
 
 ```elixir
 calculate :grade, :decimal, expr(
@@ -130,6 +134,36 @@ calculate :grade, :decimal, expr(
 )
 ```
 
+### Resource-based Inline Aggregates
+
+For aggregating over any resource without a relationship:
+
+```elixir
+# Count profiles matching the user's name
+calculate :matching_profiles, :integer, 
+  expr(count(Profile, filter: expr(name == parent(name))))
+
+# Get the latest report title by the user
+calculate :latest_report, :string,
+  expr(first(Report, 
+    field: :title,
+    query: [
+      filter: expr(author_name == parent(name)),
+      sort: [inserted_at: :desc]
+    ]
+  ))
+
+# Complex calculation with multiple resource-based 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, active == true and name == parent(name)),
+  has_recent_reports: exists(Report, author_name == parent(name) and inserted_at > ago(1, :week))
+})
+```
+
+The `parent/1` function allows referencing fields from the source resource within resource-based aggregate filters.
+
 The available aggregate kinds can also be seen in the `Ash.Query.Aggregate` module documentation.
 
 ## Templates
@@ -235,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.
 
+### Resource-based Exists
+
+Sometimes you want to check for the existence of records in any resource, not just through relationships. Resource-based 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 resource-based 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:

documentation/topics/resources/aggregates.md

@@ -2,11 +2,17 @@
 
 Aggregates in Ash allow for retrieving summary information over groups of related data. A simple example might be to show the "count of published posts for a user". Aggregates allow us quick and performant access to this data, in a way that supports being filtered/sorted on automatically. More aggregate types can be added, but you will be restricted to only the supported types. In cases where aggregates don't suffice, use [Calculations](/documentation/topics/resources/calculations.md), which are intended to be much more flexible.
 
+Aggregates can work in two ways:
+1. **Relationship-based aggregates** - aggregate over data through relationships (the traditional approach)
+2. **Resource-based aggregates** - aggregate over any resource directly without requiring a relationship
+
 ## Declaring aggregates on a resource
 
 Aggregates are defined in an `aggregates` section. For all possible types, see below.
 For a full reference, see `d:Ash.Resource.Dsl.aggregates`.
 
+### Relationship-based Aggregates
+
 ```elixir
 aggregates do
   count :count_of_posts, :posts do
@@ -15,6 +21,31 @@ aggregates do
 end
 ```
 
+### Resource-based Aggregates
+
+Resource-based aggregates allow you to aggregate over any resource without needing a relationship. Instead of providing a relationship path, you provide the target resource module directly:
+
+```elixir
+aggregates do
+  # Count profiles with matching name
+  count :matching_profiles_count, Profile do
+    filter expr(name == parent(name))
+  end
+  
+  # Sum scores from reports where author matches user's name
+  sum :total_report_score, Report, :score do
+    filter expr(author_name == parent(name))
+  end
+  
+  # Check if any active profile exists (no parent filter needed)
+  exists :has_active_profile, Profile do
+    filter expr(active == true)
+  end
+end
+```
+
+The `parent/1` function allows you to reference fields from the source resource within the aggregate's filter expression.
+
 ## Using an aggregate
 
 Aggregates are loaded and filtered on in the same way that calculations are. Lets look at some examples:
@@ -71,7 +102,7 @@ See the docs on `d:Ash.Resource.Dsl.aggregates` for more information.
 
 Custom aggregates can be added to the query and will be placed in the `aggregates` key of the results. This is an escape hatch, and is not the primary way that you should be using aggregates. It does, however, allow for dynamism, i.e if you are accepting user input that determines what the filter and/or field should be, that kind of thing.
 
-Example:
+### Relationship-based aggregate example:
 
 ```elixir
 User
@@ -85,6 +116,20 @@ User
 )
 ```
 
+### Resource-based aggregate example:
+
+```elixir
+User
+|> Ash.Query.aggregate(
+  :matching_profiles,
+  :count,
+  Profile,
+  query: [
+    filter: expr(name == parent(name))
+  ]
+)
+```
+
 See the documentation for `Ash.Query.aggregate/4` for more information.
 
 ## Join Filters
@@ -112,11 +157,20 @@ Join filters allows for more complex aggregate queries, including joining with p
 
 Aggregates can be created in-line in expressions, with their relationship path specified and any options provided that match the options given to `Ash.Query.Aggregate.new/4`. For example:
 
+### Relationship-based inline aggregates
 ```elixir
 calculate :grade, :decimal, expr(
   count(answers, query: [filter: expr(correct == true)]) /
   count(answers, query: [filter: expr(correct == false)])
 )
 ```
 
+### Resource-based inline aggregates
+```elixir
+calculate :profile_summary, :map, expr(%{
+  matching_profiles: count(Profile, filter: expr(name == parent(name))),
+  total_reports: count(Report, filter: expr(author_name == parent(name)))
+})
+```
+
 See the [Expressions guide](/documentation/topics/reference/expressions.md#inline-aggregates) for more.

lib/ash/actions/aggregate.ex

@@ -88,6 +88,8 @@ defmodule Ash.Actions.Aggregate do
                      limit: query.limit,
                      offset: query.offset,
                      distinct: query.distinct,
+                     distinct_sort: query.distinct_sort,
+                     sort: query.sort,
                      domain: query.domain,
                      tenant: query.tenant,
                      filter: query.filter,