87 lines
2.3 KiB
Go
87 lines
2.3 KiB
Go
// Package eoseenvelope provides an encoder for the EOSE (End Of Stored
|
|
// Events) event that signifies that a REQ has found all stored events and
|
|
// from here on the request morphs into a subscription, until the limit, if
|
|
// requested, or until CLOSE or CLOSED.
|
|
package eoseenvelope
|
|
|
|
import (
|
|
"io"
|
|
|
|
"lol.mleku.dev/chk"
|
|
"next.orly.dev/pkg/encoders/envelopes"
|
|
"next.orly.dev/pkg/encoders/text"
|
|
"next.orly.dev/pkg/interfaces/codec"
|
|
)
|
|
|
|
// L is the label associated with this type of codec.Envelope.
|
|
const L = "EOSE"
|
|
|
|
// T is an EOSE envelope (End of Stored Events), that signals the end of events
|
|
// that are stored and the beginning of a subscription. This is necessitated by
|
|
// the confusing multiplexing of websockets for multiple requests, and an ugly
|
|
// merging of two distinct API calls, filter and subscribe.
|
|
type T struct {
|
|
Subscription []byte
|
|
}
|
|
|
|
var _ codec.Envelope = (*T)(nil)
|
|
|
|
// New creates a new eoseenvelope.T with a standard form subscription.Id.
|
|
func New() *T {
|
|
return new(T)
|
|
}
|
|
|
|
// NewFrom creates a new eoseenvelope.T using a provided subscription.Id.
|
|
func NewFrom[V []byte | string](id V) *T { return &T{Subscription: []byte(id)} }
|
|
|
|
// Label returns the label of a EOSE envelope.
|
|
func (en *T) Label() string { return L }
|
|
|
|
// Write the eoseenvelope.T to a provided io.Writer.
|
|
func (en *T) Write(w io.Writer) (err error) {
|
|
_, err = w.Write(en.Marshal(nil))
|
|
return
|
|
}
|
|
|
|
// Marshal a eoseenvelope.T envelope in minified JSON, appending to a provided
|
|
// destination slice.
|
|
func (en *T) Marshal(dst []byte) (b []byte) {
|
|
var err error
|
|
b = dst
|
|
b = envelopes.Marshal(
|
|
b, L,
|
|
func(bst []byte) (o []byte) {
|
|
o = bst
|
|
o = append(o, '"')
|
|
o = append(o, en.Subscription...)
|
|
o = append(o, '"')
|
|
return
|
|
},
|
|
)
|
|
_ = err
|
|
return
|
|
}
|
|
|
|
// Unmarshal a eoseenvelope.T from minified JSON, returning the remainder after
|
|
// the end of the envelope.
|
|
func (en *T) Unmarshal(b []byte) (r []byte, err error) {
|
|
r = b
|
|
if en.Subscription, r, err = text.UnmarshalQuoted(r); chk.E(err) {
|
|
return
|
|
}
|
|
if r, err = envelopes.SkipToTheEnd(r); chk.E(err) {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// Parse reads a EOSE envelope in minified JSON into a newly allocated
|
|
// eoseenvelope.T.
|
|
func Parse(b []byte) (t *T, rem []byte, err error) {
|
|
t = New()
|
|
if rem, err = t.Unmarshal(b); chk.E(err) {
|
|
return
|
|
}
|
|
return
|
|
}
|