Codegen creates objects with overly long names that arent navigable

[devinnasar]

Hello,

I'm wondering if I'm misunderstanding what ariadne-codegen does. My understanding is that by giving Codegen access to the remote API, that it is crawling the schema and creating class types from the return types that it is observing. I also believe that it's supposed to do things like identify common object types and build data classes for them, then use those data classes whenever a query would indicate an instance of that class. For example, if Codegen notices that anywhere in the schema there is a 'tag' object, then it should be understanding that tags are a data class, and I should get Tag() objects back whenever one of my graphql queries would return a json structure containing tags, for example:

Given:

{
  "parentObject": {
    "tags": [
      {
        "key": 1,
        "value": "X"
      }, {
        "key": 2,
        "value": "Y"
      }, {
        //...
    ]
  }
}

I should expect to get an Object parentObject with an attribute called tags which is a list of tag Objects.

However I'm not noticing that. Instead what I'm getting in response to my query is a HUGE object that seems to build child objects based off of the full name of the JSON path that they live on in the response. That, to me seems unusable. Observe:

Given:
queries/aes.gql

query aes($query: String!, $cursor:String) {
    actor {
        entitySearch(query: $query, options: {}) {
            results(cursor: $cursor) {
                entities {
                    name
                    guid
                    tags {
                        key
                        values
                    }
                    permalink
                    domain
                    type
                }
            }
        }
    }
}

scratch.py

import os
from pprint import pprint
import json
import asyncio
from graphql_client.client import Client

nerdgraph_url = 'https://api.newrelic.com/graphql'
newrelic_api_key = os.environ.get('NEW_RELIC_API_KEY')
nerdgraph_client = Client(nerdgraph_url, {"Api-Key": newrelic_api_key})


async def main():
    # have to use async with
    async with nerdgraph_client as client:
        result = await client.aes(query="accountId = NR_ACCOUNT_ID AND name = 'NR_ENTITY_NAMME'")

    pprint(result) # This doesn't work. I have to format with black after the fact

if __name__ == "__main__":
    asyncio.run(main())

Output (values obfuscated)

Aes(
    actor=AesActor(
        entity_search=AesActorEntitySearch(
            results=AesActorEntitySearchResults(
                entities=[
                    AesActorEntitySearchResultsEntities(
                        typename__="GenericInfrastructureEntityOutline",
                        name="NR_ENTITY_NAME",
                        guid="NR_ENTITY_GUID",
                        tags=[
                            AesActorEntitySearchResultsEntitiesTags(
                                key="account", values=["NR_ACCOUNT_NAME"]
                            ),
                            AesActorEntitySearchResultsEntitiesTags(
                                key="accountId", values=["NR_ACCOUNT_ID"]
                            ),
                            AesActorEntitySearchResultsEntitiesTags(
                                key="aws.Arn",
                                values=[
                                    "arn:aws:lambda:AWS_REGION:AWS_ACCOUNT_ID:function:NR_ENTITY_NAME"
                                ],
                            ),
                            AesActorEntitySearchResultsEntitiesTags(
                                key="aws.MetricStreamArn",
                                values=[
                                    "arn:aws:cloudwatch:AWS_REGION:AWS_ACCOUNT_ID:metric-stream/NewRelic-Metric-Stream-AWS_REGION"
                                ],
                            )
                        ],
                        permalink="https://one.newrelic.com/redirect/entity/NR_ENTITY_GUID",
                        domain="INFRA",
                        type="AWSLAMBDAFUNCTIONALIAS",
                    )
                ]
            )
        )
    )
)

Compare to the JSON response of the same query:

{
  "data": {
    "actor": {
      "entitySearch": {
        "results": {
          "entities": [
            {
              "domain": "INFRA",
              "guid": "NR_ENTITY_GUID",
              "name": "NR_ENTITY_NAME",
              "permalink": "https://one.newrelic.com/redirect/entity/NR_ENTITY_GUID",
              "tags": [
                {
                  "key": "account",
                  "values": [
                    "NR_ACCOUNT_NAME"
                  ]
                },
                {
                  "key": "accountId",
                  "values": [
                    "NR_ACCOUNT_NAME"
                  ]
                },
                {
                  "key": "aws.Arn",
                  "values": [
                    "arn:aws:lambda:AWS_REGION:AWS_ACCOUNT_ID:function:NR_ENTITY_NAME"
                  ]
                },
                {
                  "key": "aws.MetricStreamArn",
                  "values": [
                    "arn:aws:cloudwatch:AWS_REGION:AWS_ACCOUNT_ID:metric-stream/NewRelic-Metric-Stream-AWS_REGION"
                  ]
                }
              ],
              "type": "AWSLAMBDAFUNCTIONALIAS"
            }
          ]
        }
      }
    }
  }
}

Am I thinking about this incorrectly? This feels more cumbersome to interact with than just working with it as consumed JSON. What am I getting wrong about my approach?