--wip-- [skip ci]

Author: nohehf

pkg/engine/TEMPLATE.go

@@ -0,0 +1,11 @@
+package engine
+
+var T = &engine{
+	Name: "",
+	Imprints: []imprint{
+		{
+			Query:   "",
+			Matcher: inResponseText([]string{""}),
+		},
+	},
+}

pkg/engine/_agoo.go

@@ -0,0 +1,11 @@
+package engine
+
+var Agoo = &engine{
+	Name: "agoo",
+	Imprints: []imprint{
+		{
+			Query:   "query { zzz }",
+			Matcher: inSection("code", []string{"eval error"}),
+		},
+	},
+}

pkg/engine/adriane.go

@@ -1,7 +1,7 @@
 package engine
 
 var Adriane = &engine{
-	Name: "adriane",
+	Name: "Adriane",
 	Imprints: []imprint{
 		{
 			Query:   "",

pkg/engine/apollo.go

@@ -1,7 +1,7 @@
 package engine
 
 var Apollo = &engine{
-	Name: "apollo",
+	Name: "Apollo",
 	Imprints: []imprint{
 		{
 			Query: "query @deprecated { __typename }",

pkg/engine/aws_app_sync.go

@@ -0,0 +1,11 @@
+package engine
+
+var AWSAppSync = &engine{
+	Name: "AWSAppSync",
+	Imprints: []imprint{
+		{
+			Query:   "query @skip { __typename }",
+			Matcher: inResponseText([]string{"MisplacedDirective"}),
+		},
+	},
+}

pkg/engine/engine.go

@@ -0,0 +1,72 @@
+package engine
+
+import (
+	"bytes"
+	"encoding/json"
+)
+
+type engine struct {
+	Name     string
+	Imprints []imprint
+}
+
+type imprint struct {
+	Query   string
+	Matcher matcher
+}
+
+// A responseMatcher is a function that takes a response body and returns true if the response matches the engine.
+type matcher func(responseBody *[]byte) bool
+
+// inResponseText returns a responseMatcher that checks if the response body contains any of the given strings.
+func inResponseText(matches []string) matcher {
+	return func(responseBody *[]byte) bool {
+		for _, match := range matches {
+			if bytes.Contains(*responseBody, []byte(match)) {
+				return true
+			}
+		}
+		return false
+	}
+}
+
+// inSection returns a responseMatcher that checks if the response body contains any of the given strings in the given section.
+func inSection(section string, matches []string) matcher {
+	return func(responseBody *[]byte) bool {
+		var reponseBody map[string]interface{}
+		json.Unmarshal(*responseBody, &reponseBody)
+		content, err := json.Marshal(reponseBody[section])
+		if err != nil {
+			return false
+		}
+		for _, match := range matches {
+			if bytes.Contains(content, []byte(match)) {
+				return true
+			}
+		}
+		return false
+	}
+}
+
+// hasJsonKey returns a responseMatcher that checks if the response body contains the given key.
+func hasJsonKey(key string) matcher {
+	return func(responseBody *[]byte) bool {
+		var reponseBody map[string]interface{}
+		json.Unmarshal(*responseBody, &reponseBody)
+		_, ok := reponseBody[key]
+		return ok
+	}
+}
+
+// Order is important here, as the first match will be returned.
+// The order has been determined by the usage statistics of the engines. (The higher the usage, the higher the priority.)
+var Engines = []*engine{
+	Apollo,
+	AWSAppSync,
+	GraphQLGo,
+	Ruby,
+	GraphQLPHP,
+	Graphene,
+	Adriane,
+	GraphQLGopherGo,
+}

pkg/engine/engines.go

@@ -0,0 +1,11 @@
+package engine
+
+var Graphene = &engine{
+	Name: "Graphene",
+	Imprints: []imprint{
+		{
+			Query:   "query { aaa }",
+			Matcher: inResponseText([]string{"Syntax Error GraphQL (1:1)"}),
+		},
+	},
+}

pkg/engine/graphene.go

@@ -0,0 +1,19 @@
+package engine
+
+var GraphQLGo = &engine{
+	Name: "GraphQLGo",
+	Imprints: []imprint{
+		{
+			Query:   "",
+			Matcher: inResponseText([]string{"Must provide an operation."}),
+		},
+		{
+			Query:   "query  { __typename {}",
+			Matcher: inResponseText([]string{"Unexpected empty IN"}),
+		},
+		{
+			Query:   "query  { __typename }",
+			Matcher: inResponseText([]string{"RootQuery"}),
+		},
+	},
+}

pkg/engine/graphql_go.go

@@ -0,0 +1,11 @@
+package engine
+
+var GraphQLGopherGo = &engine{
+	Name: "",
+	Imprints: []imprint{
+		{
+			Query:   "query {}",
+			Matcher: hasJsonKey("data"),
+		},
+	},
+}