Fix

Author: sonatard

.gitignore

@@ -1,13 +1,3 @@
-/.gqlgenc.yml
-/models_gen.go
-/**/.graphqlconfig
-/schema.graphql
-/client.go
-/query/
-/.idea/
-
-coverage.out
-.vscode/
-
-# Actual files output by the end-to-end tests
 generator/testdata/**/actual
+
+gqlgenc

.golangci.yml

@@ -74,10 +74,6 @@ issues:
       text: "`Extensions` is unused" # used in line 48
       linters:
         - structcheck
-    - path: config/config.go
-      text: "`client` is unused" # used in config/config.go
-      linters:
-        - structcheck
     - path: graphqljson/graphql.go
       text: "append to slice `frontier` with non-zero initialized length" # used in config/config.go
       linters:

README.md

@@ -4,55 +4,60 @@
 
 This is Go library for building GraphQL client with [gqlgen](https://github.com/99designs/gqlgen)
 
-## Motivation
+### Query First, not Code First
 
-Now, if you build GraphQL api client for Go, have choice:
-
- - [github.com/shurcooL/graphql](https://github.com/shurcooL/graphql)
- - [github.com/machinebox/graphql](https://github.com/machinebox/graphql)
-
-These libraries are very simple and easy to handle.
 However, as I work with [gqlgen](https://github.com/99designs/gqlgen) and [graphql-code-generator](https://graphql-code-generator.com/) every day, I find out the beauty of automatic generation.
 So I want to automatically generate types.
 
-## Installation
+### based on gqlgen
+
+- [Khan/genqlient](https://github.com/Khan/genqlient) is built from scratch as its own system. However, since gqlgenc is based on gqlgen, knowledge learned from either can be directly applied.
+
+## Usage
 
 ```shell script
-go get -u github.com/Yamashou/gqlgenc
+go get -tool github.com/Yamashou/gqlgenc
 ```
 
 ## How to use
 
 ### Client Codes Only
 
-gqlgenc base is gqlgen with [plugins](https://gqlgen.com/reference/plugins/). So the setting is yaml in each format.
-gqlgenc can be configured using a `.gqlgenc.yml` file
-
-Load a schema from a remote server:
-
 ```yaml
-model:
-  package: generated
-  filename: ./models_gen.go # https://github.com/99designs/gqlgen/tree/master/plugin/modelgen
+# schema for query
+schema:
+  - ""
+endpoint:
+  url: https://api.annict.com/graphql # Where do you want to send your request?
+  headers: # If you need header for getting introspection query, set it
+    Authorization: "Bearer ${ANNICT_KEY}" # support environment variables
+# generate config
+generate:
+  usedModelsOnly: false
+# client to generate
 client:
   package: generated
   filename: ./client.go # Where should any generated client go?
+# query to generate
+query:
+  source: "./query/*.graphql" # Where are all the query files located?
+  package: generated
+  filename: ./client.go # Where should any generated client go?
+# query to generate
+model:
+ package: generated
+ filename: ./models_gen.go # https://github.com/99designs/gqlgen/tree/master/plugin/modelgen
 models:
   Int:
     model: github.com/99designs/gqlgen/graphql.Int64
   Date:
     model: github.com/99designs/gqlgen/graphql.Time
 federation: # Add this if your schema includes Apollo Federation related directives
   version: 2
-endpoint:
-  url: https://api.annict.com/graphql # Where do you want to send your request?
-  headers: # If you need header for getting introspection query, set it
-    Authorization: "Bearer ${ANNICT_KEY}" # support environment variables
-query:
-  - "./query/*.graphql" # Where are all the query files located?
-generate:
-  clientInterfaceName: "GithubGraphQLClient" # Determine the name of the generated client interface
-  structFieldsAlwaysPointers: true # Always use pointers for struct fields (default: true)  [same as gqlgen](https://github.com/99designs/gqlgen/blob/e1ef86e795e738654c98553b325a248c02c8c2f8/docs/content/config.md?plain=1#L73)
+# input model config
+nullable_input_omittable: true
+enable_model_json_omitempty_tag: false
+enable_model_json_omitzero: true
 ```
 
 Load a schema from a local file:
@@ -138,21 +143,5 @@ func main() {
 }
 ```
 
-## Documents
-
-- [How to configure gqlgen using gqlgen.yml](https://gqlgen.com/config/)
-- [How to write plugins for gqlgen](https://gqlgen.com/reference/plugins/)
-
-
-## Comments
-
-### Japanese Comments
-These codes have Japanese comments. Replace with English.
-
-### Subscription
-
-This client does not support subscription. If you need a subscription, please create an issue or pull request.
-
-### Pre-conditions
+## VS
 
-[clientgen](https://github.com/Yamashou/gqlgenc/v3/tree/master/clientgen) is created based on [modelgen](https://github.com/99designs/gqlgen/tree/master/plugin/modelgen). So if you don't have a modelgen, it may be a mysterious move.

client/client.go

@@ -1,17 +1,9 @@
 package client
 
 import (
-	"bytes"
-	"compress/gzip"
 	"context"
-	"encoding/json"
-	"errors"
 	"fmt"
-	"io"
 	"net/http"
-
-	"github.com/Yamashou/gqlgenc/v3/graphqljson"
-	"github.com/vektah/gqlparser/v2/gqlerror"
 )
 
 type Client struct {
@@ -49,181 +41,24 @@ func (c *Client) Post(ctx context.Context, operationName, query string, variable
 		option(client)
 	}
 
-	req, err := newRequest(ctx, client.endpoint, operationName, query, variables)
-	if err != nil {
-		return fmt.Errorf("failed to create post request: %w", err)
-	}
-
-	resp, err := client.client.Do(req)
-	if err != nil {
-		return fmt.Errorf("request failed: %w", err)
-	}
-	defer resp.Body.Close()
-
-	return client.parseResponse(resp, out)
-}
-
-// PostMultipart send multipart form with files https://gqlgen.com/reference/file-upload/ https://github.com/jaydenseric/graphql-multipart-request-spec
-func (c *Client) PostMultipart(ctx context.Context, operationName, query string, variables map[string]any, out any, options ...Option) error {
-	client := &Client{
-		client:   c.client,
-		endpoint: c.endpoint,
-	}
-	for _, option := range options {
-		option(client)
-	}
-
-	req, err := multipartRequest(ctx, client.endpoint, operationName, query, variables)
+	// PostMultipart send multipart form with files https://gqlgen.com/reference/file-upload/ https://github.com/jaydenseric/graphql-multipart-request-spec
+	req, err := NewMultipartRequest(ctx, client.endpoint, operationName, query, variables)
 	if err != nil {
 		return fmt.Errorf("failed to create post multipart request: %w", err)
 	}
 
-	resp, err := client.client.Do(req)
-	if err != nil {
-		return fmt.Errorf("request failed: %w", err)
-	}
-	defer resp.Body.Close()
-
-	return client.parseResponse(resp, out)
-}
-
-/////////////////////////////////////////////////////////////////////
-// Request
-
-// Request represents an outgoing GraphQL request
-type Request struct {
-	Query         string         `json:"query"`
-	Variables     map[string]any `json:"variables,omitempty"`
-	OperationName string         `json:"operationName,omitempty"`
-}
-
-func newRequest(ctx context.Context, endpoint, operationName, query string, variables map[string]any) (*http.Request, error) {
-	graphqlRequest := &Request{
-		Query:         query,
-		Variables:     variables,
-		OperationName: operationName,
-	}
-	requestBody, err := json.Marshal(graphqlRequest)
-	if err != nil {
-		return nil, fmt.Errorf("encode: %w", err)
-	}
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewBuffer(requestBody))
-	if err != nil {
-		return nil, fmt.Errorf("create request struct failed: %w", err)
-	}
-
-	req.Header = http.Header{
-		"Content-Type": []string{"application/graphql-response+json;charset=utf-8", "application/json; charset=utf-8"},
-		"Accept":       []string{"application/graphql-response+json;charset=utf-8", "application/json; charset=utf-8"},
-	}
-
-	return req, nil
-}
-
-/////////////////////////////////////////////////////////////////////
-// Response
-
-// httpError is the error when a gqlErrors cannot be parsed
-type httpError struct {
-	Code    int    `json:"code"`
-	Message string `json:"message"`
-}
-
-// gqlErrors is the struct of a standard graphql error response
-type gqlErrors struct {
-	Errors gqlerror.List `json:"errors"`
-}
-
-func (e *gqlErrors) Error() string {
-	return e.Errors.Error()
-}
-
-// errorResponse represent an handled error
-type errorResponse struct {
-	// http status code is not OK
-	NetworkError *httpError `json:"networkErrors"`
-	// http status code is OK but the server returned at least one graphql error
-	GqlErrors *gqlerror.List `json:"graphqlErrors"`
-}
-
-// HasErrors returns true when at least one error is declared
-func (er *errorResponse) HasErrors() bool {
-	return er.NetworkError != nil || er.GqlErrors != nil
-}
-
-func (er *errorResponse) Error() string {
-	content, err := json.Marshal(er)
-	if err != nil {
-		return err.Error()
-	}
-
-	return string(content)
-}
-
-func (c *Client) parseResponse(resp *http.Response, out any) error {
-	if resp.Header.Get("Content-Encoding") == "gzip" {
-		respBody, err := gzip.NewReader(resp.Body)
+	if req == nil {
+		req, err = NewRequest(ctx, client.endpoint, operationName, query, variables)
 		if err != nil {
-			return fmt.Errorf("failed to decode gzip: %w", err)
+			return fmt.Errorf("failed to create post request: %w", err)
 		}
-		resp.Body = respBody
 	}
 
-	body, err := io.ReadAll(resp.Body)
+	resp, err := client.client.Do(req)
 	if err != nil {
-		return fmt.Errorf("failed to read response body: %w", err)
-	}
-
-	errResponse := &errorResponse{}
-	isStatusCodeOK := 200 <= resp.StatusCode && resp.StatusCode <= 299
-	if !isStatusCodeOK {
-		errResponse.NetworkError = &httpError{
-			Code:    resp.StatusCode,
-			Message: fmt.Sprintf("Response body %s", string(body)),
-		}
-	}
-
-	if err := c.unmarshalResponse(body, out); err != nil {
-		var gqlErrs *gqlErrors
-		if errors.As(err, &gqlErrs) {
-			// success to parse graphql error response
-			errResponse.GqlErrors = &gqlErrs.Errors
-		} else if isStatusCodeOK {
-			// status code is OK but the GraphQL response can't be parsed, it's an error.
-			return fmt.Errorf("http status is OK but %w", err)
-		}
-	}
-
-	if errResponse.HasErrors() {
-		return errResponse
-	}
-
-	return nil
-}
-
-// response is a GraphQL layer response from a handler.
-type response struct {
-	Data   json.RawMessage `json:"data"`
-	Errors json.RawMessage `json:"errors"`
-}
-
-func (c *Client) unmarshalResponse(respBody []byte, out any) error {
-	resp := response{}
-	if err := json.Unmarshal(respBody, &resp); err != nil {
-		return fmt.Errorf("failed to decode response %q: %w", respBody, err)
-	}
-	if err := graphqljson.UnmarshalData(resp.Data, out); err != nil {
-		return fmt.Errorf("failed to decode response data %q: %w", resp.Data, err)
-	}
-
-	if len(resp.Errors) > 0 {
-		gqlErrs := &gqlErrors{}
-		if err := json.Unmarshal(respBody, gqlErrs); err != nil {
-			return fmt.Errorf("faild to decode response error %q: %w", respBody, err)
-		}
-		return gqlErrs
+		return fmt.Errorf("request failed: %w", err)
 	}
+	defer resp.Body.Close()
 
-	return nil
+	return ParseResponse(resp, out)
 }