Enum with int values

[karthikraobr]

Is it possible to generate enum with int values rather than string values? Something that looks like the below code?

type Op int32

const (
	Op_NULL   Op = 0
	Op_CREATE Op = 1
	Op_MODIFY Op = 2
	Op_DELETE Op = 3
)

var Op_name = map[int32]string{
	0: "NULL",
	1: "CREATE",
	2: "MODIFY",
	3: "DELETE",
}
var Op_value = map[string]int32{
	"NULL":   0,
	"CREATE": 1,
	"MODIFY": 2,
	"DELETE": 3,
} 

Minimal graphql.schema and models to reproduce

enum Op {
        Op_NULL 
	Op_CREATE
	Op_MODIFY
	Op_DELETE
}

Generates

type Op string

const (
	OpOpNull   Op = "Op_NULL"
	OpOpCreate Op = "Op_CREATE"
	OpOpModify Op = "Op_MODIFY"
	OpOpDelete Op = "Op_DELETE"
)

func (e Op) IsValid() bool {
	switch e {
	case OpOpNull, OpOpCreate, OpOpModify, OpOpDelete:
		return true
	}
	return false
}

func (e Op) String() string {
	return string(e)
}

func (e *Op) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("enums must be strings")
	}

	*e = Op(str)
	if !e.IsValid() {
		return fmt.Errorf("%s is not a valid Op", str)
	}
	return nil
}

func (e Op) MarshalGQL(w io.Writer) {
	fmt.Fprint(w, strconv.Quote(e.String()))
}

Is there any way to generate int values rather than string values for enums? Perhaps a custom resolver?

[JulienBreux]

Good idea! Like grpc generator ;)

[lwc]

This is probably a good use-case for ENUM_VALUE directives - they have something similar in the GraphQL Compatibility Acceptance Tests.

[kateile]

Hi, is this possible with gqlgen now?

[lwc]

The other option would be custom mapping - you'd be opting out of model generation, but you could map the enum however you like

[mia0x75]

This is probably a good use-case for ENUM_VALUE directives - they have something similar in the GraphQL Compatibility Acceptance Tests.

@lwc How the directive function looks like?

func EnumInt(ctx context.Context, obj interface{}, next graphql.Resolver, value int) (res interface{}, err error) {
	return value, nil // Just return the value?
}

[longfellowone]

Another vote for numeric enums

type ItemStatus int

const (
	Waiting ItemStatus = iota
	Filled
	BackOrdered
	OrderExceeded
	NotOrdered
)

func (s ItemStatus) String() string {
	switch s {
	case Waiting:
		return "Waiting"
	case Filled:
		return "Filled"
	case BackOrdered:
		return "Back Ordered"
	case OrderExceeded:
		return "Order Exceeded"
	case NotOrdered:
		return "Not Ordered"
	default:
		return fmt.Sprintf("%d", int(s))
	}
}

[steebchen]

It would also be great for a simple permission system, so I could check for user.Role >= Employee to allow access to "employees" and all roles above (e.g. admin)

[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.

[karthikraobr]

@vektah Could you please reopen this issue. Thanks

[oshalygin]

@karthikraobr thanks!
This would be very helpful!

[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.

[steebchen]

No stale

[tonyhb]

Right now I'm using this fork of enumer which adds GQLGen support via this PR. It may help people :)

[kim-hetrafi]

Is there any progress on this? I'm guessing the above solution won't be merged cause it's solution that adds hacky code which only provides int enums instead of abstacting type support.

My current work around for people wanting to this (doesnt fully auto-generate)

schema.graphqls

enum AccessLevel {
  USER,
  MODERATOR,
  ADMIN
}

run gqlgen generate

add to YOUR_MODEL_FILE.go

var access_level_map = map[string]int {
    "USER": 0,
    "MODERATOR": 1,
    "ADMIN": 2,
}

func (e AccessLevel) Int () int {
	return access_level_map[e.String()]
}