Request for omitempty on json tag for models

[apoggi-carecloud]

Instead of having to manually define models with the 'omitempty' json tag, it would be great if we could pass that through the yaml config file.

[stale[bot]]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.

[iliasgal]

Any update on this? Or any workaround about the omitempty tag?

[apoggi-carecloud]

I just wrote the omitempty tags via code generation to the files

[zhulinwei]

@apoggi-carecloud Does you write a plugins to add omitempty tag? Or you wrote the omitempty tags to the files after code generation?

[RobinKamps]

Omit per field could be a be a usefull feature - if the models are marshalled for internal usage. The generated marshaling to match a graphql query returns empty things. It has no external effect if a struct attribute is marked with omitempty tag, if the attribute is marked with an ! in the schema and therefore is not generated as a pointer. I prefer using no pointers especially for strings (to avoid the nasty two step instantiation) and mark everything with a !. I reuse the generated models for typesafe db ops and add typesafe validation (via ozzo) to them in another file, which is not overwritten by the generator. usually i add the omitempty tags to every model (and do other additions and custom renamings (like adding a dot in the json name etc.) via a small script like (example only for adding all omitempty tags), which is automatically called after every new model generation:

path := "models/models_gen.go"
	read, err := ioutil.ReadFile(path)
	if err != nil {
		panic(err)
	}

	newContents = strings.Replace(newContents, "\"`", ",omitempty\"`", -1)

	err = ioutil.WriteFile(path, []byte(newContents), 0)
	if err != nil {
		panic(err)
	}

[KenG98]

Let's re-open this - omitempty is important for marshaling structs to JSON to send in a request. Lots of APIs have a default value for a field, but if you marshal a struct with an empty field right now, it'll use the default value (like an empty string), which will override the API's default.

[harmnot]

I only need use model_gen hook = https://gqlgen.com/recipes/modelgen-hook/

let's say you have gqlgen.yml in root dir, then create a file called runner_model_gen.go

in runner_model_gen.go:

package main

import (
	"fmt"
	"github.com/99designs/gqlgen/api"
	"github.com/99designs/gqlgen/codegen/config"
	"github.com/99designs/gqlgen/plugin/modelgen"
	"os"
	"strings"
)

func mutateHook(b *modelgen.ModelBuild) *modelgen.ModelBuild {
	for _, model := range b.Models {
		for _, field := range model.Fields {
                       // this is the logic to add omitempty
			omit := strings.TrimSuffix(field.Tag, `"`)
			field.Tag = fmt.Sprintf(`%v,omitempty"`, omit)
		}
	}
	return b
}

func main() {
	cfg, err := config.LoadConfigFromDefaultLocations()
	if err != nil {
		fmt.Fprintln(os.Stderr, "failed to load config", err.Error())
		os.Exit(2)
	}

	p := modelgen.Plugin{
		MutateHook: mutateHook,
	}

	err = api.Generate(cfg,
		api.NoPlugins(),
		api.AddPlugin(&p),
	)
	if err != nil {
		fmt.Fprintln(os.Stderr, err.Error())
		os.Exit(3)
	}
}

then run them go run runner_model_gen.go

check your model_gen.go then u can see the result, enjoy:)

[thestephenstanton]

I was looking for this as a feature of gqlgen and stumbled upon this issue. And I found myself wondering why it might not have been implemented (personally I like omitempty). But when I thought about it, when you have omitempty, it would be odd for someone to have a query:

{
  people {
    name
    nickname
  }
}

And get back something like:

{
    "data": {
        "people": [
            {
                "name": "Stephen",
                "nickname": "Steve"
            },
            {
                "name": "Joe"
            }
        ]
    }
}

instead of something like

{
    "data": {
        "people": [
            {
                "name": "Stephen",
                "nickname": "Steve"
            },
            {
                "name": "Joe",
                "nickname": null
            }
        ]
    }
}

Especially given that your query directly asks for it. So maybe in the graphql world, it is good to return back the empty value of the field.

~~But then again, some empty values, like for bools and ints, could be deceptive by returning falses and 0s~~ (nvm, that is what the pointers are for lol)

Thoughts?

[sanjeevchopra]

This causes default values for input types not to be applied.

input Foo {
  principalType: PrincipalType = User
}

enum PrincipalType {
  User
  Org
}

• unmarshal code checks for existence of the field in the payload, which it does. with a "null" . so the default value does nt get initialized

type Foo struct {
	PrincipalType *PrincipalType `json:"principalType" yaml:"principalType"`
}

//...

func (ec *executionContext) unmarshalInputFoo(ctx context.Context, obj interface{}) (model.Foo, error) {
	var it model.Foo
	var asMap = obj.(map[string]interface{})

	if _, present := asMap["principalType"]; !present {
		asMap["principalType"] = "User"
	}

[kelvne]

I'm re-using the models internally and I wanted the possibility to add omitempty since I'm marshalling the objects into maps to send to other APIs.

However for my scenario it can be achieve with a simple solution.

Minor example:

func cleanPayload(properties *model.UserProperties) (map[string]interface{}, error) {
	marshaled, err := json.Marshal(payload)
	if err != nil {
		return nil, err
	}

	mapped := make(map[string]interface{})
	err = json.Unmarshal(marshaled, &mapped)
	if err != nil {
		return nil, err
	}

	for key, val := range mapped {
		if val == nil {
			delete(mapped, key)
		}
	}

	return mapped, nil
}

It's working for us, hope it helps.