Allow optional attributes to remain in response when null

[seapike]

At the moment, if an attribute is not marked as required and the value is nil, it will be omitted from the response JSON.
It is semantically valid to return a null value in an API and it would be helpful if this could be nominated as a behaviour of the type generator.
At the moment a workaround is to specify the struct:tag:XXXX meta on the attribute to achieve this, but it's very clunky to do so for every non-required attribute in the DSL. Has this been considered, and why is the default behaviour to add omitempty to the generated struct tags?

[raphael]

Hello, great question! The idea is that having an API where the semantic differs between a field being present but with a nil value and a field being absent is in general not a great design. Not all clients are able to differentiate (some dynamic languages in particular) and some transports make this impossible to implement (one cannot distinguish these two cases in gRPC for example). So the best practice is to design an API that is explicit, for example by introducing a new attribute that carries that semantic explicitly.

That being said that is not always possible (e.g. for backwards compatibility or other external dependencies) so Meta provides that escape patch. In case where this behavior should be the default, it's possible to a create custom DSL, e.g.

func NullableAttribute(name string, args ...any) {
        Attribute(name, args...)
	var parent *expr.AttributeExpr
	switch def := eval.Current().(type) {
	case *expr.AttributeExpr:
		parent = def
	case expr.CompositeExpr:
		parent = def.Attribute()
	}
        if parent == nil {
               return
        }
        obj, ok := parent.Type.(*expr.Object)
        if !ok {
               return
        }
        att := obj.Attribute(name)
        if att == nil {
               return
        }
        if att.Meta == nil {
                att.Meta = make(map[string][]string)
        }
        att.Meta["struct:tag:json"] = []string{name}
}