What could be nullifying my query orderby in a resolver method?

[nimmolo]

The following simple query is not returning Observations ordered by created_at -
According to the terminal, Rails is ordering by id

Observation Load (0.9ms)  SELECT  `observations`.* FROM `observations` 
                ORDER BY `observations`.`id` ASC LIMIT 24

Here's the resolver:

module Resolvers
  class Observations < Resolvers::BaseResolver
    type Types::Models::ObservationType.connection_type, null: false
    description "List or filter all observations"

    def resolve
      ::Observation.order(created_at: :desc)
    end
  end
end

Base resolver

module Resolvers
  class BaseResolver < GraphQL::Schema::Resolver
  end
end

Query type

# graphql/types/query_type.rb
require("graphql/batch")
require("loaders/record_loader")
require("search_object")
require("search_object/plugin/graphql")

module Types
  class QueryType < Types::BaseObject
    field :observations, Types::Models::ObservationType.connection_type, null: false, resolver: Resolvers::Observations

Query (using Relay style cursor pagination)

query getObservations {
  observations {
    pageInfo {
      startCursor
      endCursor
      hasNextPage
      hasPreviousPage
    }
    edges {
      cursor
      node {
        id
        thumbImageId
        textName
        where
        when
        createdAt
        updatedAt
      }
    }
  }
}

Background: I'm planning on using a resolver for this model query because the eventual version will have a lot of filters built with search_object_graphql, and while testing the sorting filters i noticed it was ignoring the sort order. So I stripped the resolver back down to the graphql schema inheritance, hardcoded the query scope with an orderby clause, and it's still not ordering the query.

[rmosolgo]

Weird! I don't have a guess, looking at the snippets above. Maybe the LIMIT 24 would provide a clue ... any guess where that is coming from?

[nimmolo]

Yes... that's coming from my schema.
I added a default_max_page_size, connection, batch and not much else.

Maybe the problem is that i'm using Relay style connection without generating UUIDs for everything?

class MushroomObserverSchema < GraphQL::Schema
  query(Types::QueryType)
  mutation(Types::MutationType)
  # subscription(Types::Subscription)

  default_max_page_size 24
  # is this correct?
  connections.add(ActiveRecord::Relation, GraphQL::Connections::Stable)

  # GraphQL::Batch setup:
  use GraphQL::Batch

  # Union and Interface Resolution
  def self.resolve_type(_abstract_type, _obj, _ctx)
    # TODO: Implement this function
    # to return the correct object type for `obj`
    raise(GraphQL::RequiredImplementationMissingError)
  end

  # Relay-style Object Identification:

  # Return a string UUID for `object`
  def self.id_from_object(object, type_definition, query_ctx)
    # Here's a simple implementation which:
    # - joins the type name & object.id
    # - encodes it with base64:
    # GraphQL::Schema::UniqueWithinType.encode(type_definition.name, object.id)
  end

  # Given a string UUID, find the object
  def self.object_from_id(id, query_ctx)
    # For example, to decode the UUIDs generated above:
    # type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(id)
    #
    # Then, based on `type_name` and `id`
    # find an object in your application
    # ...
  end
end

[nimmolo]

I'm really stumped. Other model queries are also ordering by :id regardless of Model.order(column: :direction), there must be some setting upstream. Or a cache i haven't found?

Is there a good gem or tool I can use, other than reading the Terminal logs, to follow what it's doing more closely?

[nimmolo]

Agh. I forgot i had installed graphql-connections and added its connection type at the schema level - there it is at the top of the schema def. Sorry!

That connection type orders by primary key by default - and does not implement desc ordering if you pass it a primary key. Not usable for me, i've disabled it. Queries back to behaving normally.