cqrs

type Aggregate interface {
	GetID() string
	GetType() string
	GetVersion() int
	GetUncommittedEvents() []Event
	MarkEventsAsCommitted()
	LoadFromHistory(events []*StoredEvent) error
	ApplyEvent(event Event) error
}

type AggregateConfig struct {
	SnapshotFrequency int  `json:"snapshot_frequency"`
	EnableSnapshots   bool `json:"enable_snapshots"`
	MaxEventCount     int  `json:"max_event_count"`
}

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

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

type AsyncCommandResult struct {
	Result *CommandResult
	Error  error
}

type AsyncQueryResult struct {
	Result *QueryResult
	Error  error
}

type BaseAggregate struct {
	ID                string    `json:"id"`
	Type              string    `json:"type"`
	Version           int       `json:"version"`
	UncommittedEvents []Event   `json:"-"`
	CreatedAt         time.Time `json:"created_at"`
	UpdatedAt         time.Time `json:"updated_at"`
	TenantID          string    `json:"tenant_id"`
}

type BaseCommand struct {
	CommandType   string                 `json:"command_type"`
	AggregateID   string                 `json:"aggregate_id"`
	Metadata      map[string]interface{} `json:"metadata"`
	UserID        string                 `json:"user_id"`
	TenantID      string                 `json:"tenant_id"`
	CorrelationID string                 `json:"correlation_id"`
}

type BaseEvent struct {
	EventType     string                 `json:"event_type"`
	AggregateID   string                 `json:"aggregate_id"`
	AggregateType string                 `json:"aggregate_type"`
	EventData     map[string]interface{} `json:"event_data"`
	Metadata      map[string]interface{} `json:"metadata"`
	Timestamp     time.Time              `json:"timestamp"`
	Version       int                    `json:"version"`
	Data          map[string]interface{} `json:"data"`
	CorrelationID string                 `json:"correlation_id"`
	CausationID   string                 `json:"causation_id"`
	UserID        string                 `json:"user_id"`
	TenantID      string                 `json:"tenant_id"`
}

type BaseProjection struct {
	Name       string   `json:"name"`
	EventTypes []string `json:"event_types"`
	Position   int64    `json:"position"`
	Logger     *logrus.Logger
	ReadStore  *ReadModelStore
}

type BaseQuery struct {
	QueryType     string                 `json:"query_type"`
	Parameters    map[string]interface{} `json:"parameters"`
	CacheKey      string                 `json:"cache_key"`
	Cacheable     bool                   `json:"cacheable"`
	UserID        string                 `json:"user_id"`
	TenantID      string                 `json:"tenant_id"`
	CorrelationID string                 `json:"correlation_id"`
}

type BaseReadModel struct {
	ID          string                 `json:"id"`
	Type        string                 `json:"type"`
	Version     int                    `json:"version"`
	LastUpdated time.Time              `json:"last_updated"`
	TenantID    string                 `json:"tenant_id"`
	Metadata    map[string]interface{} `json:"metadata,omitempty"`
}

type BatchCommand struct {
	Commands    []Command `json:"commands"`
	Transaction bool      `json:"transaction"` // If true, all commands must succeed
}

type BatchResult struct {
	Results    []*CommandResult `json:"results"`
	Success    bool             `json:"success"`
	FailedAt   int              `json:"failed_at,omitempty"` // Index of failed command
	TotalCount int              `json:"total_count"`
}

type CacheStats struct {
	Hits     int64   `json:"hits"`
	Misses   int64   `json:"misses"`
	Entries  int     `json:"entries"`
	HitRatio float64 `json:"hit_ratio"`
}

type Command interface {
	GetCommandType() string
	GetAggregateID() string
	GetMetadata() map[string]interface{}
}

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

type CommandBusConfig struct {
	EnableMetrics   bool `json:"enable_metrics"`
	EnableTracing   bool `json:"enable_tracing"`
	MaxConcurrent   int  `json:"max_concurrent"`
	TimeoutDuration int  `json:"timeout_duration"` // seconds
}

type CommandHandler interface {
	Handle(ctx context.Context, command Command) (*CommandResult, error)
	GetCommandType() string
}

type CommandResult struct {
	AggregateID   string                 `json:"aggregate_id"`
	EventsEmitted []interface{}          `json:"events_emitted"`
	Success       bool                   `json:"success"`
	Message       string                 `json:"message,omitempty"`
	Metadata      map[string]interface{} `json:"metadata,omitempty"`
	Version       int                    `json:"version"`
}

type Event interface {
	GetEventType() string
	GetAggregateID() string
	GetAggregateType() string
	GetEventData() map[string]interface{}
	GetMetadata() map[string]interface{}
	GetTimestamp() time.Time
	GetVersion() int
}

type EventStore interface {
	// Event operations
	AppendEvents(ctx context.Context, aggregateID, aggregateType string, expectedVersion int, events []Event) error
	GetEventStream(ctx context.Context, aggregateID, aggregateType string, fromVersion int) (*EventStream, error)
	GetEventsByTimeRange(ctx context.Context, start, end time.Time, limit int) ([]*StoredEvent, error)
	GetEventsByType(ctx context.Context, eventType string, limit int, offset int) ([]*StoredEvent, error)
	GetEventCount(ctx context.Context) (int64, error)

	// Aggregate operations
	GetAggregateVersion(ctx context.Context, aggregateID, aggregateType string) (int, error)

	// Snapshot operations
	GetLatestSnapshot(ctx context.Context, aggregateID, aggregateType string) (*Snapshot, error)
	CreateSnapshot(ctx context.Context, aggregateID, aggregateType string, version int, data interface{}) error
}

type EventStream struct {
	AggregateID   string         `json:"aggregate_id"`
	AggregateType string         `json:"aggregate_type"`
	Events        []*StoredEvent `json:"events"`
	Version       int            `json:"version"`
	FromVersion   int            `json:"from_version"`
	ToVersion     int            `json:"to_version"`
	Timestamp     time.Time      `json:"timestamp"`
	FromSnapshot  bool           `json:"from_snapshot"`
}

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

type PaginatedQuery struct {
	*BaseQuery
	Page     int    `json:"page"`
	PageSize int    `json:"page_size"`
	SortBy   string `json:"sort_by,omitempty"`
	SortDir  string `json:"sort_dir,omitempty"` // asc, desc
}

type PaginatedResult struct {
	*QueryResult
	Page        int  `json:"page"`
	PageSize    int  `json:"page_size"`
	TotalCount  int  `json:"total_count"`
	TotalPages  int  `json:"total_pages"`
	HasNext     bool `json:"has_next"`
	HasPrevious bool `json:"has_previous"`
}

type Projection interface {
	GetName() string
	GetEventTypes() []string
	Project(ctx context.Context, event *StoredEvent) (*ProjectionResult, error)
	Reset(ctx context.Context) error
	GetPosition() int64
	SetPosition(position int64)
}

type ProjectionConfig struct {
	BatchSize       int           `json:"batch_size"`
	PollInterval    time.Duration `json:"poll_interval"`
	ErrorRetryCount int           `json:"error_retry_count"`
	ErrorRetryDelay time.Duration `json:"error_retry_delay"`
	EnableMetrics   bool          `json:"enable_metrics"`
}

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

type ProjectionResult struct {
	ReadModels []ReadModel `json:"read_models"`
	Success    bool        `json:"success"`
	Message    string      `json:"message,omitempty"`
	Position   int64       `json:"position"`
}

type ProjectionState struct {
	Name        string    `json:"name"`
	Position    int64     `json:"position"`
	LastUpdated time.Time `json:"last_updated"`
	EventsCount int64     `json:"events_count"`
	ErrorsCount int64     `json:"errors_count"`
	IsRunning   bool      `json:"is_running"`
	LastError   string    `json:"last_error,omitempty"`
}

type Query interface {
	GetQueryType() string
	GetParameters() map[string]interface{}
	GetCacheKey() string
	IsCacheable() bool
}

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

type QueryBusConfig struct {
	EnableCache     bool          `json:"enable_cache"`
	CacheTTL        time.Duration `json:"cache_ttl"`
	EnableMetrics   bool          `json:"enable_metrics"`
	EnableTracing   bool          `json:"enable_tracing"`
	MaxConcurrent   int           `json:"max_concurrent"`
	TimeoutDuration time.Duration `json:"timeout_duration"`
}

type QueryCache interface {
	Get(key string) (*QueryResult, bool)
	Set(key string, result *QueryResult, ttl time.Duration)
	Delete(key string)
	Clear()
	GetStats() CacheStats
}

type QueryHandler interface {
	Handle(ctx context.Context, query Query) (*QueryResult, error)
	GetQueryType() string
}

type QueryResult struct {
	Data      interface{}            `json:"data"`
	Success   bool                   `json:"success"`
	Message   string                 `json:"message,omitempty"`
	Metadata  map[string]interface{} `json:"metadata,omitempty"`
	Count     int                    `json:"count,omitempty"`
	FromCache bool                   `json:"from_cache"`
	Timestamp time.Time              `json:"timestamp"`
}

type ReadModel interface {
	GetID() string
	GetType() string
	GetVersion() int
	GetLastUpdated() time.Time
}

type ReadModelConfig struct {
	TablePrefix      string        `json:"table_prefix"`
	EnableVersioning bool          `json:"enable_versioning"`
	EnableTTL        bool          `json:"enable_ttl"`
	DefaultTTL       time.Duration `json:"default_ttl"`
	BatchSize        int           `json:"batch_size"`
}

type ReadModelRecord struct {
	ID        string     `gorm:"type:uuid;primary_key" json:"id"`
	Type      string     `gorm:"type:varchar(255);not null;index" json:"type"`
	Data      string     `gorm:"type:jsonb;not null" json:"data"`
	Version   int        `gorm:"not null;default:1" json:"version"`
	CreatedAt time.Time  `gorm:"autoCreateTime" json:"created_at"`
	UpdatedAt time.Time  `gorm:"autoUpdateTime" json:"updated_at"`
	ExpiresAt *time.Time `gorm:"index" json:"expires_at,omitempty"`
	TenantID  string     `gorm:"type:uuid;index" json:"tenant_id"`
	Metadata  string     `gorm:"type:jsonb" json:"metadata,omitempty"`
}

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

type Snapshot struct {
	ID            string    `gorm:"type:uuid;primary_key;default:gen_random_uuid()" json:"id"`
	AggregateID   string    `gorm:"not null;index" json:"aggregate_id"`
	AggregateType string    `gorm:"not null;index" json:"aggregate_type"`
	Version       int       `gorm:"not null" json:"version"`
	Data          string    `gorm:"type:jsonb" json:"data"`
	Timestamp     time.Time `gorm:"not null" json:"timestamp"`
	CreatedAt     time.Time `gorm:"autoCreateTime" json:"created_at"`
}

type StoredEvent struct {
	ID            string    `gorm:"type:uuid;primary_key;default:gen_random_uuid()" json:"id"`
	EventType     string    `gorm:"not null;index" json:"event_type"`
	AggregateID   string    `gorm:"not null;index" json:"aggregate_id"`
	AggregateType string    `gorm:"not null;index" json:"aggregate_type"`
	EventData     string    `gorm:"type:jsonb" json:"event_data"`
	Metadata      string    `gorm:"type:jsonb" json:"metadata"`
	Version       int       `gorm:"not null;index" json:"version"`
	Timestamp     time.Time `gorm:"not null;index" json:"timestamp"`
	CreatedAt     time.Time `gorm:"autoCreateTime" json:"created_at"`
	CorrelationID string    `gorm:"index" json:"correlation_id"`
	CausationID   string    `gorm:"index" json:"causation_id"`
	UserID        string    `gorm:"index" json:"user_id"`
	TenantID      string    `gorm:"index" json:"tenant_id"`
}

type UserAggregate struct {
	*BaseAggregate
	Email     string     `json:"email"`
	Name      string     `json:"name"`
	IsActive  bool       `json:"is_active"`
	DeletedAt *time.Time `json:"deleted_at,omitempty"`
}