store

Documentation

Index

• Variables
• func GetAddrTagElements(tagValue st) (k uint16, pkb by, d st)
• func Less(a, b tag.T) bo
• func TagSorter(a, b tag.T) no
• type Counter
• type Deleter
• type Exporter
• type I
• type Importer
• type Initer
• type Nuker
• type OK
• type Pather
• type Querent
• type Req
• type Responder
• type Saver
• type SubID
• type Syncer
• type WS

Variables

var (
	ErrDupEvent       = errors.New("duplicate: event already exists")
	ErrEventNotExists = errors.New("unknown: event not known by any source of this realy")
)

Functions

func GetAddrTagElements

func GetAddrTagElements(tagValue st) (k uint16, pkb by, d st)

func Less

func Less(a, b tag.T) bo

func TagSorter

func TagSorter(a, b tag.T) no

Types

type Counter

type Counter interface {
	// CountEvents performs the same work as QueryEvents but instead of delivering
	// the events that were found it just returns the count of events
	CountEvents(c cx, f *filter.T) (count no, approx bo, err er)
}

type Deleter

type Deleter interface {
	// DeleteEvent is used to handle deletion events, as per NIP-09.
	DeleteEvent(c cx, ev *eventid.T, noTombstone ...bo) (err er)
}

type Exporter

type Exporter interface {
	// Export writes a stream of line structured JSON of all events in the store. If
	// pubkeys are present, only those with these pubkeys in the `pubkey` field and
	// in `p` tags will be included.
	Export(c cx, w io.Writer, pubkeys ...by)
}

type I

type I interface {
	Initer
	Pather
	io.Closer
	Pather
	Nuker
	Querent
	Counter
	Deleter
	Saver
	Importer
	Exporter
	Syncer
}

I is an types for a persistence layer for nostr events handled by a relay.

type Importer

type Importer interface {
	// Import reads in a stream of line structured JSON of events to save into the
	// store.
	Import(r io.Reader)
}

type Initer

type Initer interface {
	// Init is called at the very beginning by [Server.Start], after [Relay.Init],
	// allowing a storage to initialize its internal resources. The parameters can be
	// used by the database implementations to set custom parameters such as cache
	// management and other relevant parameters to the specific implementation.
	Init(path st) (err er)
}

type Nuker

type Nuker interface {
	// Nuke deletes everything in the database.
	Nuke() (err er)
}

type OK

type OK = okenvelope.T

type Pather

type Pather interface {
	// Path returns the directory of the database.
	Path() (s st)
}

type Querent

type Querent interface {
	// QueryEvents is invoked upon a client's REQ as described in NIP-01. It returns
	// the matching events in reverse chronological order in a slice.
	QueryEvents(c cx, f *filter.T) (evs event.Ts, err er)
}

type Req

type Req = *http.Request

type Responder

type Responder = http.ResponseWriter

type Saver

type Saver interface {
	// SaveEvent is called once Relay.AcceptEvent reports true.
	SaveEvent(c cx, ev *event.T) (err er)
}

type SubID

type SubID = subscription.Id

type Syncer

type Syncer interface {
	// Sync signals the event store to flush its buffers.
	Sync() (err er)
}

type WS

type WS = *ws.Serv