meshcore-analyzer/cmd/server/user_mgmt_config.go

package main

import (
	"errors"
	"fmt"
	"net"
	"net/url"
	"path/filepath"
	"strings"
	"time"

	"github.com/meshcore-analyzer/users"
)

// UserManagementConfig is the "userManagement" block of config.json.
type UserManagementConfig struct {
	Enabled        bool           `json:"enabled"`
	DBPath         string         `json:"dbPath,omitempty"`
	AdminEmails    []string       `json:"adminEmails,omitempty"`
	PublicBaseURL  string         `json:"publicBaseUrl,omitempty"`
	SessionDays    int            `json:"sessionDays,omitempty"`
	TrustedProxies []string       `json:"trustedProxies,omitempty"`
	Mail           UserMailConfig `json:"mail"`
}

// UserMailConfig is userManagement.mail.
type UserMailConfig struct {
	Provider      string `json:"provider,omitempty"`
	BrevoAPIKey   string `json:"brevoApiKey,omitempty"`
	FromEmail     string `json:"fromEmail,omitempty"`
	FromName      string `json:"fromName,omitempty"`
	WebhookSecret string `json:"webhookSecret,omitempty"`
}

// UserManagementEnabled reports whether optional accounts are on. Nil config
// or absent section means off (the default).
func (c *Config) UserManagementEnabled() bool {
	return c != nil && c.UserManagement != nil && c.UserManagement.Enabled
}

// userMgmtSettings is the validated, resolved form the auth service runs on.
type userMgmtSettings struct {
	dbPath         string
	adminEmails    map[string]bool
	baseURL        *url.URL // no trailing slash, no query or fragment
	secureCookie   bool
	sessionTTL     time.Duration
	trustedProxies []*net.IPNet
	provider       string // "brevo" or (e2etest builds only) "fake"
	brevoAPIKey    string
	fromEmail      string
	fromName       string
	webhookSecret  string
}

const defaultSessionDays = 30

// fakeMailerAllowed is flipped only by the e2etest build (auth_e2e.go).
var fakeMailerAllowed bool

// resolveUserManagement validates the block and fills defaults. It refuses
// configurations where nobody could activate an account, so the server
// fails at startup instead of running half-working.
func resolveUserManagement(u *UserManagementConfig, measurementDBPath string, getenv func(string) string) (*userMgmtSettings, error) {
	set := &userMgmtSettings{adminEmails: map[string]bool{}}

	set.dbPath = strings.TrimSpace(u.DBPath)
	if set.dbPath == "" {
		set.dbPath = filepath.Join(filepath.Dir(measurementDBPath), "users.db")
	}
	for _, raw := range u.AdminEmails {
		e, err := users.NormalizeEmail(raw)
		if err != nil {
			return nil, fmt.Errorf("userManagement.adminEmails: %q is not a valid address", raw)
		}
		set.adminEmails[e] = true
	}

	base, err := url.Parse(strings.TrimSpace(u.PublicBaseURL))
	if err != nil || (base.Scheme != "http" && base.Scheme != "https") || base.Host == "" {
		return nil, errors.New("userManagement.publicBaseUrl must be an absolute http(s) URL, e.g. https://corescope.example.org")
	}
	base.Path = strings.TrimRight(base.Path, "/")
	base.RawQuery, base.Fragment = "", ""
	set.baseURL = base
	set.secureCookie = base.Scheme == "https"

	days := u.SessionDays
	if days <= 0 {
		days = defaultSessionDays
	}
	if days > 365 {
		days = 365
	}
	set.sessionTTL = time.Duration(days) * 24 * time.Hour
	set.trustedProxies = parseCIDRList(u.TrustedProxies, "userManagement.trustedProxies")

	set.provider = strings.ToLower(strings.TrimSpace(u.Mail.Provider))
	if set.provider == "" {
		set.provider = "brevo"
	}
	set.brevoAPIKey = envOrValue(getenv, "CORESCOPE_BREVO_API_KEY", u.Mail.BrevoAPIKey)
	set.webhookSecret = envOrValue(getenv, "CORESCOPE_BREVO_WEBHOOK_SECRET", u.Mail.WebhookSecret)
	from, err := users.NormalizeEmail(u.Mail.FromEmail)
	if err != nil {
		return nil, errors.New("userManagement.mail.fromEmail must be a valid address")
	}
	set.fromEmail = from
	set.fromName = strings.TrimSpace(u.Mail.FromName)
	if set.fromName == "" {
		set.fromName = "CoreScope"
	}

	switch set.provider {
	case "brevo":
		if set.brevoAPIKey == "" {
			return nil, errors.New("userManagement.mail: a Brevo API key is required (mail.brevoApiKey or CORESCOPE_BREVO_API_KEY)")
		}
	case "fake":
		if !fakeMailerAllowed {
			return nil, errors.New(`userManagement.mail.provider "fake" is only available in e2etest builds`)
		}
	default:
		return nil, fmt.Errorf("userManagement.mail.provider %q is not supported (use \"brevo\")", u.Mail.Provider)
	}
	if set.webhookSecret != "" && len(set.webhookSecret) < 16 {
		return nil, errors.New("userManagement.mail.webhookSecret must be at least 16 characters")
	}
	return set, nil
}

func envOrValue(getenv func(string) string, key, fallback string) string {
	if v := strings.TrimSpace(getenv(key)); v != "" {
		return v
	}
	return strings.TrimSpace(fallback)
}