From 0fc4788cda2b608f204e3ab4204bc8243539e226 Mon Sep 17 00:00:00 2001
From: Erik Frister <erik.frister@aoe.com>
Date: Tue, 17 Mar 2020 09:39:24 +0100
Subject: [PATCH] Add unquoted string / field support for arguments

---
 argument.go                                   | 43 ++++++++++++++++++-
 argument_test.go                              | 15 +++++++
 example/three_ways_to_construct_query_test.go |  3 +-
 3 files changed, 58 insertions(+), 3 deletions(-)

diff --git a/argument.go b/argument.go
index 6e988fe..c0d4fc9 100644
--- a/argument.go
+++ b/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 {
diff --git a/argument_test.go b/argument_test.go
index 0471c37..2bd53f2 100644
--- a/argument_test.go
+++ b/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
diff --git a/example/three_ways_to_construct_query_test.go b/example/three_ways_to_construct_query_test.go
index 89b4b1d..a71e8b4 100644
--- a/example/three_ways_to_construct_query_test.go
+++ b/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) {