fix(db): restore base directory-creation semantics

Creating the parent of every resolved path was too broad. An absolute or
rootpath-relative database.path with a missing parent used to fail loudly and
create nothing; it silently created a 0700 tree and an empty database instead —
so a typo'd or unmounted path looked like data loss. The scratch Docker image
sets VIKUNJA_DATABASE_PATH=/db/vikunja.db with no /db, so an unmounted volume
would have written to the container layer.

It also killed the rootpath fallback for an unwritable user data directory,
turning a warn-and-continue into a refusal to start — upgrade-breaking for
containers whose service user has an unwritable HOME.

Creation moves back inside the injected getter: resolution passes
existingUserDataDir (stat only), the engine passes createdUserDataDir. Both fall
back to rootpath on failure, so they agree once the directory exists.

Author: kolaente

pkg/db/db.go

@@ -248,10 +248,11 @@ type DatabasePathConfig struct {
 //  3. If ConfiguredPath is relative:
 //     a. If RootPath differs from ExecutablePath (explicitly configured),
 //     joins with RootPath
-//     b. Otherwise, joins with platform-specific user data directory
+//     b. Otherwise, joins with the user data directory, falling back to RootPath
+//     when userDataDir reports the directory as unavailable
 //
-// Resolution is pure: it never creates anything, so both callers agree on the
-// path. The userDataDir parameter allows injecting a mock for testing.
+// Directory creation only ever happens inside userDataDir, so an operator-configured
+// path never gets its parents created behind their back.
 func resolveDatabasePath(cfg DatabasePathConfig, userDataDir func() (string, error)) (string, error) {
 	if cfg.ConfiguredPath == DatabasePathMemory {
 		return DatabasePathMemory, nil
@@ -296,27 +297,13 @@ func databasePathConfig() DatabasePathConfig {
 // or DatabasePathMemory for the ephemeral database. Only meaningful when
 // database.type is sqlite. It creates nothing — see ensureDatabasePath.
 func ResolvedDatabasePath() (string, error) {
-	return resolveDatabasePath(databasePathConfig(), resolveUserDataDir)
+	return resolveDatabasePath(databasePathConfig(), existingUserDataDir)
 }
 
-// ensureDatabasePath returns the same path as ResolvedDatabasePath, creating its
-// parent directory.
+// ensureDatabasePath returns the path ResolvedDatabasePath reports once the user data
+// directory exists, creating that directory if it is the one selected.
 func ensureDatabasePath() (string, error) {
-	path, err := ResolvedDatabasePath()
-	if err != nil {
-		return "", err
-	}
-
-	if path == DatabasePathMemory {
-		return path, nil
-	}
-
-	dir := filepath.Dir(path)
-	if err := os.MkdirAll(dir, 0o700); err != nil { // #nosec G703 -- dir is from config or XDG standard paths
-		return "", fmt.Errorf("could not create database directory %s: %w", dir, err)
-	}
-
-	return path, nil
+	return resolveDatabasePath(databasePathConfig(), createdUserDataDir)
 }
 
 func initSqliteEngine() (engine *xorm.Engine, err error) {
@@ -375,6 +362,41 @@ func initSqliteEngine() (engine *xorm.Engine, err error) {
 	return
 }
 
+// existingUserDataDir returns the user data directory only when it is already there.
+// Treating an absent directory as unavailable keeps resolution free of side effects
+// while still reporting the path ensureDatabasePath uses, once it has run.
+func existingUserDataDir() (string, error) {
+	dir, err := resolveUserDataDir()
+	if err != nil {
+		return "", err
+	}
+
+	info, err := os.Stat(dir)
+	if err != nil {
+		return "", fmt.Errorf("could not stat data directory %s: %w", dir, err)
+	}
+	if !info.IsDir() {
+		return "", fmt.Errorf("data directory %s is not a directory", dir)
+	}
+
+	return dir, nil
+}
+
+// createdUserDataDir creates the user data directory. Creation lives here so a failure
+// surfaces as the rootpath fallback instead of a hard startup error.
+func createdUserDataDir() (string, error) {
+	dir, err := resolveUserDataDir()
+	if err != nil {
+		return "", err
+	}
+
+	if err := os.MkdirAll(dir, 0o700); err != nil { // #nosec G703 -- dir is from XDG standard paths
+		return "", fmt.Errorf("could not create data directory %s: %w", dir, err)
+	}
+
+	return dir, nil
+}
+
 func resolveUserDataDir() (string, error) {
 	var dataDir string