Add GraphQL Extensions (#184)

This enables accessing the Extensions field, as defined in the response
format: https://spec.graphql.org/October2021/#sec-Response-Format

Extensions can be enabled using configuration option use_extensions.
This will change the return parameters of the generated client
functions. Making it a breaking change if enabled.

Since extensions are untyped as defined in the spec, the Client will
return an interface of type map[string]interface{}.

docs/CHANGELOG.md

@@ -23,10 +23,12 @@ When releasing a new version:
 ### Breaking changes:
 
 - genqlient now requires Go 1.16 or higher.
+- The [`graphql.Client`](https://pkg.go.dev/github.com/Khan/genqlient/graphql#Client) interface now accepts two structs for the request and response, to allow future expansion, rather than several individual arguments.  Clients implementing the interface themselves will need to change the signature; clients who simply call `graphql.NewClient` are unaffected.
 
 ### New features:
 
 - genqlient can now run as a portable binary (i.e. without a local checkout of the repository or `go run`).
+- You can now enable `use_extensions` in the configuration file, to receive extensions returned by the GraphQL API server. Generated functions will return extensions as `map[string]interface{}`, if enabled.
 
 ### Bug fixes:
 

docs/genqlient.yaml

@@ -87,6 +87,16 @@ client_getter: "github.com/you/yourpkg.GetClient"
 # Defaults to false.
 use_struct_references: boolean
 
+# If set, generated code will have a third return parameter of type 
+# map[string]interface{}. This will contain the optional values
+# of the Extensions field send from Servers.
+# ref.: https://spec.graphql.org/October2021/#sec-Response-Format
+#
+# This can be useful for extending the GraphQL Protocol.
+#
+# Defaults to false.
+use_extensions: boolean
+
 
 # A map from GraphQL type name to Go fully-qualified type name to override
 # the Go type genqlient will use for this GraphQL type.

example/generated.go

@@ -75,16 +75,9 @@ func getUser(
 	client graphql.Client,
 	Login string,
 ) (*getUserResponse, error) {
-	__input := __getUserInput{
+	req := &graphql.Request{
-		Login: Login,
+		OpName: "getUser",
-	}
+		Query: `
-	var err error
-
-	var retval getUserResponse
-	err = client.MakeRequest(
-		ctx,
-		"getUser",
-		`
 query getUser ($Login: String!) {
 	user(login: $Login) {
 		theirName: name
@@ -92,23 +85,31 @@ query getUser ($Login: String!) {
 	}
 }
 `,
-		&retval,
+		Variables: &__getUserInput{
-		&__input,
+			Login: Login,
+		},
+	}
+	var err error
+
+	var data getUserResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 
 func getViewer(
 	ctx context.Context,
 	client graphql.Client,
 ) (*getViewerResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "getViewer",
-	var retval getViewerResponse
+		Query: `
-	err = client.MakeRequest(
-		ctx,
-		"getViewer",
-		`
 query getViewer {
 	viewer {
 		MyName: name
@@ -116,8 +117,17 @@ query getViewer {
 	}
 }
 `,
-		&retval,
+	}
-		nil,
+	var err error
+
+	var data getViewerResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }

example/genqlient.yaml

@@ -2,7 +2,6 @@ schema: schema.graphql
 operations:
 - genqlient.graphql
 generated: generated.go
-
 # needed since it doesn't match the directory name:
 package: main
 

generate/config.go

@@ -27,6 +27,7 @@ type Config struct {
 	ClientGetter     string                  `yaml:"client_getter"`
 	Bindings         map[string]*TypeBinding `yaml:"bindings"`
 	StructReferences bool                    `yaml:"use_struct_references"`
+	Extensions       bool                    `yaml:"use_extensions"`
 
 	// Set to true to use features that aren't fully ready to use.
 	//

generate/generate_test.go

@@ -191,6 +191,10 @@ func TestGenerateWithConfig(t *testing.T) {
 			ClientGetter: "github.com/Khan/genqlient/internal/testutil.GetClientFromNowhere",
 			ContextType:  "-",
 		}},
+		{"Extensions", "", &Config{
+			Generated:  "generated.go",
+			Extensions: true,
+		}},
 	}
 
 	sourceFilename := "SimpleQuery.graphql"

generate/operation.go.tmpl

@@ -12,34 +12,35 @@ func {{.Name}}(
     {{.GraphQLName}} {{.GoType.Reference}},
     {{end -}}
     {{end -}}
-) (*{{.ResponseName}}, error) {
+) (*{{.ResponseName}}, {{if .Config.Extensions -}}map[string]interface{},{{end}} error) {
-    {{- if .Input -}}
+    req := &graphql.Request{
-    {{/* We need to avoid conflicting with any of the function's argument names
+        OpName: "{{.Name}}",
-         which are derived from the GraphQL argument names; notably `input` is
+        Query:  `{{.Body}}`,
-         a common one.  So we use a name that's not legal in GraphQL, namely
+    {{if .Input -}}
-         one starting with a double-underscore. */ -}}
+        Variables: &{{.Input.GoName}}{
-    __input := {{.Input.GoName}}{
         {{range .Input.Fields -}}
         {{.GoName}}: {{.GraphQLName}},
         {{end -}}
-    }
+        },
     {{end -}}
-
+    }
     var err error
     {{if .Config.ClientGetter -}}
-    client, err := {{ref .Config.ClientGetter}}({{if ne .Config.ContextType "-"}}ctx{{else}}{{end}})
+    var client graphql.Client
+
+    client, err = {{ref .Config.ClientGetter}}({{if ne .Config.ContextType "-"}}ctx{{else}}{{end}})
     if err != nil {
-        return nil, err
+        return nil, {{if .Config.Extensions -}}nil,{{end -}} err
     }
     {{end}}
+    var data {{.ResponseName}}
+    resp := &graphql.Response{Data: &data}
 
-	var retval {{.ResponseName}}
     err = client.MakeRequest(
         {{if ne .Config.ContextType "-"}}ctx{{else}}nil{{end}},
-        "{{.Name}}",
+        req,
-        `{{.Body}}`,
+        resp,
-        &retval,
-        {{if .Input}}&__input{{else}}nil{{end}},
     )
-    return &retval, err
+	
+    return &data, {{if .Config.Extensions -}}resp.Extensions,{{end -}} err
 }

generate/testdata/snapshots/TestGenerate-ComplexInlineFragments.graphql-ComplexInlineFragments.graphql.go

@@ -1348,13 +1348,9 @@ func (v *ComplexInlineFragmentsRootTopic) GetName() string { return v.Name }
 func ComplexInlineFragments(
 	client graphql.Client,
 ) (*ComplexInlineFragmentsResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "ComplexInlineFragments",
-	var retval ComplexInlineFragmentsResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"ComplexInlineFragments",
-		`
 query ComplexInlineFragments {
 	root {
 		id
@@ -1441,9 +1437,18 @@ query ComplexInlineFragments {
 	}
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data ComplexInlineFragmentsResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-ComplexNamedFragments.graphql-ComplexNamedFragments.graphql.go

@@ -1742,13 +1742,9 @@ func (v *VideoFieldsThumbnail) GetId() testutil.ID { return v.Id }
 func ComplexNamedFragments(
 	client graphql.Client,
 ) (*ComplexNamedFragmentsResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "ComplexNamedFragments",
-	var retval ComplexNamedFragmentsResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"ComplexNamedFragments",
-		`
 query ComplexNamedFragments {
 	... on Query {
 		... QueryFragment
@@ -1807,9 +1803,18 @@ fragment MoreVideoFields on Video {
 	}
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data ComplexNamedFragmentsResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-CustomMarshal.graphql-CustomMarshal.graphql.go

@@ -178,16 +178,9 @@ func CustomMarshal(
 	client graphql.Client,
 	date time.Time,
 ) (*CustomMarshalResponse, error) {
-	__input := __CustomMarshalInput{
+	req := &graphql.Request{
-		Date: date,
+		OpName: "CustomMarshal",
-	}
+		Query: `
-	var err error
-
-	var retval CustomMarshalResponse
-	err = client.MakeRequest(
-		nil,
-		"CustomMarshal",
-		`
 query CustomMarshal ($date: Date!) {
 	usersBornOn(date: $date) {
 		id
@@ -195,9 +188,21 @@ query CustomMarshal ($date: Date!) {
 	}
 }
 `,
-		&retval,
+		Variables: &__CustomMarshalInput{
-		&__input,
+			Date: date,
+		},
+	}
+	var err error
+
+	var data CustomMarshalResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-CustomMarshalSlice.graphql-CustomMarshalSlice.graphql.go

@@ -208,25 +208,30 @@ func CustomMarshalSlice(
 	datesss [][][]time.Time,
 	datesssp [][][]*time.Time,
 ) (*CustomMarshalSliceResponse, error) {
-	__input := __CustomMarshalSliceInput{
+	req := &graphql.Request{
-		Datesss:  datesss,
+		OpName: "CustomMarshalSlice",
-		Datesssp: datesssp,
+		Query: `
-	}
-	var err error
-
-	var retval CustomMarshalSliceResponse
-	err = client.MakeRequest(
-		nil,
-		"CustomMarshalSlice",
-		`
 query CustomMarshalSlice ($datesss: [[[Date!]!]!]!, $datesssp: [[[Date!]!]!]!) {
 	acceptsListOfListOfListsOfDates(datesss: $datesss)
 	withPointer: acceptsListOfListOfListsOfDates(datesss: $datesssp)
 }
 `,
-		&retval,
+		Variables: &__CustomMarshalSliceInput{
-		&__input,
+			Datesss:  datesss,
+			Datesssp: datesssp,
+		},
+	}
+	var err error
+
+	var data CustomMarshalSliceResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-DateTime.graphql-DateTime.graphql.go

@@ -33,24 +33,29 @@ func convertTimezone(
 	dt time.Time,
 	tz string,
 ) (*convertTimezoneResponse, error) {
-	__input := __convertTimezoneInput{
+	req := &graphql.Request{
-		Dt: dt,
+		OpName: "convertTimezone",
-		Tz: tz,
+		Query: `
-	}
-	var err error
-
-	var retval convertTimezoneResponse
-	err = client.MakeRequest(
-		nil,
-		"convertTimezone",
-		`
 query convertTimezone ($dt: DateTime!, $tz: String) {
 	convert(dt: $dt, tz: $tz)
 }
 `,
-		&retval,
+		Variables: &__convertTimezoneInput{
-		&__input,
+			Dt: dt,
+			Tz: tz,
+		},
+	}
+	var err error
+
+	var data convertTimezoneResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-EmptyInterface.graphql-EmptyInterface.graphql.go

@@ -23,21 +23,26 @@ func (v *EmptyInterfaceResponse) GetGetComplexJunk() []map[string]*[]*map[string
 func EmptyInterface(
 	client graphql.Client,
 ) (*EmptyInterfaceResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "EmptyInterface",
-	var retval EmptyInterfaceResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"EmptyInterface",
-		`
 query EmptyInterface {
 	getJunk
 	getComplexJunk
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data EmptyInterfaceResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-Flatten.graphql-Flatten.graphql.go

@@ -269,13 +269,9 @@ func (v *VideoFieldsParentTopic) GetVideoChildren() []ChildVideoFields { return
 func ComplexNamedFragments(
 	client graphql.Client,
 ) (*InnerQueryFragment, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "ComplexNamedFragments",
-	var retval InnerQueryFragment
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"ComplexNamedFragments",
-		`
 query ComplexNamedFragments {
 	... QueryFragment
 }
@@ -311,9 +307,18 @@ fragment ChildVideoFields on Video {
 	name
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data InnerQueryFragment
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-InputEnum.graphql-InputEnum.graphql.go

@@ -58,25 +58,30 @@ func InputEnumQuery(
 	client graphql.Client,
 	role Role,
 ) (*InputEnumQueryResponse, error) {
-	__input := __InputEnumQueryInput{
+	req := &graphql.Request{
-		Role: role,
+		OpName: "InputEnumQuery",
-	}
+		Query: `
-	var err error
-
-	var retval InputEnumQueryResponse
-	err = client.MakeRequest(
-		nil,
-		"InputEnumQuery",
-		`
 query InputEnumQuery ($role: Role!) {
 	usersWithRole(role: $role) {
 		id
 	}
 }
 `,
-		&retval,
+		Variables: &__InputEnumQueryInput{
-		&__input,
+			Role: role,
+		},
+	}
+	var err error
+
+	var data InputEnumQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-InputObject.graphql-InputObject.graphql.go

@@ -181,25 +181,30 @@ func InputObjectQuery(
 	client graphql.Client,
 	query UserQueryInput,
 ) (*InputObjectQueryResponse, error) {
-	__input := __InputObjectQueryInput{
+	req := &graphql.Request{
-		Query: query,
+		OpName: "InputObjectQuery",
-	}
+		Query: `
-	var err error
-
-	var retval InputObjectQueryResponse
-	err = client.MakeRequest(
-		nil,
-		"InputObjectQuery",
-		`
 query InputObjectQuery ($query: UserQueryInput) {
 	user(query: $query) {
 		id
 	}
 }
 `,
-		&retval,
+		Variables: &__InputObjectQueryInput{
-		&__input,
+			Query: query,
+		},
+	}
+	var err error
+
+	var data InputObjectQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-InterfaceListField.graphql-InterfaceListField.graphql.go

@@ -523,13 +523,9 @@ func (v *InterfaceListFieldWithPointerTopicChildrenVideo) GetName() string { ret
 func InterfaceListField(
 	client graphql.Client,
 ) (*InterfaceListFieldResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "InterfaceListField",
-	var retval InterfaceListFieldResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"InterfaceListField",
-		`
 query InterfaceListField {
 	root {
 		id
@@ -551,9 +547,18 @@ query InterfaceListField {
 	}
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data InterfaceListFieldResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-InterfaceListOfListsOfListsField.graphql-InterfaceListOfListsOfListsField.graphql.go

@@ -509,13 +509,9 @@ func (v *InterfaceListOfListOfListsFieldWithPointerVideo) GetName() *string { re
 func InterfaceListOfListOfListsField(
 	client graphql.Client,
 ) (*InterfaceListOfListOfListsFieldResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "InterfaceListOfListOfListsField",
-	var retval InterfaceListOfListOfListsFieldResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"InterfaceListOfListOfListsField",
-		`
 query InterfaceListOfListOfListsField {
 	listOfListsOfListsOfContent {
 		__typename
@@ -529,9 +525,18 @@ query InterfaceListOfListOfListsField {
 	}
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data InterfaceListOfListOfListsFieldResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-InterfaceNesting.graphql-InterfaceNesting.graphql.go

@@ -507,13 +507,9 @@ func (v *InterfaceNestingRootTopicChildrenVideo) GetParent() InterfaceNestingRoo
 func InterfaceNesting(
 	client graphql.Client,
 ) (*InterfaceNestingResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "InterfaceNesting",
-	var retval InterfaceNestingResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"InterfaceNesting",
-		`
 query InterfaceNesting {
 	root {
 		id
@@ -531,9 +527,18 @@ query InterfaceNesting {
 	}
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data InterfaceNestingResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-InterfaceNoFragments.graphql-InterfaceNoFragments.graphql.go

@@ -629,13 +629,9 @@ func (v *InterfaceNoFragmentsQueryWithPointerVideo) GetName() *string { return v
 func InterfaceNoFragmentsQuery(
 	client graphql.Client,
 ) (*InterfaceNoFragmentsQueryResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "InterfaceNoFragmentsQuery",
-	var retval InterfaceNoFragmentsQueryResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"InterfaceNoFragmentsQuery",
-		`
 query InterfaceNoFragmentsQuery {
 	root {
 		id
@@ -658,9 +654,18 @@ query InterfaceNoFragmentsQuery {
 	}
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data InterfaceNoFragmentsQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-ListInput.graphql-ListInput.graphql.go

@@ -45,25 +45,30 @@ func ListInputQuery(
 	client graphql.Client,
 	names []string,
 ) (*ListInputQueryResponse, error) {
-	__input := __ListInputQueryInput{
+	req := &graphql.Request{
-		Names: names,
+		OpName: "ListInputQuery",
-	}
+		Query: `
-	var err error
-
-	var retval ListInputQueryResponse
-	err = client.MakeRequest(
-		nil,
-		"ListInputQuery",
-		`
 query ListInputQuery ($names: [String]) {
 	user(query: {names:$names}) {
 		id
 	}
 }
 `,
-		&retval,
+		Variables: &__ListInputQueryInput{
-		&__input,
+			Names: names,
+		},
+	}
+	var err error
+
+	var data ListInputQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-ListOfListsOfLists.graphql-ListOfListsOfLists.graphql.go

@@ -19,20 +19,25 @@ func (v *ListOfListsOfListsResponse) GetListOfListsOfLists() [][][]string {
 func ListOfListsOfLists(
 	client graphql.Client,
 ) (*ListOfListsOfListsResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "ListOfListsOfLists",
-	var retval ListOfListsOfListsResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"ListOfListsOfLists",
-		`
 query ListOfListsOfLists {
 	listOfListsOfLists
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data ListOfListsOfListsResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-MultipleDirectives.graphql-MultipleDirectives.graphql.go

@@ -330,17 +330,9 @@ func MultipleDirectives(
 	query MyInput,
 	queries []*UserQueryInput,
 ) (*MyMultipleDirectivesResponse, error) {
-	__input := __MultipleDirectivesInput{
+	req := &graphql.Request{
-		Query:   query,
+		OpName: "MultipleDirectives",
-		Queries: queries,
+		Query: `
-	}
-	var err error
-
-	var retval MyMultipleDirectivesResponse
-	err = client.MakeRequest(
-		nil,
-		"MultipleDirectives",
-		`
 query MultipleDirectives ($query: UserQueryInput, $queries: [UserQueryInput]) {
 	user(query: $query) {
 		id
@@ -350,9 +342,22 @@ query MultipleDirectives ($query: UserQueryInput, $queries: [UserQueryInput]) {
 	}
 }
 `,
-		&retval,
+		Variables: &__MultipleDirectivesInput{
-		&__input,
+			Query:   query,
+			Queries: queries,
+		},
+	}
+	var err error
+
+	var data MyMultipleDirectivesResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-Omitempty.graphql-Omitempty.graphql.go

@@ -227,20 +227,9 @@ func OmitEmptyQuery(
 	tz string,
 	tzNoOmitEmpty string,
 ) (*OmitEmptyQueryResponse, error) {
-	__input := __OmitEmptyQueryInput{
+	req := &graphql.Request{
-		Query:         query,
+		OpName: "OmitEmptyQuery",
-		Queries:       queries,
+		Query: `
-		Dt:            dt,
-		Tz:            tz,
-		TzNoOmitEmpty: tzNoOmitEmpty,
-	}
-	var err error
-
-	var retval OmitEmptyQueryResponse
-	err = client.MakeRequest(
-		nil,
-		"OmitEmptyQuery",
-		`
 query OmitEmptyQuery ($query: UserQueryInput, $queries: [UserQueryInput], $dt: DateTime, $tz: String, $tzNoOmitEmpty: String) {
 	user(query: $query) {
 		id
@@ -252,9 +241,25 @@ query OmitEmptyQuery ($query: UserQueryInput, $queries: [UserQueryInput], $dt: D
 	convert2: maybeConvert(dt: $dt, tz: $tzNoOmitEmpty)
 }
 `,
-		&retval,
+		Variables: &__OmitEmptyQueryInput{
-		&__input,
+			Query:         query,
+			Queries:       queries,
+			Dt:            dt,
+			Tz:            tz,
+			TzNoOmitEmpty: tzNoOmitEmpty,
+		},
+	}
+	var err error
+
+	var data OmitEmptyQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-Pointers.graphql-Pointers.graphql.go

@@ -236,18 +236,9 @@ func PointersQuery(
 	dt time.Time,
 	tz *string,
 ) (*PointersQueryResponse, error) {
-	__input := __PointersQueryInput{
+	req := &graphql.Request{
-		Query: query,
+		OpName: "PointersQuery",
-		Dt:    dt,
+		Query: `
-		Tz:    tz,
-	}
-	var err error
-
-	var retval PointersQueryResponse
-	err = client.MakeRequest(
-		nil,
-		"PointersQuery",
-		`
 query PointersQuery ($query: UserQueryInput, $dt: DateTime, $tz: String) {
 	user(query: $query) {
 		id
@@ -262,9 +253,23 @@ query PointersQuery ($query: UserQueryInput, $dt: DateTime, $tz: String) {
 	maybeConvert(dt: $dt, tz: $tz)
 }
 `,
-		&retval,
+		Variables: &__PointersQueryInput{
-		&__input,
+			Query: query,
+			Dt:    dt,
+			Tz:    tz,
+		},
+	}
+	var err error
+
+	var data PointersQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-PointersInline.graphql-PointersInline.graphql.go

@@ -233,18 +233,9 @@ func PointersQuery(
 	dt *time.Time,
 	tz string,
 ) (*PointersQueryResponse, error) {
-	__input := __PointersQueryInput{
+	req := &graphql.Request{
-		Query: query,
+		OpName: "PointersQuery",
-		Dt:    dt,
+		Query: `
-		Tz:    tz,
-	}
-	var err error
-
-	var retval PointersQueryResponse
-	err = client.MakeRequest(
-		nil,
-		"PointersQuery",
-		`
 query PointersQuery ($query: UserQueryInput, $dt: DateTime, $tz: String) {
 	user(query: $query) {
 		id
@@ -259,9 +250,23 @@ query PointersQuery ($query: UserQueryInput, $dt: DateTime, $tz: String) {
 	maybeConvert(dt: $dt, tz: $tz)
 }
 `,
-		&retval,
+		Variables: &__PointersQueryInput{
-		&__input,
+			Query: query,
+			Dt:    dt,
+			Tz:    tz,
+		},
+	}
+	var err error
+
+	var data PointersQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-Pokemon.graphql-Pokemon.graphql.go

@@ -75,16 +75,9 @@ func GetPokemonSiblings(
 	client graphql.Client,
 	input testutil.Pokemon,
 ) (*GetPokemonSiblingsResponse, error) {
-	__input := __GetPokemonSiblingsInput{
+	req := &graphql.Request{
-		Input: input,
+		OpName: "GetPokemonSiblings",
-	}
+		Query: `
-	var err error
-
-	var retval GetPokemonSiblingsResponse
-	err = client.MakeRequest(
-		nil,
-		"GetPokemonSiblings",
-		`
 query GetPokemonSiblings ($input: PokemonInput!) {
 	user(query: {hasPokemon:$input}) {
 		id
@@ -101,9 +94,21 @@ query GetPokemonSiblings ($input: PokemonInput!) {
 	}
 }
 `,
-		&retval,
+		Variables: &__GetPokemonSiblingsInput{
-		&__input,
+			Input: input,
+		},
+	}
+	var err error
+
+	var data GetPokemonSiblingsResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-QueryWithAlias.graphql-QueryWithAlias.graphql.go

@@ -43,13 +43,9 @@ func (v *QueryWithAliasUser) GetOtherID() testutil.ID { return v.OtherID }
 func QueryWithAlias(
 	client graphql.Client,
 ) (*QueryWithAliasResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "QueryWithAlias",
-	var retval QueryWithAliasResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"QueryWithAlias",
-		`
 query QueryWithAlias {
 	User: user {
 		ID: id
@@ -57,9 +53,18 @@ query QueryWithAlias {
 	}
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data QueryWithAliasResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-QueryWithDoubleAlias.graphql-QueryWithDoubleAlias.graphql.go

@@ -43,13 +43,9 @@ func (v *QueryWithDoubleAliasUser) GetAlsoID() testutil.ID { return v.AlsoID }
 func QueryWithDoubleAlias(
 	client graphql.Client,
 ) (*QueryWithDoubleAliasResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "QueryWithDoubleAlias",
-	var retval QueryWithDoubleAliasResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"QueryWithDoubleAlias",
-		`
 query QueryWithDoubleAlias {
 	user {
 		ID: id
@@ -57,9 +53,18 @@ query QueryWithDoubleAlias {
 	}
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data QueryWithDoubleAliasResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-QueryWithEnums.graphql-QueryWithEnums.graphql.go

@@ -65,13 +65,9 @@ const (
 func QueryWithEnums(
 	client graphql.Client,
 ) (*QueryWithEnumsResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "QueryWithEnums",
-	var retval QueryWithEnumsResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"QueryWithEnums",
-		`
 query QueryWithEnums {
 	user {
 		roles
@@ -81,9 +77,18 @@ query QueryWithEnums {
 	}
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data QueryWithEnumsResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-QueryWithSlices.graphql-QueryWithSlices.graphql.go

@@ -44,13 +44,9 @@ func (v *QueryWithSlicesUser) GetEmailsWithNullsOrNull() []string { return v.Ema
 func QueryWithSlices(
 	client graphql.Client,
 ) (*QueryWithSlicesResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "QueryWithSlices",
-	var retval QueryWithSlicesResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"QueryWithSlices",
-		`
 query QueryWithSlices {
 	user {
 		emails
@@ -60,9 +56,18 @@ query QueryWithSlices {
 	}
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data QueryWithSlicesResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-QueryWithStructs.graphql-QueryWithStructs.graphql.go

@@ -46,13 +46,9 @@ func (v *QueryWithStructsUserAuthMethodsAuthMethod) GetEmail() string { return v
 func QueryWithStructs(
 	client graphql.Client,
 ) (*QueryWithStructsResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "QueryWithStructs",
-	var retval QueryWithStructsResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"QueryWithStructs",
-		`
 query QueryWithStructs {
 	user {
 		authMethods {
@@ -62,9 +58,18 @@ query QueryWithStructs {
 	}
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data QueryWithStructsResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-Recursion.graphql-Recursion.graphql.go

@@ -72,16 +72,9 @@ func Recursion(
 	client graphql.Client,
 	input RecursiveInput,
 ) (*RecursionResponse, error) {
-	__input := __RecursionInput{
+	req := &graphql.Request{
-		Input: input,
+		OpName: "Recursion",
-	}
+		Query: `
-	var err error
-
-	var retval RecursionResponse
-	err = client.MakeRequest(
-		nil,
-		"Recursion",
-		`
 query Recursion ($input: RecursiveInput!) {
 	recur(input: $input) {
 		rec {
@@ -94,9 +87,21 @@ query Recursion ($input: RecursiveInput!) {
 	}
 }
 `,
-		&retval,
+		Variables: &__RecursionInput{
-		&__input,
+			Input: input,
+		},
+	}
+	var err error
+
+	var data RecursionResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-SimpleInlineFragment.graphql-SimpleInlineFragment.graphql.go

@@ -242,13 +242,9 @@ func (v *SimpleInlineFragmentResponse) __premarshalJSON() (*__premarshalSimpleIn
 func SimpleInlineFragment(
 	client graphql.Client,
 ) (*SimpleInlineFragmentResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "SimpleInlineFragment",
-	var retval SimpleInlineFragmentResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"SimpleInlineFragment",
-		`
 query SimpleInlineFragment {
 	randomItem {
 		__typename
@@ -263,9 +259,18 @@ query SimpleInlineFragment {
 	}
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data SimpleInlineFragmentResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-SimpleInput.graphql-SimpleInput.graphql.go

@@ -45,25 +45,30 @@ func SimpleInputQuery(
 	client graphql.Client,
 	name string,
 ) (*SimpleInputQueryResponse, error) {
-	__input := __SimpleInputQueryInput{
+	req := &graphql.Request{
-		Name: name,
+		OpName: "SimpleInputQuery",
-	}
+		Query: `
-	var err error
-
-	var retval SimpleInputQueryResponse
-	err = client.MakeRequest(
-		nil,
-		"SimpleInputQuery",
-		`
 query SimpleInputQuery ($name: String!) {
 	user(query: {name:$name}) {
 		id
 	}
 }
 `,
-		&retval,
+		Variables: &__SimpleInputQueryInput{
-		&__input,
+			Name: name,
+		},
+	}
+	var err error
+
+	var data SimpleInputQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-SimpleMutation.graphql-SimpleMutation.graphql.go

@@ -49,16 +49,9 @@ func SimpleMutation(
 	client graphql.Client,
 	name string,
 ) (*SimpleMutationResponse, error) {
-	__input := __SimpleMutationInput{
+	req := &graphql.Request{
-		Name: name,
+		OpName: "SimpleMutation",
-	}
+		Query: `
-	var err error
-
-	var retval SimpleMutationResponse
-	err = client.MakeRequest(
-		nil,
-		"SimpleMutation",
-		`
 mutation SimpleMutation ($name: String!) {
 	createUser(name: $name) {
 		id
@@ -66,9 +59,21 @@ mutation SimpleMutation ($name: String!) {
 	}
 }
 `,
-		&retval,
+		Variables: &__SimpleMutationInput{
-		&__input,
+			Name: name,
+		},
+	}
+	var err error
+
+	var data SimpleMutationResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-SimpleNamedFragment.graphql-SimpleNamedFragment.graphql.go

@@ -549,13 +549,9 @@ func (v *VideoFieldsThumbnail) GetId() testutil.ID { return v.Id }
 func SimpleNamedFragment(
 	client graphql.Client,
 ) (*SimpleNamedFragmentResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "SimpleNamedFragment",
-	var retval SimpleNamedFragmentResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"SimpleNamedFragment",
-		`
 query SimpleNamedFragment {
 	randomItem {
 		__typename
@@ -578,9 +574,18 @@ fragment VideoFields on Video {
 	}
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data SimpleNamedFragmentResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-SimpleQuery.graphql-SimpleQuery.graphql.go

@@ -36,22 +36,27 @@ func (v *SimpleQueryUser) GetId() testutil.ID { return v.Id }
 func SimpleQuery(
 	client graphql.Client,
 ) (*SimpleQueryResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "SimpleQuery",
-	var retval SimpleQueryResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"SimpleQuery",
-		`
 query SimpleQuery {
 	user {
 		id
 	}
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data SimpleQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-StructOption.graphql-StructOption.graphql.go

@@ -427,13 +427,9 @@ func (v *VideoFields) GetDuration() int { return v.Duration }
 func StructOption(
 	client graphql.Client,
 ) (*StructOptionResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "StructOption",
-	var retval StructOptionResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"StructOption",
-		`
 query StructOption {
 	root {
 		id
@@ -462,9 +458,18 @@ fragment VideoFields on Video {
 	duration
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data StructOptionResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-TypeName.graphql-TypeName.graphql.go

@@ -40,13 +40,9 @@ func (v *TypeNameQueryUser) GetId() testutil.ID { return v.Id }
 func TypeNameQuery(
 	client graphql.Client,
 ) (*TypeNameQueryResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "TypeNameQuery",
-	var retval TypeNameQueryResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"TypeNameQuery",
-		`
 query TypeNameQuery {
 	user {
 		__typename
@@ -54,9 +50,18 @@ query TypeNameQuery {
 	}
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data TypeNameQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-TypeNames.graphql-TypeNames.graphql.go

@@ -267,13 +267,9 @@ func (v *User) GetName() string { return v.Name }
 func TypeNames(
 	client graphql.Client,
 ) (*Resp, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "TypeNames",
-	var retval Resp
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"TypeNames",
-		`
 query TypeNames {
 	user {
 		id
@@ -290,9 +286,18 @@ query TypeNames {
 	}
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data Resp
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-UnionNoFragments.graphql-UnionNoFragments.graphql.go

@@ -177,22 +177,27 @@ func (v *UnionNoFragmentsQueryResponse) __premarshalJSON() (*__premarshalUnionNo
 func UnionNoFragmentsQuery(
 	client graphql.Client,
 ) (*UnionNoFragmentsQueryResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "UnionNoFragmentsQuery",
-	var retval UnionNoFragmentsQueryResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"UnionNoFragmentsQuery",
-		`
 query UnionNoFragmentsQuery {
 	randomLeaf {
 		__typename
 	}
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data UnionNoFragmentsQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-UsesEnumTwice.graphql-UsesEnumTwice.graphql.go

@@ -65,13 +65,9 @@ func (v *UsesEnumTwiceQueryResponse) GetOtherUser() UsesEnumTwiceQueryOtherUser
 func UsesEnumTwiceQuery(
 	client graphql.Client,
 ) (*UsesEnumTwiceQueryResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "UsesEnumTwiceQuery",
-	var retval UsesEnumTwiceQueryResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"UsesEnumTwiceQuery",
-		`
 query UsesEnumTwiceQuery {
 	Me: user {
 		roles
@@ -81,9 +77,18 @@ query UsesEnumTwiceQuery {
 	}
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data UsesEnumTwiceQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerate-unexported.graphql-unexported.graphql.go

@@ -181,25 +181,30 @@ func unexported(
 	client graphql.Client,
 	query UserQueryInput,
 ) (*unexportedResponse, error) {
-	__input := __unexportedInput{
+	req := &graphql.Request{
-		Query: query,
+		OpName: "unexported",
-	}
+		Query: `
-	var err error
-
-	var retval unexportedResponse
-	err = client.MakeRequest(
-		nil,
-		"unexported",
-		`
 query unexported ($query: UserQueryInput) {
 	user(query: $query) {
 		id
 	}
 }
 `,
-		&retval,
+		Variables: &__unexportedInput{
-		&__input,
+			Query: query,
+		},
+	}
+	var err error
+
+	var data unexportedResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerateWithConfig-ClientGetter-testdata-queries-generated.go

@@ -5,6 +5,7 @@ package queries
 import (
 	"context"
 
+	"github.com/Khan/genqlient/graphql"
 	"github.com/Khan/genqlient/internal/testutil"
 )
 
@@ -37,26 +38,33 @@ func (v *SimpleQueryUser) GetId() string { return v.Id }
 func SimpleQuery(
 	ctx context.Context,
 ) (*SimpleQueryResponse, error) {
-	var err error
+	req := &graphql.Request{
-	client, err := testutil.GetClientFromContext(ctx)
+		OpName: "SimpleQuery",
-	if err != nil {
+		Query: `
-		return nil, err
-	}
-
-	var retval SimpleQueryResponse
-	err = client.MakeRequest(
-		ctx,
-		"SimpleQuery",
-		`
 query SimpleQuery {
 	user {
 		id
 	}
 }
 `,
-		&retval,
+	}
-		nil,
+	var err error
+	var client graphql.Client
+
+	client, err = testutil.GetClientFromContext(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	var data SimpleQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerateWithConfig-ClientGetterCustomContext-testdata-queries-generated.go

@@ -5,6 +5,7 @@ package queries
 import (
 	"context"
 
+	"github.com/Khan/genqlient/graphql"
 	"github.com/Khan/genqlient/internal/testutil"
 )
 
@@ -40,26 +41,33 @@ func (v *SimpleQueryUser) GetId() string { return v.Id }
 func SimpleQuery(
 	ctx testutil.MyContext,
 ) (*SimpleQueryResponse, error) {
-	var err error
+	req := &graphql.Request{
-	client, err := testutil.GetClientFromMyContext(ctx)
+		OpName: "SimpleQuery",
-	if err != nil {
+		Query: `
-		return nil, err
-	}
-
-	var retval SimpleQueryResponse
-	err = client.MakeRequest(
-		ctx,
-		"SimpleQuery",
-		`
 query SimpleQuery {
 	user {
 		id
 	}
 }
 `,
-		&retval,
+	}
-		nil,
+	var err error
+	var client graphql.Client
+
+	client, err = testutil.GetClientFromMyContext(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	var data SimpleQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerateWithConfig-ClientGetterNoContext-testdata-queries-generated.go

@@ -3,6 +3,7 @@
 package queries
 
 import (
+	"github.com/Khan/genqlient/graphql"
 	"github.com/Khan/genqlient/internal/testutil"
 )
 
@@ -33,26 +34,33 @@ type SimpleQueryUser struct {
 func (v *SimpleQueryUser) GetId() string { return v.Id }
 
 func SimpleQuery() (*SimpleQueryResponse, error) {
-	var err error
+	req := &graphql.Request{
-	client, err := testutil.GetClientFromNowhere()
+		OpName: "SimpleQuery",
-	if err != nil {
+		Query: `
-		return nil, err
-	}
-
-	var retval SimpleQueryResponse
-	err = client.MakeRequest(
-		nil,
-		"SimpleQuery",
-		`
 query SimpleQuery {
 	user {
 		id
 	}
 }
 `,
-		&retval,
+	}
+	var err error
+	var client graphql.Client
+
+	client, err = testutil.GetClientFromNowhere()
+	if err != nil {
+		return nil, err
+	}
+
+	var data SimpleQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerateWithConfig-CustomContext-testdata-queries-generated.go

@@ -42,22 +42,27 @@ func SimpleQuery(
 	ctx testutil.MyContext,
 	client graphql.Client,
 ) (*SimpleQueryResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "SimpleQuery",
-	var retval SimpleQueryResponse
+		Query: `
-	err = client.MakeRequest(
-		ctx,
-		"SimpleQuery",
-		`
 query SimpleQuery {
 	user {
 		id
 	}
 }
 `,
-		&retval,
+	}
-		nil,
+	var err error
+
+	var data SimpleQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerateWithConfig-DefaultConfig-testdata-queries-generated.go

@@ -38,22 +38,27 @@ func SimpleQuery(
 	ctx context.Context,
 	client graphql.Client,
 ) (*SimpleQueryResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "SimpleQuery",
-	var retval SimpleQueryResponse
+		Query: `
-	err = client.MakeRequest(
-		ctx,
-		"SimpleQuery",
-		`
 query SimpleQuery {
 	user {
 		id
 	}
 }
 `,
-		&retval,
+	}
-		nil,
+	var err error
+
+	var data SimpleQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerateWithConfig-ExportOperations-testdata-queries-generated.go

@@ -38,22 +38,27 @@ func SimpleQuery(
 	ctx context.Context,
 	client graphql.Client,
 ) (*SimpleQueryResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "SimpleQuery",
-	var retval SimpleQueryResponse
+		Query: `
-	err = client.MakeRequest(
-		ctx,
-		"SimpleQuery",
-		`
 query SimpleQuery {
 	user {
 		id
 	}
 }
 `,
-		&retval,
+	}
-		nil,
+	var err error
+
+	var data SimpleQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerateWithConfig-Extensions-testdata-queries-generated.go

@@ -0,0 +1,64 @@
+// Code generated by github.com/Khan/genqlient, DO NOT EDIT.
+
+package queries
+
+import (
+	"context"
+
+	"github.com/Khan/genqlient/graphql"
+)
+
+// SimpleQueryResponse is returned by SimpleQuery on success.
+type SimpleQueryResponse struct {
+	// user looks up a user by some stuff.
+	//
+	// See UserQueryInput for what stuff is supported.
+	// If query is null, returns the current user.
+	User SimpleQueryUser `json:"user"`
+}
+
+// GetUser returns SimpleQueryResponse.User, and is useful for accessing the field via an interface.
+func (v *SimpleQueryResponse) GetUser() SimpleQueryUser { return v.User }
+
+// SimpleQueryUser includes the requested fields of the GraphQL type User.
+// The GraphQL type's documentation follows.
+//
+// A User is a user!
+type SimpleQueryUser struct {
+	// id is the user's ID.
+	//
+	// It is stable, unique, and opaque, like all good IDs.
+	Id string `json:"id"`
+}
+
+// GetId returns SimpleQueryUser.Id, and is useful for accessing the field via an interface.
+func (v *SimpleQueryUser) GetId() string { return v.Id }
+
+func SimpleQuery(
+	ctx context.Context,
+	client graphql.Client,
+) (*SimpleQueryResponse, map[string]interface{}, error) {
+	req := &graphql.Request{
+		OpName: "SimpleQuery",
+		Query: `
+query SimpleQuery {
+	user {
+		id
+	}
+}
+`,
+	}
+	var err error
+
+	var data SimpleQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
+	)
+
+	return &data, resp.Extensions, err
+}
+

generate/testdata/snapshots/TestGenerateWithConfig-NoContext-testdata-queries-generated.go

@@ -35,22 +35,27 @@ func (v *SimpleQueryUser) GetId() string { return v.Id }
 func SimpleQuery(
 	client graphql.Client,
 ) (*SimpleQueryResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "SimpleQuery",
-	var retval SimpleQueryResponse
+		Query: `
-	err = client.MakeRequest(
-		nil,
-		"SimpleQuery",
-		`
 query SimpleQuery {
 	user {
 		id
 	}
 }
 `,
-		&retval,
+	}
+	var err error
+
+	var data SimpleQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
 		nil,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerateWithConfig-PackageName-testdata-queries-myfile.go

@@ -38,22 +38,27 @@ func SimpleQuery(
 	ctx context.Context,
 	client graphql.Client,
 ) (*SimpleQueryResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "SimpleQuery",
-	var retval SimpleQueryResponse
+		Query: `
-	err = client.MakeRequest(
-		ctx,
-		"SimpleQuery",
-		`
 query SimpleQuery {
 	user {
 		id
 	}
 }
 `,
-		&retval,
+	}
-		nil,
+	var err error
+
+	var data SimpleQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerateWithConfig-StructReferences-testdata-queries-generated-structrefs.go

@@ -38,22 +38,27 @@ func SimpleQuery(
 	ctx context.Context,
 	client graphql.Client,
 ) (*SimpleQueryResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "SimpleQuery",
-	var retval SimpleQueryResponse
+		Query: `
-	err = client.MakeRequest(
-		ctx,
-		"SimpleQuery",
-		`
 query SimpleQuery {
 	user {
 		id
 	}
 }
 `,
-		&retval,
+	}
-		nil,
+	var err error
+
+	var data SimpleQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerateWithConfig-Subpackage-testdata-queries-mypkg-myfile.go

@@ -38,22 +38,27 @@ func SimpleQuery(
 	ctx context.Context,
 	client graphql.Client,
 ) (*SimpleQueryResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "SimpleQuery",
-	var retval SimpleQueryResponse
+		Query: `
-	err = client.MakeRequest(
-		ctx,
-		"SimpleQuery",
-		`
 query SimpleQuery {
 	user {
 		id
 	}
 }
 `,
-		&retval,
+	}
-		nil,
+	var err error
+
+	var data SimpleQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

generate/testdata/snapshots/TestGenerateWithConfig-SubpackageConfig-testdata-queries-mypkg-myfile.go

@@ -38,22 +38,27 @@ func SimpleQuery(
 	ctx context.Context,
 	client graphql.Client,
 ) (*SimpleQueryResponse, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "SimpleQuery",
-	var retval SimpleQueryResponse
+		Query: `
-	err = client.MakeRequest(
-		ctx,
-		"SimpleQuery",
-		`
 query SimpleQuery {
 	user {
 		id
 	}
 }
 `,
-		&retval,
+	}
-		nil,
+	var err error
+
+	var data SimpleQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, err
 }
 

graphql/client.go

@@ -13,9 +13,6 @@ import (
 
 // Client is the interface that the generated code calls into to actually make
 // requests.
-//
-// Unstable: This interface is likely to change before v1.0, see #19.  Creating
-// a client with NewClient will remain the same.
 type Client interface {
 	// MakeRequest must make a request to the client's GraphQL API.
 	//
@@ -23,26 +20,20 @@ type Client interface {
 	// is disabled in the genqlient settings, this will be set to
 	// context.Background().
 	//
-	// query is the literal string representing the GraphQL query, e.g.
+	// req contains the data to be sent to the GraphQL server.  Typically GraphQL
-	// `query myQuery { myField }`.  variables contains a JSON-marshalable
+	// APIs will expect it to simply be marshalled as JSON, but MakeRequest may
-	// value containing the variables to be sent along with the query,
+	// customize this.
-	// or may be nil if there are none.  Typically, GraphQL APIs will
-	// accept a JSON payload of the form
-	//	{"query": "query myQuery { ... }", "variables": {...}}`
-	// but MakeRequest may use some other transport, handle extensions, or set
-	// other parameters, if it wishes.
 	//
-	// retval is a pointer to the struct representing the query result, e.g.
+	// resp is the Response object into which the server's response will be
-	// new(myQueryResponse).  Typically, GraphQL APIs will return a JSON
+	// unmarshalled. Typically GraphQL APIs will return JSON which can be
-	// payload of the form
+	// unmarshalled directly into resp, but MakeRequest can customize it.
-	//	{"data": {...}, "errors": {...}}
+	// If the response contains an error, this must also be returned by
-	// and retval is designed so that `data` will json-unmarshal into `retval`.
+	// MakeRequest.  The field resp.Data will be prepopulated with a pointer
-	// (Errors are returned.) But again, MakeRequest may customize this.
+	// to an empty struct of the correct generated type (e.g. MyQueryResponse).
 	MakeRequest(
 		ctx context.Context,
-		opName string,
+		req *Request,
-		query string,
+		resp *Response,
-		retval, input interface{},
 	) error
 }
 
@@ -75,65 +66,79 @@ type Doer interface {
 	Do(*http.Request) (*http.Response, error)
 }
 
-type payload struct {
+// Request contains all the values required to build queries executed by
-	Query     string      `json:"query"`
+// the graphql.Client.
+//
+// Typically, GraphQL APIs will accept a JSON payload of the form
+//	{"query": "query myQuery { ... }", "variables": {...}}`
+// and Request marshals to this format.  However, MakeRequest may
+// marshal the data in some other way desired by the backend.
+type Request struct {
+	// The literal string representing the GraphQL query, e.g.
+	// `query myQuery { myField }`.
+	Query string `json:"query"`
+	// A JSON-marshalable value containing the variables to be sent
+	// along with the query, or nil if there are none.
 	Variables interface{} `json:"variables,omitempty"`
-	// OpName is only required if there are multiple queries in the document,
+	// The GraphQL operation name. The server typically doesn't
-	// but we set it unconditionally, because that's easier.
+	// require this unless there are multiple queries in the
+	// document, but genqlient sets it unconditionally anyway.
 	OpName string `json:"operationName"`
 }
 
-type response struct {
+// Response that contains data returned by the GraphQL API.
-	Data   interface{}   `json:"data"`
+//
-	Errors gqlerror.List `json:"errors"`
+// Typically, GraphQL APIs will return a JSON payload of the form
+//	{"data": {...}, "errors": {...}}
+// It may additionally contain a key named "extensions", that
+// might hold GraphQL protocol extensions. Extensions and Errors
+// are optional, depending on the values returned by the server.
+type Response struct {
+	Data       interface{}            `json:"data"`
+	Extensions map[string]interface{} `json:"extensions,omitempty"`
+	Errors     gqlerror.List          `json:"errors,omitempty"`
 }
 
-func (c *client) MakeRequest(ctx context.Context, opName string, query string, retval interface{}, variables interface{}) error {
+func (c *client) MakeRequest(ctx context.Context, req *Request, resp *Response) error {
-	body, err := json.Marshal(payload{
+	body, err := json.Marshal(req)
-		Query:     query,
-		Variables: variables,
-		OpName:    opName,
-	})
 	if err != nil {
 		return err
 	}
 
-	req, err := http.NewRequest(
+	httpReq, err := http.NewRequest(
 		c.method,
 		c.endpoint,
 		bytes.NewReader(body))
 	if err != nil {
 		return err
 	}
-	req.Header.Set("Content-Type", "application/json")
+	httpReq.Header.Set("Content-Type", "application/json")
 
 	if ctx != nil {
-		req = req.WithContext(ctx)
+		httpReq = httpReq.WithContext(ctx)
 	}
-	resp, err := c.httpClient.Do(req)
+
+	httpResp, err := c.httpClient.Do(httpReq)
 	if err != nil {
 		return err
 	}
-	defer resp.Body.Close()
+	defer httpResp.Body.Close()
 
-	if resp.StatusCode != http.StatusOK {
+	if httpResp.StatusCode != http.StatusOK {
 		var respBody []byte
-		respBody, err = io.ReadAll(resp.Body)
+		respBody, err = io.ReadAll(httpResp.Body)
 		if err != nil {
 			respBody = []byte(fmt.Sprintf("<unreadable: %v>", err))
 		}
-		return fmt.Errorf("returned error %v: %s", resp.Status, respBody)
+		return fmt.Errorf("returned error %v: %s", httpResp.Status, respBody)
 	}
 
-	var dataAndErrors response
+	err = json.NewDecoder(httpResp.Body).Decode(resp)
-	dataAndErrors.Data = retval
-	err = json.NewDecoder(resp.Body).Decode(&dataAndErrors)
 	if err != nil {
 		return err
 	}
-
+	if len(resp.Errors) > 0 {
-	if len(dataAndErrors.Errors) > 0 {
+		return resp.Errors
-		return dataAndErrors.Errors
 	}
 	return nil
 }

internal/integration/generated.go

@@ -2995,6 +2995,30 @@ func (v *queryWithVariablesUser) GetName() string { return v.Name }
 // GetLuckyNumber returns queryWithVariablesUser.LuckyNumber, and is useful for accessing the field via an interface.
 func (v *queryWithVariablesUser) GetLuckyNumber() int { return v.LuckyNumber }
 
+// simpleQueryExtMeUser includes the requested fields of the GraphQL type User.
+type simpleQueryExtMeUser struct {
+	Id          string `json:"id"`
+	Name        string `json:"name"`
+	LuckyNumber int    `json:"luckyNumber"`
+}
+
+// GetId returns simpleQueryExtMeUser.Id, and is useful for accessing the field via an interface.
+func (v *simpleQueryExtMeUser) GetId() string { return v.Id }
+
+// GetName returns simpleQueryExtMeUser.Name, and is useful for accessing the field via an interface.
+func (v *simpleQueryExtMeUser) GetName() string { return v.Name }
+
+// GetLuckyNumber returns simpleQueryExtMeUser.LuckyNumber, and is useful for accessing the field via an interface.
+func (v *simpleQueryExtMeUser) GetLuckyNumber() int { return v.LuckyNumber }
+
+// simpleQueryExtResponse is returned by simpleQueryExt on success.
+type simpleQueryExtResponse struct {
+	Me simpleQueryExtMeUser `json:"me"`
+}
+
+// GetMe returns simpleQueryExtResponse.Me, and is useful for accessing the field via an interface.
+func (v *simpleQueryExtResponse) GetMe() simpleQueryExtMeUser { return v.Me }
+
 // simpleQueryMeUser includes the requested fields of the GraphQL type User.
 type simpleQueryMeUser struct {
 	Id          string `json:"id"`
@@ -3022,14 +3046,10 @@ func (v *simpleQueryResponse) GetMe() simpleQueryMeUser { return v.Me }
 func failingQuery(
 	ctx context.Context,
 	client graphql.Client,
-) (*failingQueryResponse, error) {
+) (*failingQueryResponse, map[string]interface{}, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "failingQuery",
-	var retval failingQueryResponse
+		Query: `
-	err = client.MakeRequest(
-		ctx,
-		"failingQuery",
-		`
 query failingQuery {
 	fail
 	me {
@@ -3037,27 +3057,29 @@ query failingQuery {
 	}
 }
 `,
-		&retval,
+	}
-		nil,
+	var err error
+
+	var data failingQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, resp.Extensions, err
 }
 
 func queryWithCustomMarshal(
 	ctx context.Context,
 	client graphql.Client,
 	date time.Time,
-) (*queryWithCustomMarshalResponse, error) {
+) (*queryWithCustomMarshalResponse, map[string]interface{}, error) {
-	__input := __queryWithCustomMarshalInput{
+	req := &graphql.Request{
-		Date: date,
+		OpName: "queryWithCustomMarshal",
-	}
+		Query: `
-	var err error
-
-	var retval queryWithCustomMarshalResponse
-	err = client.MakeRequest(
-		ctx,
-		"queryWithCustomMarshal",
-		`
 query queryWithCustomMarshal ($date: Date!) {
 	usersBornOn(date: $date) {
 		id
@@ -3066,10 +3088,22 @@ query queryWithCustomMarshal ($date: Date!) {
 	}
 }
 `,
-		&retval,
+		Variables: &__queryWithCustomMarshalInput{
-		&__input,
+			Date: date,
+		},
+	}
+	var err error
+
+	var data queryWithCustomMarshalResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, resp.Extensions, err
 }
 
 func queryWithCustomMarshalOptional(
@@ -3077,18 +3111,10 @@ func queryWithCustomMarshalOptional(
 	client graphql.Client,
 	date *time.Time,
 	id *string,
-) (*queryWithCustomMarshalOptionalResponse, error) {
+) (*queryWithCustomMarshalOptionalResponse, map[string]interface{}, error) {
-	__input := __queryWithCustomMarshalOptionalInput{
+	req := &graphql.Request{
-		Date: date,
+		OpName: "queryWithCustomMarshalOptional",
-		Id:   id,
+		Query: `
-	}
-	var err error
-
-	var retval queryWithCustomMarshalOptionalResponse
-	err = client.MakeRequest(
-		ctx,
-		"queryWithCustomMarshalOptional",
-		`
 query queryWithCustomMarshalOptional ($date: Date, $id: ID) {
 	userSearch(birthdate: $date, id: $id) {
 		id
@@ -3097,27 +3123,33 @@ query queryWithCustomMarshalOptional ($date: Date, $id: ID) {
 	}
 }
 `,
-		&retval,
+		Variables: &__queryWithCustomMarshalOptionalInput{
-		&__input,
+			Date: date,
+			Id:   id,
+		},
+	}
+	var err error
+
+	var data queryWithCustomMarshalOptionalResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, resp.Extensions, err
 }
 
 func queryWithCustomMarshalSlice(
 	ctx context.Context,
 	client graphql.Client,
 	dates []time.Time,
-) (*queryWithCustomMarshalSliceResponse, error) {
+) (*queryWithCustomMarshalSliceResponse, map[string]interface{}, error) {
-	__input := __queryWithCustomMarshalSliceInput{
+	req := &graphql.Request{
-		Dates: dates,
+		OpName: "queryWithCustomMarshalSlice",
-	}
+		Query: `
-	var err error
-
-	var retval queryWithCustomMarshalSliceResponse
-	err = client.MakeRequest(
-		ctx,
-		"queryWithCustomMarshalSlice",
-		`
 query queryWithCustomMarshalSlice ($dates: [Date!]!) {
 	usersBornOnDates(dates: $dates) {
 		id
@@ -3126,27 +3158,32 @@ query queryWithCustomMarshalSlice ($dates: [Date!]!) {
 	}
 }
 `,
-		&retval,
+		Variables: &__queryWithCustomMarshalSliceInput{
-		&__input,
+			Dates: dates,
+		},
+	}
+	var err error
+
+	var data queryWithCustomMarshalSliceResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, resp.Extensions, err
 }
 
 func queryWithFlatten(
 	ctx context.Context,
 	client graphql.Client,
 	ids []string,
-) (*QueryFragment, error) {
+) (*QueryFragment, map[string]interface{}, error) {
-	__input := __queryWithFlattenInput{
+	req := &graphql.Request{
-		Ids: ids,
+		OpName: "queryWithFlatten",
-	}
+		Query: `
-	var err error
-
-	var retval QueryFragment
-	err = client.MakeRequest(
-		ctx,
-		"queryWithFlatten",
-		`
 query queryWithFlatten ($ids: [ID!]!) {
 	... QueryFragment
 }
@@ -3189,27 +3226,32 @@ fragment FriendsFields on User {
 	name
 }
 `,
-		&retval,
+		Variables: &__queryWithFlattenInput{
-		&__input,
+			Ids: ids,
+		},
+	}
+	var err error
+
+	var data QueryFragment
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, resp.Extensions, err
 }
 
 func queryWithFragments(
 	ctx context.Context,
 	client graphql.Client,
 	ids []string,
-) (*queryWithFragmentsResponse, error) {
+) (*queryWithFragmentsResponse, map[string]interface{}, error) {
-	__input := __queryWithFragmentsInput{
+	req := &graphql.Request{
-		Ids: ids,
+		OpName: "queryWithFragments",
-	}
+		Query: `
-	var err error
-
-	var retval queryWithFragmentsResponse
-	err = client.MakeRequest(
-		ctx,
-		"queryWithFragments",
-		`
 query queryWithFragments ($ids: [ID!]!) {
 	beings(ids: $ids) {
 		__typename
@@ -3246,27 +3288,32 @@ query queryWithFragments ($ids: [ID!]!) {
 	}
 }
 `,
-		&retval,
+		Variables: &__queryWithFragmentsInput{
-		&__input,
+			Ids: ids,
+		},
+	}
+	var err error
+
+	var data queryWithFragmentsResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, resp.Extensions, err
 }
 
 func queryWithInterfaceListField(
 	ctx context.Context,
 	client graphql.Client,
 	ids []string,
-) (*queryWithInterfaceListFieldResponse, error) {
+) (*queryWithInterfaceListFieldResponse, map[string]interface{}, error) {
-	__input := __queryWithInterfaceListFieldInput{
+	req := &graphql.Request{
-		Ids: ids,
+		OpName: "queryWithInterfaceListField",
-	}
+		Query: `
-	var err error
-
-	var retval queryWithInterfaceListFieldResponse
-	err = client.MakeRequest(
-		ctx,
-		"queryWithInterfaceListField",
-		`
 query queryWithInterfaceListField ($ids: [ID!]!) {
 	beings(ids: $ids) {
 		__typename
@@ -3275,27 +3322,32 @@ query queryWithInterfaceListField ($ids: [ID!]!) {
 	}
 }
 `,
-		&retval,
+		Variables: &__queryWithInterfaceListFieldInput{
-		&__input,
+			Ids: ids,
+		},
+	}
+	var err error
+
+	var data queryWithInterfaceListFieldResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, resp.Extensions, err
 }
 
 func queryWithInterfaceListPointerField(
 	ctx context.Context,
 	client graphql.Client,
 	ids []string,
-) (*queryWithInterfaceListPointerFieldResponse, error) {
+) (*queryWithInterfaceListPointerFieldResponse, map[string]interface{}, error) {
-	__input := __queryWithInterfaceListPointerFieldInput{
+	req := &graphql.Request{
-		Ids: ids,
+		OpName: "queryWithInterfaceListPointerField",
-	}
+		Query: `
-	var err error
-
-	var retval queryWithInterfaceListPointerFieldResponse
-	err = client.MakeRequest(
-		ctx,
-		"queryWithInterfaceListPointerField",
-		`
 query queryWithInterfaceListPointerField ($ids: [ID!]!) {
 	beings(ids: $ids) {
 		__typename
@@ -3304,27 +3356,32 @@ query queryWithInterfaceListPointerField ($ids: [ID!]!) {
 	}
 }
 `,
-		&retval,
+		Variables: &__queryWithInterfaceListPointerFieldInput{
-		&__input,
+			Ids: ids,
+		},
+	}
+	var err error
+
+	var data queryWithInterfaceListPointerFieldResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, resp.Extensions, err
 }
 
 func queryWithInterfaceNoFragments(
 	ctx context.Context,
 	client graphql.Client,
 	id string,
-) (*queryWithInterfaceNoFragmentsResponse, error) {
+) (*queryWithInterfaceNoFragmentsResponse, map[string]interface{}, error) {
-	__input := __queryWithInterfaceNoFragmentsInput{
+	req := &graphql.Request{
-		Id: id,
+		OpName: "queryWithInterfaceNoFragments",
-	}
+		Query: `
-	var err error
-
-	var retval queryWithInterfaceNoFragmentsResponse
-	err = client.MakeRequest(
-		ctx,
-		"queryWithInterfaceNoFragments",
-		`
 query queryWithInterfaceNoFragments ($id: ID!) {
 	being(id: $id) {
 		__typename
@@ -3337,27 +3394,32 @@ query queryWithInterfaceNoFragments ($id: ID!) {
 	}
 }
 `,
-		&retval,
+		Variables: &__queryWithInterfaceNoFragmentsInput{
-		&__input,
+			Id: id,
+		},
+	}
+	var err error
+
+	var data queryWithInterfaceNoFragmentsResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, resp.Extensions, err
 }
 
 func queryWithNamedFragments(
 	ctx context.Context,
 	client graphql.Client,
 	ids []string,
-) (*queryWithNamedFragmentsResponse, error) {
+) (*queryWithNamedFragmentsResponse, map[string]interface{}, error) {
-	__input := __queryWithNamedFragmentsInput{
+	req := &graphql.Request{
-		Ids: ids,
+		OpName: "queryWithNamedFragments",
-	}
+		Query: `
-	var err error
-
-	var retval queryWithNamedFragmentsResponse
-	err = client.MakeRequest(
-		ctx,
-		"queryWithNamedFragments",
-		`
 query queryWithNamedFragments ($ids: [ID!]!) {
 	beings(ids: $ids) {
 		__typename
@@ -3394,27 +3456,32 @@ fragment MoreUserFields on User {
 	}
 }
 `,
-		&retval,
+		Variables: &__queryWithNamedFragmentsInput{
-		&__input,
+			Ids: ids,
+		},
+	}
+	var err error
+
+	var data queryWithNamedFragmentsResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, resp.Extensions, err
 }
 
 func queryWithOmitempty(
 	ctx context.Context,
 	client graphql.Client,
 	id string,
-) (*queryWithOmitemptyResponse, error) {
+) (*queryWithOmitemptyResponse, map[string]interface{}, error) {
-	__input := __queryWithOmitemptyInput{
+	req := &graphql.Request{
-		Id: id,
+		OpName: "queryWithOmitempty",
-	}
+		Query: `
-	var err error
-
-	var retval queryWithOmitemptyResponse
-	err = client.MakeRequest(
-		ctx,
-		"queryWithOmitempty",
-		`
 query queryWithOmitempty ($id: ID) {
 	user(id: $id) {
 		id
@@ -3423,27 +3490,32 @@ query queryWithOmitempty ($id: ID) {
 	}
 }
 `,
-		&retval,
+		Variables: &__queryWithOmitemptyInput{
-		&__input,
+			Id: id,
+		},
+	}
+	var err error
+
+	var data queryWithOmitemptyResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, resp.Extensions, err
 }
 
 func queryWithVariables(
 	ctx context.Context,
 	client graphql.Client,
 	id string,
-) (*queryWithVariablesResponse, error) {
+) (*queryWithVariablesResponse, map[string]interface{}, error) {
-	__input := __queryWithVariablesInput{
+	req := &graphql.Request{
-		Id: id,
+		OpName: "queryWithVariables",
-	}
+		Query: `
-	var err error
-
-	var retval queryWithVariablesResponse
-	err = client.MakeRequest(
-		ctx,
-		"queryWithVariables",
-		`
 query queryWithVariables ($id: ID!) {
 	user(id: $id) {
 		id
@@ -3452,23 +3524,31 @@ query queryWithVariables ($id: ID!) {
 	}
 }
 `,
-		&retval,
+		Variables: &__queryWithVariablesInput{
-		&__input,
+			Id: id,
+		},
+	}
+	var err error
+
+	var data queryWithVariablesResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, resp.Extensions, err
 }
 
 func simpleQuery(
 	ctx context.Context,
 	client graphql.Client,
-) (*simpleQueryResponse, error) {
+) (*simpleQueryResponse, map[string]interface{}, error) {
-	var err error
+	req := &graphql.Request{
-
+		OpName: "simpleQuery",
-	var retval simpleQueryResponse
+		Query: `
-	err = client.MakeRequest(
-		ctx,
-		"simpleQuery",
-		`
 query simpleQuery {
 	me {
 		id
@@ -3477,8 +3557,47 @@ query simpleQuery {
 	}
 }
 `,
-		&retval,
+	}
-		nil,
+	var err error
+
+	var data simpleQueryResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
 	)
-	return &retval, err
+
+	return &data, resp.Extensions, err
+}
+
+func simpleQueryExt(
+	ctx context.Context,
+	client graphql.Client,
+) (*simpleQueryExtResponse, map[string]interface{}, error) {
+	req := &graphql.Request{
+		OpName: "simpleQueryExt",
+		Query: `
+query simpleQueryExt {
+	me {
+		id
+		name
+		luckyNumber
+	}
+}
+`,
+	}
+	var err error
+
+	var data simpleQueryExtResponse
+	resp := &graphql.Response{Data: &data}
+
+	err = client.MakeRequest(
+		ctx,
+		req,
+		resp,
+	)
+
+	return &data, resp.Extensions, err
 }

internal/integration/genqlient.yaml

@@ -2,6 +2,7 @@ schema: schema.graphql
 operations: "*_test.go"
 generated: generated.go
 allow_broken_features: true
+use_extensions: true
 bindings:
   Date:
     type: time.Time

internal/integration/integration_test.go

@@ -27,7 +27,7 @@ func TestSimpleQuery(t *testing.T) {
 	defer server.Close()
 	client := newRoundtripClient(t, server.URL)
 
-	resp, err := simpleQuery(ctx, client)
+	resp, _, err := simpleQuery(ctx, client)
 	require.NoError(t, err)
 
 	assert.Equal(t, "1", resp.Me.Id)
@@ -44,7 +44,7 @@ func TestServerError(t *testing.T) {
 	defer server.Close()
 	client := newRoundtripClient(t, server.URL)
 
-	resp, err := failingQuery(ctx, client)
+	resp, _, err := failingQuery(ctx, client)
 	// As long as we get some response back, we should still return a full
 	// response -- and indeed in this case it should even have another field
 	// (which didn't err) set.
@@ -57,7 +57,7 @@ func TestNetworkError(t *testing.T) {
 	ctx := context.Background()
 	client := newRoundtripClient(t, "https://nothing.invalid/graphql")
 
-	resp, err := failingQuery(ctx, client)
+	resp, _, err := failingQuery(ctx, client)
 	// As we guarantee in the README, even on network error you always get a
 	// non-nil response; this is so you can write e.g.
 	//	resp, err := failingQuery(ctx)
@@ -82,19 +82,34 @@ func TestVariables(t *testing.T) {
 	// worry about it.
 	client := graphql.NewClient(server.URL, http.DefaultClient)
 
-	resp, err := queryWithVariables(ctx, client, "2")
+	resp, _, err := queryWithVariables(ctx, client, "2")
 	require.NoError(t, err)
 
 	assert.Equal(t, "2", resp.User.Id)
 	assert.Equal(t, "Raven", resp.User.Name)
 	assert.Equal(t, -1, resp.User.LuckyNumber)
 
-	resp, err = queryWithVariables(ctx, client, "374892379482379")
+	resp, _, err = queryWithVariables(ctx, client, "374892379482379")
 	require.NoError(t, err)
 
 	assert.Zero(t, resp.User)
 }
 
+func TestExtensions(t *testing.T) {
+	_ = `# @genqlient
+	query simpleQueryExt { me { id name luckyNumber } }`
+
+	ctx := context.Background()
+	server := server.RunServer()
+	defer server.Close()
+	client := newRoundtripClient(t, server.URL)
+
+	_, extensions, err := simpleQueryExt(ctx, client)
+	require.NoError(t, err)
+	assert.NotNil(t, extensions)
+	assert.Equal(t, extensions["foobar"], "test")
+}
+
 func TestOmitempty(t *testing.T) {
 	_ = `# @genqlient(omitempty: true)
 	query queryWithOmitempty($id: ID) {
@@ -106,7 +121,7 @@ func TestOmitempty(t *testing.T) {
 	defer server.Close()
 	client := newRoundtripClient(t, server.URL)
 
-	resp, err := queryWithOmitempty(ctx, client, "2")
+	resp, _, err := queryWithOmitempty(ctx, client, "2")
 	require.NoError(t, err)
 
 	assert.Equal(t, "2", resp.User.Id)
@@ -114,7 +129,7 @@ func TestOmitempty(t *testing.T) {
 	assert.Equal(t, -1, resp.User.LuckyNumber)
 
 	// should return default user, not the user with ID ""
-	resp, err = queryWithOmitempty(ctx, client, "")
+	resp, _, err = queryWithOmitempty(ctx, client, "")
 	require.NoError(t, err)
 
 	assert.Equal(t, "1", resp.User.Id)
@@ -133,7 +148,7 @@ func TestCustomMarshal(t *testing.T) {
 	defer server.Close()
 	client := newRoundtripClient(t, server.URL)
 
-	resp, err := queryWithCustomMarshal(ctx, client,
+	resp, _, err := queryWithCustomMarshal(ctx, client,
 		time.Date(2025, time.January, 1, 12, 34, 56, 789, time.UTC))
 	require.NoError(t, err)
 
@@ -145,7 +160,7 @@ func TestCustomMarshal(t *testing.T) {
 		time.Date(2025, time.January, 1, 0, 0, 0, 0, time.UTC),
 		user.Birthdate)
 
-	resp, err = queryWithCustomMarshal(ctx, client,
+	resp, _, err = queryWithCustomMarshal(ctx, client,
 		time.Date(2021, time.January, 1, 12, 34, 56, 789, time.UTC))
 	require.NoError(t, err)
 	assert.Len(t, resp.UsersBornOn, 0)
@@ -162,7 +177,7 @@ func TestCustomMarshalSlice(t *testing.T) {
 	defer server.Close()
 	client := newRoundtripClient(t, server.URL)
 
-	resp, err := queryWithCustomMarshalSlice(ctx, client,
+	resp, _, err := queryWithCustomMarshalSlice(ctx, client,
 		[]time.Time{time.Date(2025, time.January, 1, 12, 34, 56, 789, time.UTC)})
 	require.NoError(t, err)
 
@@ -174,7 +189,7 @@ func TestCustomMarshalSlice(t *testing.T) {
 		time.Date(2025, time.January, 1, 0, 0, 0, 0, time.UTC),
 		user.Birthdate)
 
-	resp, err = queryWithCustomMarshalSlice(ctx, client,
+	resp, _, err = queryWithCustomMarshalSlice(ctx, client,
 		[]time.Time{time.Date(2021, time.January, 1, 12, 34, 56, 789, time.UTC)})
 	require.NoError(t, err)
 	assert.Len(t, resp.UsersBornOnDates, 0)
@@ -197,7 +212,7 @@ func TestCustomMarshalOptional(t *testing.T) {
 	client := newRoundtripClient(t, server.URL)
 
 	date := time.Date(2025, time.January, 1, 12, 34, 56, 789, time.UTC)
-	resp, err := queryWithCustomMarshalOptional(ctx, client, &date, nil)
+	resp, _, err := queryWithCustomMarshalOptional(ctx, client, &date, nil)
 	require.NoError(t, err)
 
 	assert.Len(t, resp.UserSearch, 1)
@@ -209,7 +224,7 @@ func TestCustomMarshalOptional(t *testing.T) {
 		user.Birthdate)
 
 	id := "2"
-	resp, err = queryWithCustomMarshalOptional(ctx, client, nil, &id)
+	resp, _, err = queryWithCustomMarshalOptional(ctx, client, nil, &id)
 	require.NoError(t, err)
 	assert.Len(t, resp.UserSearch, 1)
 	user = resp.UserSearch[0]
@@ -230,7 +245,7 @@ func TestInterfaceNoFragments(t *testing.T) {
 	defer server.Close()
 	client := newRoundtripClient(t, server.URL)
 
-	resp, err := queryWithInterfaceNoFragments(ctx, client, "1")
+	resp, _, err := queryWithInterfaceNoFragments(ctx, client, "1")
 	require.NoError(t, err)
 
 	// We should get the following response:
@@ -250,7 +265,7 @@ func TestInterfaceNoFragments(t *testing.T) {
 	assert.Equal(t, "1", user.Id)
 	assert.Equal(t, "Yours Truly", user.Name)
 
-	resp, err = queryWithInterfaceNoFragments(ctx, client, "3")
+	resp, _, err = queryWithInterfaceNoFragments(ctx, client, "3")
 	require.NoError(t, err)
 
 	// We should get the following response:
@@ -269,7 +284,7 @@ func TestInterfaceNoFragments(t *testing.T) {
 	assert.Equal(t, "3", animal.Id)
 	assert.Equal(t, "Fido", animal.Name)
 
-	resp, err = queryWithInterfaceNoFragments(ctx, client, "4757233945723")
+	resp, _, err = queryWithInterfaceNoFragments(ctx, client, "4757233945723")
 	require.NoError(t, err)
 
 	// We should get the following response:
@@ -293,7 +308,7 @@ func TestInterfaceListField(t *testing.T) {
 	defer server.Close()
 	client := newRoundtripClient(t, server.URL)
 
-	resp, err := queryWithInterfaceListField(ctx, client,
+	resp, _, err := queryWithInterfaceListField(ctx, client,
 		[]string{"1", "3", "12847394823"})
 	require.NoError(t, err)
 
@@ -340,7 +355,7 @@ func TestInterfaceListPointerField(t *testing.T) {
 	defer server.Close()
 	client := newRoundtripClient(t, server.URL)
 
-	resp, err := queryWithInterfaceListPointerField(ctx, client,
+	resp, _, err := queryWithInterfaceListPointerField(ctx, client,
 		[]string{"1", "3", "12847394823"})
 	require.NoError(t, err)
 
@@ -394,7 +409,7 @@ func TestFragments(t *testing.T) {
 	defer server.Close()
 	client := newRoundtripClient(t, server.URL)
 
-	resp, err := queryWithFragments(ctx, client, []string{"1", "3", "12847394823"})
+	resp, _, err := queryWithFragments(ctx, client, []string{"1", "3", "12847394823"})
 	require.NoError(t, err)
 
 	require.Len(t, resp.Beings, 3)
@@ -487,7 +502,7 @@ func TestNamedFragments(t *testing.T) {
 	defer server.Close()
 	client := newRoundtripClient(t, server.URL)
 
-	resp, err := queryWithNamedFragments(ctx, client, []string{"1", "3", "12847394823"})
+	resp, _, err := queryWithNamedFragments(ctx, client, []string{"1", "3", "12847394823"})
 	require.NoError(t, err)
 
 	require.Len(t, resp.Beings, 3)
@@ -616,7 +631,7 @@ func TestFlatten(t *testing.T) {
 	defer server.Close()
 	client := newRoundtripClient(t, server.URL)
 
-	resp, err := queryWithFlatten(ctx, client, []string{"1", "3", "12847394823"})
+	resp, _, err := queryWithFlatten(ctx, client, []string{"1", "3", "12847394823"})
 	require.NoError(t, err)
 
 	require.Len(t, resp.Beings, 3)

internal/integration/roundtrip.go

@@ -88,16 +88,16 @@ func (c *roundtripClient) roundtripResponse(resp interface{}) {
 	assert.Equal(c.t, string(body), string(bodyAgain))
 }
 
-func (c *roundtripClient) MakeRequest(ctx context.Context, opName, query string, retval, variables interface{}) error {
+func (c *roundtripClient) MakeRequest(ctx context.Context, req *graphql.Request, resp *graphql.Response) error {
 	// TODO(benkraft): Also check the variables round-trip.  This is a bit less
 	// important since most of the code is the same (and input types are
 	// strictly simpler), and a bit hard to do because when asserting about
 	// structs we need to worry about things like equality of time.Time values.
-	err := c.wrapped.MakeRequest(ctx, opName, query, retval, variables)
+	err := c.wrapped.MakeRequest(ctx, req, resp)
 	if err != nil {
 		return err
 	}
-	c.roundtripResponse(retval)
+	c.roundtripResponse(resp.Data)
 	return nil
 }
 

internal/integration/server/server.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"net/http/httptest"
 
+	"github.com/99designs/gqlgen/graphql"
 	"github.com/99designs/gqlgen/graphql/handler"
 	"github.com/99designs/gqlgen/graphql/handler/transport"
 )
@@ -131,6 +132,10 @@ func (r *queryResolver) Fail(ctx context.Context) (*bool, error) {
 func RunServer() *httptest.Server {
 	gqlgenServer := handler.New(NewExecutableSchema(Config{Resolvers: &resolver{}}))
 	gqlgenServer.AddTransport(transport.POST{})
+	gqlgenServer.AroundResponses(func(ctx context.Context, next graphql.ResponseHandler) *graphql.Response {
+		graphql.RegisterExtension(ctx, "foobar", "test")
+		return next(ctx)
+	})
 	return httptest.NewServer(gqlgenServer)
 }