From 245640d23348084acb6c00b3d6b3ceef02c7f5ee Mon Sep 17 00:00:00 2001 From: Toan Nguyen Date: Fri, 21 Jun 2024 00:01:01 +0700 Subject: [PATCH] cmd: improve nested types generation (#120) --- cmd/hasura-ndc-go/connector.go | 71 +- cmd/hasura-ndc-go/main.go | 3 +- cmd/hasura-ndc-go/schema.go | 142 ++- example/codegen/connector.generated.go | 3 +- example/codegen/connector_test.go | 26 +- example/codegen/functions/comment.go | 46 +- example/codegen/functions/prefix.go | 169 +--- example/codegen/functions/types.generated.go | 846 ------------------ example/codegen/types/arguments/arguments.go | 165 ++++ .../types/arguments/types.generated.go | 777 ++++++++++++++++ example/codegen/types/types.generated.go | 87 ++ example/codegen/types/types.go | 46 + 12 files changed, 1246 insertions(+), 1135 deletions(-) create mode 100644 example/codegen/types/arguments/arguments.go create mode 100644 example/codegen/types/arguments/types.generated.go create mode 100644 example/codegen/types/types.generated.go create mode 100644 example/codegen/types/types.go diff --git a/cmd/hasura-ndc-go/connector.go b/cmd/hasura-ndc-go/connector.go index bb57c4b..5ec3eef 100644 --- a/cmd/hasura-ndc-go/connector.go +++ b/cmd/hasura-ndc-go/connector.go @@ -195,7 +195,13 @@ func (cg *connectorGenerator) genConnectorFunctions(rawSchema *RawConnectorSchem }`) } - if fn.ArgumentsType != "" { + if fn.ArgumentsType != nil { + argName := fn.ArgumentsType.Name + if fn.ArgumentsType.PackagePath != "" { + cg.rawSchema.Imports[fn.ArgumentsType.PackagePath] = true + argName = fmt.Sprintf("%s.%s", fn.ArgumentsType.PackageName, fn.ArgumentsType.Name) + } + argumentStr := fmt.Sprintf(` rawArgs, err := utils.ResolveArgumentVariables(request.Arguments, variables) if err != nil { @@ -208,7 +214,7 @@ func (cg *connectorGenerator) genConnectorFunctions(rawSchema *RawConnectorSchem "raw_arguments": rawArgs, }) - var args %s.%s + var args %s if err = args.FromValue(rawArgs); err != nil { return nil, schema.UnprocessableContentError("failed to resolve arguments", map[string]any{ "cause": err.Error(), @@ -217,7 +223,7 @@ func (cg *connectorGenerator) genConnectorFunctions(rawSchema *RawConnectorSchem connector_addSpanEvent(span, logger, "execute_function", map[string]any{ "arguments": args, - })`, fn.PackageName, fn.ArgumentsType) + })`, argName) sb.WriteString(argumentStr) argumentParamStr = ", &args" } @@ -299,14 +305,20 @@ func (cg *connectorGenerator) genConnectorProcedures(rawSchema *RawConnectorSche }) }`) } - if fn.ArgumentsType != "" { + if fn.ArgumentsType != nil { + argName := fn.ArgumentsType.Name + if fn.ArgumentsType.PackagePath != "" { + cg.rawSchema.Imports[fn.ArgumentsType.PackagePath] = true + argName = fmt.Sprintf("%s.%s", fn.ArgumentsType.PackageName, fn.ArgumentsType.Name) + } + argumentStr := fmt.Sprintf(` - var args %s.%s + var args %s if err := json.Unmarshal(operation.Arguments, &args); err != nil { return nil, schema.UnprocessableContentError("failed to decode arguments", map[string]any{ "cause": err.Error(), }) - }`, fn.PackageName, fn.ArgumentsType) + }`, argName) sb.WriteString(argumentStr) argumentParamStr = ", &args" } @@ -349,7 +361,7 @@ func (cg *connectorGenerator) genTypeMethods() error { return err } - log.Debug().Msg("generating types...") + log.Debug().Msg("Generating types...") for packagePath, builder := range cg.typeBuilders { relativePath := strings.TrimPrefix(packagePath, cg.moduleName) schemaPath := path.Join(cg.basePath, relativePath, typeMethodsOutputFile) @@ -435,7 +447,7 @@ func (cg *connectorGenerator) genToMapProperty(sb *connectorTypeBuilder, field * } innerObject, ok := cg.rawSchema.Objects[ty.Name] if !ok { - _, tyName := buildTypeNameFromFragments(ty.TypeFragments, sb.packagePath) + tyName := buildTypeNameFromFragments(ty.TypeFragments, ty.PackagePath, sb.packagePath) innerObject, ok = cg.rawSchema.Objects[tyName] if !ok { return selector @@ -554,15 +566,15 @@ func (cg *connectorGenerator) genFunctionArgumentConstructors() error { } for _, fn := range cg.rawSchema.Functions { - if len(fn.Arguments) == 0 { + if len(fn.Arguments) == 0 || fn.ArgumentsType == nil { continue } - sb := cg.getOrCreateTypeBuilder(fn.PackagePath) + sb := cg.getOrCreateTypeBuilder(fn.ArgumentsType.PackagePath) sb.builder.WriteString(fmt.Sprintf(` // FromValue decodes values from map func (j *%s) FromValue(input map[string]any) error { var err error -`, fn.ArgumentsType)) +`, fn.ArgumentsType.Name)) argumentKeys := getSortedKeys(fn.Arguments) for _, key := range argumentKeys { @@ -743,9 +755,10 @@ func (cg *connectorGenerator) genGetTypeValueDecoder(sb *connectorTypeBuilder, t typeName := strings.TrimLeft(typeName, "*") pkgName, tyName, ok := findAndReplaceNativeScalarPackage(typeName) if !ok { - pkgName, tyName = buildTypeNameFromFragments(ty.TypeFragments[1:], sb.packagePath) + pkgName = ty.PackagePath + tyName = buildTypeNameFromFragments(ty.TypeFragments[1:], ty.PackagePath, sb.packagePath) } - if pkgName != "" { + if pkgName != "" && pkgName != sb.packagePath { sb.imports[pkgName] = "" } sb.builder.WriteString(fmt.Sprintf(` j.%s = new(%s) @@ -757,39 +770,29 @@ func (cg *connectorGenerator) genGetTypeValueDecoder(sb *connectorTypeBuilder, t sb.builder.WriteString(textBlockErrorCheck) } -func buildTypeNameFromFragments(items []string, packagePath string) (string, string) { +func buildTypeNameFromFragments(items []string, typePackagePath string, currentPackagePath string) string { results := make([]string, len(items)) - importModule := "" for i, item := range items { if item == "*" || item == "[]" { results[i] = item continue } - importModule, results[i] = extractPackageAndTypeName(item, packagePath) + results[i] = buildTypeWithAlias(item, typePackagePath, currentPackagePath) } - return importModule, strings.Join(results, "") + return strings.Join(results, "") } -func extractPackageAndTypeName(name string, packagePath string) (string, string) { - if packagePath != "" { - packagePath = fmt.Sprintf("%s.", packagePath) - } - - if packagePath != "" && strings.HasPrefix(name, packagePath) { - return "", strings.ReplaceAll(name, packagePath, "") - } - parts := strings.Split(name, "/") - typeName := parts[len(parts)-1] - typeNameParts := strings.Split(typeName, ".") - if len(typeNameParts) < 2 { - return "", typeName - } - if len(parts) == 1 { - return typeNameParts[0], typeName +func buildTypeWithAlias(name string, typePackagePath string, currentPackagePath string) string { + if typePackagePath == "" || typePackagePath == currentPackagePath || + // do not add alias to anonymous struct + strings.HasPrefix(name, "struct{") { + return name } - return strings.Join(append(parts[:len(parts)-1], typeNameParts[0]), "/"), typeName + parts := strings.Split(typePackagePath, "/") + alias := parts[len(parts)-1] + return fmt.Sprintf("%s.%s", alias, name) } func getSortedKeys[V any](input map[string]V) []string { diff --git a/cmd/hasura-ndc-go/main.go b/cmd/hasura-ndc-go/main.go index e59ee20..050cf2b 100644 --- a/cmd/hasura-ndc-go/main.go +++ b/cmd/hasura-ndc-go/main.go @@ -16,7 +16,7 @@ type GenerateArguments struct { Path string `help:"The path of the root directory where the go.mod file is present" short:"p" default:"."` ConnectorDir string `help:"The directory where the connector.go file is placed" default:"."` PackageTypes string `help:"The name of types package where the State struct is in"` - Directories []string `help:"Folders contain NDC operation functions" short:"d" default:"functions,types"` + Directories []string `help:"Folders contain NDC operation functions" short:"d"` Trace string `help:"Enable tracing and write to target file path."` } @@ -66,7 +66,6 @@ func main() { Str("path", cli.Generate.Path). Str("connector_dir", cli.Generate.ConnectorDir). Str("package_types", cli.Generate.PackageTypes). - Interface("directories", cli.Generate.Directories). Msg("generating connector schema...") moduleName, err := getModuleName(cli.Generate.Path) diff --git a/cmd/hasura-ndc-go/schema.go b/cmd/hasura-ndc-go/schema.go index 0f366ca..a599749 100644 --- a/cmd/hasura-ndc-go/schema.go +++ b/cmd/hasura-ndc-go/schema.go @@ -8,6 +8,7 @@ import ( "go/ast" "go/token" "go/types" + "os" "path" "path/filepath" "regexp" @@ -242,7 +243,7 @@ type OperationInfo struct { PackageName string PackagePath string Description *string - ArgumentsType string + ArgumentsType *TypeInfo Arguments map[string]ArgumentInfo ResultType *TypeInfo } @@ -333,9 +334,25 @@ func (rcs RawConnectorSchema) IsCustomType(name string) bool { } type SchemaParser struct { - context context.Context - moduleName string - pkg *packages.Package + context context.Context + moduleName string + packages []*packages.Package + packageIndex int +} + +// GetCurrentPackage gets the current evaluating package +func (sp SchemaParser) GetCurrentPackage() *packages.Package { + return sp.packages[sp.packageIndex] +} + +// FindPackageByPath finds the package by package path +func (sp SchemaParser) FindPackageByPath(input string) *packages.Package { + for _, p := range sp.packages { + if p.ID == input { + return p + } + } + return nil } func parseRawConnectorSchemaFromGoCode(ctx context.Context, moduleName string, filePath string, args *GenerateArguments) (*RawConnectorSchema, error) { @@ -347,8 +364,41 @@ func parseRawConnectorSchemaFromGoCode(ctx context.Context, moduleName string, f } rawSchema.Imports[pkgTypes] = true + directories := args.Directories + if len(args.Directories) == 0 { + // recursively walk directories if the user don't explicitly specify target folders + entries, err := os.ReadDir(filePath) + if err != nil { + return nil, fmt.Errorf("failed to read subdirectories of %s: %s", filePath, err) + } + for _, entry := range entries { + if !entry.IsDir() { + continue + } + + for _, globPath := range []string{path.Join(filePath, entry.Name(), "*.go"), path.Join(filePath, entry.Name(), "**", "*.go")} { + goFiles, err := filepath.Glob(globPath) + if err != nil { + return nil, fmt.Errorf("failed to read subdirectories of %s/%s: %s", filePath, entry.Name(), err) + } + + if len(goFiles) > 0 { + directories = append(directories, entry.Name()) + break + } + } + } + } + if len(directories) == 0 { + log.Info().Msgf("no subdirectory in %s", filePath) + return rawSchema, nil + } + + log.Info().Interface("directories", directories).Msgf("parsing connector schema...") + + var packageList []*packages.Package fset := token.NewFileSet() - for _, folder := range args.Directories { + for _, folder := range directories { _, parseCodeTask := trace.NewTask(ctx, fmt.Sprintf("parse_%s_code", folder)) folderPath := path.Join(filePath, folder) @@ -362,20 +412,22 @@ func parseRawConnectorSchemaFromGoCode(ctx context.Context, moduleName string, f if err != nil { return nil, err } + packageList = append(packageList, pkgList...) + } - for i, pkg := range pkgList { - parseSchemaCtx, parseSchemaTask := trace.NewTask(ctx, fmt.Sprintf("parse_%s_schema_%d_%s", folder, i, pkg.Name)) - sp := &SchemaParser{ - context: parseSchemaCtx, - moduleName: moduleName, - pkg: pkg, - } + for i := range packageList { + parseSchemaCtx, parseSchemaTask := trace.NewTask(ctx, fmt.Sprintf("parse_schema_%s", packageList[i].ID)) + sp := &SchemaParser{ + context: parseSchemaCtx, + moduleName: moduleName, + packages: packageList, + packageIndex: i, + } - err = sp.parseRawConnectorSchema(rawSchema, pkg.Types) - parseSchemaTask.End() - if err != nil { - return nil, err - } + err = sp.parseRawConnectorSchema(rawSchema, packageList[i].Types) + parseSchemaTask.End() + if err != nil { + return nil, err } } @@ -409,7 +461,7 @@ func evalPackageTypesLocation(name string, moduleName string, filePath string, c func (sp *SchemaParser) parseRawConnectorSchema(rawSchema *RawConnectorSchema, pkg *types.Package) error { for _, name := range pkg.Scope().Names() { - _, task := trace.NewTask(sp.context, fmt.Sprintf("parse_%s_schema_%s", sp.pkg.Name, name)) + _, task := trace.NewTask(sp.context, fmt.Sprintf("parse_%s_schema_%s", sp.GetCurrentPackage().Name, name)) err := sp.parsePackageScope(rawSchema, pkg, name) task.End() if err != nil { @@ -455,11 +507,11 @@ func (sp *SchemaParser) parsePackageScope(rawSchema *RawConnectorSchema, pkg *ty // ignore 2 first parameters (context and state) if params.Len() == 3 { arg := params.At(2) - arguments, argumentTypeName, err := sp.parseArgumentTypes(rawSchema, arg.Type(), []string{}) + arguments, argumentType, err := sp.parseArgumentTypes(rawSchema, arg.Type(), []string{}) if err != nil { return err } - opInfo.ArgumentsType = argumentTypeName + opInfo.ArgumentsType = argumentType opInfo.Arguments = arguments } @@ -479,7 +531,7 @@ func (sp *SchemaParser) parsePackageScope(rawSchema *RawConnectorSchema, pkg *ty return nil } -func (sp *SchemaParser) parseArgumentTypes(rawSchema *RawConnectorSchema, ty types.Type, fieldPaths []string) (map[string]ArgumentInfo, string, error) { +func (sp *SchemaParser) parseArgumentTypes(rawSchema *RawConnectorSchema, ty types.Type, fieldPaths []string) (map[string]ArgumentInfo, *TypeInfo, error) { switch inferredType := ty.(type) { case *types.Pointer: @@ -499,7 +551,7 @@ func (sp *SchemaParser) parseArgumentTypes(rawSchema *RawConnectorSchema, ty typ } fieldType, err := sp.parseType(rawSchema, typeInfo, fieldVar.Type(), append(fieldPaths, fieldVar.Name()), false) if err != nil { - return nil, "", err + return nil, nil, err } fieldName := getFieldNameOrTag(fieldVar.Name(), fieldTag) if fieldType.TypeAST == nil { @@ -510,15 +562,26 @@ func (sp *SchemaParser) parseArgumentTypes(rawSchema *RawConnectorSchema, ty typ Type: fieldType, } } - return result, "", nil + return result, nil, nil case *types.Named: arguments, _, err := sp.parseArgumentTypes(rawSchema, inferredType.Obj().Type().Underlying(), append(fieldPaths, inferredType.Obj().Name())) if err != nil { - return nil, "", err + return nil, nil, err + } + + typeObj := inferredType.Obj() + typeInfo := &TypeInfo{ + Name: typeObj.Name(), + SchemaName: typeObj.Name(), } - return arguments, inferredType.Obj().Name(), nil + pkg := typeObj.Pkg() + if pkg != nil { + typeInfo.PackagePath = pkg.Path() + typeInfo.PackageName = pkg.Name() + } + return arguments, typeInfo, nil default: - return nil, "", fmt.Errorf("expected struct type, got %s", ty.String()) + return nil, nil, fmt.Errorf("expected struct type, got %s", ty.String()) } } @@ -603,16 +666,21 @@ func (sp *SchemaParser) parseType(rawSchema *RawConnectorSchema, rootType *TypeI if innerType == nil { return nil, fmt.Errorf("failed to parse named type: %s", inferredType.String()) } - typeInfo, err := sp.parseTypeInfoFromComments(innerType.Name(), innerType.Parent()) + + innerPkg := innerType.Pkg() + var packagePath string + if innerPkg != nil { + packagePath = innerPkg.Path() + } + + typeInfo, err := sp.parseTypeInfoFromComments(innerType.Name(), packagePath, innerType.Parent()) if err != nil { return nil, err } - innerPkg := innerType.Pkg() - if innerPkg != nil { var scalarName ScalarName typeInfo.PackageName = innerPkg.Name() - typeInfo.PackagePath = innerPkg.Path() + typeInfo.PackagePath = packagePath scalarSchema := schema.NewScalarType() switch innerPkg.Path() { @@ -739,7 +807,10 @@ func (sp *SchemaParser) parseType(rawSchema *RawConnectorSchema, rootType *TypeI SchemaName: string(scalarName), TypeAST: ty, } + } else { + rootType.PackagePath = "" } + if _, ok := rawSchema.ScalarSchemas[string(scalarName)]; !ok { rawSchema.ScalarSchemas[string(scalarName)] = defaultScalarTypes[scalarName] } @@ -753,7 +824,7 @@ func (sp *SchemaParser) parseType(rawSchema *RawConnectorSchema, rootType *TypeI } } -func (sp *SchemaParser) parseTypeInfoFromComments(typeName string, scope *types.Scope) (*TypeInfo, error) { +func (sp *SchemaParser) parseTypeInfoFromComments(typeName string, packagePath string, scope *types.Scope) (*TypeInfo, error) { typeInfo := &TypeInfo{ Name: typeName, SchemaName: typeName, @@ -762,8 +833,7 @@ func (sp *SchemaParser) parseTypeInfoFromComments(typeName string, scope *types. Schema: schema.NewNamedType(typeName), } comments := make([]string, 0) - commentGroup := findCommentsFromPos(sp.pkg, scope, typeName) - + commentGroup := findCommentsFromPos(sp.FindPackageByPath(packagePath), scope, typeName) if commentGroup != nil { for i, line := range commentGroup.List { text := strings.TrimSpace(strings.TrimLeft(line.Text, "/")) @@ -860,7 +930,7 @@ func (sp *SchemaParser) parseOperationInfo(fn *types.Func) *OperationInfo { } var descriptions []string - commentGroup := findCommentsFromPos(sp.pkg, fn.Scope(), functionName) + commentGroup := findCommentsFromPos(sp.GetCurrentPackage(), fn.Scope(), functionName) if commentGroup != nil { for i, comment := range commentGroup.List { text := strings.TrimSpace(strings.TrimLeft(comment.Text, "/")) @@ -913,6 +983,10 @@ func (sp *SchemaParser) parseOperationInfo(fn *types.Func) *OperationInfo { } func findCommentsFromPos(pkg *packages.Package, scope *types.Scope, name string) *ast.CommentGroup { + if pkg == nil { + return nil + } + for _, f := range pkg.Syntax { for _, cg := range f.Comments { if len(cg.List) == 0 { diff --git a/example/codegen/connector.generated.go b/example/codegen/connector.generated.go index 32109da..6229982 100644 --- a/example/codegen/connector.generated.go +++ b/example/codegen/connector.generated.go @@ -9,6 +9,7 @@ import ( "encoding/json" "github.com/hasura/ndc-codegen-example/functions" "github.com/hasura/ndc-codegen-example/types" + "github.com/hasura/ndc-codegen-example/types/arguments" "github.com/hasura/ndc-sdk-go/connector" "github.com/hasura/ndc-sdk-go/schema" "github.com/hasura/ndc-sdk-go/utils" @@ -152,7 +153,7 @@ func execQuery(ctx context.Context, state *types.State, request *schema.QueryReq "raw_arguments": rawArgs, }) - var args functions.GetTypesArguments + var args arguments.GetTypesArguments if err = args.FromValue(rawArgs); err != nil { return nil, schema.UnprocessableContentError("failed to resolve arguments", map[string]any{ "cause": err.Error(), diff --git a/example/codegen/connector_test.go b/example/codegen/connector_test.go index 2debc84..88b5be4 100644 --- a/example/codegen/connector_test.go +++ b/example/codegen/connector_test.go @@ -11,8 +11,8 @@ import ( "time" "github.com/google/uuid" - "github.com/hasura/ndc-codegen-example/functions" "github.com/hasura/ndc-codegen-example/types" + "github.com/hasura/ndc-codegen-example/types/arguments" "github.com/hasura/ndc-sdk-go/connector" "github.com/hasura/ndc-sdk-go/scalar" "github.com/hasura/ndc-sdk-go/utils" @@ -31,16 +31,16 @@ func createTestServer(t *testing.T) *connector.Server[types.Configuration, types } func TestQueryGetTypes(t *testing.T) { - commentText := functions.CommentText{} + commentText := types.CommentText{} assert.NoError(t, commentText.FromValue("a comment")) - commentTextPtr := functions.CommentText{} + commentTextPtr := types.CommentText{} assert.NoError(t, commentTextPtr.FromValue("a comment pointer")) testCases := []struct { name string body string status int - response functions.GetTypesArguments + response arguments.GetTypesArguments errorMsg string }{ { @@ -1299,7 +1299,7 @@ func TestQueryGetTypes(t *testing.T) { }, "collection_relationships": {} }`, - response: functions.GetTypesArguments{ + response: arguments.GetTypesArguments{ UUID: uuid.MustParse("b085b0b9-007c-440e-9661-0d8f2de98a5a"), Bool: true, String: "hello", @@ -1318,7 +1318,7 @@ func TestQueryGetTypes(t *testing.T) { Time: time.Date(2024, 3, 5, 7, 0, 56, 0, time.UTC), Text: "text", CustomScalar: commentText, - Enum: functions.SomeEnumFoo, + Enum: types.SomeEnumFoo, BigInt: 10000, Date: *scalar.NewDate(2024, 04, 02), UUIDPtr: utils.ToPtr(uuid.MustParse("b085b0b9-007c-440e-9661-0d8f2de98a5b")), @@ -1337,9 +1337,9 @@ func TestQueryGetTypes(t *testing.T) { Float32Ptr: utils.ToPtr(float32(3.3)), Float64Ptr: utils.ToPtr(float64(4.4)), TimePtr: utils.ToPtr(time.Date(2024, 3, 5, 7, 0, 0, 0, time.UTC)), - TextPtr: utils.ToPtr(functions.Text("text pointer")), + TextPtr: utils.ToPtr(types.Text("text pointer")), CustomScalarPtr: &commentTextPtr, - EnumPtr: utils.ToPtr(functions.SomeEnumBar), + EnumPtr: utils.ToPtr(types.SomeEnumBar), BigIntPtr: utils.ToPtr(scalar.BigInt(20000)), DatePtr: scalar.NewDate(2024, 04, 03), Object: struct { @@ -1370,21 +1370,21 @@ func TestQueryGetTypes(t *testing.T) { Content: "a content pointer", }, }, - NamedObject: functions.Author{ + NamedObject: types.Author{ ID: "1", CreatedAt: time.Date(2024, 3, 5, 5, 0, 0, 0, time.UTC), }, - NamedObjectPtr: &functions.Author{ + NamedObjectPtr: &types.Author{ ID: "2", CreatedAt: time.Date(2024, 3, 5, 4, 0, 0, 0, time.UTC), }, - NamedArray: []functions.Author{ + NamedArray: []types.Author{ { ID: "3", CreatedAt: time.Date(2024, 3, 5, 3, 0, 0, 0, time.UTC), }, }, - NamedArrayPtr: &[]functions.Author{ + NamedArrayPtr: &[]types.Author{ { ID: "bPgG5cs38N", CreatedAt: time.Date(2024, 3, 5, 2, 0, 0, 0, time.UTC), @@ -1509,7 +1509,7 @@ func TestQueryGetTypes(t *testing.T) { log.Print("response: ", string(respBody)) var results []struct { Rows []struct { - Value functions.GetTypesArguments `json:"__value"` + Value arguments.GetTypesArguments `json:"__value"` } `json:"rows,omitempty" mapstructure:"rows,omitempty"` } assert.NoError(t, json.Unmarshal(respBody, &results), "failed to decode response") diff --git a/example/codegen/functions/comment.go b/example/codegen/functions/comment.go index 0a16b35..2d48961 100644 --- a/example/codegen/functions/comment.go +++ b/example/codegen/functions/comment.go @@ -2,51 +2,19 @@ package functions import ( "context" - "encoding/json" "time" "github.com/google/uuid" "github.com/hasura/ndc-codegen-example/types" - "github.com/hasura/ndc-sdk-go/utils" ) -// CommentText -// @scalar CommentString string -type CommentText struct { - comment string -} - -func (c CommentText) MarshalJSON() ([]byte, error) { - return json.Marshal(c.comment) -} - -func (c *CommentText) UnmarshalJSON(b []byte) error { - var s string - if err := json.Unmarshal(b, &s); err != nil { - return err - } - - c.comment = s - - return nil -} - -func (ct *CommentText) FromValue(value any) (err error) { - ct.comment, err = utils.DecodeString(value) - return -} - -// SomeEnum -// @enum foo, bar -type SomeEnum string - type GetArticlesArguments struct { Limit float64 } type GetArticlesResult struct { ID string `json:"id"` - Name Text + Name types.Text } // GetArticles @@ -67,15 +35,9 @@ type CreateArticleArguments struct { } `json:"author"` } -type Author struct { - ID string `json:"id"` - CreatedAt time.Time `json:"created_at"` - Tags []string `json:"tags"` -} - type CreateArticleResult struct { - ID uint `json:"id"` - Authors []Author `json:"authors"` + ID uint `json:"id"` + Authors []types.Author `json:"authors"` } // CreateArticle @@ -83,7 +45,7 @@ type CreateArticleResult struct { func CreateArticle(ctx context.Context, state *types.State, arguments *CreateArticleArguments) (*CreateArticleResult, error) { return &CreateArticleResult{ ID: 1, - Authors: []Author{}, + Authors: []types.Author{}, }, nil } diff --git a/example/codegen/functions/prefix.go b/example/codegen/functions/prefix.go index 452a151..bc2fbe0 100644 --- a/example/codegen/functions/prefix.go +++ b/example/codegen/functions/prefix.go @@ -9,11 +9,9 @@ import ( "github.com/google/uuid" "github.com/hasura/ndc-codegen-example/types" - "github.com/hasura/ndc-sdk-go/scalar" + "github.com/hasura/ndc-codegen-example/types/arguments" ) -type Text string - // A foo scalar type ScalarFoo struct { bar string @@ -31,10 +29,10 @@ func (s *ScalarFoo) FromValue(value any) error { // A hello result type HelloResult struct { - ID uuid.UUID `json:"id"` - Num int `json:"num"` - Text Text `json:"text"` - Foo ScalarFoo `json:"foo"` + ID uuid.UUID `json:"id"` + Num int `json:"num"` + Text types.Text `json:"text"` + Foo ScalarFoo `json:"foo"` } // FunctionHello sends a hello message @@ -86,161 +84,6 @@ func FunctionGetBool(ctx context.Context, state *types.State) (bool, error) { return true, nil } -type GetTypesArguments struct { - UUID uuid.UUID - Bool bool - String string - Int int - Int8 int8 - Int16 int16 - Int32 int32 - Int64 int64 - Uint uint - Uint8 uint8 - Uint16 uint16 - Uint32 uint32 - Uint64 uint64 - Float32 float32 - Float64 float64 - Time time.Time - Text Text - CustomScalar CommentText - Enum SomeEnum - BigInt scalar.BigInt - Date scalar.Date - - UUIDPtr *uuid.UUID - BoolPtr *bool - StringPtr *string - IntPtr *int - Int8Ptr *int8 - Int16Ptr *int16 - Int32Ptr *int32 - Int64Ptr *int64 - UintPtr *uint - Uint8Ptr *uint8 - Uint16Ptr *uint16 - Uint32Ptr *uint32 - Uint64Ptr *uint64 - Float32Ptr *float32 - Float64Ptr *float64 - TimePtr *time.Time - TextPtr *Text - CustomScalarPtr *CommentText - EnumPtr *SomeEnum - BigIntPtr *scalar.BigInt - DatePtr *scalar.Date - - ArrayBool []bool - ArrayString []string - ArrayInt []int - ArrayInt8 []int8 - ArrayInt16 []int16 - ArrayInt32 []int32 - ArrayInt64 []int64 - ArrayUint []uint - ArrayUint8 []uint8 - ArrayUint16 []uint16 - ArrayUint32 []uint32 - ArrayUint64 []uint64 - ArrayFloat32 []float32 - ArrayFloat64 []float64 - ArrayUUID []uuid.UUID - ArrayBoolPtr []*bool - ArrayStringPtr []*string - ArrayIntPtr []*int - ArrayInt8Ptr []*int8 - ArrayInt16Ptr []*int16 - ArrayInt32Ptr []*int32 - ArrayInt64Ptr []*int64 - ArrayUintPtr []*uint - ArrayUint8Ptr []*uint8 - ArrayUint16Ptr []*uint16 - ArrayUint32Ptr []*uint32 - ArrayUint64Ptr []*uint64 - ArrayFloat32Ptr []*float32 - ArrayFloat64Ptr []*float64 - ArrayUUIDPtr []*uuid.UUID - ArrayJSON []any - ArrayJSONPtr []*interface{} - ArrayRawJSON []json.RawMessage - ArrayRawJSONPtr []*json.RawMessage - ArrayBigInt []scalar.BigInt - ArrayBigIntPtr []*scalar.BigInt - ArrayTime []time.Time - ArrayTimePtr []*time.Time - - PtrArrayBool *[]bool - PtrArrayString *[]string - PtrArrayInt *[]int - PtrArrayInt8 *[]int8 - PtrArrayInt16 *[]int16 - PtrArrayInt32 *[]int32 - PtrArrayInt64 *[]int64 - PtrArrayUint *[]uint - PtrArrayUint8 *[]uint8 - PtrArrayUint16 *[]uint16 - PtrArrayUint32 *[]uint32 - PtrArrayUint64 *[]uint64 - PtrArrayFloat32 *[]float32 - PtrArrayFloat64 *[]float64 - PtrArrayUUID *[]uuid.UUID - PtrArrayBoolPtr *[]*bool - PtrArrayStringPtr *[]*string - PtrArrayIntPtr *[]*int - PtrArrayInt8Ptr *[]*int8 - PtrArrayInt16Ptr *[]*int16 - PtrArrayInt32Ptr *[]*int32 - PtrArrayInt64Ptr *[]*int64 - PtrArrayUintPtr *[]*uint - PtrArrayUint8Ptr *[]*uint8 - PtrArrayUint16Ptr *[]*uint16 - PtrArrayUint32Ptr *[]*uint32 - PtrArrayUint64Ptr *[]*uint64 - PtrArrayFloat32Ptr *[]*float32 - PtrArrayFloat64Ptr *[]*float64 - PtrArrayUUIDPtr *[]*uuid.UUID - PtrArrayJSON *[]any - PtrArrayJSONPtr *[]*interface{} - PtrArrayRawJSON *[]json.RawMessage - PtrArrayRawJSONPtr *[]*json.RawMessage - PtrArrayBigInt *[]scalar.BigInt - PtrArrayBigIntPtr *[]*scalar.BigInt - PtrArrayTime *[]time.Time - PtrArrayTimePtr *[]*time.Time - - Object struct { - ID uuid.UUID `json:"id"` - CreatedAt time.Time `json:"created_at"` - } - ObjectPtr *struct { - Long int - Lat int - } - ArrayObject []struct { - Content string `json:"content"` - } - ArrayObjectPtr *[]struct { - Content string `json:"content"` - } - NamedObject Author - NamedObjectPtr *Author - NamedArray []Author - NamedArrayPtr *[]Author - - Map map[string]any - MapPtr *map[string]any - ArrayMap []map[string]any - ArrayMapPtr *[]map[string]any - - JSON any - JSONPtr *interface{} - RawJSON json.RawMessage - RawJSONPtr *json.RawMessage - Bytes scalar.Bytes - BytesPtr *scalar.Bytes -} - -func FunctionGetTypes(ctx context.Context, state *types.State, arguments *GetTypesArguments) (*GetTypesArguments, error) { +func FunctionGetTypes(ctx context.Context, state *types.State, arguments *arguments.GetTypesArguments) (*arguments.GetTypesArguments, error) { return arguments, nil } diff --git a/example/codegen/functions/types.generated.go b/example/codegen/functions/types.generated.go index 6de5227..4056306 100644 --- a/example/codegen/functions/types.generated.go +++ b/example/codegen/functions/types.generated.go @@ -2,604 +2,11 @@ package functions import ( - "encoding/json" - "errors" - "github.com/google/uuid" - "github.com/hasura/ndc-sdk-go/scalar" - "github.com/hasura/ndc-sdk-go/schema" "github.com/hasura/ndc-sdk-go/utils" - "time" ) var functions_Decoder = utils.NewDecoder() -// FromValue decodes values from map -func (j *GetTypesArguments) FromValue(input map[string]any) error { - var err error - err = functions_Decoder.DecodeObjectValue(&j.ArrayBigInt, input, "ArrayBigInt") - if err != nil { - return err - } - err = functions_Decoder.DecodeObjectValue(&j.ArrayBigIntPtr, input, "ArrayBigIntPtr") - if err != nil { - return err - } - j.ArrayBool, err = utils.GetBooleanSlice(input, "ArrayBool") - if err != nil { - return err - } - j.ArrayBoolPtr, err = utils.GetBooleanPtrSlice(input, "ArrayBoolPtr") - if err != nil { - return err - } - j.ArrayFloat32, err = utils.GetFloatSlice[float32](input, "ArrayFloat32") - if err != nil { - return err - } - j.ArrayFloat32Ptr, err = utils.GetFloatPtrSlice[float32](input, "ArrayFloat32Ptr") - if err != nil { - return err - } - j.ArrayFloat64, err = utils.GetFloatSlice[float64](input, "ArrayFloat64") - if err != nil { - return err - } - j.ArrayFloat64Ptr, err = utils.GetFloatPtrSlice[float64](input, "ArrayFloat64Ptr") - if err != nil { - return err - } - j.ArrayInt, err = utils.GetIntSlice[int](input, "ArrayInt") - if err != nil { - return err - } - j.ArrayInt16, err = utils.GetIntSlice[int16](input, "ArrayInt16") - if err != nil { - return err - } - j.ArrayInt16Ptr, err = utils.GetIntPtrSlice[int16](input, "ArrayInt16Ptr") - if err != nil { - return err - } - j.ArrayInt32, err = utils.GetIntSlice[int32](input, "ArrayInt32") - if err != nil { - return err - } - j.ArrayInt32Ptr, err = utils.GetIntPtrSlice[int32](input, "ArrayInt32Ptr") - if err != nil { - return err - } - j.ArrayInt64, err = utils.GetIntSlice[int64](input, "ArrayInt64") - if err != nil { - return err - } - j.ArrayInt64Ptr, err = utils.GetIntPtrSlice[int64](input, "ArrayInt64Ptr") - if err != nil { - return err - } - j.ArrayInt8, err = utils.GetIntSlice[int8](input, "ArrayInt8") - if err != nil { - return err - } - j.ArrayInt8Ptr, err = utils.GetIntPtrSlice[int8](input, "ArrayInt8Ptr") - if err != nil { - return err - } - j.ArrayIntPtr, err = utils.GetIntPtrSlice[int](input, "ArrayIntPtr") - if err != nil { - return err - } - j.ArrayJSON, err = utils.GetArbitraryJSONSlice(input, "ArrayJSON") - if err != nil { - return err - } - j.ArrayJSONPtr, err = utils.GetArbitraryJSONPtrSlice(input, "ArrayJSONPtr") - if err != nil { - return err - } - err = functions_Decoder.DecodeObjectValue(&j.ArrayMap, input, "ArrayMap") - if err != nil { - return err - } - j.ArrayMapPtr = new([]map[string]any) - err = functions_Decoder.DecodeNullableObjectValue(j.ArrayMapPtr, input, "ArrayMapPtr") - if err != nil { - return err - } - err = functions_Decoder.DecodeObjectValue(&j.ArrayObject, input, "ArrayObject") - if err != nil { - return err - } - j.ArrayObjectPtr = new([]struct { - Content string "json:\"content\"" - }) - err = functions_Decoder.DecodeNullableObjectValue(j.ArrayObjectPtr, input, "ArrayObjectPtr") - if err != nil { - return err - } - j.ArrayRawJSON, err = utils.GetRawJSONSlice(input, "ArrayRawJSON") - if err != nil { - return err - } - j.ArrayRawJSONPtr, err = utils.GetRawJSONPtrSlice(input, "ArrayRawJSONPtr") - if err != nil { - return err - } - j.ArrayString, err = utils.GetStringSlice(input, "ArrayString") - if err != nil { - return err - } - j.ArrayStringPtr, err = utils.GetStringPtrSlice(input, "ArrayStringPtr") - if err != nil { - return err - } - j.ArrayTime, err = utils.GetDateTimeSlice(input, "ArrayTime") - if err != nil { - return err - } - j.ArrayTimePtr, err = utils.GetDateTimePtrSlice(input, "ArrayTimePtr") - if err != nil { - return err - } - j.ArrayUUID, err = utils.GetUUIDSlice(input, "ArrayUUID") - if err != nil { - return err - } - j.ArrayUUIDPtr, err = utils.GetUUIDPtrSlice(input, "ArrayUUIDPtr") - if err != nil { - return err - } - j.ArrayUint, err = utils.GetUintSlice[uint](input, "ArrayUint") - if err != nil { - return err - } - j.ArrayUint16, err = utils.GetUintSlice[uint16](input, "ArrayUint16") - if err != nil { - return err - } - j.ArrayUint16Ptr, err = utils.GetUintPtrSlice[uint16](input, "ArrayUint16Ptr") - if err != nil { - return err - } - j.ArrayUint32, err = utils.GetUintSlice[uint32](input, "ArrayUint32") - if err != nil { - return err - } - j.ArrayUint32Ptr, err = utils.GetUintPtrSlice[uint32](input, "ArrayUint32Ptr") - if err != nil { - return err - } - j.ArrayUint64, err = utils.GetUintSlice[uint64](input, "ArrayUint64") - if err != nil { - return err - } - j.ArrayUint64Ptr, err = utils.GetUintPtrSlice[uint64](input, "ArrayUint64Ptr") - if err != nil { - return err - } - j.ArrayUint8, err = utils.GetUintSlice[uint8](input, "ArrayUint8") - if err != nil { - return err - } - j.ArrayUint8Ptr, err = utils.GetUintPtrSlice[uint8](input, "ArrayUint8Ptr") - if err != nil { - return err - } - j.ArrayUintPtr, err = utils.GetUintPtrSlice[uint](input, "ArrayUintPtr") - if err != nil { - return err - } - err = functions_Decoder.DecodeObjectValue(&j.BigInt, input, "BigInt") - if err != nil { - return err - } - j.BigIntPtr = new(scalar.BigInt) - err = functions_Decoder.DecodeNullableObjectValue(j.BigIntPtr, input, "BigIntPtr") - if err != nil { - return err - } - j.Bool, err = utils.GetBoolean(input, "Bool") - if err != nil { - return err - } - j.BoolPtr, err = utils.GetNullableBoolean(input, "BoolPtr") - if err != nil { - return err - } - err = functions_Decoder.DecodeObjectValue(&j.Bytes, input, "Bytes") - if err != nil { - return err - } - j.BytesPtr = new(scalar.Bytes) - err = functions_Decoder.DecodeNullableObjectValue(j.BytesPtr, input, "BytesPtr") - if err != nil { - return err - } - err = functions_Decoder.DecodeObjectValue(&j.CustomScalar, input, "CustomScalar") - if err != nil { - return err - } - j.CustomScalarPtr = new(CommentText) - err = functions_Decoder.DecodeNullableObjectValue(j.CustomScalarPtr, input, "CustomScalarPtr") - if err != nil { - return err - } - err = functions_Decoder.DecodeObjectValue(&j.Date, input, "Date") - if err != nil { - return err - } - j.DatePtr = new(scalar.Date) - err = functions_Decoder.DecodeNullableObjectValue(j.DatePtr, input, "DatePtr") - if err != nil { - return err - } - err = functions_Decoder.DecodeObjectValue(&j.Enum, input, "Enum") - if err != nil { - return err - } - j.EnumPtr = new(SomeEnum) - err = functions_Decoder.DecodeNullableObjectValue(j.EnumPtr, input, "EnumPtr") - if err != nil { - return err - } - j.Float32, err = utils.GetFloat[float32](input, "Float32") - if err != nil { - return err - } - j.Float32Ptr, err = utils.GetNullableFloat[float32](input, "Float32Ptr") - if err != nil { - return err - } - j.Float64, err = utils.GetFloat[float64](input, "Float64") - if err != nil { - return err - } - j.Float64Ptr, err = utils.GetNullableFloat[float64](input, "Float64Ptr") - if err != nil { - return err - } - j.Int, err = utils.GetInt[int](input, "Int") - if err != nil { - return err - } - j.Int16, err = utils.GetInt[int16](input, "Int16") - if err != nil { - return err - } - j.Int16Ptr, err = utils.GetNullableInt[int16](input, "Int16Ptr") - if err != nil { - return err - } - j.Int32, err = utils.GetInt[int32](input, "Int32") - if err != nil { - return err - } - j.Int32Ptr, err = utils.GetNullableInt[int32](input, "Int32Ptr") - if err != nil { - return err - } - j.Int64, err = utils.GetInt[int64](input, "Int64") - if err != nil { - return err - } - j.Int64Ptr, err = utils.GetNullableInt[int64](input, "Int64Ptr") - if err != nil { - return err - } - j.Int8, err = utils.GetInt[int8](input, "Int8") - if err != nil { - return err - } - j.Int8Ptr, err = utils.GetNullableInt[int8](input, "Int8Ptr") - if err != nil { - return err - } - j.IntPtr, err = utils.GetNullableInt[int](input, "IntPtr") - if err != nil { - return err - } - j.JSON, err = utils.GetArbitraryJSON(input, "JSON") - if err != nil { - return err - } - j.JSONPtr, err = utils.GetNullableArbitraryJSON(input, "JSONPtr") - if err != nil { - return err - } - err = functions_Decoder.DecodeObjectValue(&j.Map, input, "Map") - if err != nil { - return err - } - j.MapPtr = new(map[string]any) - err = functions_Decoder.DecodeNullableObjectValue(j.MapPtr, input, "MapPtr") - if err != nil { - return err - } - err = functions_Decoder.DecodeObjectValue(&j.NamedArray, input, "NamedArray") - if err != nil { - return err - } - j.NamedArrayPtr = new([]Author) - err = functions_Decoder.DecodeNullableObjectValue(j.NamedArrayPtr, input, "NamedArrayPtr") - if err != nil { - return err - } - err = functions_Decoder.DecodeObjectValue(&j.NamedObject, input, "NamedObject") - if err != nil { - return err - } - j.NamedObjectPtr = new(Author) - err = functions_Decoder.DecodeNullableObjectValue(j.NamedObjectPtr, input, "NamedObjectPtr") - if err != nil { - return err - } - err = functions_Decoder.DecodeObjectValue(&j.Object, input, "Object") - if err != nil { - return err - } - j.ObjectPtr = new(struct { - Long int - Lat int - }) - err = functions_Decoder.DecodeNullableObjectValue(j.ObjectPtr, input, "ObjectPtr") - if err != nil { - return err - } - j.PtrArrayBigInt = new([]scalar.BigInt) - err = functions_Decoder.DecodeNullableObjectValue(j.PtrArrayBigInt, input, "PtrArrayBigInt") - if err != nil { - return err - } - j.PtrArrayBigIntPtr = new([]*scalar.BigInt) - err = functions_Decoder.DecodeNullableObjectValue(j.PtrArrayBigIntPtr, input, "PtrArrayBigIntPtr") - if err != nil { - return err - } - j.PtrArrayBool = new([]bool) - err = functions_Decoder.DecodeNullableObjectValue(j.PtrArrayBool, input, "PtrArrayBool") - if err != nil { - return err - } - j.PtrArrayBoolPtr, err = utils.GetNullableBooleanPtrSlice(input, "PtrArrayBoolPtr") - if err != nil { - return err - } - j.PtrArrayFloat32 = new([]float32) - err = functions_Decoder.DecodeNullableObjectValue(j.PtrArrayFloat32, input, "PtrArrayFloat32") - if err != nil { - return err - } - j.PtrArrayFloat32Ptr, err = utils.GetNullableFloatPtrSlice[float32](input, "PtrArrayFloat32Ptr") - if err != nil { - return err - } - j.PtrArrayFloat64 = new([]float64) - err = functions_Decoder.DecodeNullableObjectValue(j.PtrArrayFloat64, input, "PtrArrayFloat64") - if err != nil { - return err - } - j.PtrArrayFloat64Ptr, err = utils.GetNullableFloatPtrSlice[float64](input, "PtrArrayFloat64Ptr") - if err != nil { - return err - } - j.PtrArrayInt = new([]int) - err = functions_Decoder.DecodeNullableObjectValue(j.PtrArrayInt, input, "PtrArrayInt") - if err != nil { - return err - } - j.PtrArrayInt16 = new([]int16) - err = functions_Decoder.DecodeNullableObjectValue(j.PtrArrayInt16, input, "PtrArrayInt16") - if err != nil { - return err - } - j.PtrArrayInt16Ptr, err = utils.GetNullableIntPtrSlice[int16](input, "PtrArrayInt16Ptr") - if err != nil { - return err - } - j.PtrArrayInt32 = new([]int32) - err = functions_Decoder.DecodeNullableObjectValue(j.PtrArrayInt32, input, "PtrArrayInt32") - if err != nil { - return err - } - j.PtrArrayInt32Ptr, err = utils.GetNullableIntPtrSlice[int32](input, "PtrArrayInt32Ptr") - if err != nil { - return err - } - j.PtrArrayInt64 = new([]int64) - err = functions_Decoder.DecodeNullableObjectValue(j.PtrArrayInt64, input, "PtrArrayInt64") - if err != nil { - return err - } - j.PtrArrayInt64Ptr, err = utils.GetNullableIntPtrSlice[int64](input, "PtrArrayInt64Ptr") - if err != nil { - return err - } - j.PtrArrayInt8 = new([]int8) - err = functions_Decoder.DecodeNullableObjectValue(j.PtrArrayInt8, input, "PtrArrayInt8") - if err != nil { - return err - } - j.PtrArrayInt8Ptr, err = utils.GetNullableIntPtrSlice[int8](input, "PtrArrayInt8Ptr") - if err != nil { - return err - } - j.PtrArrayIntPtr, err = utils.GetNullableIntPtrSlice[int](input, "PtrArrayIntPtr") - if err != nil { - return err - } - j.PtrArrayJSON = new([]any) - err = functions_Decoder.DecodeNullableObjectValue(j.PtrArrayJSON, input, "PtrArrayJSON") - if err != nil { - return err - } - j.PtrArrayJSONPtr, err = utils.GetNullableArbitraryJSONPtrSlice(input, "PtrArrayJSONPtr") - if err != nil { - return err - } - j.PtrArrayRawJSON = new([]json.RawMessage) - err = functions_Decoder.DecodeNullableObjectValue(j.PtrArrayRawJSON, input, "PtrArrayRawJSON") - if err != nil { - return err - } - j.PtrArrayRawJSONPtr, err = utils.GetNullableRawJSONPtrSlice(input, "PtrArrayRawJSONPtr") - if err != nil { - return err - } - j.PtrArrayString = new([]string) - err = functions_Decoder.DecodeNullableObjectValue(j.PtrArrayString, input, "PtrArrayString") - if err != nil { - return err - } - j.PtrArrayStringPtr, err = utils.GetNullableStringPtrSlice(input, "PtrArrayStringPtr") - if err != nil { - return err - } - j.PtrArrayTime = new([]time.Time) - err = functions_Decoder.DecodeNullableObjectValue(j.PtrArrayTime, input, "PtrArrayTime") - if err != nil { - return err - } - j.PtrArrayTimePtr, err = utils.GetNullableDateTimePtrSlice(input, "PtrArrayTimePtr") - if err != nil { - return err - } - j.PtrArrayUUID = new([]uuid.UUID) - err = functions_Decoder.DecodeNullableObjectValue(j.PtrArrayUUID, input, "PtrArrayUUID") - if err != nil { - return err - } - j.PtrArrayUUIDPtr, err = utils.GetNullableUUIDPtrSlice(input, "PtrArrayUUIDPtr") - if err != nil { - return err - } - j.PtrArrayUint = new([]uint) - err = functions_Decoder.DecodeNullableObjectValue(j.PtrArrayUint, input, "PtrArrayUint") - if err != nil { - return err - } - j.PtrArrayUint16 = new([]uint16) - err = functions_Decoder.DecodeNullableObjectValue(j.PtrArrayUint16, input, "PtrArrayUint16") - if err != nil { - return err - } - j.PtrArrayUint16Ptr, err = utils.GetNullableUintPtrSlice[uint16](input, "PtrArrayUint16Ptr") - if err != nil { - return err - } - j.PtrArrayUint32 = new([]uint32) - err = functions_Decoder.DecodeNullableObjectValue(j.PtrArrayUint32, input, "PtrArrayUint32") - if err != nil { - return err - } - j.PtrArrayUint32Ptr, err = utils.GetNullableUintPtrSlice[uint32](input, "PtrArrayUint32Ptr") - if err != nil { - return err - } - j.PtrArrayUint64 = new([]uint64) - err = functions_Decoder.DecodeNullableObjectValue(j.PtrArrayUint64, input, "PtrArrayUint64") - if err != nil { - return err - } - j.PtrArrayUint64Ptr, err = utils.GetNullableUintPtrSlice[uint64](input, "PtrArrayUint64Ptr") - if err != nil { - return err - } - j.PtrArrayUint8 = new([]uint8) - err = functions_Decoder.DecodeNullableObjectValue(j.PtrArrayUint8, input, "PtrArrayUint8") - if err != nil { - return err - } - j.PtrArrayUint8Ptr, err = utils.GetNullableUintPtrSlice[uint8](input, "PtrArrayUint8Ptr") - if err != nil { - return err - } - j.PtrArrayUintPtr, err = utils.GetNullableUintPtrSlice[uint](input, "PtrArrayUintPtr") - if err != nil { - return err - } - j.RawJSON, err = utils.GetRawJSON(input, "RawJSON") - if err != nil { - return err - } - j.RawJSONPtr, err = utils.GetNullableRawJSON(input, "RawJSONPtr") - if err != nil { - return err - } - j.String, err = utils.GetString(input, "String") - if err != nil { - return err - } - j.StringPtr, err = utils.GetNullableString(input, "StringPtr") - if err != nil { - return err - } - err = functions_Decoder.DecodeObjectValue(&j.Text, input, "Text") - if err != nil { - return err - } - j.TextPtr = new(Text) - err = functions_Decoder.DecodeNullableObjectValue(j.TextPtr, input, "TextPtr") - if err != nil { - return err - } - j.Time, err = utils.GetDateTime(input, "Time") - if err != nil { - return err - } - j.TimePtr, err = utils.GetNullableDateTime(input, "TimePtr") - if err != nil { - return err - } - j.UUID, err = utils.GetUUID(input, "UUID") - if err != nil { - return err - } - j.UUIDPtr, err = utils.GetNullableUUID(input, "UUIDPtr") - if err != nil { - return err - } - j.Uint, err = utils.GetUint[uint](input, "Uint") - if err != nil { - return err - } - j.Uint16, err = utils.GetUint[uint16](input, "Uint16") - if err != nil { - return err - } - j.Uint16Ptr, err = utils.GetNullableUint[uint16](input, "Uint16Ptr") - if err != nil { - return err - } - j.Uint32, err = utils.GetUint[uint32](input, "Uint32") - if err != nil { - return err - } - j.Uint32Ptr, err = utils.GetNullableUint[uint32](input, "Uint32Ptr") - if err != nil { - return err - } - j.Uint64, err = utils.GetUint[uint64](input, "Uint64") - if err != nil { - return err - } - j.Uint64Ptr, err = utils.GetNullableUint[uint64](input, "Uint64Ptr") - if err != nil { - return err - } - j.Uint8, err = utils.GetUint[uint8](input, "Uint8") - if err != nil { - return err - } - j.Uint8Ptr, err = utils.GetNullableUint[uint8](input, "Uint8Ptr") - if err != nil { - return err - } - j.UintPtr, err = utils.GetNullableUint[uint](input, "UintPtr") - if err != nil { - return err - } - return nil -} - // FromValue decodes values from map func (j *GetArticlesArguments) FromValue(input map[string]any) error { var err error @@ -610,16 +17,6 @@ func (j *GetArticlesArguments) FromValue(input map[string]any) error { return nil } -// ToMap encodes the struct to a value map -func (j Author) ToMap() map[string]any { - r := make(map[string]any) - r["created_at"] = j.CreatedAt - r["id"] = j.ID - r["tags"] = j.Tags - - return r -} - // ToMap encodes the struct to a value map func (j CreateArticleResult) ToMap() map[string]any { r := make(map[string]any) @@ -652,183 +49,6 @@ func (j GetArticlesResult) ToMap() map[string]any { return r } -// ToMap encodes the struct to a value map -func (j GetTypesArguments) ToMap() map[string]any { - r := make(map[string]any) - r["ArrayBigInt"] = j.ArrayBigInt - r["ArrayBigIntPtr"] = j.ArrayBigIntPtr - r["ArrayBool"] = j.ArrayBool - r["ArrayBoolPtr"] = j.ArrayBoolPtr - r["ArrayFloat32"] = j.ArrayFloat32 - r["ArrayFloat32Ptr"] = j.ArrayFloat32Ptr - r["ArrayFloat64"] = j.ArrayFloat64 - r["ArrayFloat64Ptr"] = j.ArrayFloat64Ptr - r["ArrayInt"] = j.ArrayInt - r["ArrayInt16"] = j.ArrayInt16 - r["ArrayInt16Ptr"] = j.ArrayInt16Ptr - r["ArrayInt32"] = j.ArrayInt32 - r["ArrayInt32Ptr"] = j.ArrayInt32Ptr - r["ArrayInt64"] = j.ArrayInt64 - r["ArrayInt64Ptr"] = j.ArrayInt64Ptr - r["ArrayInt8"] = j.ArrayInt8 - r["ArrayInt8Ptr"] = j.ArrayInt8Ptr - r["ArrayIntPtr"] = j.ArrayIntPtr - r["ArrayJSON"] = j.ArrayJSON - r["ArrayJSONPtr"] = j.ArrayJSONPtr - r["ArrayMap"] = j.ArrayMap - r["ArrayMapPtr"] = j.ArrayMapPtr - j_ArrayObject := make([]map[string]any, len(j.ArrayObject)) - for i, j_ArrayObject_v := range j.ArrayObject { - j_ArrayObject_v_obj := make(map[string]any) - j_ArrayObject_v_obj["content"] = j_ArrayObject_v.Content - j_ArrayObject[i] = j_ArrayObject_v_obj - } - r["ArrayObject"] = j_ArrayObject - if j.ArrayObjectPtr != nil { - j_ArrayObjectPtr := make([]map[string]any, len((*j.ArrayObjectPtr))) - for i, j_ArrayObjectPtr_v := range *j.ArrayObjectPtr { - j_ArrayObjectPtr_v_obj := make(map[string]any) - j_ArrayObjectPtr_v_obj["content"] = j_ArrayObjectPtr_v.Content - j_ArrayObjectPtr[i] = j_ArrayObjectPtr_v_obj - } - r["ArrayObjectPtr"] = j_ArrayObjectPtr - } - r["ArrayRawJSON"] = j.ArrayRawJSON - r["ArrayRawJSONPtr"] = j.ArrayRawJSONPtr - r["ArrayString"] = j.ArrayString - r["ArrayStringPtr"] = j.ArrayStringPtr - r["ArrayTime"] = j.ArrayTime - r["ArrayTimePtr"] = j.ArrayTimePtr - r["ArrayUUID"] = j.ArrayUUID - r["ArrayUUIDPtr"] = j.ArrayUUIDPtr - r["ArrayUint"] = j.ArrayUint - r["ArrayUint16"] = j.ArrayUint16 - r["ArrayUint16Ptr"] = j.ArrayUint16Ptr - r["ArrayUint32"] = j.ArrayUint32 - r["ArrayUint32Ptr"] = j.ArrayUint32Ptr - r["ArrayUint64"] = j.ArrayUint64 - r["ArrayUint64Ptr"] = j.ArrayUint64Ptr - r["ArrayUint8"] = j.ArrayUint8 - r["ArrayUint8Ptr"] = j.ArrayUint8Ptr - r["ArrayUintPtr"] = j.ArrayUintPtr - r["BigInt"] = j.BigInt - r["BigIntPtr"] = j.BigIntPtr - r["Bool"] = j.Bool - r["BoolPtr"] = j.BoolPtr - r["Bytes"] = j.Bytes - r["BytesPtr"] = j.BytesPtr - r["CustomScalar"] = j.CustomScalar - r["CustomScalarPtr"] = j.CustomScalarPtr - r["Date"] = j.Date - r["DatePtr"] = j.DatePtr - r["Enum"] = j.Enum - r["EnumPtr"] = j.EnumPtr - r["Float32"] = j.Float32 - r["Float32Ptr"] = j.Float32Ptr - r["Float64"] = j.Float64 - r["Float64Ptr"] = j.Float64Ptr - r["Int"] = j.Int - r["Int16"] = j.Int16 - r["Int16Ptr"] = j.Int16Ptr - r["Int32"] = j.Int32 - r["Int32Ptr"] = j.Int32Ptr - r["Int64"] = j.Int64 - r["Int64Ptr"] = j.Int64Ptr - r["Int8"] = j.Int8 - r["Int8Ptr"] = j.Int8Ptr - r["IntPtr"] = j.IntPtr - r["JSON"] = j.JSON - r["JSONPtr"] = j.JSONPtr - r["Map"] = j.Map - r["MapPtr"] = j.MapPtr - j_NamedArray := make([]map[string]any, len(j.NamedArray)) - for i, j_NamedArray_v := range j.NamedArray { - j_NamedArray[i] = utils.EncodeMap(j_NamedArray_v) - } - r["NamedArray"] = j_NamedArray - if j.NamedArrayPtr != nil { - j_NamedArrayPtr := make([]map[string]any, len((*j.NamedArrayPtr))) - for i, j_NamedArrayPtr_v := range *j.NamedArrayPtr { - j_NamedArrayPtr[i] = utils.EncodeMap(j_NamedArrayPtr_v) - } - r["NamedArrayPtr"] = j_NamedArrayPtr - } - r["NamedObject"] = utils.EncodeMap(j.NamedObject) - if j.NamedObjectPtr != nil { - r["NamedObjectPtr"] = utils.EncodeMap((*j.NamedObjectPtr)) - } - j_Object_obj := make(map[string]any) - j_Object_obj["created_at"] = j.Object.CreatedAt - j_Object_obj["id"] = j.Object.ID - r["Object"] = j_Object_obj - if j.ObjectPtr != nil { - j_ObjectPtr__obj := make(map[string]any) - j_ObjectPtr__obj["Lat"] = (*j.ObjectPtr).Lat - j_ObjectPtr__obj["Long"] = (*j.ObjectPtr).Long - r["ObjectPtr"] = j_ObjectPtr__obj - } - r["PtrArrayBigInt"] = j.PtrArrayBigInt - r["PtrArrayBigIntPtr"] = j.PtrArrayBigIntPtr - r["PtrArrayBool"] = j.PtrArrayBool - r["PtrArrayBoolPtr"] = j.PtrArrayBoolPtr - r["PtrArrayFloat32"] = j.PtrArrayFloat32 - r["PtrArrayFloat32Ptr"] = j.PtrArrayFloat32Ptr - r["PtrArrayFloat64"] = j.PtrArrayFloat64 - r["PtrArrayFloat64Ptr"] = j.PtrArrayFloat64Ptr - r["PtrArrayInt"] = j.PtrArrayInt - r["PtrArrayInt16"] = j.PtrArrayInt16 - r["PtrArrayInt16Ptr"] = j.PtrArrayInt16Ptr - r["PtrArrayInt32"] = j.PtrArrayInt32 - r["PtrArrayInt32Ptr"] = j.PtrArrayInt32Ptr - r["PtrArrayInt64"] = j.PtrArrayInt64 - r["PtrArrayInt64Ptr"] = j.PtrArrayInt64Ptr - r["PtrArrayInt8"] = j.PtrArrayInt8 - r["PtrArrayInt8Ptr"] = j.PtrArrayInt8Ptr - r["PtrArrayIntPtr"] = j.PtrArrayIntPtr - r["PtrArrayJSON"] = j.PtrArrayJSON - r["PtrArrayJSONPtr"] = j.PtrArrayJSONPtr - r["PtrArrayRawJSON"] = j.PtrArrayRawJSON - r["PtrArrayRawJSONPtr"] = j.PtrArrayRawJSONPtr - r["PtrArrayString"] = j.PtrArrayString - r["PtrArrayStringPtr"] = j.PtrArrayStringPtr - r["PtrArrayTime"] = j.PtrArrayTime - r["PtrArrayTimePtr"] = j.PtrArrayTimePtr - r["PtrArrayUUID"] = j.PtrArrayUUID - r["PtrArrayUUIDPtr"] = j.PtrArrayUUIDPtr - r["PtrArrayUint"] = j.PtrArrayUint - r["PtrArrayUint16"] = j.PtrArrayUint16 - r["PtrArrayUint16Ptr"] = j.PtrArrayUint16Ptr - r["PtrArrayUint32"] = j.PtrArrayUint32 - r["PtrArrayUint32Ptr"] = j.PtrArrayUint32Ptr - r["PtrArrayUint64"] = j.PtrArrayUint64 - r["PtrArrayUint64Ptr"] = j.PtrArrayUint64Ptr - r["PtrArrayUint8"] = j.PtrArrayUint8 - r["PtrArrayUint8Ptr"] = j.PtrArrayUint8Ptr - r["PtrArrayUintPtr"] = j.PtrArrayUintPtr - r["RawJSON"] = j.RawJSON - r["RawJSONPtr"] = j.RawJSONPtr - r["String"] = j.String - r["StringPtr"] = j.StringPtr - r["Text"] = j.Text - r["TextPtr"] = j.TextPtr - r["Time"] = j.Time - r["TimePtr"] = j.TimePtr - r["UUID"] = j.UUID - r["UUIDPtr"] = j.UUIDPtr - r["Uint"] = j.Uint - r["Uint16"] = j.Uint16 - r["Uint16Ptr"] = j.Uint16Ptr - r["Uint32"] = j.Uint32 - r["Uint32Ptr"] = j.Uint32Ptr - r["Uint64"] = j.Uint64 - r["Uint64Ptr"] = j.Uint64Ptr - r["Uint8"] = j.Uint8 - r["Uint8Ptr"] = j.Uint8Ptr - r["UintPtr"] = j.UintPtr - - return r -} - // ToMap encodes the struct to a value map func (j HelloResult) ToMap() map[string]any { r := make(map[string]any) @@ -840,73 +60,7 @@ func (j HelloResult) ToMap() map[string]any { return r } -// ScalarName get the schema name of the scalar -func (j CommentText) ScalarName() string { - return "CommentString" -} - // ScalarName get the schema name of the scalar func (j ScalarFoo) ScalarName() string { return "Foo" } - -// ScalarName get the schema name of the scalar -func (j SomeEnum) ScalarName() string { - return "SomeEnum" -} - -const ( - SomeEnumFoo SomeEnum = "foo" - SomeEnumBar SomeEnum = "bar" -) - -var enumValues_SomeEnum = []SomeEnum{SomeEnumFoo, SomeEnumBar} - -// ParseSomeEnum parses a SomeEnum enum from string -func ParseSomeEnum(input string) (SomeEnum, error) { - result := SomeEnum(input) - if !schema.Contains(enumValues_SomeEnum, result) { - return SomeEnum(""), errors.New("failed to parse SomeEnum, expect one of SomeEnumFoo, SomeEnumBar") - } - - return result, nil -} - -// IsValid checks if the value is invalid -func (j SomeEnum) IsValid() bool { - return schema.Contains(enumValues_SomeEnum, j) -} - -// UnmarshalJSON implements json.Unmarshaler. -func (j *SomeEnum) UnmarshalJSON(b []byte) error { - var rawValue string - if err := json.Unmarshal(b, &rawValue); err != nil { - return err - } - - value, err := ParseSomeEnum(rawValue) - if err != nil { - return err - } - - *j = value - return nil -} - -// FromValue decodes the scalar from an unknown value -func (s *SomeEnum) FromValue(value any) error { - valueStr, err := utils.DecodeNullableString(value) - if err != nil { - return err - } - if valueStr == nil { - return nil - } - result, err := ParseSomeEnum(*valueStr) - if err != nil { - return err - } - - *s = result - return nil -} diff --git a/example/codegen/types/arguments/arguments.go b/example/codegen/types/arguments/arguments.go new file mode 100644 index 0000000..903ab92 --- /dev/null +++ b/example/codegen/types/arguments/arguments.go @@ -0,0 +1,165 @@ +package arguments + +import ( + "encoding/json" + "time" + + "github.com/google/uuid" + "github.com/hasura/ndc-codegen-example/types" + "github.com/hasura/ndc-sdk-go/scalar" +) + +type GetTypesArguments struct { + UUID uuid.UUID + Bool bool + String string + Int int + Int8 int8 + Int16 int16 + Int32 int32 + Int64 int64 + Uint uint + Uint8 uint8 + Uint16 uint16 + Uint32 uint32 + Uint64 uint64 + Float32 float32 + Float64 float64 + Time time.Time + Text types.Text + CustomScalar types.CommentText + Enum types.SomeEnum + BigInt scalar.BigInt + Date scalar.Date + + UUIDPtr *uuid.UUID + BoolPtr *bool + StringPtr *string + IntPtr *int + Int8Ptr *int8 + Int16Ptr *int16 + Int32Ptr *int32 + Int64Ptr *int64 + UintPtr *uint + Uint8Ptr *uint8 + Uint16Ptr *uint16 + Uint32Ptr *uint32 + Uint64Ptr *uint64 + Float32Ptr *float32 + Float64Ptr *float64 + TimePtr *time.Time + TextPtr *types.Text + CustomScalarPtr *types.CommentText + EnumPtr *types.SomeEnum + BigIntPtr *scalar.BigInt + DatePtr *scalar.Date + + ArrayBool []bool + ArrayString []string + ArrayInt []int + ArrayInt8 []int8 + ArrayInt16 []int16 + ArrayInt32 []int32 + ArrayInt64 []int64 + ArrayUint []uint + ArrayUint8 []uint8 + ArrayUint16 []uint16 + ArrayUint32 []uint32 + ArrayUint64 []uint64 + ArrayFloat32 []float32 + ArrayFloat64 []float64 + ArrayUUID []uuid.UUID + ArrayBoolPtr []*bool + ArrayStringPtr []*string + ArrayIntPtr []*int + ArrayInt8Ptr []*int8 + ArrayInt16Ptr []*int16 + ArrayInt32Ptr []*int32 + ArrayInt64Ptr []*int64 + ArrayUintPtr []*uint + ArrayUint8Ptr []*uint8 + ArrayUint16Ptr []*uint16 + ArrayUint32Ptr []*uint32 + ArrayUint64Ptr []*uint64 + ArrayFloat32Ptr []*float32 + ArrayFloat64Ptr []*float64 + ArrayUUIDPtr []*uuid.UUID + ArrayJSON []any + ArrayJSONPtr []*interface{} + ArrayRawJSON []json.RawMessage + ArrayRawJSONPtr []*json.RawMessage + ArrayBigInt []scalar.BigInt + ArrayBigIntPtr []*scalar.BigInt + ArrayTime []time.Time + ArrayTimePtr []*time.Time + + PtrArrayBool *[]bool + PtrArrayString *[]string + PtrArrayInt *[]int + PtrArrayInt8 *[]int8 + PtrArrayInt16 *[]int16 + PtrArrayInt32 *[]int32 + PtrArrayInt64 *[]int64 + PtrArrayUint *[]uint + PtrArrayUint8 *[]uint8 + PtrArrayUint16 *[]uint16 + PtrArrayUint32 *[]uint32 + PtrArrayUint64 *[]uint64 + PtrArrayFloat32 *[]float32 + PtrArrayFloat64 *[]float64 + PtrArrayUUID *[]uuid.UUID + PtrArrayBoolPtr *[]*bool + PtrArrayStringPtr *[]*string + PtrArrayIntPtr *[]*int + PtrArrayInt8Ptr *[]*int8 + PtrArrayInt16Ptr *[]*int16 + PtrArrayInt32Ptr *[]*int32 + PtrArrayInt64Ptr *[]*int64 + PtrArrayUintPtr *[]*uint + PtrArrayUint8Ptr *[]*uint8 + PtrArrayUint16Ptr *[]*uint16 + PtrArrayUint32Ptr *[]*uint32 + PtrArrayUint64Ptr *[]*uint64 + PtrArrayFloat32Ptr *[]*float32 + PtrArrayFloat64Ptr *[]*float64 + PtrArrayUUIDPtr *[]*uuid.UUID + PtrArrayJSON *[]any + PtrArrayJSONPtr *[]*interface{} + PtrArrayRawJSON *[]json.RawMessage + PtrArrayRawJSONPtr *[]*json.RawMessage + PtrArrayBigInt *[]scalar.BigInt + PtrArrayBigIntPtr *[]*scalar.BigInt + PtrArrayTime *[]time.Time + PtrArrayTimePtr *[]*time.Time + + Object struct { + ID uuid.UUID `json:"id"` + CreatedAt time.Time `json:"created_at"` + } + ObjectPtr *struct { + Long int + Lat int + } + ArrayObject []struct { + Content string `json:"content"` + } + ArrayObjectPtr *[]struct { + Content string `json:"content"` + } + NamedObject types.Author + NamedObjectPtr *types.Author + NamedArray []types.Author + NamedArrayPtr *[]types.Author + + Map map[string]any + MapPtr *map[string]any + ArrayMap []map[string]any + ArrayMapPtr *[]map[string]any + + JSON any + JSONPtr *interface{} + RawJSON json.RawMessage + RawJSONPtr *json.RawMessage + Bytes scalar.Bytes + BytesPtr *scalar.Bytes +} diff --git a/example/codegen/types/arguments/types.generated.go b/example/codegen/types/arguments/types.generated.go new file mode 100644 index 0000000..13a8ca4 --- /dev/null +++ b/example/codegen/types/arguments/types.generated.go @@ -0,0 +1,777 @@ +// Code generated by github.com/hasura/ndc-sdk-go/codegen, DO NOT EDIT. +package arguments + +import ( + "encoding/json" + "github.com/google/uuid" + "github.com/hasura/ndc-codegen-example/types" + "github.com/hasura/ndc-sdk-go/scalar" + "github.com/hasura/ndc-sdk-go/utils" + "time" +) + +var arguments_Decoder = utils.NewDecoder() + +// FromValue decodes values from map +func (j *GetTypesArguments) FromValue(input map[string]any) error { + var err error + err = arguments_Decoder.DecodeObjectValue(&j.ArrayBigInt, input, "ArrayBigInt") + if err != nil { + return err + } + err = arguments_Decoder.DecodeObjectValue(&j.ArrayBigIntPtr, input, "ArrayBigIntPtr") + if err != nil { + return err + } + j.ArrayBool, err = utils.GetBooleanSlice(input, "ArrayBool") + if err != nil { + return err + } + j.ArrayBoolPtr, err = utils.GetBooleanPtrSlice(input, "ArrayBoolPtr") + if err != nil { + return err + } + j.ArrayFloat32, err = utils.GetFloatSlice[float32](input, "ArrayFloat32") + if err != nil { + return err + } + j.ArrayFloat32Ptr, err = utils.GetFloatPtrSlice[float32](input, "ArrayFloat32Ptr") + if err != nil { + return err + } + j.ArrayFloat64, err = utils.GetFloatSlice[float64](input, "ArrayFloat64") + if err != nil { + return err + } + j.ArrayFloat64Ptr, err = utils.GetFloatPtrSlice[float64](input, "ArrayFloat64Ptr") + if err != nil { + return err + } + j.ArrayInt, err = utils.GetIntSlice[int](input, "ArrayInt") + if err != nil { + return err + } + j.ArrayInt16, err = utils.GetIntSlice[int16](input, "ArrayInt16") + if err != nil { + return err + } + j.ArrayInt16Ptr, err = utils.GetIntPtrSlice[int16](input, "ArrayInt16Ptr") + if err != nil { + return err + } + j.ArrayInt32, err = utils.GetIntSlice[int32](input, "ArrayInt32") + if err != nil { + return err + } + j.ArrayInt32Ptr, err = utils.GetIntPtrSlice[int32](input, "ArrayInt32Ptr") + if err != nil { + return err + } + j.ArrayInt64, err = utils.GetIntSlice[int64](input, "ArrayInt64") + if err != nil { + return err + } + j.ArrayInt64Ptr, err = utils.GetIntPtrSlice[int64](input, "ArrayInt64Ptr") + if err != nil { + return err + } + j.ArrayInt8, err = utils.GetIntSlice[int8](input, "ArrayInt8") + if err != nil { + return err + } + j.ArrayInt8Ptr, err = utils.GetIntPtrSlice[int8](input, "ArrayInt8Ptr") + if err != nil { + return err + } + j.ArrayIntPtr, err = utils.GetIntPtrSlice[int](input, "ArrayIntPtr") + if err != nil { + return err + } + j.ArrayJSON, err = utils.GetArbitraryJSONSlice(input, "ArrayJSON") + if err != nil { + return err + } + j.ArrayJSONPtr, err = utils.GetArbitraryJSONPtrSlice(input, "ArrayJSONPtr") + if err != nil { + return err + } + err = arguments_Decoder.DecodeObjectValue(&j.ArrayMap, input, "ArrayMap") + if err != nil { + return err + } + j.ArrayMapPtr = new([]map[string]any) + err = arguments_Decoder.DecodeNullableObjectValue(j.ArrayMapPtr, input, "ArrayMapPtr") + if err != nil { + return err + } + err = arguments_Decoder.DecodeObjectValue(&j.ArrayObject, input, "ArrayObject") + if err != nil { + return err + } + j.ArrayObjectPtr = new([]struct { + Content string "json:\"content\"" + }) + err = arguments_Decoder.DecodeNullableObjectValue(j.ArrayObjectPtr, input, "ArrayObjectPtr") + if err != nil { + return err + } + j.ArrayRawJSON, err = utils.GetRawJSONSlice(input, "ArrayRawJSON") + if err != nil { + return err + } + j.ArrayRawJSONPtr, err = utils.GetRawJSONPtrSlice(input, "ArrayRawJSONPtr") + if err != nil { + return err + } + j.ArrayString, err = utils.GetStringSlice(input, "ArrayString") + if err != nil { + return err + } + j.ArrayStringPtr, err = utils.GetStringPtrSlice(input, "ArrayStringPtr") + if err != nil { + return err + } + j.ArrayTime, err = utils.GetDateTimeSlice(input, "ArrayTime") + if err != nil { + return err + } + j.ArrayTimePtr, err = utils.GetDateTimePtrSlice(input, "ArrayTimePtr") + if err != nil { + return err + } + j.ArrayUUID, err = utils.GetUUIDSlice(input, "ArrayUUID") + if err != nil { + return err + } + j.ArrayUUIDPtr, err = utils.GetUUIDPtrSlice(input, "ArrayUUIDPtr") + if err != nil { + return err + } + j.ArrayUint, err = utils.GetUintSlice[uint](input, "ArrayUint") + if err != nil { + return err + } + j.ArrayUint16, err = utils.GetUintSlice[uint16](input, "ArrayUint16") + if err != nil { + return err + } + j.ArrayUint16Ptr, err = utils.GetUintPtrSlice[uint16](input, "ArrayUint16Ptr") + if err != nil { + return err + } + j.ArrayUint32, err = utils.GetUintSlice[uint32](input, "ArrayUint32") + if err != nil { + return err + } + j.ArrayUint32Ptr, err = utils.GetUintPtrSlice[uint32](input, "ArrayUint32Ptr") + if err != nil { + return err + } + j.ArrayUint64, err = utils.GetUintSlice[uint64](input, "ArrayUint64") + if err != nil { + return err + } + j.ArrayUint64Ptr, err = utils.GetUintPtrSlice[uint64](input, "ArrayUint64Ptr") + if err != nil { + return err + } + j.ArrayUint8, err = utils.GetUintSlice[uint8](input, "ArrayUint8") + if err != nil { + return err + } + j.ArrayUint8Ptr, err = utils.GetUintPtrSlice[uint8](input, "ArrayUint8Ptr") + if err != nil { + return err + } + j.ArrayUintPtr, err = utils.GetUintPtrSlice[uint](input, "ArrayUintPtr") + if err != nil { + return err + } + err = arguments_Decoder.DecodeObjectValue(&j.BigInt, input, "BigInt") + if err != nil { + return err + } + j.BigIntPtr = new(scalar.BigInt) + err = arguments_Decoder.DecodeNullableObjectValue(j.BigIntPtr, input, "BigIntPtr") + if err != nil { + return err + } + j.Bool, err = utils.GetBoolean(input, "Bool") + if err != nil { + return err + } + j.BoolPtr, err = utils.GetNullableBoolean(input, "BoolPtr") + if err != nil { + return err + } + err = arguments_Decoder.DecodeObjectValue(&j.Bytes, input, "Bytes") + if err != nil { + return err + } + j.BytesPtr = new(scalar.Bytes) + err = arguments_Decoder.DecodeNullableObjectValue(j.BytesPtr, input, "BytesPtr") + if err != nil { + return err + } + err = arguments_Decoder.DecodeObjectValue(&j.CustomScalar, input, "CustomScalar") + if err != nil { + return err + } + j.CustomScalarPtr = new(types.CommentText) + err = arguments_Decoder.DecodeNullableObjectValue(j.CustomScalarPtr, input, "CustomScalarPtr") + if err != nil { + return err + } + err = arguments_Decoder.DecodeObjectValue(&j.Date, input, "Date") + if err != nil { + return err + } + j.DatePtr = new(scalar.Date) + err = arguments_Decoder.DecodeNullableObjectValue(j.DatePtr, input, "DatePtr") + if err != nil { + return err + } + err = arguments_Decoder.DecodeObjectValue(&j.Enum, input, "Enum") + if err != nil { + return err + } + j.EnumPtr = new(types.SomeEnum) + err = arguments_Decoder.DecodeNullableObjectValue(j.EnumPtr, input, "EnumPtr") + if err != nil { + return err + } + j.Float32, err = utils.GetFloat[float32](input, "Float32") + if err != nil { + return err + } + j.Float32Ptr, err = utils.GetNullableFloat[float32](input, "Float32Ptr") + if err != nil { + return err + } + j.Float64, err = utils.GetFloat[float64](input, "Float64") + if err != nil { + return err + } + j.Float64Ptr, err = utils.GetNullableFloat[float64](input, "Float64Ptr") + if err != nil { + return err + } + j.Int, err = utils.GetInt[int](input, "Int") + if err != nil { + return err + } + j.Int16, err = utils.GetInt[int16](input, "Int16") + if err != nil { + return err + } + j.Int16Ptr, err = utils.GetNullableInt[int16](input, "Int16Ptr") + if err != nil { + return err + } + j.Int32, err = utils.GetInt[int32](input, "Int32") + if err != nil { + return err + } + j.Int32Ptr, err = utils.GetNullableInt[int32](input, "Int32Ptr") + if err != nil { + return err + } + j.Int64, err = utils.GetInt[int64](input, "Int64") + if err != nil { + return err + } + j.Int64Ptr, err = utils.GetNullableInt[int64](input, "Int64Ptr") + if err != nil { + return err + } + j.Int8, err = utils.GetInt[int8](input, "Int8") + if err != nil { + return err + } + j.Int8Ptr, err = utils.GetNullableInt[int8](input, "Int8Ptr") + if err != nil { + return err + } + j.IntPtr, err = utils.GetNullableInt[int](input, "IntPtr") + if err != nil { + return err + } + j.JSON, err = utils.GetArbitraryJSON(input, "JSON") + if err != nil { + return err + } + j.JSONPtr, err = utils.GetNullableArbitraryJSON(input, "JSONPtr") + if err != nil { + return err + } + err = arguments_Decoder.DecodeObjectValue(&j.Map, input, "Map") + if err != nil { + return err + } + j.MapPtr = new(map[string]any) + err = arguments_Decoder.DecodeNullableObjectValue(j.MapPtr, input, "MapPtr") + if err != nil { + return err + } + err = arguments_Decoder.DecodeObjectValue(&j.NamedArray, input, "NamedArray") + if err != nil { + return err + } + j.NamedArrayPtr = new([]types.Author) + err = arguments_Decoder.DecodeNullableObjectValue(j.NamedArrayPtr, input, "NamedArrayPtr") + if err != nil { + return err + } + err = arguments_Decoder.DecodeObjectValue(&j.NamedObject, input, "NamedObject") + if err != nil { + return err + } + j.NamedObjectPtr = new(types.Author) + err = arguments_Decoder.DecodeNullableObjectValue(j.NamedObjectPtr, input, "NamedObjectPtr") + if err != nil { + return err + } + err = arguments_Decoder.DecodeObjectValue(&j.Object, input, "Object") + if err != nil { + return err + } + j.ObjectPtr = new(struct { + Long int + Lat int + }) + err = arguments_Decoder.DecodeNullableObjectValue(j.ObjectPtr, input, "ObjectPtr") + if err != nil { + return err + } + j.PtrArrayBigInt = new([]scalar.BigInt) + err = arguments_Decoder.DecodeNullableObjectValue(j.PtrArrayBigInt, input, "PtrArrayBigInt") + if err != nil { + return err + } + j.PtrArrayBigIntPtr = new([]*scalar.BigInt) + err = arguments_Decoder.DecodeNullableObjectValue(j.PtrArrayBigIntPtr, input, "PtrArrayBigIntPtr") + if err != nil { + return err + } + j.PtrArrayBool = new([]bool) + err = arguments_Decoder.DecodeNullableObjectValue(j.PtrArrayBool, input, "PtrArrayBool") + if err != nil { + return err + } + j.PtrArrayBoolPtr, err = utils.GetNullableBooleanPtrSlice(input, "PtrArrayBoolPtr") + if err != nil { + return err + } + j.PtrArrayFloat32 = new([]float32) + err = arguments_Decoder.DecodeNullableObjectValue(j.PtrArrayFloat32, input, "PtrArrayFloat32") + if err != nil { + return err + } + j.PtrArrayFloat32Ptr, err = utils.GetNullableFloatPtrSlice[float32](input, "PtrArrayFloat32Ptr") + if err != nil { + return err + } + j.PtrArrayFloat64 = new([]float64) + err = arguments_Decoder.DecodeNullableObjectValue(j.PtrArrayFloat64, input, "PtrArrayFloat64") + if err != nil { + return err + } + j.PtrArrayFloat64Ptr, err = utils.GetNullableFloatPtrSlice[float64](input, "PtrArrayFloat64Ptr") + if err != nil { + return err + } + j.PtrArrayInt = new([]int) + err = arguments_Decoder.DecodeNullableObjectValue(j.PtrArrayInt, input, "PtrArrayInt") + if err != nil { + return err + } + j.PtrArrayInt16 = new([]int16) + err = arguments_Decoder.DecodeNullableObjectValue(j.PtrArrayInt16, input, "PtrArrayInt16") + if err != nil { + return err + } + j.PtrArrayInt16Ptr, err = utils.GetNullableIntPtrSlice[int16](input, "PtrArrayInt16Ptr") + if err != nil { + return err + } + j.PtrArrayInt32 = new([]int32) + err = arguments_Decoder.DecodeNullableObjectValue(j.PtrArrayInt32, input, "PtrArrayInt32") + if err != nil { + return err + } + j.PtrArrayInt32Ptr, err = utils.GetNullableIntPtrSlice[int32](input, "PtrArrayInt32Ptr") + if err != nil { + return err + } + j.PtrArrayInt64 = new([]int64) + err = arguments_Decoder.DecodeNullableObjectValue(j.PtrArrayInt64, input, "PtrArrayInt64") + if err != nil { + return err + } + j.PtrArrayInt64Ptr, err = utils.GetNullableIntPtrSlice[int64](input, "PtrArrayInt64Ptr") + if err != nil { + return err + } + j.PtrArrayInt8 = new([]int8) + err = arguments_Decoder.DecodeNullableObjectValue(j.PtrArrayInt8, input, "PtrArrayInt8") + if err != nil { + return err + } + j.PtrArrayInt8Ptr, err = utils.GetNullableIntPtrSlice[int8](input, "PtrArrayInt8Ptr") + if err != nil { + return err + } + j.PtrArrayIntPtr, err = utils.GetNullableIntPtrSlice[int](input, "PtrArrayIntPtr") + if err != nil { + return err + } + j.PtrArrayJSON = new([]any) + err = arguments_Decoder.DecodeNullableObjectValue(j.PtrArrayJSON, input, "PtrArrayJSON") + if err != nil { + return err + } + j.PtrArrayJSONPtr, err = utils.GetNullableArbitraryJSONPtrSlice(input, "PtrArrayJSONPtr") + if err != nil { + return err + } + j.PtrArrayRawJSON = new([]json.RawMessage) + err = arguments_Decoder.DecodeNullableObjectValue(j.PtrArrayRawJSON, input, "PtrArrayRawJSON") + if err != nil { + return err + } + j.PtrArrayRawJSONPtr, err = utils.GetNullableRawJSONPtrSlice(input, "PtrArrayRawJSONPtr") + if err != nil { + return err + } + j.PtrArrayString = new([]string) + err = arguments_Decoder.DecodeNullableObjectValue(j.PtrArrayString, input, "PtrArrayString") + if err != nil { + return err + } + j.PtrArrayStringPtr, err = utils.GetNullableStringPtrSlice(input, "PtrArrayStringPtr") + if err != nil { + return err + } + j.PtrArrayTime = new([]time.Time) + err = arguments_Decoder.DecodeNullableObjectValue(j.PtrArrayTime, input, "PtrArrayTime") + if err != nil { + return err + } + j.PtrArrayTimePtr, err = utils.GetNullableDateTimePtrSlice(input, "PtrArrayTimePtr") + if err != nil { + return err + } + j.PtrArrayUUID = new([]uuid.UUID) + err = arguments_Decoder.DecodeNullableObjectValue(j.PtrArrayUUID, input, "PtrArrayUUID") + if err != nil { + return err + } + j.PtrArrayUUIDPtr, err = utils.GetNullableUUIDPtrSlice(input, "PtrArrayUUIDPtr") + if err != nil { + return err + } + j.PtrArrayUint = new([]uint) + err = arguments_Decoder.DecodeNullableObjectValue(j.PtrArrayUint, input, "PtrArrayUint") + if err != nil { + return err + } + j.PtrArrayUint16 = new([]uint16) + err = arguments_Decoder.DecodeNullableObjectValue(j.PtrArrayUint16, input, "PtrArrayUint16") + if err != nil { + return err + } + j.PtrArrayUint16Ptr, err = utils.GetNullableUintPtrSlice[uint16](input, "PtrArrayUint16Ptr") + if err != nil { + return err + } + j.PtrArrayUint32 = new([]uint32) + err = arguments_Decoder.DecodeNullableObjectValue(j.PtrArrayUint32, input, "PtrArrayUint32") + if err != nil { + return err + } + j.PtrArrayUint32Ptr, err = utils.GetNullableUintPtrSlice[uint32](input, "PtrArrayUint32Ptr") + if err != nil { + return err + } + j.PtrArrayUint64 = new([]uint64) + err = arguments_Decoder.DecodeNullableObjectValue(j.PtrArrayUint64, input, "PtrArrayUint64") + if err != nil { + return err + } + j.PtrArrayUint64Ptr, err = utils.GetNullableUintPtrSlice[uint64](input, "PtrArrayUint64Ptr") + if err != nil { + return err + } + j.PtrArrayUint8 = new([]uint8) + err = arguments_Decoder.DecodeNullableObjectValue(j.PtrArrayUint8, input, "PtrArrayUint8") + if err != nil { + return err + } + j.PtrArrayUint8Ptr, err = utils.GetNullableUintPtrSlice[uint8](input, "PtrArrayUint8Ptr") + if err != nil { + return err + } + j.PtrArrayUintPtr, err = utils.GetNullableUintPtrSlice[uint](input, "PtrArrayUintPtr") + if err != nil { + return err + } + j.RawJSON, err = utils.GetRawJSON(input, "RawJSON") + if err != nil { + return err + } + j.RawJSONPtr, err = utils.GetNullableRawJSON(input, "RawJSONPtr") + if err != nil { + return err + } + j.String, err = utils.GetString(input, "String") + if err != nil { + return err + } + j.StringPtr, err = utils.GetNullableString(input, "StringPtr") + if err != nil { + return err + } + err = arguments_Decoder.DecodeObjectValue(&j.Text, input, "Text") + if err != nil { + return err + } + j.TextPtr = new(types.Text) + err = arguments_Decoder.DecodeNullableObjectValue(j.TextPtr, input, "TextPtr") + if err != nil { + return err + } + j.Time, err = utils.GetDateTime(input, "Time") + if err != nil { + return err + } + j.TimePtr, err = utils.GetNullableDateTime(input, "TimePtr") + if err != nil { + return err + } + j.UUID, err = utils.GetUUID(input, "UUID") + if err != nil { + return err + } + j.UUIDPtr, err = utils.GetNullableUUID(input, "UUIDPtr") + if err != nil { + return err + } + j.Uint, err = utils.GetUint[uint](input, "Uint") + if err != nil { + return err + } + j.Uint16, err = utils.GetUint[uint16](input, "Uint16") + if err != nil { + return err + } + j.Uint16Ptr, err = utils.GetNullableUint[uint16](input, "Uint16Ptr") + if err != nil { + return err + } + j.Uint32, err = utils.GetUint[uint32](input, "Uint32") + if err != nil { + return err + } + j.Uint32Ptr, err = utils.GetNullableUint[uint32](input, "Uint32Ptr") + if err != nil { + return err + } + j.Uint64, err = utils.GetUint[uint64](input, "Uint64") + if err != nil { + return err + } + j.Uint64Ptr, err = utils.GetNullableUint[uint64](input, "Uint64Ptr") + if err != nil { + return err + } + j.Uint8, err = utils.GetUint[uint8](input, "Uint8") + if err != nil { + return err + } + j.Uint8Ptr, err = utils.GetNullableUint[uint8](input, "Uint8Ptr") + if err != nil { + return err + } + j.UintPtr, err = utils.GetNullableUint[uint](input, "UintPtr") + if err != nil { + return err + } + return nil +} + +// ToMap encodes the struct to a value map +func (j GetTypesArguments) ToMap() map[string]any { + r := make(map[string]any) + r["ArrayBigInt"] = j.ArrayBigInt + r["ArrayBigIntPtr"] = j.ArrayBigIntPtr + r["ArrayBool"] = j.ArrayBool + r["ArrayBoolPtr"] = j.ArrayBoolPtr + r["ArrayFloat32"] = j.ArrayFloat32 + r["ArrayFloat32Ptr"] = j.ArrayFloat32Ptr + r["ArrayFloat64"] = j.ArrayFloat64 + r["ArrayFloat64Ptr"] = j.ArrayFloat64Ptr + r["ArrayInt"] = j.ArrayInt + r["ArrayInt16"] = j.ArrayInt16 + r["ArrayInt16Ptr"] = j.ArrayInt16Ptr + r["ArrayInt32"] = j.ArrayInt32 + r["ArrayInt32Ptr"] = j.ArrayInt32Ptr + r["ArrayInt64"] = j.ArrayInt64 + r["ArrayInt64Ptr"] = j.ArrayInt64Ptr + r["ArrayInt8"] = j.ArrayInt8 + r["ArrayInt8Ptr"] = j.ArrayInt8Ptr + r["ArrayIntPtr"] = j.ArrayIntPtr + r["ArrayJSON"] = j.ArrayJSON + r["ArrayJSONPtr"] = j.ArrayJSONPtr + r["ArrayMap"] = j.ArrayMap + r["ArrayMapPtr"] = j.ArrayMapPtr + j_ArrayObject := make([]map[string]any, len(j.ArrayObject)) + for i, j_ArrayObject_v := range j.ArrayObject { + j_ArrayObject_v_obj := make(map[string]any) + j_ArrayObject_v_obj["content"] = j_ArrayObject_v.Content + j_ArrayObject[i] = j_ArrayObject_v_obj + } + r["ArrayObject"] = j_ArrayObject + if j.ArrayObjectPtr != nil { + j_ArrayObjectPtr := make([]map[string]any, len((*j.ArrayObjectPtr))) + for i, j_ArrayObjectPtr_v := range *j.ArrayObjectPtr { + j_ArrayObjectPtr_v_obj := make(map[string]any) + j_ArrayObjectPtr_v_obj["content"] = j_ArrayObjectPtr_v.Content + j_ArrayObjectPtr[i] = j_ArrayObjectPtr_v_obj + } + r["ArrayObjectPtr"] = j_ArrayObjectPtr + } + r["ArrayRawJSON"] = j.ArrayRawJSON + r["ArrayRawJSONPtr"] = j.ArrayRawJSONPtr + r["ArrayString"] = j.ArrayString + r["ArrayStringPtr"] = j.ArrayStringPtr + r["ArrayTime"] = j.ArrayTime + r["ArrayTimePtr"] = j.ArrayTimePtr + r["ArrayUUID"] = j.ArrayUUID + r["ArrayUUIDPtr"] = j.ArrayUUIDPtr + r["ArrayUint"] = j.ArrayUint + r["ArrayUint16"] = j.ArrayUint16 + r["ArrayUint16Ptr"] = j.ArrayUint16Ptr + r["ArrayUint32"] = j.ArrayUint32 + r["ArrayUint32Ptr"] = j.ArrayUint32Ptr + r["ArrayUint64"] = j.ArrayUint64 + r["ArrayUint64Ptr"] = j.ArrayUint64Ptr + r["ArrayUint8"] = j.ArrayUint8 + r["ArrayUint8Ptr"] = j.ArrayUint8Ptr + r["ArrayUintPtr"] = j.ArrayUintPtr + r["BigInt"] = j.BigInt + r["BigIntPtr"] = j.BigIntPtr + r["Bool"] = j.Bool + r["BoolPtr"] = j.BoolPtr + r["Bytes"] = j.Bytes + r["BytesPtr"] = j.BytesPtr + r["CustomScalar"] = j.CustomScalar + r["CustomScalarPtr"] = j.CustomScalarPtr + r["Date"] = j.Date + r["DatePtr"] = j.DatePtr + r["Enum"] = j.Enum + r["EnumPtr"] = j.EnumPtr + r["Float32"] = j.Float32 + r["Float32Ptr"] = j.Float32Ptr + r["Float64"] = j.Float64 + r["Float64Ptr"] = j.Float64Ptr + r["Int"] = j.Int + r["Int16"] = j.Int16 + r["Int16Ptr"] = j.Int16Ptr + r["Int32"] = j.Int32 + r["Int32Ptr"] = j.Int32Ptr + r["Int64"] = j.Int64 + r["Int64Ptr"] = j.Int64Ptr + r["Int8"] = j.Int8 + r["Int8Ptr"] = j.Int8Ptr + r["IntPtr"] = j.IntPtr + r["JSON"] = j.JSON + r["JSONPtr"] = j.JSONPtr + r["Map"] = j.Map + r["MapPtr"] = j.MapPtr + j_NamedArray := make([]map[string]any, len(j.NamedArray)) + for i, j_NamedArray_v := range j.NamedArray { + j_NamedArray[i] = utils.EncodeMap(j_NamedArray_v) + } + r["NamedArray"] = j_NamedArray + if j.NamedArrayPtr != nil { + j_NamedArrayPtr := make([]map[string]any, len((*j.NamedArrayPtr))) + for i, j_NamedArrayPtr_v := range *j.NamedArrayPtr { + j_NamedArrayPtr[i] = utils.EncodeMap(j_NamedArrayPtr_v) + } + r["NamedArrayPtr"] = j_NamedArrayPtr + } + r["NamedObject"] = utils.EncodeMap(j.NamedObject) + if j.NamedObjectPtr != nil { + r["NamedObjectPtr"] = utils.EncodeMap((*j.NamedObjectPtr)) + } + j_Object_obj := make(map[string]any) + j_Object_obj["created_at"] = j.Object.CreatedAt + j_Object_obj["id"] = j.Object.ID + r["Object"] = j_Object_obj + if j.ObjectPtr != nil { + j_ObjectPtr__obj := make(map[string]any) + j_ObjectPtr__obj["Lat"] = (*j.ObjectPtr).Lat + j_ObjectPtr__obj["Long"] = (*j.ObjectPtr).Long + r["ObjectPtr"] = j_ObjectPtr__obj + } + r["PtrArrayBigInt"] = j.PtrArrayBigInt + r["PtrArrayBigIntPtr"] = j.PtrArrayBigIntPtr + r["PtrArrayBool"] = j.PtrArrayBool + r["PtrArrayBoolPtr"] = j.PtrArrayBoolPtr + r["PtrArrayFloat32"] = j.PtrArrayFloat32 + r["PtrArrayFloat32Ptr"] = j.PtrArrayFloat32Ptr + r["PtrArrayFloat64"] = j.PtrArrayFloat64 + r["PtrArrayFloat64Ptr"] = j.PtrArrayFloat64Ptr + r["PtrArrayInt"] = j.PtrArrayInt + r["PtrArrayInt16"] = j.PtrArrayInt16 + r["PtrArrayInt16Ptr"] = j.PtrArrayInt16Ptr + r["PtrArrayInt32"] = j.PtrArrayInt32 + r["PtrArrayInt32Ptr"] = j.PtrArrayInt32Ptr + r["PtrArrayInt64"] = j.PtrArrayInt64 + r["PtrArrayInt64Ptr"] = j.PtrArrayInt64Ptr + r["PtrArrayInt8"] = j.PtrArrayInt8 + r["PtrArrayInt8Ptr"] = j.PtrArrayInt8Ptr + r["PtrArrayIntPtr"] = j.PtrArrayIntPtr + r["PtrArrayJSON"] = j.PtrArrayJSON + r["PtrArrayJSONPtr"] = j.PtrArrayJSONPtr + r["PtrArrayRawJSON"] = j.PtrArrayRawJSON + r["PtrArrayRawJSONPtr"] = j.PtrArrayRawJSONPtr + r["PtrArrayString"] = j.PtrArrayString + r["PtrArrayStringPtr"] = j.PtrArrayStringPtr + r["PtrArrayTime"] = j.PtrArrayTime + r["PtrArrayTimePtr"] = j.PtrArrayTimePtr + r["PtrArrayUUID"] = j.PtrArrayUUID + r["PtrArrayUUIDPtr"] = j.PtrArrayUUIDPtr + r["PtrArrayUint"] = j.PtrArrayUint + r["PtrArrayUint16"] = j.PtrArrayUint16 + r["PtrArrayUint16Ptr"] = j.PtrArrayUint16Ptr + r["PtrArrayUint32"] = j.PtrArrayUint32 + r["PtrArrayUint32Ptr"] = j.PtrArrayUint32Ptr + r["PtrArrayUint64"] = j.PtrArrayUint64 + r["PtrArrayUint64Ptr"] = j.PtrArrayUint64Ptr + r["PtrArrayUint8"] = j.PtrArrayUint8 + r["PtrArrayUint8Ptr"] = j.PtrArrayUint8Ptr + r["PtrArrayUintPtr"] = j.PtrArrayUintPtr + r["RawJSON"] = j.RawJSON + r["RawJSONPtr"] = j.RawJSONPtr + r["String"] = j.String + r["StringPtr"] = j.StringPtr + r["Text"] = j.Text + r["TextPtr"] = j.TextPtr + r["Time"] = j.Time + r["TimePtr"] = j.TimePtr + r["UUID"] = j.UUID + r["UUIDPtr"] = j.UUIDPtr + r["Uint"] = j.Uint + r["Uint16"] = j.Uint16 + r["Uint16Ptr"] = j.Uint16Ptr + r["Uint32"] = j.Uint32 + r["Uint32Ptr"] = j.Uint32Ptr + r["Uint64"] = j.Uint64 + r["Uint64Ptr"] = j.Uint64Ptr + r["Uint8"] = j.Uint8 + r["Uint8Ptr"] = j.Uint8Ptr + r["UintPtr"] = j.UintPtr + + return r +} diff --git a/example/codegen/types/types.generated.go b/example/codegen/types/types.generated.go new file mode 100644 index 0000000..1ac4c23 --- /dev/null +++ b/example/codegen/types/types.generated.go @@ -0,0 +1,87 @@ +// Code generated by github.com/hasura/ndc-sdk-go/codegen, DO NOT EDIT. +package types + +import ( + "encoding/json" + "errors" + "github.com/hasura/ndc-sdk-go/schema" + "github.com/hasura/ndc-sdk-go/utils" +) + +var types_Decoder = utils.NewDecoder() + +// ToMap encodes the struct to a value map +func (j Author) ToMap() map[string]any { + r := make(map[string]any) + r["created_at"] = j.CreatedAt + r["id"] = j.ID + r["tags"] = j.Tags + + return r +} + +// ScalarName get the schema name of the scalar +func (j CommentText) ScalarName() string { + return "CommentString" +} + +// ScalarName get the schema name of the scalar +func (j SomeEnum) ScalarName() string { + return "SomeEnum" +} + +const ( + SomeEnumFoo SomeEnum = "foo" + SomeEnumBar SomeEnum = "bar" +) + +var enumValues_SomeEnum = []SomeEnum{SomeEnumFoo, SomeEnumBar} + +// ParseSomeEnum parses a SomeEnum enum from string +func ParseSomeEnum(input string) (SomeEnum, error) { + result := SomeEnum(input) + if !schema.Contains(enumValues_SomeEnum, result) { + return SomeEnum(""), errors.New("failed to parse SomeEnum, expect one of SomeEnumFoo, SomeEnumBar") + } + + return result, nil +} + +// IsValid checks if the value is invalid +func (j SomeEnum) IsValid() bool { + return schema.Contains(enumValues_SomeEnum, j) +} + +// UnmarshalJSON implements json.Unmarshaler. +func (j *SomeEnum) UnmarshalJSON(b []byte) error { + var rawValue string + if err := json.Unmarshal(b, &rawValue); err != nil { + return err + } + + value, err := ParseSomeEnum(rawValue) + if err != nil { + return err + } + + *j = value + return nil +} + +// FromValue decodes the scalar from an unknown value +func (s *SomeEnum) FromValue(value any) error { + valueStr, err := utils.DecodeNullableString(value) + if err != nil { + return err + } + if valueStr == nil { + return nil + } + result, err := ParseSomeEnum(*valueStr) + if err != nil { + return err + } + + *s = result + return nil +} diff --git a/example/codegen/types/types.go b/example/codegen/types/types.go new file mode 100644 index 0000000..6505cf7 --- /dev/null +++ b/example/codegen/types/types.go @@ -0,0 +1,46 @@ +package types + +import ( + "encoding/json" + "time" + + "github.com/hasura/ndc-sdk-go/utils" +) + +type Text string + +// CommentText +// @scalar CommentString string +type CommentText struct { + comment string +} + +func (c CommentText) MarshalJSON() ([]byte, error) { + return json.Marshal(c.comment) +} + +func (c *CommentText) UnmarshalJSON(b []byte) error { + var s string + if err := json.Unmarshal(b, &s); err != nil { + return err + } + + c.comment = s + + return nil +} + +func (ct *CommentText) FromValue(value any) (err error) { + ct.comment, err = utils.DecodeString(value) + return +} + +// SomeEnum +// @enum foo, bar +type SomeEnum string + +type Author struct { + ID string `json:"id"` + CreatedAt time.Time `json:"created_at"` + Tags []string `json:"tags"` +}