Feature request: enable wrapping EdgeDB types

[lsdch]

AFAIK there are currently two ways to bind optional or non-primitive type values with EdgeDB:

• using one of the provided types in edgedbtypes, e.g. OptionalStr, which cannot be extended with additional methods
• implementing one of the EdgeDB{*}Marshaler interfaces, which is cumbersome when you have to do it for multiple types

Would it be possible to expose an interface that custom wrappers for EdgeDB-compatible types could implement ?
Something like:

type EdgeDBTypeWrapper[T any] interface {
  Value() *T
}

EdgeDBTypeWrapper.Value() could then be used internally to retrieve the wrapped type and marshal/unmarshal values when interacting with EdgeDB.

Example use-case:

type OptionalStrWrapper struct {
  edgedb.OptionalStr
}

func (o OptionalStrWrapper) Value() *edgedb.OptionalStr {
  return o.OptionalStr
}

func (o OptionalStrWrapper) SomeMethodUnrelatedToEdgeDB() {
  // ...
}

I would be willing to submit a PR for this, but I am not sure where to start. Would it be as simple as adding an extra case in codecs.*.Encode methods ?

[fmoor]

I understand the friction. There may be room for improvement here. I'll have to think about this.

It seems like there should be an interface for decoding too.

[jdpedrie]

+1 to this, and a related request for a shared interface allowing assertions that a value is a gel db type. This ability would help considerably in switch cases and type assertions.

Something like...

switch v.(type) {
    case v.(geltypes.Value):
         // do something
    case string:
         // do something else
    default:
         return errors.New("invalid value type")
}

[fmoor]

@jdpedrie can you provide a more complete example of what you would like to do with the type switch? How would it be different than this?:

switch v.(type) {
    case v.(geltypes.OptionalStr):
        // do something
    case string:
        // do something else
    default:
        return errors.New("invalid value type")
}

[jdpedrie]

I've found the UX of inserting deeply nested objects to be quite difficult. I'm playing around with querybuilding for gel, and currently, I have to maintain a map of all known types:

// isGelType checks if v is one of the allowed Gel types
func isGelType(v any) (string, bool) {
	vType := reflect.TypeOf(v)

	// Direct type match
	if cast, ok := gelTypeMap[vType]; ok {
		return cast, true
	}

	// Handle pointers by dereferencing them
	if vType != nil && vType.Kind() == reflect.Ptr {
		if cast, ok := gelTypeMap[vType.Elem()]; ok {
			return cast, true
		}
	}

	return "", false
}

var gelTypeMap = map[reflect.Type]string{
	reflect.TypeOf(geltypes.DateDuration{}):               "date_duration",
	reflect.TypeOf(geltypes.Duration(0)):                  "duration",
	reflect.TypeOf(geltypes.LocalDate{}):                  "local_date",
	reflect.TypeOf(geltypes.LocalDateTime{}):              "local_datetime",
        [.....]
}

An interface I'd love is something like:

type GelType interface {
    Assertion() string // e.g. "uuid" for query type assertions.
}

But really, anything that lets me write _, ok := v.(geltypes.GelType); ok would be fine.

This is my first time using gel/edgedb, though I've been watching the project for a long time. I certainly could be missing something obvious!

[fmoor]

I don't think you are missing anything obvious. In this case it seems like a function that is just a long type switch that returns the edgeql type name as a string is the way to go. It would have the advantage of not requiring the reflect package which is slow.

It makes sense in a query builder, but I'm having a hard time imagining when an EdgeQLTypeName() string method would be useful in a typical application. That in conjunction with the geltypes package only having a partial list of the edgeql scalar types it doesn't seem like much of a win for users in general. I could be the one missing something though. Let me know.

I've found the UX of inserting deeply nested objects to be quite difficult.

I think #319 will help with this when I can finally get some time to work on it.