bump github.com/dagger/graphql

go.mod

@@ -1,9 +1,9 @@
 module github.com/dagger/graphql-go-tools
 
-go 1.13
+go 1.18
 
 require (
-	github.com/dagger/graphql v0.0.0-20221102000338-24d5e47d3b72
+	github.com/dagger/graphql v0.0.0-20230919174923-21d038582a21
 	github.com/google/uuid v1.3.0
 	github.com/gorilla/websocket v1.4.2
 )

go.sum

@@ -1,5 +1,5 @@
-github.com/dagger/graphql v0.0.0-20221102000338-24d5e47d3b72 h1:0I9Y9nsFVcP42k9eOpjYmcm+NMEIFxNuJFOHfQ8MKpo=
-github.com/dagger/graphql v0.0.0-20221102000338-24d5e47d3b72/go.mod h1:z9nYmunTkok2pE+Kdjpl1ICaqcCzlDxcVjwaFE0MJTc=
+github.com/dagger/graphql v0.0.0-20230919174923-21d038582a21 h1:6H/36Lk+mcSXxlbjjIMUYd4DR+aqCzeaRigK5dUe/a0=
+github.com/dagger/graphql v0.0.0-20230919174923-21d038582a21/go.mod h1:jxe8vuRdvEbdLR5nrc6F7gLPmPeJhGe2DbIgEok+pCA=
 github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
 github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc=

helpers.go

@@ -2,7 +2,7 @@ package tools
 
 import (
 	"fmt"
-	"io/ioutil"
+	"io/fs"
 	"os"
 	"path/filepath"
 	"strings"
@@ -108,15 +108,15 @@ func parseDefaultValue(inputType ast.Type, value any) (any, error) {
 	case *ast.Named:
 		switch t.Name.Value {
 		case "Int":
-			value = graphql.Int.ParseValue(value)
+			return graphql.Int.ParseValue(value)
 		case "Float":
-			value = graphql.Float.ParseValue(value)
+			return graphql.Float.ParseValue(value)
 		case "Boolean":
-			value = graphql.Boolean.ParseValue(value)
+			return graphql.Boolean.ParseValue(value)
 		case "ID":
-			value = graphql.ID.ParseValue(value)
+			return graphql.ID.ParseValue(value)
 		case "String":
-			value = graphql.String.ParseValue(value)
+			return graphql.String.ParseValue(value)
 		}
 	}
 
@@ -145,14 +145,14 @@ func ReadSourceFiles(p string, recursive ...bool) (string, error) {
 		return "", err
 	}
 
-	var readFunc = func(p string, info os.FileInfo, err error) error {
+	var readFunc = func(p string, info fs.FileInfo, err error) error {
 		if info.IsDir() {
 			return nil
 		}
 
 		switch ext := strings.ToLower(filepath.Ext(info.Name())); ext {
 		case ".gql", ".graphql":
-			data, err := ioutil.ReadFile(p)
+			data, err := os.ReadFile(p)
 			if err != nil {
 				return err
 			}
@@ -168,12 +168,16 @@ func ReadSourceFiles(p string, recursive ...bool) (string, error) {
 			return "", err
 		}
 	} else {
-		files, err := ioutil.ReadDir(abs)
+		files, err := os.ReadDir(abs)
 		if err != nil {
 			return "", err
 		}
 		for _, file := range files {
-			if err := readFunc(abs, file, nil); err != nil {
+			info, err := file.Info()
+			if err != nil {
+				return "", err
+			}
+			if err := readFunc(abs, info, nil); err != nil {
 				return "", err
 			}
 		}

scalars/bool_string.go

@@ -12,28 +12,28 @@ var ScalarBoolString = graphql.NewScalar(
 	graphql.ScalarConfig{
 		Name:        "BoolString",
 		Description: "BoolString converts a boolean to/from a string",
-		Serialize: func(value any) any {
+		Serialize: func(value any) (any, error) {
 			valStr := fmt.Sprintf("%v", value)
-			return valStr == "true" || valStr == "1"
+			return valStr == "true" || valStr == "1", nil
 		},
-		ParseValue: func(value any) any {
+		ParseValue: func(value any) (any, error) {
 			b, ok := value.(bool)
 			if !ok {
-				return "false"
+				return "false", nil
 			} else if b {
-				return "true"
+				return "true", nil
 			}
-			return "false"
+			return "false", nil
 		},
-		ParseLiteral: func(astValue ast.Value) any {
+		ParseLiteral: func(astValue ast.Value) (any, error) {
 			value := astValue.GetValue()
 			b, ok := value.(bool)
 			if !ok {
-				return "false"
+				return "false", nil
 			} else if b {
-				return "true"
+				return "true", nil
 			}
-			return "false"
+			return "false", nil
 		},
 	},
 )

scalars/json.go

@@ -1,6 +1,8 @@
 package scalars
 
 import (
+	"fmt"
+
 	"github.com/dagger/graphql"
 	"github.com/dagger/graphql/language/ast"
 	"github.com/dagger/graphql/language/kinds"
@@ -11,41 +13,48 @@ var ScalarJSON = graphql.NewScalar(
 	graphql.ScalarConfig{
 		Name:        "JSON",
 		Description: "The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf)",
-		Serialize: func(value any) any {
-			return value
+		Serialize: func(value any) (any, error) {
+			return value, nil
 		},
-		ParseValue: func(value any) any {
-			return value
+		ParseValue: func(value any) (any, error) {
+			return value, nil
 		},
 		ParseLiteral: parseLiteralJSONFn,
 	},
 )
 
 // recursively parse ast
-func parseLiteralJSONFn(astValue ast.Value) any {
+func parseLiteralJSONFn(astValue ast.Value) (any, error) {
 	switch kind := astValue.GetKind(); kind {
 	// get value for primitive types
 	case kinds.StringValue, kinds.BooleanValue, kinds.IntValue, kinds.FloatValue:
-		return astValue.GetValue()
+		return astValue.GetValue(), nil
 
 	// make a map for objects
 	case kinds.ObjectValue:
 		obj := make(map[string]any)
 		for _, v := range astValue.GetValue().([]*ast.ObjectField) {
-			obj[v.Name.Value] = parseLiteralJSONFn(v.Value)
+			recur, err := parseLiteralJSONFn(v.Value)
+			if err != nil {
+				return nil, err
+			}
+			obj[v.Name.Value] = recur
 		}
-		return obj
+		return obj, nil
 
 	// make a slice for lists
 	case kinds.ListValue:
 		list := make([]any, 0)
 		for _, v := range astValue.GetValue().([]ast.Value) {
-			list = append(list, parseLiteralJSONFn(v))
+			recur, err := parseLiteralJSONFn(v)
+			if err != nil {
+				return nil, err
+			}
+			list = append(list, recur)
 		}
-		return list
+		return list, nil
 
-	// default to nil
 	default:
-		return nil
+		return nil, fmt.Errorf("unknown kind %v", kind)
 	}
 }

scalars/query_document.go

@@ -2,6 +2,7 @@ package scalars
 
 import (
 	"encoding/json"
+	"fmt"
 	"regexp"
 
 	"github.com/dagger/graphql"
@@ -34,27 +35,27 @@ func replacePrefixedKeys(obj any, prefixRx *regexp.Regexp, replacement string) a
 	}
 }
 
-func serializeQueryDocFn(value any) any {
-	return replacePrefixedKeys(value, storedQueryDocOperatorRx, "$")
+func serializeQueryDocFn(value any) (any, error) {
+	return replacePrefixedKeys(value, storedQueryDocOperatorRx, "$"), nil
 }
 
-func parseValueQueryDocFn(value any) any {
-	return replacePrefixedKeys(value, queryDocOperatorRx, "_")
+func parseValueQueryDocFn(value any) (any, error) {
+	return replacePrefixedKeys(value, queryDocOperatorRx, "_"), nil
 }
 
-func parseLiteralQueryDocFn(astValue ast.Value) any {
+func parseLiteralQueryDocFn(astValue ast.Value) (any, error) {
 	var val any
 	switch astValue.GetKind() {
 	case kinds.StringValue:
 		bvalue := []byte(astValue.GetValue().(string))
 		if err := json.Unmarshal(bvalue, &val); err != nil {
-			return nil
+			return nil, err
 		}
-		return replacePrefixedKeys(val, queryDocOperatorRx, "_")
+		return replacePrefixedKeys(val, queryDocOperatorRx, "_"), nil
 	case kinds.ObjectValue:
 		return parseLiteralJSONFn(astValue)
 	}
-	return nil
+	return nil, fmt.Errorf("unknown kind %v", astValue.GetKind())
 }
 
 // ScalarQueryDocument a mongodb style query document

scalars/string_set.go

@@ -7,28 +7,28 @@ import (
 	"github.com/dagger/graphql/language/ast"
 )
 
-func ensureArray(value any) any {
+func ensureArray(value any) (any, error) {
 	switch kind := reflect.TypeOf(value).Kind(); kind {
 	case reflect.Slice, reflect.Array:
-		return value
+		return value, nil
 	default:
 		if reflect.ValueOf(value).IsNil() {
-			return nil
+			return nil, nil
 		}
-		return []any{value}
+		return []any{value}, nil
 	}
 }
 
-func serializeStringSetFn(value any) any {
+func serializeStringSetFn(value any) (any, error) {
 	switch kind := reflect.TypeOf(value).Kind(); kind {
 	case reflect.Slice, reflect.Array:
 		v := reflect.ValueOf(value)
 		if v.Len() == 1 {
-			return v.Index(0).Interface()
+			return v.Index(0).Interface(), nil
 		}
-		return value
+		return value, nil
 	default:
-		return []any{}
+		return []any{}, nil
 	}
 }
 
@@ -39,11 +39,13 @@ var ScalarStringSet = graphql.NewScalar(
 		Name:        "StringSet",
 		Description: "StringSet allows either a string or list of strings",
 		Serialize:   serializeStringSetFn,
-		ParseValue: func(value any) any {
-			return ensureArray(value)
-		},
-		ParseLiteral: func(astValue ast.Value) any {
-			return ensureArray(parseLiteralJSONFn(astValue))
+		ParseValue:  ensureArray,
+		ParseLiteral: func(astValue ast.Value) (any, error) {
+			val, err := parseLiteralJSONFn(astValue)
+			if err != nil {
+				return nil, err
+			}
+			return ensureArray(val)
 		},
 	},
 )