core

type ActingContext struct {
	ActorID           uuid.UUID
	Domain            *ResolvedDomain
	IsImpersonating   bool
	ImpersonateReason string
	ImpersonateExpiry time.Time
}

type Dependencies struct {
	Client         *ent.Client             // Backend Ent client
	FrameClient    *frameEnt.Client        // Framework Ent client
	Config         *config.Config          // Configuration
	PermManager    *auth.PermissionManager // Permission manager (RBAC/ABAC)
	PermSyncer     *permissionsync.Syncer  // Permission syncer
	JWTService     *jwt.JWTService         // JWT service for impersonation/switch-tenant
	CaptchaService frameCaptcha.Service    // Captcha service for verification
	Router         chi.Router              // Root router for snapshotting

	// Middleware functions (optional, for modules that need them).
	APIKeyMiddleware func(http.Handler) http.Handler

	// Common services can be added here if needed across modules.
	DomainService       DomainResolver
	InvitationProviders *InvitationProviderRegistry
}

type DomainResolver interface {
	ResolveDomain(ctx context.Context, typeCode, key string) (*ResolvedDomain, error)
	ResolveDomainByID(ctx context.Context, domainID uuid.UUID) (*ResolvedDomain, error)
	CheckMembership(ctx context.Context, domainID, subjectID uuid.UUID) (bool, error)
	GetUserDefaultDomain(ctx context.Context, userID uuid.UUID) (*ResolvedDomain, error)
	GetDomainString(typeCode, key string) string
	ListUserDomains(ctx context.Context, userID uuid.UUID) ([]*UserDomainInfo, error)
}

type DomainType string

type DomainTypeInfo struct {
	ID   uuid.UUID
	Code string
	Name string
}

type DomainWriter interface {
	DomainResolver
	EnsureDomain(ctx context.Context, typeCode, key, displayName string) (*ResolvedDomain, error)
	AddMembership(ctx context.Context, domainID, subjectID uuid.UUID, memberRole string, isDefault bool) error
	RemoveMembership(ctx context.Context, domainID, subjectID uuid.UUID) error
}

type Identity struct {
	UserID       uuid.UUID      `json:"userId"`
	Username     string         `json:"username,omitempty"`
	Type         IdentityType   `json:"type"`
	Roles        []string       `json:"roles,omitempty"`
	Permissions  []string       `json:"permissions,omitempty"`
	TenantID     string         `json:"tenantId,omitempty"`
	IsSuperAdmin bool           `json:"isSuperAdmin"`
	DataFilters  map[string]any `json:"dataFilters,omitempty"`
	Metadata     map[string]any `json:"metadata,omitempty"`
}

type IdentityType string

type InvitationActivatedRequest struct {
	InvitationID uuid.UUID
	ActivatedBy  uuid.UUID
	DomainType   string
	DomainKey    string
	RoleIDs      []string
}

type InvitationCreateRequest struct {
	Username   string
	Email      string
	DomainType string
	DomainKey  string
	RoleIDs    []string
	CreatedBy  uuid.UUID
}

type InvitationDomainProvider interface {
	TypeCode() string
	ValidateCreate(ctx context.Context, req InvitationCreateRequest) error
	OnActivated(ctx context.Context, req InvitationActivatedRequest) error
}

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

type Module interface {
	// Name returns the unique name of the module.
	Name() string

	// RegisterPublicRoutes registers public API endpoints (no authentication required).
	RegisterPublicRoutes(router chi.Router)

	// RegisterPrivateRoutes registers private API endpoints (JWT authentication required).
	RegisterPrivateRoutes(router chi.Router)
}

type ModuleFactory func(logger logging.Logger, dependencies *Dependencies) Module

type ResolvedDomain struct {
	DomainID    uuid.UUID `json:"domainId"`
	TypeCode    string    `json:"typeCode"`
	Key         string    `json:"key"`
	DisplayName string    `json:"displayName"`
}

type UserDomainInfo struct {
	DomainID    uuid.UUID `json:"domainId"`
	TypeCode    string    `json:"typeCode"`
	Key         string    `json:"key"`
	DisplayName string    `json:"displayName"`
	MemberRole  string    `json:"memberRole"`
	IsDefault   bool      `json:"isDefault"`
}