Deeply nested list fails with "Uncaught RuntimeException: Reached the limit of nesting in type info"

[jausions]

I had an issue with a schema that had a element of this type:

{
  "data": {
    "__type": {
      "name": "BsvhuMetadataFields",
      "kind": "OBJECT",
      "fields": [
        {
          "name": "sealed",
          "description": "Liste des champs scellés",
          "isDeprecated": false,
          "deprecationReason": null,
          "type": {
            "name": null,
            "kind": "NON_NULL",
            "description": null,
            "ofType": {
              "name": null,
              "kind": "LIST",
              "ofType": {
                "name": null,
                "kind": "NON_NULL",
                "ofType": {
                  "name": null,
                  "kind": "LIST",
                  "ofType": {
                    "name": null,
                    "kind": "NON_NULL",
                    "ofType": {
                      "name": "String",
                      "kind": "SCALAR",
                      "ofType": null
                    }
                  }
                }
              }
            }
          },
          "args": []
        }
      ]
    }
  }
}

The generator chocked on the issue with this error:

Fatal error: Uncaught RuntimeException: Reached the limit of nesting in type info in some/path/\vendor/gmostafa/php-graphql-oqm/src/SchemaGenerator/SchemaClassGenerator.php:333

Indeed, by adding more depth to the introspection sub-query \GraphQL\SchemaGenerator\SchemaInspector::TYPE_SUB_QUERY, I was able to unlock the problem:

{
    __type(name: "BsvhuMetadataFields") {
        name
        kind
        fields(includeDeprecated: true){
            name
            description
            isDeprecated
            deprecationReason
            type{
                name
                kind
                description
                ofType{
                    name
                    kind
                    ofType{
                        name
                        kind
                        ofType{
                            name
                            kind
                            ofType{
                                name
                                kind
                                ofType{
                                    name
                                    kind
                                    ofType{
                                        name
                                        kind
                                    }
                                }
                            }
                        }
                    }
                }
            }
            args{
                name
                description
                defaultValue
                type{
                    name
                    kind
                    description
                    ofType{
                        name
                        kind
                        ofType{
                            name
                            kind
                            ofType{
                                name
                                kind
                                ofType{
                                    name
                                    kind
                                    ofType{
                                        name
                                        kind
                                        ofType{
                                            name
                                            kind
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

But, this is hardly an solution. That solved my problem punctually and very temporarily.

No doubt, that someone will encounter a even more deeply nested type. So, the solution would be to try to go deeper whenever the ofType is not found, until we get the exact same answer from the server. If we get the same answer after trying to do deeper, then that's our cue that something is wrong with the schema, then naturally bail out of the generation process (as currently)

Alternatively, we could add an option to indicate how deep one wants to go.

I could try to code that into a PR, but I don't know when I'll be able to.

[jausions]

I opened 2 different PRs, each resolving the issue by adding an option to the CLI command. However, their implementations differ by how the depth level information is passed through the call stack.

One is more flexible in that the level is passed to each method, allowing for a better possible control. The other has much less impact on the existing code, but is not flexible at all.

So, the problem of ofType level nesting was not treated dynamically in those PRs, but if we wanted to let the package decide for itself if it needs to go deeper for ofType, only the first PR would permit it I think,

I let you decide.

[jausions]

Codacy coding style rules seem wonky. Have you enabled contradictory rules, especially the ones with a required //end <methodname> comment, with at the same time a space after // and an ending ., plus a blank line before the last } of a function/method, but no blank line after a // style comment? @mghoneimy

Ah, and there's one saying "put 2 spaces after a argument name in a doc block" and another "put only 1 space". 🙃

Basically, it seems like a big mess.