eventing

type BlobEventData struct {
	Bucket  string    `json:"bucket"`
	Key     string    `json:"key"`
	Size    int64     `json:"size"`
	Version string    `json:"version"`
	Time    time.Time `json:"time"`
}

type BlobWatcher struct {
	// contains filtered or unexported fields
}

type BucketLister interface {
	List(ctx context.Context, ns v1.NamespaceName, bucket v1.ObjectName, prefix string) ([]blob.Attributes, error)
}

type CloudEvent struct {
	SpecVersion     string          `json:"specversion"`
	ID              string          `json:"id"`
	Source          string          `json:"source"` // funcd://<ns>/eventsource/<name>
	Type            string          `json:"type"`   // the event name (ADR-0108)
	Time            time.Time       `json:"time"`
	DataContentType string          `json:"datacontenttype,omitempty"`
	Data            json.RawMessage `json:"data,omitempty"`
}

type Deps struct {
	Store     store.Store  // required
	Publisher Publisher    // where a firing emits its named CloudEvent (required)
	Blob      *BlobWatcher // ADR-0119: the poll watcher a `blob:` source registers on; nil ⇒ no blob support
	Logger    *slog.Logger // default slog.Default()
	Clock     clock.Clock  // ADR-0182: the timer seed and the Run loop read it; default clock.System()
	// BucketRecheckInterval is eventing.bucketRecheckInterval (ADR-0163); 0 ⇒ bucketRecheckInterval.
	BucketRecheckInterval time.Duration
}

type Fanout struct {
	// contains filtered or unexported fields
}

type KVWatermark struct {
	// contains filtered or unexported fields
}

type MemWatermark struct {
	// contains filtered or unexported fields
}

type Publisher interface {
	Publish(ctx context.Context, ev CloudEvent) error
}

type SeenList struct {
	Bucket v1.ObjectName     `json:"bucket"`
	Prefix string            `json:"prefix"`
	UID    v1.UID            `json:"uid"`
	Seen   map[string]string `json:"seen"` // object key → the data.version it fired with (versionOf)
}

type Source struct {
	// contains filtered or unexported fields
}

type SourceRef struct {
	Namespace v1.NamespaceName
	Name      v1.ObjectName
}

type WatchHooks struct {
	Exists      func(ctx context.Context, src SourceRef) (bool, error)
	SaveFailing func(ctx context.Context, src SourceRef, failing map[v1.ObjectName]error) error // empty map clears
}

type Watermark interface {
	// Load never returns a nil Seen: a missing record, or one saved with "seen":null, loads with an empty map.
	Load(ctx context.Context, ns v1.NamespaceName, source, event v1.ObjectName) (SeenList, error)
	Save(ctx context.Context, ns v1.NamespaceName, source, event v1.ObjectName, s SeenList) error
	// Delete removes every event record of one source; a source with no record is not an error.
	Delete(ctx context.Context, ns v1.NamespaceName, source v1.ObjectName) error
	// ListSources returns each source that has at least one record, once (the start sweep, ADR-0157 Decision 8).
	ListSources(ctx context.Context) ([]SourceRef, error)
}