161 lines
3.3 KiB
Go
161 lines
3.3 KiB
Go
package uuid
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"strconv"
|
|
"time"
|
|
|
|
fuuid "github.com/gofrs/uuid/v5"
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
"go.mongodb.org/mongo-driver/bson"
|
|
"go.mongodb.org/mongo-driver/bson/bsontype"
|
|
"go.mongodb.org/mongo-driver/x/bsonx/bsoncore"
|
|
)
|
|
|
|
var Nil = UUID{}
|
|
|
|
type UUIDList = []UUID
|
|
|
|
type UUID struct {
|
|
fuuid.UUID
|
|
}
|
|
|
|
func New() UUID {
|
|
return UUID{fuuid.Must(fuuid.NewV7())}
|
|
}
|
|
|
|
func NewFromTime(t time.Time) UUID {
|
|
gen := fuuid.NewGenWithOptions(
|
|
fuuid.WithEpochFunc(func() time.Time { return t }),
|
|
)
|
|
return UUID{fuuid.Must(gen.NewV7())}
|
|
}
|
|
|
|
func NewP() *UUID {
|
|
return &UUID{fuuid.Must(fuuid.NewV7())}
|
|
}
|
|
|
|
func FromString(text string) (UUID, error) {
|
|
u, err := fuuid.FromString(text)
|
|
if err != nil {
|
|
return Nil, err
|
|
}
|
|
|
|
return UUID{u}, nil
|
|
}
|
|
|
|
func MustFromString(text string) UUID {
|
|
u, err := fuuid.FromString(text)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
return UUID{u}
|
|
}
|
|
|
|
func FromBytes(input []byte) (UUID, error) {
|
|
u, err := fuuid.FromBytes(input)
|
|
if err != nil {
|
|
return Nil, err
|
|
}
|
|
|
|
return UUID{u}, nil
|
|
}
|
|
|
|
func (a *UUID) UnmarshalJSON(b []byte) error {
|
|
var s string
|
|
if err := json.Unmarshal(b, &s); err != nil {
|
|
return err
|
|
}
|
|
|
|
if s == "" {
|
|
a.UUID = fuuid.Nil
|
|
return nil
|
|
}
|
|
|
|
return a.UUID.Parse(s)
|
|
}
|
|
|
|
func (a UUID) MarshalJSON() ([]byte, error) {
|
|
if a.IsNil() {
|
|
return json.Marshal("")
|
|
}
|
|
|
|
return json.Marshal(a.UUID)
|
|
}
|
|
|
|
// UnmarshalGQL implements the graphql.Unmarshaler interface
|
|
func (u *UUID) UnmarshalGQL(v interface{}) error {
|
|
id, ok := v.(string)
|
|
if !ok {
|
|
return fmt.Errorf("uuid must be a string")
|
|
}
|
|
|
|
return u.Parse(id)
|
|
}
|
|
|
|
// MarshalGQL implements the graphql.Marshaler interface
|
|
func (u UUID) MarshalGQL(w io.Writer) {
|
|
b := []byte(strconv.Quote(u.String()))
|
|
_, err := w.Write(b)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
const uuidSubtype = 4
|
|
|
|
// MarshalBSONValue для официального mongo драйвера (go.mongodb.org/mongo-driver/mongo)
|
|
func (id UUID) MarshalBSONValue() (bsontype.Type, []byte, error) {
|
|
if id.IsNil() {
|
|
return bsontype.Null, nil, nil
|
|
} else {
|
|
bin := bsoncore.AppendBinary(nil, uuidSubtype, id.UUID.Bytes())
|
|
return bson.TypeBinary, bin, nil
|
|
}
|
|
}
|
|
|
|
// MarshalBSONValue для официального mongo драйвера (go.mongodb.org/mongo-driver/mongo)
|
|
func (id *UUID) UnmarshalBSONValue(t bsontype.Type, data []byte) error {
|
|
switch t {
|
|
case bsontype.Null, bsontype.Undefined:
|
|
id = &UUID{} // nil uuid value 00000000-0000-0000-0000-000000000000
|
|
return nil
|
|
case bsontype.Binary:
|
|
subtype, bin, _, ok := bsoncore.ReadBinary(data)
|
|
if !ok {
|
|
return errors.New("invalid bson binary value")
|
|
}
|
|
if subtype != uuidSubtype && subtype != 3 { // 3 is a deprecated uuid subtype, used for compatibility
|
|
return fmt.Errorf("unsupported binary subtype for uuid: %d", subtype)
|
|
}
|
|
return id.UUID.UnmarshalBinary(bin)
|
|
default:
|
|
return fmt.Errorf("unsupported value type for uuid: %s", t.String())
|
|
}
|
|
}
|
|
|
|
var _ pgtype.UUIDValuer = UUID{}
|
|
|
|
// UUIDValue implements pgtype.UUIDValuer.
|
|
func (a UUID) UUIDValue() (pgtype.UUID, error) {
|
|
return pgtype.UUID{
|
|
Bytes: a.UUID,
|
|
Valid: true,
|
|
}, nil
|
|
}
|
|
|
|
var _ pgtype.UUIDScanner = (*UUID)(nil)
|
|
|
|
// ScanUUID implements pgtype.UUIDScanner.
|
|
func (a *UUID) ScanUUID(v pgtype.UUID) error {
|
|
if !v.Valid {
|
|
return fmt.Errorf("cannot scan NULL into *uuid.UUID")
|
|
}
|
|
|
|
a.UUID = v.Bytes
|
|
return nil
|
|
}
|