graphql-ruby: Configure complexity on connection fields

I took a try at the change described above, but found it was too hard to reliably implement. nodes and edges might have different subselections, and it’s hard to efficiently implement a reliable check for whether their selections match exactly or not. For clients who are pushing complexity limits, they can always use edges for everything that nodes would have provided.

The change above will be in 1.13.0 👍 !

@crpahl yep that’s basically it 👍

For complexity procs, you can do this:

data[:field].complexity.call(data[:query].context, data[:arguments], 0)

I found myself needing the ability to break down queries to help understand where they’re growing too complex, and in the process I found that it’s very useful to be able to separate the page-multiplied scopes from the non-multiplied scopes, rather than trying to reverse it after the fact.

I’ve modified the QueryComplexity analyzer to track complexity for paged child keys (nodes and edges, by default, though it’s configurable) separately from other keys, then those complexities get passed to calculate_complexity, which makes the actual complexity calculations quite a lot simpler.

The changes are here, for those that might find them useful. It breaks the complexity_for and field_complexity interfaces, so it wouldn’t be super easy to pull back upstream, but it does work, and it’s here if others might find it useful. There are probably more intelligent ways to do the paginated fields split, but nodes/edges works for my purposes.

https://gist.github.com/cheald/8c9be84ad0dbc80fb41a194f83e23b33

This gives me reliable calculations for tree costs and makes it very easy to reason about the complexity breakdowns:

puts Graphql::QueryComplexityWithFieldDetails.report(q)

QueryComplexityWithFieldDetails#report gives me a nice readable output for the query. So, for example here, I can see that accountGrants has a cost of 1907, which breaks down to a page size of 100 * a paged complexity of 19, plus a non-paged complexity of 6, plus the accountGrants complexity of 1.

account {                                  1909.00 (child complexity: 1908.00, paged child complexity: 0.00)
  accountGrants {                          1907.00 (max page size: 100, child complexity: 6.00, paged child complexity: 19.00)
    pageInfo {                                5.00 (child complexity: 4.00, paged child complexity: 0.00)
      endCursor                               1.00
      hasNextPage                             1.00
      hasPreviousPage                         1.00
      startCursor                             1.00
    }
    totalCount                                1.00
    nodes {                                  19.00 (child complexity: 18.00, paged child complexity: 0.00)
      accepted                                1.00
      account {                               3.00 (child complexity: 2.00, paged child complexity: 0.00)
        id                                    1.00
        name                                  1.00
      }
      createdAt                               1.00
      email                                   1.00
      id                                      1.00
      isSelf                                  1.00
      lastActivity                            1.00
      link {                                  8.00 (child complexity: 7.00, paged child complexity: 0.00)
        account {                             5.00 (child complexity: 4.00, paged child complexity: 0.00)
          boundingAccount {                   2.00 (child complexity: 1.00, paged child complexity: 0.00)
            id                                1.00
          }
          id                                  1.00
          name                                1.00
        }
        id                                    1.00
        name                                  1.00
      }
      roles                                   1.00
    }
  }
  id                                          1.00
}

(Oh, nodes and edges should probably count for 1 each, not 1 * page_size)

I took a try at it in https://github.com/rmosolgo/graphql-ruby/pull/3609, could you take a quick look and see if that looks like what you had in mind?

I may have to touch it up in order to merge it to 1.12.x – I don’t want to change the default behavior on that until 1.13.0.

useful to others … directly in the framework

I’m open to it, though personally I’m not that convinced of complexity. In practice, I find it hard to guess exactly which fields / under which conditions they will be resource-intensive. And when implementations change, how to keep the complexity configuration up-to-date? We have a server process timeout that ends up terminating long-running queries 🙈…

Anyhow, I’ll take a look soon and follow up here 👍