Merge branch 'main' into fix/issue-25

Previously, deleteSnapshotFromLocalDB logged errors but always returned nil,
causing callers to believe deletion succeeded even when it failed. This could
lead to data inconsistency where remote metadata is deleted while local
records persist.

Now returns the first error encountered, allowing callers to handle failures
appropriately.

internal/vaultik/snapshot.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"regexp"
 	"sort"
 	"strings"
 	"text/tabwriter"
@@ -1003,16 +1004,16 @@ func (v *Vaultik) deleteSnapshotFromLocalDB(snapshotID string) error {
 
 	// Delete related records first to avoid foreign key constraints
 	if err := v.Repositories.Snapshots.DeleteSnapshotFiles(v.ctx, snapshotID); err != nil {
-		log.Error("Failed to delete snapshot files", "snapshot_id", snapshotID, "error", err)
+		return fmt.Errorf("deleting snapshot files for %s: %w", snapshotID, err)
 	}
 	if err := v.Repositories.Snapshots.DeleteSnapshotBlobs(v.ctx, snapshotID); err != nil {
-		log.Error("Failed to delete snapshot blobs", "snapshot_id", snapshotID, "error", err)
+		return fmt.Errorf("deleting snapshot blobs for %s: %w", snapshotID, err)
 	}
 	if err := v.Repositories.Snapshots.DeleteSnapshotUploads(v.ctx, snapshotID); err != nil {
-		log.Error("Failed to delete snapshot uploads", "snapshot_id", snapshotID, "error", err)
+		return fmt.Errorf("deleting snapshot uploads for %s: %w", snapshotID, err)
 	}
 	if err := v.Repositories.Snapshots.Delete(v.ctx, snapshotID); err != nil {
-		log.Error("Failed to delete snapshot record", "snapshot_id", snapshotID, "error", err)
+		return fmt.Errorf("deleting snapshot record %s: %w", snapshotID, err)
 	}
 
 	return nil
@@ -1126,27 +1127,20 @@ func (v *Vaultik) PruneDatabase() (*PruneResult, error) {
 	return result, nil
 }
 
-// allowedTableNames is the exhaustive whitelist of table names that may be
-// passed to getTableCount. Any name not in this set is rejected, preventing
-// SQL injection even if caller-controlled input is accidentally supplied.
-var allowedTableNames = map[string]struct{}{
-	"files":  {},
-	"chunks": {},
-	"blobs":  {},
-}
+// validTableNameRe matches table names containing only lowercase alphanumeric characters and underscores.
+var validTableNameRe = regexp.MustCompile(`^[a-z0-9_]+$`)
 
-// getTableCount returns the number of rows in the given table.
-// tableName must appear in the allowedTableNames whitelist; all other values
-// are rejected with an error, preventing SQL injection.
+// getTableCount returns the count of rows in a table.
+// The tableName is sanitized to only allow [a-z0-9_] characters to prevent SQL injection.
 func (v *Vaultik) getTableCount(tableName string) (int64, error) {
-	if _, ok := allowedTableNames[tableName]; !ok {
-		return 0, fmt.Errorf("table name not allowed: %q", tableName)
-	}
-
 	if v.DB == nil {
 		return 0, nil
 	}
 
+	if !validTableNameRe.MatchString(tableName) {
+		return 0, fmt.Errorf("invalid table name: %q", tableName)
+	}
+
 	var count int64
 	query := fmt.Sprintf("SELECT COUNT(*) FROM %s", tableName)
 	err := v.DB.Conn().QueryRowContext(v.ctx, query).Scan(&count)

internal/vaultik/table_count_test.go

@@ -1,51 +0,0 @@
-package vaultik
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestAllowedTableNames(t *testing.T) {
-	// Verify the whitelist contains exactly the expected tables
-	expected := []string{"files", "chunks", "blobs"}
-	assert.Len(t, allowedTableNames, len(expected))
-	for _, name := range expected {
-		_, ok := allowedTableNames[name]
-		assert.True(t, ok, "expected %q in allowedTableNames", name)
-	}
-}
-
-func TestGetTableCount_RejectsInvalidNames(t *testing.T) {
-	v := &Vaultik{} // DB is nil, but rejection happens before DB access
-	v.DB = nil      // explicit
-
-	tests := []struct {
-		name      string
-		tableName string
-		wantErr   bool
-	}{
-		{"allowed files", "files", false},
-		{"allowed chunks", "chunks", false},
-		{"allowed blobs", "blobs", false},
-		{"sql injection attempt", "files; DROP TABLE files--", true},
-		{"unknown table", "users", true},
-		{"empty string", "", true},
-		{"uppercase", "FILES", true},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			count, err := v.getTableCount(tt.tableName)
-			if tt.wantErr {
-				assert.Error(t, err)
-				assert.Contains(t, err.Error(), "not allowed")
-				assert.Equal(t, int64(0), count)
-			} else {
-				// DB is nil so returns 0, nil for allowed names
-				assert.NoError(t, err)
-				assert.Equal(t, int64(0), count)
-			}
-		})
-	}
-}