Configuration tweaks (#2567)

This makes the following changes:

* The various `Defaults` functions are now responsible for setting sane defaults if `generate` is specified, rather than hiding them in `generate-config`
* Some configuration options have been marked as `omitempty` so that they don't appear in generated configs unnecessarily (monolith-specific vs. polylith-specific options)
* A new option `-polylith` has been added to `generate-config` to create a config that makes sense for polylith deployments (i.e. including the internal/external API listeners and per-component database sections)
* A new option `-normalise` has been added to `generate-config` to take an existing file and add any missing options and/or defaults

setup/config/config.go

@@ -211,7 +211,10 @@ func loadConfig(
 	monolithic bool,
 ) (*Dendrite, error) {
 	var c Dendrite
-	c.Defaults(false)
+	c.Defaults(DefaultOpts{
+		Generate:   false,
+		Monolithic: monolithic,
+	})
 	c.IsMonolith = monolithic
 
 	var err error
@@ -295,21 +298,25 @@ func (config *Dendrite) Derive() error {
 	return nil
 }
 
+type DefaultOpts struct {
+	Generate   bool
+	Monolithic bool
+}
+
 // SetDefaults sets default config values if they are not explicitly set.
-func (c *Dendrite) Defaults(generate bool) {
+func (c *Dendrite) Defaults(opts DefaultOpts) {
 	c.Version = Version
 
-	c.Global.Defaults(generate)
-	c.ClientAPI.Defaults(generate)
-	c.FederationAPI.Defaults(generate)
-	c.KeyServer.Defaults(generate)
-	c.MediaAPI.Defaults(generate)
-	c.RoomServer.Defaults(generate)
-	c.SyncAPI.Defaults(generate)
-	c.UserAPI.Defaults(generate)
-	c.AppServiceAPI.Defaults(generate)
-	c.MSCs.Defaults(generate)
-
+	c.Global.Defaults(opts)
+	c.ClientAPI.Defaults(opts)
+	c.FederationAPI.Defaults(opts)
+	c.KeyServer.Defaults(opts)
+	c.MediaAPI.Defaults(opts)
+	c.RoomServer.Defaults(opts)
+	c.SyncAPI.Defaults(opts)
+	c.UserAPI.Defaults(opts)
+	c.AppServiceAPI.Defaults(opts)
+	c.MSCs.Defaults(opts)
 	c.Wiring()
 }
 

setup/config/config_appservice.go

@@ -29,7 +29,7 @@ type AppServiceAPI struct {
 	Matrix  *Global  `yaml:"-"`
 	Derived *Derived `yaml:"-"` // TODO: Nuke Derived from orbit
 
-	InternalAPI InternalAPIOptions `yaml:"internal_api"`
+	InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
 
 	// DisableTLSValidation disables the validation of X.509 TLS certs
 	// on appservice endpoints. This is not recommended in production!
@@ -38,9 +38,11 @@ type AppServiceAPI struct {
 	ConfigFiles []string `yaml:"config_files"`
 }
 
-func (c *AppServiceAPI) Defaults(generate bool) {
-	c.InternalAPI.Listen = "http://localhost:7777"
-	c.InternalAPI.Connect = "http://localhost:7777"
+func (c *AppServiceAPI) Defaults(opts DefaultOpts) {
+	if !opts.Monolithic {
+		c.InternalAPI.Listen = "http://localhost:7777"
+		c.InternalAPI.Connect = "http://localhost:7777"
+	}
 }
 
 func (c *AppServiceAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {

setup/config/config_clientapi.go

@@ -9,8 +9,8 @@ type ClientAPI struct {
 	Matrix  *Global  `yaml:"-"`
 	Derived *Derived `yaml:"-"` // TODO: Nuke Derived from orbit
 
-	InternalAPI InternalAPIOptions `yaml:"internal_api"`
-	ExternalAPI ExternalAPIOptions `yaml:"external_api"`
+	InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
+	ExternalAPI ExternalAPIOptions `yaml:"external_api,omitempty"`
 
 	// If set disables new users from registering (except via shared
 	// secrets)
@@ -48,13 +48,15 @@ type ClientAPI struct {
 	// Rate-limiting options
 	RateLimiting RateLimiting `yaml:"rate_limiting"`
 
-	MSCs *MSCs `yaml:"mscs"`
+	MSCs *MSCs `yaml:"-"`
 }
 
-func (c *ClientAPI) Defaults(generate bool) {
-	c.InternalAPI.Listen = "http://localhost:7771"
-	c.InternalAPI.Connect = "http://localhost:7771"
-	c.ExternalAPI.Listen = "http://[::]:8071"
+func (c *ClientAPI) Defaults(opts DefaultOpts) {
+	if !opts.Monolithic {
+		c.InternalAPI.Listen = "http://localhost:7771"
+		c.InternalAPI.Connect = "http://localhost:7771"
+		c.ExternalAPI.Listen = "http://[::]:8071"
+	}
 	c.RegistrationSharedSecret = ""
 	c.RecaptchaPublicKey = ""
 	c.RecaptchaPrivateKey = ""

setup/config/config_federationapi.go

@@ -5,12 +5,12 @@ import "github.com/matrix-org/gomatrixserverlib"
 type FederationAPI struct {
 	Matrix *Global `yaml:"-"`
 
-	InternalAPI InternalAPIOptions `yaml:"internal_api"`
-	ExternalAPI ExternalAPIOptions `yaml:"external_api"`
+	InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
+	ExternalAPI ExternalAPIOptions `yaml:"external_api,omitempty"`
 
 	// The database stores information used by the federation destination queues to
 	// send transactions to remote servers.
-	Database DatabaseOptions `yaml:"database"`
+	Database DatabaseOptions `yaml:"database,omitempty"`
 
 	// Federation failure threshold. How many consecutive failures that we should
 	// tolerate when sending federation requests to a specific server. The backoff
@@ -30,25 +30,44 @@ type FederationAPI struct {
 	PreferDirectFetch bool `yaml:"prefer_direct_fetch"`
 }
 
-func (c *FederationAPI) Defaults(generate bool) {
-	c.InternalAPI.Listen = "http://localhost:7772"
-	c.InternalAPI.Connect = "http://localhost:7772"
-	c.ExternalAPI.Listen = "http://[::]:8072"
+func (c *FederationAPI) Defaults(opts DefaultOpts) {
+	if !opts.Monolithic {
+		c.InternalAPI.Listen = "http://localhost:7772"
+		c.InternalAPI.Connect = "http://localhost:7772"
+		c.ExternalAPI.Listen = "http://[::]:8072"
+		c.Database.Defaults(10)
+	}
 	c.FederationMaxRetries = 16
 	c.DisableTLSValidation = false
-	c.Database.Defaults(10)
-	if generate {
-		c.Database.ConnectionString = "file:federationapi.db"
+	if opts.Generate {
+		c.KeyPerspectives = KeyPerspectives{
+			{
+				ServerName: "matrix.org",
+				Keys: []KeyPerspectiveTrustKey{
+					{
+						KeyID:     "ed25519:auto",
+						PublicKey: "Noi6WqcDj0QmPxCNQqgezwTlBKrfqehY1u2FyWP9uYw",
+					},
+					{
+						KeyID:     "ed25519:a_RXGa",
+						PublicKey: "l8Hft5qXKn1vfHrg3p4+W8gELQVo8N13JkluMfmn2sQ",
+					},
+				},
+			},
+		}
+		if !opts.Monolithic {
+			c.Database.ConnectionString = "file:federationapi.db"
+		}
 	}
 }
 
 func (c *FederationAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
-	if c.Matrix.DatabaseOptions.ConnectionString == "" {
-		checkNotEmpty(configErrs, "federation_api.database.connection_string", string(c.Database.ConnectionString))
-	}
 	if isMonolith { // polylith required configs below
 		return
 	}
+	if c.Matrix.DatabaseOptions.ConnectionString == "" {
+		checkNotEmpty(configErrs, "federation_api.database.connection_string", string(c.Database.ConnectionString))
+	}
 	checkURL(configErrs, "federation_api.external_api.listen", string(c.ExternalAPI.Listen))
 	checkURL(configErrs, "federation_api.internal_api.listen", string(c.InternalAPI.Listen))
 	checkURL(configErrs, "federation_api.internal_api.connect", string(c.InternalAPI.Connect))

setup/config/config_global.go

@@ -41,7 +41,7 @@ type Global struct {
 	// connections will be used instead. This way we don't have to manage connection
 	// counts on a per-component basis, but can instead do it for the entire monolith.
 	// In a polylith deployment, this will be ignored.
-	DatabaseOptions DatabaseOptions `yaml:"database"`
+	DatabaseOptions DatabaseOptions `yaml:"database,omitempty"`
 
 	// The server name to delegate server-server communications to, with optional port
 	WellKnownServerName string `yaml:"well_known_server_name"`
@@ -83,22 +83,28 @@ type Global struct {
 	Cache Cache `yaml:"cache"`
 }
 
-func (c *Global) Defaults(generate bool) {
-	if generate {
+func (c *Global) Defaults(opts DefaultOpts) {
+	if opts.Generate {
 		c.ServerName = "localhost"
 		c.PrivateKeyPath = "matrix_key.pem"
 		_, c.PrivateKey, _ = ed25519.GenerateKey(rand.New(rand.NewSource(0)))
 		c.KeyID = "ed25519:auto"
+		c.TrustedIDServers = []string{
+			"matrix.org",
+			"vector.im",
+		}
 	}
 	c.KeyValidityPeriod = time.Hour * 24 * 7
-
-	c.JetStream.Defaults(generate)
-	c.Metrics.Defaults(generate)
+	if opts.Monolithic {
+		c.DatabaseOptions.Defaults(90)
+	}
+	c.JetStream.Defaults(opts)
+	c.Metrics.Defaults(opts)
 	c.DNSCache.Defaults()
 	c.Sentry.Defaults()
-	c.ServerNotices.Defaults(generate)
+	c.ServerNotices.Defaults(opts)
 	c.ReportStats.Defaults()
-	c.Cache.Defaults(generate)
+	c.Cache.Defaults()
 }
 
 func (c *Global) Verify(configErrs *ConfigErrors, isMonolith bool) {
@@ -142,9 +148,9 @@ type Metrics struct {
 	} `yaml:"basic_auth"`
 }
 
-func (c *Metrics) Defaults(generate bool) {
+func (c *Metrics) Defaults(opts DefaultOpts) {
 	c.Enabled = false
-	if generate {
+	if opts.Generate {
 		c.BasicAuth.Username = "metrics"
 		c.BasicAuth.Password = "metrics"
 	}
@@ -166,8 +172,8 @@ type ServerNotices struct {
 	RoomName string `yaml:"room_name"`
 }
 
-func (c *ServerNotices) Defaults(generate bool) {
-	if generate {
+func (c *ServerNotices) Defaults(opts DefaultOpts) {
+	if opts.Generate {
 		c.Enabled = true
 		c.LocalPart = "_server"
 		c.DisplayName = "Server Alert"
@@ -183,7 +189,7 @@ type Cache struct {
 	MaxAge           time.Duration `yaml:"max_age"`
 }
 
-func (c *Cache) Defaults(generate bool) {
+func (c *Cache) Defaults() {
 	c.EstimatedMaxSize = 1024 * 1024 * 1024 // 1GB
 	c.MaxAge = time.Hour
 }

setup/config/config_jetstream.go

@@ -31,10 +31,10 @@ func (c *JetStream) Durable(name string) string {
 	return c.Prefixed(name)
 }
 
-func (c *JetStream) Defaults(generate bool) {
+func (c *JetStream) Defaults(opts DefaultOpts) {
 	c.Addresses = []string{}
 	c.TopicPrefix = "Dendrite"
-	if generate {
+	if opts.Generate {
 		c.StoragePath = Path("./")
 		c.NoLog = true
 		c.DisableTLSValidation = true

setup/config/config_keyserver.go

@@ -3,27 +3,31 @@ package config
 type KeyServer struct {
 	Matrix *Global `yaml:"-"`
 
-	InternalAPI InternalAPIOptions `yaml:"internal_api"`
+	InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
 
-	Database DatabaseOptions `yaml:"database"`
+	Database DatabaseOptions `yaml:"database,omitempty"`
 }
 
-func (c *KeyServer) Defaults(generate bool) {
-	c.InternalAPI.Listen = "http://localhost:7779"
-	c.InternalAPI.Connect = "http://localhost:7779"
-	c.Database.Defaults(10)
-	if generate {
-		c.Database.ConnectionString = "file:keyserver.db"
+func (c *KeyServer) Defaults(opts DefaultOpts) {
+	if !opts.Monolithic {
+		c.InternalAPI.Listen = "http://localhost:7779"
+		c.InternalAPI.Connect = "http://localhost:7779"
+		c.Database.Defaults(10)
+	}
+	if opts.Generate {
+		if !opts.Monolithic {
+			c.Database.ConnectionString = "file:keyserver.db"
+		}
 	}
 }
 
 func (c *KeyServer) Verify(configErrs *ConfigErrors, isMonolith bool) {
-	if c.Matrix.DatabaseOptions.ConnectionString == "" {
-		checkNotEmpty(configErrs, "key_server.database.connection_string", string(c.Database.ConnectionString))
-	}
 	if isMonolith { // polylith required configs below
 		return
 	}
+	if c.Matrix.DatabaseOptions.ConnectionString == "" {
+		checkNotEmpty(configErrs, "key_server.database.connection_string", string(c.Database.ConnectionString))
+	}
 	checkURL(configErrs, "key_server.internal_api.listen", string(c.InternalAPI.Listen))
 	checkURL(configErrs, "key_server.internal_api.connect", string(c.InternalAPI.Connect))
 }

setup/config/config_mediaapi.go

@@ -7,12 +7,12 @@ import (
 type MediaAPI struct {
 	Matrix *Global `yaml:"-"`
 
-	InternalAPI InternalAPIOptions `yaml:"internal_api"`
-	ExternalAPI ExternalAPIOptions `yaml:"external_api"`
+	InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
+	ExternalAPI ExternalAPIOptions `yaml:"external_api,omitempty"`
 
 	// The MediaAPI database stores information about files uploaded and downloaded
 	// by local users. It is only accessed by the MediaAPI.
-	Database DatabaseOptions `yaml:"database"`
+	Database DatabaseOptions `yaml:"database,omitempty"`
 
 	// The base path to where the media files will be stored. May be relative or absolute.
 	BasePath Path `yaml:"base_path"`
@@ -38,23 +38,41 @@ type MediaAPI struct {
 // DefaultMaxFileSizeBytes defines the default file size allowed in transfers
 var DefaultMaxFileSizeBytes = FileSizeBytes(10485760)
 
-func (c *MediaAPI) Defaults(generate bool) {
-	c.InternalAPI.Listen = "http://localhost:7774"
-	c.InternalAPI.Connect = "http://localhost:7774"
-	c.ExternalAPI.Listen = "http://[::]:8074"
+func (c *MediaAPI) Defaults(opts DefaultOpts) {
+	if !opts.Monolithic {
+		c.InternalAPI.Listen = "http://localhost:7774"
+		c.InternalAPI.Connect = "http://localhost:7774"
+		c.ExternalAPI.Listen = "http://[::]:8074"
+		c.Database.Defaults(5)
+	}
 	c.MaxFileSizeBytes = DefaultMaxFileSizeBytes
 	c.MaxThumbnailGenerators = 10
-	c.Database.Defaults(5)
-	if generate {
-		c.Database.ConnectionString = "file:mediaapi.db"
+	if opts.Generate {
+		c.ThumbnailSizes = []ThumbnailSize{
+			{
+				Width:        32,
+				Height:       32,
+				ResizeMethod: "crop",
+			},
+			{
+				Width:        96,
+				Height:       96,
+				ResizeMethod: "crop",
+			},
+			{
+				Width:        640,
+				Height:       480,
+				ResizeMethod: "scale",
+			},
+		}
+		if !opts.Monolithic {
+			c.Database.ConnectionString = "file:mediaapi.db"
+		}
 		c.BasePath = "./media_store"
 	}
 }
 
 func (c *MediaAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
-	if c.Matrix.DatabaseOptions.ConnectionString == "" {
-		checkNotEmpty(configErrs, "media_api.database.connection_string", string(c.Database.ConnectionString))
-	}
 	checkNotEmpty(configErrs, "media_api.base_path", string(c.BasePath))
 	checkPositive(configErrs, "media_api.max_file_size_bytes", int64(c.MaxFileSizeBytes))
 	checkPositive(configErrs, "media_api.max_thumbnail_generators", int64(c.MaxThumbnailGenerators))
@@ -66,6 +84,9 @@ func (c *MediaAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
 	if isMonolith { // polylith required configs below
 		return
 	}
+	if c.Matrix.DatabaseOptions.ConnectionString == "" {
+		checkNotEmpty(configErrs, "media_api.database.connection_string", string(c.Database.ConnectionString))
+	}
 	checkURL(configErrs, "media_api.internal_api.listen", string(c.InternalAPI.Listen))
 	checkURL(configErrs, "media_api.internal_api.connect", string(c.InternalAPI.Connect))
 	checkURL(configErrs, "media_api.external_api.listen", string(c.ExternalAPI.Listen))

setup/config/config_mscs.go

@@ -10,13 +10,17 @@ type MSCs struct {
 	// 'msc2946': Spaces Summary - https://github.com/matrix-org/matrix-doc/pull/2946
 	MSCs []string `yaml:"mscs"`
 
-	Database DatabaseOptions `yaml:"database"`
+	Database DatabaseOptions `yaml:"database,omitempty"`
 }
 
-func (c *MSCs) Defaults(generate bool) {
-	c.Database.Defaults(5)
-	if generate {
-		c.Database.ConnectionString = "file:mscs.db"
+func (c *MSCs) Defaults(opts DefaultOpts) {
+	if !opts.Monolithic {
+		c.Database.Defaults(5)
+	}
+	if opts.Generate {
+		if !opts.Monolithic {
+			c.Database.ConnectionString = "file:mscs.db"
+		}
 	}
 }
 
@@ -31,6 +35,9 @@ func (c *MSCs) Enabled(msc string) bool {
 }
 
 func (c *MSCs) Verify(configErrs *ConfigErrors, isMonolith bool) {
+	if isMonolith { // polylith required configs below
+		return
+	}
 	if c.Matrix.DatabaseOptions.ConnectionString == "" {
 		checkNotEmpty(configErrs, "mscs.database.connection_string", string(c.Database.ConnectionString))
 	}

setup/config/config_roomserver.go

@@ -3,27 +3,31 @@ package config
 type RoomServer struct {
 	Matrix *Global `yaml:"-"`
 
-	InternalAPI InternalAPIOptions `yaml:"internal_api"`
+	InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
 
-	Database DatabaseOptions `yaml:"database"`
+	Database DatabaseOptions `yaml:"database,omitempty"`
 }
 
-func (c *RoomServer) Defaults(generate bool) {
-	c.InternalAPI.Listen = "http://localhost:7770"
-	c.InternalAPI.Connect = "http://localhost:7770"
-	c.Database.Defaults(10)
-	if generate {
-		c.Database.ConnectionString = "file:roomserver.db"
+func (c *RoomServer) Defaults(opts DefaultOpts) {
+	if !opts.Monolithic {
+		c.InternalAPI.Listen = "http://localhost:7770"
+		c.InternalAPI.Connect = "http://localhost:7770"
+		c.Database.Defaults(20)
+	}
+	if opts.Generate {
+		if !opts.Monolithic {
+			c.Database.ConnectionString = "file:roomserver.db"
+		}
 	}
 }
 
 func (c *RoomServer) Verify(configErrs *ConfigErrors, isMonolith bool) {
-	if c.Matrix.DatabaseOptions.ConnectionString == "" {
-		checkNotEmpty(configErrs, "room_server.database.connection_string", string(c.Database.ConnectionString))
-	}
 	if isMonolith { // polylith required configs below
 		return
 	}
+	if c.Matrix.DatabaseOptions.ConnectionString == "" {
+		checkNotEmpty(configErrs, "room_server.database.connection_string", string(c.Database.ConnectionString))
+	}
 	checkURL(configErrs, "room_server.internal_api.listen", string(c.InternalAPI.Listen))
 	checkURL(configErrs, "room_server.internal_ap.connect", string(c.InternalAPI.Connect))
 }

setup/config/config_syncapi.go

@@ -3,31 +3,35 @@ package config
 type SyncAPI struct {
 	Matrix *Global `yaml:"-"`
 
-	InternalAPI InternalAPIOptions `yaml:"internal_api"`
-	ExternalAPI ExternalAPIOptions `yaml:"external_api"`
+	InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
+	ExternalAPI ExternalAPIOptions `yaml:"external_api,omitempty"`
 
-	Database DatabaseOptions `yaml:"database"`
+	Database DatabaseOptions `yaml:"database,omitempty"`
 
 	RealIPHeader string `yaml:"real_ip_header"`
 }
 
-func (c *SyncAPI) Defaults(generate bool) {
-	c.InternalAPI.Listen = "http://localhost:7773"
-	c.InternalAPI.Connect = "http://localhost:7773"
-	c.ExternalAPI.Listen = "http://localhost:8073"
-	c.Database.Defaults(10)
-	if generate {
-		c.Database.ConnectionString = "file:syncapi.db"
+func (c *SyncAPI) Defaults(opts DefaultOpts) {
+	if !opts.Monolithic {
+		c.InternalAPI.Listen = "http://localhost:7773"
+		c.InternalAPI.Connect = "http://localhost:7773"
+		c.ExternalAPI.Listen = "http://localhost:8073"
+		c.Database.Defaults(20)
+	}
+	if opts.Generate {
+		if !opts.Monolithic {
+			c.Database.ConnectionString = "file:syncapi.db"
+		}
 	}
 }
 
 func (c *SyncAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
-	if c.Matrix.DatabaseOptions.ConnectionString == "" {
-		checkNotEmpty(configErrs, "sync_api.database", string(c.Database.ConnectionString))
-	}
 	if isMonolith { // polylith required configs below
 		return
 	}
+	if c.Matrix.DatabaseOptions.ConnectionString == "" {
+		checkNotEmpty(configErrs, "sync_api.database", string(c.Database.ConnectionString))
+	}
 	checkURL(configErrs, "sync_api.internal_api.listen", string(c.InternalAPI.Listen))
 	checkURL(configErrs, "sync_api.internal_api.connect", string(c.InternalAPI.Connect))
 	checkURL(configErrs, "sync_api.external_api.listen", string(c.ExternalAPI.Listen))

setup/config/config_userapi.go

@@ -5,7 +5,7 @@ import "golang.org/x/crypto/bcrypt"
 type UserAPI struct {
 	Matrix *Global `yaml:"-"`
 
-	InternalAPI InternalAPIOptions `yaml:"internal_api"`
+	InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
 
 	// The cost when hashing passwords.
 	BCryptCost int `yaml:"bcrypt_cost"`
@@ -18,30 +18,34 @@ type UserAPI struct {
 
 	// The Account database stores the login details and account information
 	// for local users. It is accessed by the UserAPI.
-	AccountDatabase DatabaseOptions `yaml:"account_database"`
+	AccountDatabase DatabaseOptions `yaml:"account_database,omitempty"`
 }
 
 const DefaultOpenIDTokenLifetimeMS = 3600000 // 60 minutes
 
-func (c *UserAPI) Defaults(generate bool) {
-	c.InternalAPI.Listen = "http://localhost:7781"
-	c.InternalAPI.Connect = "http://localhost:7781"
+func (c *UserAPI) Defaults(opts DefaultOpts) {
+	if !opts.Monolithic {
+		c.InternalAPI.Listen = "http://localhost:7781"
+		c.InternalAPI.Connect = "http://localhost:7781"
+		c.AccountDatabase.Defaults(10)
+	}
 	c.BCryptCost = bcrypt.DefaultCost
 	c.OpenIDTokenLifetimeMS = DefaultOpenIDTokenLifetimeMS
-	c.AccountDatabase.Defaults(10)
-	if generate {
-		c.AccountDatabase.ConnectionString = "file:userapi_accounts.db"
+	if opts.Generate {
+		if !opts.Monolithic {
+			c.AccountDatabase.ConnectionString = "file:userapi_accounts.db"
+		}
 	}
 }
 
 func (c *UserAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
 	checkPositive(configErrs, "user_api.openid_token_lifetime_ms", c.OpenIDTokenLifetimeMS)
-	if c.Matrix.DatabaseOptions.ConnectionString == "" {
-		checkNotEmpty(configErrs, "user_api.account_database.connection_string", string(c.AccountDatabase.ConnectionString))
-	}
 	if isMonolith { // polylith required configs below
 		return
 	}
+	if c.Matrix.DatabaseOptions.ConnectionString == "" {
+		checkNotEmpty(configErrs, "user_api.account_database.connection_string", string(c.AccountDatabase.ConnectionString))
+	}
 	checkURL(configErrs, "user_api.internal_api.listen", string(c.InternalAPI.Listen))
 	checkURL(configErrs, "user_api.internal_api.connect", string(c.InternalAPI.Connect))
 }