feat: argument any slice

argument.go

@@ -43,6 +43,9 @@ func ArgumentAny(name string, value interface{}) (Argument, error) {
 	case []string:
 		return ArgumentStringSlice(name, v...), nil
 
+	case []interface{}:
+		return ArgumentAnySlice(name, v...), nil
+
 	default:
 		return Argument{}, ArgumentTypeNotSupportedErr{Value: value}
 	}
@@ -72,6 +75,10 @@ func ArgumentStringSlice(name string, values ...string) Argument {
 	return Argument{name, argStringSlice(values)}
 }
 
+func ArgumentAnySlice(name string, values ...interface{}) Argument {
+	return Argument{name, argAnySlice(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)}
@@ -186,6 +193,31 @@ func (s argStringSlice) stringChan() <-chan string {
 	return tokenChan
 }
 
+type argAnySlice []interface{}
+
+func (s argAnySlice) stringChan() <-chan string {
+	tokenChan := make(chan string)
+	go func() {
+		tokenChan <- "["
+		for i, v := range s {
+			if i != 0 {
+				tokenChan <- ","
+			}
+			switch v.(type) {
+			case bool:
+				tokenChan <- fmt.Sprintf("%t", v)
+			case int:
+				tokenChan <- fmt.Sprintf(`%v`, v)
+			case string:
+				tokenChan <- fmt.Sprintf(`"%s"`, v)
+			}
+		}
+		tokenChan <- "]"
+		close(tokenChan)
+	}()
+	return tokenChan
+}
+
 type argumentSlice []Argument
 
 func (s argumentSlice) stringChan() <-chan string {

argument_test.go

@@ -31,6 +31,10 @@ func TestArgumentAny(t *testing.T) {
 	assert.Nil(t, err)
 	assert.Equal(t, Argument{"arg", argIntSlice([]int{1, 2})}, arg)
 
+	arg, err = ArgumentAny("arg", []interface{}{1, "str", true})
+	assert.Nil(t, err)
+	assert.Equal(t, Argument{"arg", argAnySlice([]interface{}{1, "str", true})}, arg)
+
 	// Type Not Supported
 	arg, err = ArgumentAny("arg", 1.1)
 	assert.IsType(t, ArgumentTypeNotSupportedErr{}, err)
@@ -66,6 +70,14 @@ func TestArgumentStringSlice(t *testing.T) {
 	assert.Equal(t, Argument{"blocked", argStringSlice(nil)}, a)
 }
 
+func TestArgumentAnySlice(t *testing.T) {
+	a := ArgumentAnySlice("blocked", "a", 12, true, " ")
+	assert.Equal(t, Argument{"blocked", argAnySlice([]interface{}{"a", 12, true, " "})}, a)
+
+	a = ArgumentAnySlice("blocked")
+	assert.Equal(t, Argument{"blocked", argAnySlice(nil)}, a)
+}
+
 func Test_argBool(t *testing.T) {
 	b := argBool(true)
 	i := 0