feat: Type and Query complexity callbacks

A custom complexity callback can be provided for a type to be used when that type is resolved through a relationship.

A query-level complexity callback applies when the resource has a top-level query in the schema.

Author: mbuhot

.formatter.exs

@@ -16,6 +16,7 @@ spark_locals_without_parens = [
   create: 2,
   create: 3,
   create: 4,
+  complexity: 1,
   depth_limit: 1,
   derive_filter?: 1,
   derive_sort?: 1,

lib/resource/info.ex

@@ -229,4 +229,9 @@ defmodule AshGraphql.Resource.Info do
           true
         )
   end
+
+  @doc "The complexity callback `{mod, fun}` for this type"
+  def complexity(resource) do
+    Extension.get_opt(resource, [:graphql], :complexity, nil)
+  end
 end

lib/resource/query.ex

@@ -10,6 +10,7 @@ defmodule AshGraphql.Resource.Query do
     :modify_resolution,
     :relay_id_translations,
     :description,
+    :complexity,
     as_mutation?: false,
     hide_inputs: [],
     metadata_names: [],
@@ -74,6 +75,13 @@ defmodule AshGraphql.Resource.Query do
       type: {:list, :atom},
       doc: "A list of inputs to hide from the mutation.",
       default: []
+    ],
+    complexity: [
+      type: :mod_arg,
+      doc: """
+      An {module, function} that will be called with the arguments and complexity value of the child fields query. It should return the complexity of this query.
+      """,
+      default: {AshGraphql.Graphql.Resolver, :query_complexity}
     ]
   ]
 

lib/resource/resource.ex

@@ -192,7 +192,7 @@ defmodule AshGraphql.Resource do
     describe: """
     Configures the behavior of a given managed_relationship for a given action.
 
-    If there are type conflicts (for example, if the input could create or update a record, and the 
+    If there are type conflicts (for example, if the input could create or update a record, and the
     create and update actions have an argument of the same name but with a different type),
     a warning is emitted at compile time and the first one is used. If that is insufficient, you will need to do one of the following:
 
@@ -419,6 +419,12 @@ defmodule AshGraphql.Resource do
         A simple way to prevent massive queries.
         """
       ],
+      complexity: [
+        type: :mod_arg,
+        doc: """
+        An {module, function} that will be called with the arguments and complexity value of the child fields query. It should return the complexity of this query.
+        """
+      ],
       generate_object?: [
         type: :boolean,
         doc:
@@ -688,7 +694,7 @@ defmodule AshGraphql.Resource do
               [
                 {{AshGraphql.Graphql.Resolver, :resolve}, {domain, resource, query, relay_ids?}}
               ],
-          complexity: {AshGraphql.Graphql.Resolver, :query_complexity},
+          complexity: query.complexity || {AshGraphql.Graphql.Resolver, :query_complexity},
           module: schema,
           name: to_string(query.name),
           description: query.description || query_action.description,
@@ -4303,6 +4309,7 @@ defmodule AshGraphql.Resource do
           end
 
         type = AshGraphql.Resource.Info.type(relationship.destination)
+        type_complexity = AshGraphql.Resource.Info.complexity(relationship.destination)
 
         pagination_strategy =
           relationship_pagination_strategy(resource, relationship.name, read_action)
@@ -4314,7 +4321,7 @@ defmodule AshGraphql.Resource do
           module: schema,
           name: to_string(name),
           description: relationship.description,
-          complexity: {AshGraphql.Graphql.Resolver, :query_complexity},
+          complexity: type_complexity || {AshGraphql.Graphql.Resolver, :query_complexity},
           middleware: [
             {{AshGraphql.Graphql.Resolver, :resolve_assoc_many},
              {domain, relationship, pagination_strategy}}

test/read_test.exs

@@ -421,6 +421,37 @@ defmodule AshGraphql.ReadTest do
            ]
   end
 
+  test "custom complexity calculation" do
+    query = """
+    query PostLibrary {
+      paginatedPosts(limit: 2) {
+        results{
+          text
+          sponsoredComments(limit: 5) {
+            text
+          }
+        }
+      }
+    }
+    """
+
+    resp =
+      query
+      |> Absinthe.run(AshGraphql.Test.Schema,
+        analyze_complexity: true,
+        max_complexity: 300
+      )
+
+    assert {:ok, %{errors: errors}} = resp
+
+    assert errors |> Enum.map(& &1.message) |> Enum.sort() == [
+             "Field paginatedPosts is too complex: complexity is 1014 and maximum is 300",
+             "Field results is too complex: complexity is 507 and maximum is 300",
+             "Field sponsoredComments is too complex: complexity is 505 and maximum is 300",
+             "Operation PostLibrary is too complex: complexity is 1014 and maximum is 300"
+           ]
+  end
+
   test "a read with a loaded field works" do
     AshGraphql.Test.Post
     |> Ash.Changeset.for_create(:create, text: "bar", published: true)

test/support/resources/sponsored_comment.ex

@@ -8,9 +8,10 @@ defmodule AshGraphql.Test.SponsoredComment do
 
   graphql do
     type :sponsored_comment
+    complexity {__MODULE__, :query_complexity}
 
     queries do
-      get :get_sponsored_comment, :read
+      get :get_sponsored_comment, :read, complexity: {__MODULE__, :query_complexity}
     end
 
     mutations do
@@ -45,4 +46,13 @@ defmodule AshGraphql.Test.SponsoredComment do
   relationships do
     belongs_to(:post, AshGraphql.Test.Post, public?: true)
   end
+
+  @doc "Sponsored comments are complex to serve, add 100 to the cost per comment"
+  def query_complexity(%{limit: n}, child_complexity, _resolution) do
+    n * (child_complexity + 100)
+  end
+
+  def query_complexity(_args, child_complexity, _resolution) do
+    child_complexity + 100
+  end
 end