storage

type ActorRepository[T spry.Actor[T]] struct {
	Repository[T]
}

type AggregateIdMap struct {
	ActorName  string
	ActorId    uuid.UUID
	Aggregated AggregatedIds
}

type AggregateRepository[T spry.Aggregate[T]] struct {
	Repository[T]
}

type AggregatedIds = map[string][]uuid.UUID

type Caster = func(any) (any, error)

type CommandRecord struct {
	// a generated uuid for this event
	Id uuid.UUID `json:"id"`
	// the type name of the command
	Type string `json:"type"`
	// namespace for the command
	Namespace string `json:"namespace"`
	// the time the command was handled
	CreatedOn time.Time `json:"createdOn"`
	// the time the command was handled
	ReceivedOn time.Time `json:"receivedOn"`
	// the time the command was handled
	HandledOn time.Time `json:"handledOn"`
	// the id of the recipient actor
	HandledBy uuid.UUID `json:"handledBy"`
	// the version of the actor that handled the command
	HandledVersion uint64
	// the contents of the command
	Data any `json:"data"`
}

type CommandStore interface {
	Add(context.Context, string, CommandRecord) error
}

type EventRecord struct {
	// a generated uuid for this event
	Id uuid.UUID `json:"id"`
	// the type name of the event
	Type string `json:"type"`
	// inferred from the actor emitting the event
	ActorNamespace string `json:"namespace"`
	// this is the addressable identity of the owning model
	ActorId uuid.UUID `json:"actorId"`
	// the type of the model the event was generated for
	ActorName string `json:"actor"`
	// UTC ISO date time string when event was created
	CreatedOn time.Time `json:"createdOn"`
	// the type of the actor instantiating the event
	CreatedBy string `json:"createdBy"`
	// the id of the snapshot instantiating the event
	CreatedById uuid.UUID `json:"createdById"`
	// the vector of the snapshot instantiating the event
	CreatedByVector string `json:"createdByVector"`
	// the version of the snapshot instantiating the event
	CreatedByVersion uint64 `json:"createdByVersion"`
	// the command type/topic that triggered the event
	InitiatedBy string `json:"initiatedBy"`
	// the id of the message that triggered the event
	InitiatedById uuid.UUID `json:"initiatedById"`
	// the contents of the event
	Data any `json:"data"`
}

type EventStore interface {
	Add(context.Context, []EventRecord) error
	FetchAggregatedSince(context.Context, string, uuid.UUID, uuid.UUID, LastEventMap, TypeMap) ([]EventRecord, error)
	FetchSince(context.Context, string, uuid.UUID, uuid.UUID, TypeMap) ([]EventRecord, error)
}

type IdAssignment struct {
	ActorName   string
	AssignedId  uuid.UUID
	Identifiers spry.Identifiers
	Json        string
}

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

type LastEventMap struct {
	LastEvents map[string]map[uuid.UUID]uuid.UUID
}

type MapStore interface {
	AddId(context.Context, string, spry.Identifiers, uuid.UUID) error
	AddLink(context.Context, string, uuid.UUID, string, uuid.UUID) error
	GetId(context.Context, string, spry.Identifiers) (uuid.UUID, error)
	GetIdMap(context.Context, string, uuid.UUID) (AggregateIdMap, error)
}

type NoOpTx struct{}

type Repository[T any] struct {
	ActorType reflect.Type
	ActorName string
	Storage   Storage
	Mapping   TypeMap
}

type Snapshot struct {
	// aggregates track records and last events from each
	// for each child type, track the last event per Identifier
	LastEventMap
	// a generated uuid (system id) for the snapshot instance
	Id uuid.UUID `json:"id"`
	// this is the addressable identity of the owning model
	ActorId uuid.UUID `json:"actorId"`
	// the type name of the actor
	Type string `json:"type"`
	// a serialized causal tracker
	Vector string `json:"vector"`
	// a numeric version of the model
	Version uint64 `json:"version"`
	// the causal tracker of the preceding snapshot
	Ancestor string `json:"ancestor"`
	// UTC ISO date time string when event was created
	CreatedOn time.Time `json:"createdOn"`
	// the number of events applied to reach the present state
	EventsApplied uint64 `json:"eventsApplied"`
	// the number of events since the last snapshot was created
	EventSinceSnapshot int
	// the UUID of the last event played against the instance
	LastEventId uuid.UUID `json:"lastEventId"`
	// the UUID of the last command handled
	LastCommandId uuid.UUID `json:"lastCommandId"`
	// the wall clock at the time of the last command
	LastCommandOn time.Time `json:"lastCommandOn"`
	// the wall clock at the time of the last event
	LastEventOn time.Time `json:"lastEventOn"`
	// the contents of the snapshot
	Data any `json:"data"`
}

type SnapshotStore interface {
	Add(context.Context, string, Snapshot, bool) error
	Fetch(context.Context, string, uuid.UUID) (Snapshot, error)
}

type Storage interface {
	AddCommand(context.Context, string, CommandRecord) error
	AddEvents(context.Context, []EventRecord) error
	AddMap(context.Context, string, spry.Identifiers, uuid.UUID) error
	AddSnapshot(context.Context, string, Snapshot, bool) error
	AddLink(context.Context, string, uuid.UUID, string, uuid.UUID) error
	Commit(context.Context) error
	FetchAggregatedEventsSince(context.Context, string, uuid.UUID, uuid.UUID, LastEventMap) ([]EventRecord, error)
	FetchEventsSince(context.Context, string, uuid.UUID, uuid.UUID) ([]EventRecord, error)
	FetchId(context.Context, string, spry.Identifiers) (uuid.UUID, error)
	FetchIdMap(context.Context, string, uuid.UUID) (AggregateIdMap, error)
	FetchLatestSnapshot(context.Context, string, uuid.UUID) (Snapshot, error)
	GetContext(context.Context) (context.Context, error)
	RegisterPrimitives(...any)
	Rollback(context.Context) error
}

type Stores[Tx any] struct {
	Commands     CommandStore
	Events       EventStore
	Maps         MapStore
	Primitives   TypeMap
	Snapshots    SnapshotStore
	Transactions TxProvider[Tx]
}

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

type TxProvider[T any] interface {
	GetTransaction(ctx context.Context) (T, error)
	Commit(ctx context.Context) error
	Rollback(ctx context.Context) error
}

type TypeMap struct {
	Events   map[string]Caster
	Commands map[string]Caster
}