Use case for resolve and resolveField outside of root query?

[abdullahseba]

What is the use case for having resolve and resolveField at the type level? If the root query does not have a resolver, none of the resolvers further down get executed. I learned from #721 (comment), that if the root query resolver returns anything other than null, the resolvers further down get executed. However, for a multi-level query, resolvers that return true, cause an error. Take the following query:

{
  objectRecords {
    edges {
      node {
        objBriefDesc
      }
    }
  }
}

Root query field:

'objectRecords' => [
        'type' => TR::objectRecordConnection(),
        'resolve' => function ($root, $args) {
            return true;
        }, 
    ],

ObjectRecordConnection type:

[
    'name' => 'ObjectRecordConnection',
    'description' => 'ObjectRecordConnection',
    'fields' => [
        'totalCount' => [
            'type' => TR::int(),
            'description' => 'The total number of object records in the database.'
        ],
        'edges' => [
            'type' => TR::ListOf(TR::objectRecordEdge()),
            'description' => 'The total number of object records in the database.',
            'resolve' => function ($root, $args) {
                return ['edges' => []];
            }
        ],
      ...
    ],
];

ObjectRecord Edge type:

 [
            'name' => 'ObjectRecordEdge',
            'description' => 'ObjectRecordEdge',
            'fields' => [

                'node' => [
                    'type' => TR::objectRecord(),
                    'description' => 'The item at the end of the edge.',
                    'resolve' => function ($root, $args) {
                        return ['node' => []];
                    }
                ],
              ...
            ]

ObjectRecord type:

[
    'name' => 'ObjectRecord',
    'description' => 'ObjectRecord',
    'fields' => [
        'id' => TR::id(),
        'objBriefDesc' => [
            'type' => TR::string(),
            'resolve' => function () {
                return 'description';
            }
        ],
   ...
    ]
];

Result:

{
  "data": {
    "objectRecords": {
      "edges": [
        {
          "node": {
            "objBriefDesc": "description"
          }
        }
      ]
    }
  }
}

Without ObjectRecordConnection returning edges and ObjectRecordEdge returning node arrays, the description resolver does not run. With the code above, the description resolver overwrites anything returned by the previous resolver in the node array.

Having to return part of the query in each resolver seems long-winded for multi-level queries, and I was curious what use cases there would be for doing this. I may well be missing something obvious, and it's a case 'just because you can, doesn't mean you should'. To be clear, I'm just experimenting and trying to find the best way to structure my project.

Thank you for the great library!