How we can extend query

[0xHexE]

How can we add one more to extend the query type?

So I want to add one more field to the query.

	fun buildSchema(@Observes builder: GraphQLSchema.Builder): GraphQLSchema.Builder? {
           // Extend the query here.
	}

[quarkus-bot[bot]]

/cc @evanchooly(kotlin), @geoand(kotlin)

[geoand]

cc @jmartisk

[roggenbrot]

No sure if I understood the question:

@GraphQLApi
public class GraphQLHandler {

    public class PongResult{

        public String pong = "pong";

    }
    
    @Query
    public String fieldOnRootQuery(){
        return "pong";
    }

    @Query
    public PongResult ping(){
        return new PongResult();
    }

    public String extendPong(@Source PongResult source ){
        return "pongx";
    }
}

type PongResult {
  extendPong: String
  pong: String
}
"Query root"
type Query {
  _service: _Service!
  fieldOnRootQuery: String
  ping: PongResult
}

[jmartisk]

Yeah I don't quite understand it either. Is it about adding a new query to the query root, or about adding a field to a type?

[0xHexE]

Hi, Everyone.

I wanted to extend the query using the https://quarkus.io/guides/smallrye-graphql#graphql-java.

So I want to build a query builder that will take the JPA entities and make them queriable using graphql. To archive that I need extend query

type Query {
   # Existing query, which is built upon annotation.
}

After calling the function

	fun buildSchema(@Observes builder: GraphQLSchema.Builder): GraphQLSchema.Builder? {
           // Extend the query here.
	}

It should extend the type to something like

extend type Query {
  some: String
}

This is supported in the DGS framework.
https://netflix.github.io/dgs/advanced/dynamic-schemas/#creating-a-schema-from-code

[jmartisk]

I'm still not sure I understand what you want to do. You say you want to "extend the query", but I don't see how that would help making JPA entities queryable, for that you would probably need separate new queries, no?

So do you want to

1. extend the "query root", which basically means dynamically create something that normally is annotated @Query?
2. dynamically extend an existing query (not the query root, but something annotated with @Query) to make it return an extra field?

Let's make the terminology clear

• when I say "Query root" I mean the root query in the schema, in the schema it appears as

"Query root"
type Query {
   .... queries go here	
}

• when I say "Query" I mean a query that is normally annotated with @Query and basically translates to a field inside the Query root.