Add unquoted string / field support for arguments

argument.go

@@ -4,13 +4,13 @@ import (
 	"fmt"
 )
 
-type argumentValue interface {
+type ArgumentValue interface {
 	stringChan() <-chan string
 }
 
 type Argument struct {
 	Name  string
-	Value argumentValue
+	Value ArgumentValue
 }
 
 func (a *Argument) stringChan() <-chan string {
@@ -60,6 +60,10 @@ func ArgumentString(name string, value string) Argument {
 	return Argument{name, argString(value)}
 }
 
+func ArgumentField(name string, value string) Argument {
+	return Argument{name, argField(value)}
+}
+
 func ArgumentBoolSlice(name string, values ...bool) Argument {
 	return Argument{name, argBoolSlice(values)}
 }
@@ -72,6 +76,10 @@ func ArgumentStringSlice(name string, values ...string) Argument {
 	return Argument{name, argStringSlice(values)}
 }
 
+func ArgumentFieldSlice(name string, values ...string) Argument {
+	return Argument{name, argFieldSlice(values)}
+}
+
 // ArgumentCustomType returns a custom GraphQL type's argument representation, which could be a recursive structure.
 func ArgumentCustomType(name string, values ...Argument) Argument {
 	return Argument{name, argumentSlice(values)}
@@ -125,6 +133,18 @@ func (v argString) stringChan() <-chan string {
 	return tokenChan
 }
 
+// argField represents a field value.
+type argField string
+
+func (v argField) stringChan() <-chan string {
+	tokenChan := make(chan string)
+	go func() {
+		tokenChan <- fmt.Sprintf(`%s`, v)
+		close(tokenChan)
+	}()
+	return tokenChan
+}
+
 //////////////////////////////////
 // Primitive List Wrapper Types //
 //////////////////////////////////
@@ -186,6 +206,25 @@ func (s argStringSlice) stringChan() <-chan string {
 	return tokenChan
 }
 
+// argFieldSlice implements valueSlice
+type argFieldSlice []string
+
+func (s argFieldSlice) stringChan() <-chan string {
+	tokenChan := make(chan string)
+	go func() {
+		tokenChan <- "["
+		for i, v := range s {
+			if i != 0 {
+				tokenChan <- ","
+			}
+			tokenChan <- fmt.Sprintf(`%s`, v)
+		}
+		tokenChan <- "]"
+		close(tokenChan)
+	}()
+	return tokenChan
+}
+
 type argumentSlice []Argument
 
 func (s argumentSlice) stringChan() <-chan string {

argument_test.go

@@ -66,6 +66,21 @@ func TestArgumentStringSlice(t *testing.T) {
 	assert.Equal(t, Argument{"blocked", argStringSlice(nil)}, a)
 }
 
+func TestArgumentField(t *testing.T) {
+	a := ArgumentField("blocked", "a")
+	assert.Equal(t, Argument{"blocked", argField("a")}, a)
+	a = ArgumentField("blocked", "")
+	assert.Equal(t, Argument{"blocked", argField("")}, a)
+}
+
+func TestArgumentFieldSlice(t *testing.T) {
+	a := ArgumentFieldSlice("blocked", "a", "b", "", " ", "d")
+	assert.Equal(t, Argument{"blocked", argFieldSlice([]string{"a", "b", "", " ", "d"})}, a)
+
+	a = ArgumentFieldSlice("blocked")
+	assert.Equal(t, Argument{"blocked", argFieldSlice(nil)}, a)
+}
+
 func Test_argBool(t *testing.T) {
 	b := argBool(true)
 	i := 0

example/three_ways_to_construct_query_test.go

@@ -36,6 +36,7 @@ func TestMethodChaining(t *testing.T) {
 							graphb.ArgumentInt("fizzbuzz", 45),
 						),
 					),
+					graphb.ArgumentField("field", "fizzbuzz"),
 				).
 				SetFields(
 					graphb.MakeField("x").
@@ -50,7 +51,7 @@ func TestMethodChaining(t *testing.T) {
 		AddFields(graphb.MakeField("b"))
 	s, err := q.JSON()
 	assert.Nil(t, err)
-	assert.Equal(t, `{"query":"query{some_alias:a(string:\"123\",mapArray:[{foo:\"bar\",fizzbuzz:15},{foo:\"baz\",fizzbuzz:45}]){x(string:\"123\",int_slice:[1,2,3]),y},b}"}`, s)
+	assert.Equal(t, `{"query":"query{some_alias:a(string:\"123\",mapArray:[{foo:\"bar\",fizzbuzz:15},{foo:\"baz\",fizzbuzz:45}],field:fizzbuzz){x(string:\"123\",int_slice:[1,2,3]),y},b}"}`, s)
 }
 
 func TestFunctionalOptions(t *testing.T) {