models

type Account struct {
	ID                    string       `json:"id" gorm:"primaryKey"`
	UserID                string       `json:"user_id" gorm:"index"`
	AccountID             string       `json:"account_id"`
	ProviderID            ProviderType `json:"provider_id"`
	AccessToken           *string      `json:"access_token,omitempty"`
	RefreshToken          *string      `json:"refresh_token,omitempty"`
	IDToken               *string      `json:"id_token,omitempty"`
	AccessTokenExpiresAt  *time.Time   `json:"access_token_expires_at,omitempty"`
	RefreshTokenExpiresAt *time.Time   `json:"refresh_token_expires_at,omitempty"`
	Scope                 *string      `json:"scope,omitempty"`
	Password              *string      `json:"password,omitempty"` // for email/password auth
	CreatedAt             time.Time    `json:"created_at"`
	UpdatedAt             time.Time    `json:"updated_at"`
	User                  User         `gorm:"foreignKey:UserID"`
}

type AccountDatabaseHooksConfig struct {
	BeforeCreate func(account *Account) error
	AfterCreate  func(account Account) error
	BeforeUpdate func(account *Account) error
	AfterUpdate  func(account Account) error
}

type AccountService interface {
	CreateAccount(account *Account) error
	GetAccountByUserID(userID string) (*Account, error)
	GetAccountByProviderAndAccountID(provider ProviderType, accountID string) (*Account, error)
	UpdateAccount(account *Account) error
}

type AfterCreateHook[T any] func(ctx *PluginContext, entity *T) error

type AfterDeleteHook[T any] func(ctx *PluginContext, entity *T) error

type AfterReadHook[T any] func(ctx *PluginContext, results *[]T) error

type AfterUpdateHook[T any] func(ctx *PluginContext, updated *T) error

type Api struct {
	Users         UserService
	Accounts      AccountService
	Sessions      SessionService
	Verifications VerificationService
	Tokens        TokenService
	RateLimit     RateLimitService
}

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

type BeforeCreateHook[T any] func(ctx *PluginContext, entity *T) error

type BeforeDeleteHook[T any] func(ctx *PluginContext, entity *T) error

type BeforeReadHook[T any] func(ctx *PluginContext) error

type BeforeUpdateHook[T any] func(ctx *PluginContext, existing *T, updatedData map[string]any) error

type CSRFConfig struct {
	Enabled    bool
	CookieName string
	HeaderName string
	ExpiresIn  time.Duration
}

type ChangeEmailConfig struct {
	Enabled                          bool
	SendEmailChangeVerificationEmail func(user User, newEmail string, url string, token string) error
}

type Config struct {
	AppName           string
	BaseURL           string
	BasePath          string
	Secret            string
	DB                *gorm.DB
	Database          DatabaseConfig
	SecondaryStorage  SecondaryStorageConfig
	EmailPassword     EmailPasswordConfig
	EmailVerification EmailVerificationConfig
	User              UserConfig
	Session           SessionConfig
	CSRF              CSRFConfig
	SocialProviders   SocialProvidersConfig
	TrustedOrigins    TrustedOriginsConfig
	RateLimit         RateLimitConfig
	EndpointHooks     EndpointHooksConfig
	DatabaseHooks     DatabaseHooksConfig
	EventHooks        EventHooksConfig
	EventBus          EventBusConfig
	Plugins           PluginsConfig
}

type ConfigOption func(*Config)

type CustomRoute struct {
	Method     string
	Path       string
	Middleware []CustomRouteMiddleware
	Handler    CustomRouteHandler
}

type CustomRouteHandler func(config *Config) http.Handler

type CustomRouteMiddleware func(http.Handler) http.Handler

type DatabaseConfig struct {
	Provider         string
	ConnectionString string
	MaxOpenConns     int
	MaxIdleConns     int
	ConnMaxLifetime  time.Duration
}

type DatabaseHooksConfig struct {
	Users         *UserDatabaseHooksConfig
	Accounts      *AccountDatabaseHooksConfig
	Sessions      *SessionDatabaseHooksConfig
	Verifications *VerificationDatabaseHooksConfig
}

type DefaultOAuth2ProvidersConfig struct {
	Google  *OAuth2Config
	GitHub  *OAuth2Config
	Discord *OAuth2Config
}

type EmailPasswordConfig struct {
	Enabled                  bool
	MinPasswordLength        int
	MaxPasswordLength        int
	DisableSignUp            bool
	RequireEmailVerification bool
	AutoSignIn               bool
	SendResetPasswordEmail   func(user User, url string, token string) error
	ResetTokenExpiry         time.Duration
	Password                 *PasswordConfig
}

type EmailVerificationConfig struct {
	SendVerificationEmail func(user User, url string, token string) error
	AutoSignIn            bool
	SendOnSignUp          bool
	SendOnSignIn          bool
	ExpiresIn             time.Duration
}

type EndpointHookContext struct {
	Path            string
	Method          string
	Body            map[string]any
	Headers         map[string][]string
	Query           map[string][]string
	Request         *http.Request
	User            *User
	ResponseStatus  int
	ResponseBody    []byte
	ResponseHeaders map[string][]string
	ResponseCookies []*http.Cookie
}

type EndpointHooksConfig struct {
	Before   func(ctx *EndpointHookContext) error
	Response func(ctx *EndpointHookContext) error
	After    func(ctx *EndpointHookContext) error
}

type Event struct {
	ID        string            `json:"id"`
	Type      string            `json:"type"`
	Timestamp time.Time         `json:"timestamp"`
	Payload   json.RawMessage   `json:"payload"`
	Metadata  map[string]string `json:"metadata"`
}

type EventBus interface {
	EventPublisher
	EventSubscriber
}

type EventBusConfig struct {
	Enabled               bool
	Prefix                string
	MaxConcurrentHandlers int
	PubSub                PubSub
}

type EventHandler func(ctx context.Context, event Event) error

type EventHooksConfig struct {
	OnUserSignedUp    func(user User) error
	OnUserLoggedIn    func(user User) error
	OnEmailVerified   func(user User) error
	OnPasswordChanged func(user User) error
	OnEmailChanged    func(user User) error
}

type EventPublisher interface {
	Publish(ctx context.Context, event Event) error
	Close() error
}

type EventSubscriber interface {
	Subscribe(eventType string, handler EventHandler) (SubscriptionID, error)
	Unsubscribe(eventType string, id SubscriptionID)
	Close() error
}

type GenericOAuth2Config struct {
	OAuth2Config
	Endpoint GenericOAuth2EndpointConfig
}

type GenericOAuth2EndpointConfig struct {
	AuthURL     string
	TokenURL    string
	UserInfoURL string
}

type IPConfig struct {
	Headers []string
}

type KeyValueStore struct {
	Key       string     `json:"key" gorm:"primaryKey"`
	Value     string     `json:"value"`
	ExpiresAt *time.Time `json:"expires_at,omitempty"`
	CreatedAt time.Time  `json:"created_at"`
	UpdatedAt time.Time  `json:"updated_at"`
}

type Message struct {
	UUID     string
	Payload  []byte // Message payload (serialized data)
	Metadata map[string]string
}

type OAuth2Config struct {
	ClientID     string
	ClientSecret string
	RedirectURL  string
	Scopes       []string
}

type OAuth2UserInfo struct {
	ID       string
	Email    string
	Name     string
	Picture  string
	Verified bool
}

type PasswordConfig struct {
	Hash   func(password string) (string, error)
	Verify func(hashedPassword, password string) bool
}

type Plugin interface {
	Metadata() PluginMetadata
	SetMetadata(meta PluginMetadata)

	Config() PluginConfig
	SetConfig(cfg PluginConfig)

	Ctx() *PluginContext
	SetCtx(ctx *PluginContext)

	Init(ctx *PluginContext) error
	SetInit(fn func(ctx *PluginContext) error)

	Migrations() []any
	SetMigrations(migrations []any)

	Routes() []PluginRoute
	SetRoutes(routes []PluginRoute)

	RateLimit() *PluginRateLimit
	SetRateLimit(rateLimit *PluginRateLimit)

	DatabaseHooks() *PluginDatabaseHooks
	SetDatabaseHooks(hooks *PluginDatabaseHooks)

	EventHooks() *PluginEventHooks
	SetEventHooks(hooks *PluginEventHooks)

	Close() error
	SetClose(fn func() error)
}

type PluginConfig struct {
	Enabled bool
	Options any
}

type PluginContext struct {
	Config     *Config
	Api        *Api
	EventBus   EventBus
	Middleware *PluginMiddleware
}

type PluginDatabaseHookOperations[T any] struct {
	BeforeCreate *BeforeCreateHook[T]
	AfterCreate  *AfterCreateHook[T]

	BeforeRead *BeforeReadHook[T]
	AfterRead  *AfterReadHook[T]

	BeforeUpdate *BeforeUpdateHook[T]
	AfterUpdate  *AfterUpdateHook[T]

	BeforeDelete *BeforeDeleteHook[T]
	AfterDelete  *AfterDeleteHook[T]
}

type PluginDatabaseHooks map[string]PluginDatabaseHookOperations[any]

type PluginEventHookFunc func(ctx *PluginContext, payload PluginEventHookPayload) error

type PluginEventHookPayload any

type PluginEventHooks map[string]PluginEventHookFunc

type PluginMetadata struct {
	Name        string
	Version     string
	Description string
}

type PluginMiddleware struct {
	Auth          func() func(http.Handler) http.Handler
	OptionalAuth  func() func(http.Handler) http.Handler
	CorsAuth      func() func(http.Handler) http.Handler
	CSRF          func() func(http.Handler) http.Handler
	RateLimit     func() func(http.Handler) http.Handler
	EndpointHooks func() func(http.Handler) http.Handler
}

type PluginOption func(p Plugin)

type PluginRateLimit = RateLimitConfig

type PluginRoute struct {
	Method     string
	Path       string // Relative path, /auth is auto-prefixed
	Middleware []PluginRouteMiddleware
	Handler    PluginRouteHandler
}

type PluginRouteHandler func() http.Handler

type PluginRouteMiddleware func(http.Handler) http.Handler

type PluginsConfig struct {
	Plugins []Plugin
}

type ProviderType string

type PubSub interface {
	// Publish sends a message to the specified topic
	Publish(ctx context.Context, topic string, msg *Message) error

	// Subscribe returns a channel that receives messages from the specified topic.
	// The channel should be closed when the subscription is cancelled or closed.
	Subscribe(ctx context.Context, topic string) (<-chan *Message, error)

	// Close closes the pub/sub and cleans up resources
	Close() error
}

type RateLimitConfig struct {
	Enabled     bool
	Window      time.Duration
	Max         int
	Algorithm   string
	Prefix      string
	CustomRules map[string]RateLimitCustomRuleFunc
	IP          IPConfig
}

type RateLimitCustomRule struct {
	Disabled bool
	Window   time.Duration
	Max      int
}

type RateLimitCustomRuleFunc func(req *http.Request) RateLimitCustomRule

type RateLimitService interface {
	Allow(ctx context.Context, key string, req *http.Request) (bool, error)
	GetClientIP(req *http.Request) string
	BuildKey(key string) string
}

type SecondaryStorage interface {
	Get(ctx context.Context, key string) (any, error)
	Set(ctx context.Context, key string, value any, ttl *time.Duration) error
	Delete(ctx context.Context, key string) error
	Incr(ctx context.Context, key string, ttl *time.Duration) (int, error)
}

type SecondaryStorageConfig struct {
	Type            SecondaryStorageType
	MemoryOptions   *SecondaryStorageMemoryOptions
	DatabaseOptions *SecondaryStorageDatabaseOptions
	Storage         SecondaryStorage
}

type SecondaryStorageDatabaseOptions struct {
	// CleanupInterval controls how often expired entries are cleaned up.
	// If zero, the implementation should use a default.
	CleanupInterval time.Duration
}

type SecondaryStorageMemoryOptions struct {
	// CleanupInterval controls how often expired entries are cleaned up.
	// If zero, the implementation should use a default.
	CleanupInterval time.Duration
}

type SecondaryStorageType string

type Session struct {
	ID        string    `json:"id" gorm:"primaryKey"`
	UserID    string    `json:"user_id" gorm:"index"`
	Token     string    `json:"token" gorm:"uniqueIndex"`
	ExpiresAt time.Time `json:"expires_at"`
	IPAddress *string   `json:"ip_address,omitempty"`
	UserAgent *string   `json:"user_agent,omitempty"`
	CreatedAt time.Time `json:"created_at"`
	UpdatedAt time.Time `json:"updated_at"`
}

type SessionConfig struct {
	CookieName string
	ExpiresIn  time.Duration
	UpdateAge  time.Duration
}

type SessionDatabaseHooksConfig struct {
	BeforeCreate func(session *Session) error
	AfterCreate  func(session Session) error
}

type SessionService interface {
	CreateSession(userID string, token string) (*Session, error)
	GetSessionByUserID(userID string) (*Session, error)
	GetSessionByToken(token string) (*Session, error)
	DeleteSessionByID(ID string) error
}

type SocialProvidersConfig struct {
	Default DefaultOAuth2ProvidersConfig
	Generic map[string]GenericOAuth2Config
}

type SubscriptionID uint64

type TokenService interface {
	GenerateToken() (string, error)
	HashToken(token string) string
	GenerateEncryptedToken() (string, error)
	EncryptToken(token string) (string, error)
	DecryptToken(encryptedToken string) (string, error)
}

type TrustedOriginsConfig struct {
	Origins []string
}

type TypedPluginEventHook[T any] func(ctx *PluginContext, payload T) error

type User struct {
	ID            string    `json:"id" gorm:"primaryKey"`
	Name          string    `json:"name"`
	Email         string    `json:"email" gorm:"uniqueIndex"`
	EmailVerified bool      `json:"email_verified"`
	Image         *string   `json:"image,omitempty"`
	CreatedAt     time.Time `json:"created_at"`
	UpdatedAt     time.Time `json:"updated_at"`
}

type UserConfig struct {
	ChangeEmail ChangeEmailConfig
}

type UserDatabaseHooksConfig struct {
	BeforeCreate func(user *User) error
	AfterCreate  func(user User) error
	BeforeUpdate func(user *User) error
	AfterUpdate  func(user User) error
}

type UserService interface {
	CreateUser(user *User) error
	GetUserByID(id string) (*User, error)
	GetUserByEmail(email string) (*User, error)
	UpdateUser(user *User) error
}

type Verification struct {
	ID         string           `json:"id" gorm:"primaryKey"`
	UserID     *string          `json:"user_id,omitempty"`
	Identifier string           `json:"identifier"` // email or other identifier
	Token      string           `json:"token"`
	Type       VerificationType `json:"type"`
	ExpiresAt  time.Time        `json:"expires_at"`
	CreatedAt  time.Time        `json:"created_at"`
	UpdatedAt  time.Time        `json:"updated_at"`
}

type VerificationDatabaseHooksConfig struct {
	BeforeCreate func(verification *Verification) error
	AfterCreate  func(verification Verification) error
}

type VerificationService interface {
	CreateVerification(verif *Verification) error
	GetVerificationByToken(token string) (*Verification, error)
	DeleteVerification(id string) error
	IsExpired(verif *Verification) bool
}

type VerificationType string