graph-gophers / graphql-go Goto Github PK

      "directives": [],
      "mutationType": {
        "name": "Mutation"
      },
      "queryType": {
        "name": "Query"
      },

{
  widgets(first: 10) {
    edges {
      node { id, name }
    }
  }
}

type Query {
	boolFilter(id: ID!): BoolFilter
}
type Mutation {
	createBoolFilter(input: BoolFilterInput!): BoolFilter
}
type BoolFilter {
	id: ID!
	# many more, but only need id to make sure it's working
}
enum Operator {
	AND
	OR
	NOT
	XOR
}
type BoolFilterInput {
	operator: Operator!
	newFilters: [BoolFilterInput!] # termination case, stops recursing when newFilters is null
	existingFiltersIDs: [ID!]
	choiceIDs: [ID!]
}

type BoolFilterInput struct {
	Operator string
	NewFilters *[]*BoolFilterInput
	ExistingFilterIDs *[]string
	ChoiceIDs *[]string
}

type Resolver struct {db: *sql.DB}

func (r *Resolver) CreateBoolFilter(args *struct { Input *BoolFilterInput } *BoolFilterResolver {
	tx, _ := r.db.Begin()
	id, _ := createNewBoolFilter(*newFilter, tx)
	_ = tx.Exec("INSERT ...", ...)
	_ = tx.Commit()
	return &BoolFilterResolver {db: r.db, id.String()}
}

func createNewBoolFilter(input BoolFilterInput, tx *sql.Tx) (uuid.UUID, error) {
	id := uuid.NewV1()
	var relevantIDs []uuid.UUID
	// ...
	if input.NewFilters != nil {
		for _, newFilter := range input.NewFilters {
			if newFilter != nil {
				id, _ := createNewBoolFilter(*newFilter, tx)
				relevantIDs = append(relevantIDs, id)
			}
		}
	}
	_, _ := tx.Exec("INSERT ... id & operator...", ...)
	for _, relevantID := range relevantIDs {
		_, _ := tx.Exec("INSERT ... id & relevantID", ...)
	}

	return id, nil
}

{
   errors: {
      'email': 'Invalid email address'
      'contact.phone': 'Invalid phone number',
      'payment.creditcardnumber': 'This looks like an american express, not accepted here'
      ...
   }
}

var JSON = &graphql.ScalarConfig{
	ReflectType: reflect.TypeOf(json.RawMessage{}),
	CoerceInput: func(input interface{}) (interface{}, error) {
		switch input := input.(type) {
		case string:
			j := json.RawMessage([]byte(input))
			return &j, nil
		default:
			return nil, fmt.Errorf("wrong type")
		}
	},
}

2016/11/17 20:23:14 graphql: graphql: panic occured: reflect.Set: value of type *string is not assignable to type *json.RawMessage
goroutine 54 [running]:
github.com/neelance/graphql-go/internal/exec.(*request).handlePanic(0xc4202b4600)
	/Users/bsr/.../external/src/github.com/neelance/graphql-go/internal/exec/exec.go:393 +0x123
panic(0x57a380, 0xc420345ef0)
	/usr/local/go/src/runtime/panic.go:458 +0x243
reflect.Value.assignTo(0x5629e0, 0xc420345ee0, 0x16, 0x66308e, 0xb, 0x5b1d00, 0x0, 0x16, 0x5629e0, 0xc420345ee0)
	/usr/local/go/src/reflect/value.go:2163 +0x35c
reflect.Value.Set(0x5b1d00, 0xc4202b4bf0, 0x196, 0x5629e0, 0xc420345ee0, 0x16)
	/usr/local/go/src/reflect/value.go:1333 +0xa4
github.com/neelance/graphql-go/internal/exec.(*structPacker).pack(0xc42046e640, 0x5ab660, 0xc4204dfb38, 0x57a380, 0xc420198580, 0x9349e0)
INFO     2016-11-18 01:23:14,549 module.py:788] default: "POST /graphql HTTP/1.1" 200 138
	/Users/bsr/.../external/src/github.com/neelance/graphql-go/internal/exec/exec.go:751 +0x2b3

interface Node {
  id: ID!
}

type Viewer implements Node {
  # id: ID!
  widgets(first: Int, q: String): WidgetConnection!
}

Error: "Node" expects field "id" but "Viewer" does not provide it.
    at invariant (http://localhost:8082/index.js:25961:12)
    at http://localhost:8082/index.js:26453:30
    at Array.forEach (native)
    at assertObjectImplementsInterface (http://localhost:8082/index.js:26448:31)
    at http://localhost:8082/index.js:26326:19
    at Array.forEach (native)
    at http://localhost:8082/index.js:26325:31
    at Array.forEach (native)
    at new GraphQLSchema (http://localhost:8082/index.js:26322:33)
    at buildClientSchema (http://localhost:8082/index.js:33920:11)

2016/11/18 15:52:27 graphql: graphql: panic occured: reflect: reflect.Value.Set using value obtained using unexported field
goroutine 10 [running]:
github.com/neelance/graphql-go/internal/exec.(*request).handlePanic(0xc4201d4a00)
	/Users/bsr/.../external/src/github.com/neelance/graphql-go/internal/exec/exec.go:392 +0x123
panic(0x57b880, 0xc420103760)
	/usr/local/go/src/runtime/panic.go:458 +0x243
reflect.flag.mustBeAssignable(0x1b6)
	/usr/local/go/src/reflect/value.go:225 +0x1a2
reflect.Value.Set(0x5552a0, 0xc420024300, 0x1b6, 0x5552a0, 0xc42047ed50, 0x16)
	/usr/local/go/src/reflect/value.go:1327 +0x2f
github.com/neelance/graphql-go/internal/exec.(*structPacker).pack(0xc42046d000, 0x5acc60, 0xc4200452f0, 0x5acc60, 0xc42047ec60, 0x936a20)
	/Users/bsr/.../external/src/github.com/neelance/graphql-go/internal/exec/exec.go:749 +0x2b3
github.com/neelance/graphql-go/internal/exec.(*fieldExec).execField2(0xc42046aff0, 0x933400, 0xc42047ecf0, 0xc4201d4a00, 0xc4201d4900, 0x5c0860, 0x983ae8, 0x16, 0x936a20, 0xc42048e

type Mutation {
  updateHuman(ClientMutationId: String!, input: UpdateHumanInput!): updateHumanPayload
}

mutation M($in: UpdateHumanInput!) {
  updateHuman(clientMutationId: "1",input: $in ) {
    ...
  }
}

mutation M($in: UpdateHumanInput!) {
  updateHuman(ClientMutationId: "1",input: $in ) {
    ...
  }
}

2016/11/18 18:04:46 graphql: graphql: panic occured: runtime error: invalid memory address or nil pointer dereference
goroutine 36 [running]:
github.com/neelance/graphql-go/internal/exec.(*request).handlePanic(0xc4201a18c0)
	/Users/bsr/.../external/src/github.com/neelance/graphql-go/internal/exec/exec.go:392 +0x123
panic(0x5b1760, 0xc420012060)
	/usr/local/go/src/runtime/panic.go:458 +0x243
github.com/neelance/graphql-go/internal/exec.(*fieldExec).execField2(0xc4204513b0, 0x934400, 0xc4201c5ad0, 0xc4201a18c0, 0xc4201a17c0, 0x5c0960, 0x984ae8, 0x16, 0x937a20, 0xc420472c80, ...)
	/Users/bsr/.../external/src/github.com/neelance/graphql-go/internal/exec/exec.go:664 +0x1f9
github.com/neelance/graphql-go/internal/exec.(*fieldExec).execField(0xc4204513b0, 0x934400, 0xc4201c59b0, 0xc4201a18c0, 0xc4201a17c0, 0x5c0960, 0x984ae8, 0x16, 0xc4201872c0)
	/Users/bsr/.../external/src/github.com/neelance/graphql-go/internal/exec/exec.go:640 +0x3b2
github.com/neelance/graphql-go/internal/exec.(*objectExec).execSelectionSet.func2()
	/Users/bsr/.../external/src/github.com/neelance/graphql-go/internal/exec/exec.go:573 +0x3f4
github.com/neelance/graphql-go/internal/exec.(*objectExec).execSelectionSet.func1(0xc42019d540)
	/Users/bsr/.../external/src/github.com/neelance/graphql-go/internal/exec/exec.go:524 +0xc0
INFO     2016-11-18 23:04:46,763 module.py:788] default: "POST /graphql HTTP/1.1" 200 125
github.com/neelance/graphql-go/internal/exec.(*objectExec).execSelectionSet(0xc4204568a0, 0x934400, 0xc4201c59b0, 0xc4201a18c0, 0xc420187260, 0x5c0960, 0x984ae8, 0x16, 0xc4201872c0, 0x54701)

{
  character(id: "1000") {
    id
    name
    friends
  }
}

{
  character(id: "1000")
}

type Mutation {
	createFoo(blurb: String!, bar: Bar): Foo
}
enum Bar {
	Bar1
	Bar2
	...
	BarN
}

type Resolver struct {
	db *sql.DB
}
func (r *Resolver) CreateFoo(args *struct{ Blurb, Bar string }) *FooResolver { ... }

type FooResolver struct {
	db *sql.DB
	id uuid.UUID
}
func (r *FooResolver) Bar() *string {
	...
	return  &barString
}

func (r *Resolver) CreateFoo(args *struct{
	Blurb string
	Bar *string
}) *FooResolver { ... }

{
  "data": {
    "createFoo": null
  },
  "errors": [
    {
      "message": "could not unmarshal \"Bar1\" (string) into *string: incompatible type"
    }
  ]
}

scalar Time
scalar JSON

diff --git a/example/starwars/starwars.go b/example/starwars/starwars.go
index 23eb068..0bd6de6 100644
--- a/example/starwars/starwars.go
+++ b/example/starwars/starwars.go
@@ -357,7 +357,7 @@ func (r *Resolver) CreateReview(args *struct {
        Review  *reviewInput
 }) *reviewResolver {
        review := &review{
-               stars:      args.Review.Stars,
+               stars:      args.Review.Stars(),
                commentary: args.Review.Commentary,
        }
        reviews[args.Episode] = append(reviews[args.Episode], review)
@@ -646,6 +646,10 @@ func (r *pageInfoResolver) HasNextPage() bool {
 }
 
 type reviewInput struct {
-       Stars      int32
+       the_stars  int32
        Commentary *string
 }
+
+func (r *reviewInput) Stars() int32 {
+       return r.the_stars
+}

panic: method "CreateReview" of *starwars.Resolver: missing argument "stars"

goroutine 1 [running]:
panic(0x2b9d60, 0xc420143c00)
        /usr/local/Cellar/go/1.7/libexec/src/runtime/panic.go:500 +0x1a1
main.init.1()
        /Users/dan/go/src/github.com/neelance/graphql-go/example/starwars/server/server.go:18 +0xc2
main.init()
        /Users/dan/go/src/github.com/neelance/graphql-go/example/starwars/server/server.go:89 +0x47

{
  hero {
    ...NameAndAppearancesAndFriends
  }
}

fragment NameAndAppearancesAndFriends on Character {
  name
  appearsIn
  friends {
    ...NameAndAppearancesAndFriends
  }
}

{
  hero {
    name {
      firstCharacterOfName
    }
  }
}

var Time *graphql.Scalar

func init() {
  Time = graphql.NewScalar(graphql.ScalarConfig{
    Name: "DateTime",
    Description: `Scalar type representing a date and time with offset, serialized as a string
     in ISO-8601 date format.\n\ne.g. "2016-05-05T20:16:06Z"`,
    // Serialize: gets invoked when serializing the result to send it back to a client.
    // adapted from time.MarshalJSON https://golang.org/src/time/time.go?s=26891:26934#L918
    Serialize: func(value interface{}) interface{} {
      t, ok := value.(time.Time)
      if !ok {
        panic("TODO")
      }
      return formatTime(t)
    },
    // parseValue: gets invoked to parse client input that was passed through variables.
    // value is a a plain type
    ParseValue: func(value interface{}) interface{} {
      str, ok := value.(string)
      if !ok {
        panic("TODO")
      }

      t, err := parseDate(str)
      pkg.Check(err)
      return t
    },
    // parseLiteral: gets invoked to parse client input that was passed inline in the query.
    // value is ast.Value
    ParseLiteral: func(valueAST ast.Value) interface{} {
      switch valueAST := valueAST.(type) {
      case *ast.StringValue:
        t, err := parseDate(valueAST.Value)
        if err != nil {
          panic("TODO")
        }
        return t
      }
      return nil
    },
  })
}

2016/11/29 18:00:45 CRITICAL: panic: interface conversion: interface is string, not []interface {}

goroutine 24 [running]:
...
github.com/neelance/graphql-go/internal/exec.coerceValue(0x0, 0x8b8840, 0xc4205154f0, 0x51bd20, 0xc4205143c0, 0xc42050d001, 0xc4205143d4, 0x1, 0xc4204142f8)
	/Users/.../external/src/github.com/neelance/graphql-go/internal/exec/exec.go:649 +0x18c
github.com/neelance/graphql-go/internal/exec.coerceMap(0x0, 0xc4202d3058, 0xc42050c600, 0xc4202d3040, 0x0, 0x0)
	/Users/.../external/src/github.com/neelance/graphql-go/internal/exec/exec.go:621 +0x144
github.com/neelance/graphql-go/internal/exec.ExecuteRequest(0x8c15c0, 0xc42050d290, 0xc4204387c0, 0xc420515440, 0xc4205143d4, 0x1, 0xc42050c600, 0x8c4aa0, 0xc4201dd900, 0xea2000, ...)
	/Users/.../external/src/github.com/neelance/graphql-go/internal/exec/exec.go:323 +0x9c
github.com/neelance/graphql-go.(*Schema).Exec(0xc420536d00, 0x8c15c0, 0xc42050cc00, 0xc4202b8500, 0x4d8, 0xc4205143d4, 0x1, 0xc42050c600, 0x0)
INFO     2016-11-29 23:00:45,399 module.py:788] default: "POST /graphql HTTP/1.1" 500 -
	/Users/.../external/src/github.com/neelance/graphql-go/graphql.go:125 +0x3cd
main.(*Handler).ServeHTTP(0xc42051b518, 0x8be100, 0xc420526420, 0xc42025c0f0)

ERROR: type "Time" not found

	input MyInputType {
		test1: String!
		test2: String!
	}

	# The Input object sent when saving Events
	input MyInput {
		test: String!
		myArray: [MyInputType!]!
	}

diff --git a/graphql_test.go b/graphql_test.go
index 7b64c6e..8853a63 100644
--- a/graphql_test.go
+++ b/graphql_test.go
@@ -666,6 +666,23 @@ func TestConnections(t *testing.T) {
                                                                }
                                                        }
                                                }
+                                       },
+                                       moreFriends: hero {
+                                               name
+                                               friendsConnection(first: 1, after: "Y3Vyc29yMg==") {
+                                                       totalCount
+                                                       pageInfo {
+                                                               startCursor
+                                                               endCursor
+                                                               hasNextPage
+                                                       }
+                                                       edges {
+                                                               cursor
+                                                               node {
+                                                                       name
+                                                               }
+                                                       }
+                                               }
                                        }
                                }
                        `,
@@ -689,6 +706,25 @@ func TestConnections(t *testing.T) {
                                                                }
                                                        ]
                                                }
+                                       },
+                                       "moreFriends": {
+                                               "name": "R2-D2",
+                                               "friendsConnection": {
+                                                       "totalCount": 3,
+                                                       "pageInfo": {
+                                                               "startCursor": "Y3Vyc29yMw==",
+                                                               "endCursor": "Y3Vyc29yMw==",
+                                                               "hasNextPage": false
+                                                       },
+                                                       "edges": [
+                                                               {
+                                                                       "cursor": "Y3Vyc29yMw==",
+                                                                       "node": {
+                                                                               "name": "Leia Organa"
+                                                                       }
+                                                               }
+                                                       ]
+                                               }
                                        }
                                }
                        `,

2016/11/07 12:26:15 graphql: graphql: panic occured: runtime error: makeslice: len out of range
goroutine 89 [running]:
github.com/neelance/graphql-go/internal/exec.(*request).handlePanic(0xc4201d8840)
        /Users/dan/go/src/github.com/neelance/graphql-go/internal/exec/exec.go:384 +0x123
panic(0x2ce460, 0xc4201ecab0)
        /usr/local/Cellar/go/1.7/libexec/src/runtime/panic.go:458 +0x243
github.com/neelance/graphql-go/example/starwars.(*friendsConnectionResolver).Edges(0xc4201f2c00, 0x0)
        /Users/dan/go/src/github.com/neelance/graphql-go/example/starwars/starwars.go:591 +0x65

--- FAIL: TestMutation (0.00s)
    --- FAIL: TestMutation/2 (0.00s)
    	testing.go:35: graphql: graphql: missing "commentary"

	input ReviewInput {
		# 0-5 stars
		stars: Int!
		# Comment about the movie, optional
		commentary: String
	}

var Schema = `
schema {
    query: Query
}

interface Node {
    id: ID!
}

type Query {
    node(id: ID!): Node
}

type Human implements Node {
    id: ID!
}

type Droid implements Node {
    id: ID!
}
`

type NodeResolver interface {
    ID() graphql.ID
}

type Resolver struct{}

func (r *Resolver) Node(ctx context.Context, args *struct{ ID graphql.ID }) (NodeResolver, error) {
  tp := getTypeFromID(args.ID)
  switch tp {
    case "human":
      return &HumanResolver{getHumanOnID(string(args.ID))}
    case "droid":
      return &DroidResolver{getDroidOnID(string(args.ID))}
    default:
      return nil, fmt.Errorf("no fetcher for %s", tp)
  }
}

type TestType {
		created:     Time!
}

$ ls -l 
schema.gql
schema.go // <- go generate graphql
schema.gql.go // generated file with interface of resolver, enum and other helpers %)))