Add custom types, version command, and restore --verify flag

- Add internal/types package with type-safe wrappers for IDs, hashes,
  paths, and credentials (FileID, BlobID, ChunkHash, etc.)
- Implement driver.Valuer and sql.Scanner for UUID-based types
- Add `vaultik version` command showing version, commit, go version
- Add `--verify` flag to restore command that checksums all restored
  files against expected chunk hashes with progress bar
- Remove fetch.go (dead code, functionality in restore)
- Clean up TODO.md, remove completed items
- Update all database and snapshot code to use new custom types

internal/database/blob_chunks_test.go

@@ -5,6 +5,8 @@ import (
 	"strings"
 	"testing"
 	"time"
+
+	"git.eeqj.de/sneak/vaultik/internal/types"
 )
 
 func TestBlobChunkRepository(t *testing.T) {
@@ -16,8 +18,8 @@ func TestBlobChunkRepository(t *testing.T) {
 
 	// Create blob first
 	blob := &Blob{
-		ID:        "blob1-uuid",
-		Hash:      "blob1-hash",
+		ID:        types.NewBlobID(),
+		Hash:      types.BlobHash("blob1-hash"),
 		CreatedTS: time.Now(),
 	}
 	err := repos.Blobs.Create(ctx, nil, blob)
@@ -26,7 +28,7 @@ func TestBlobChunkRepository(t *testing.T) {
 	}
 
 	// Create chunks
-	chunks := []string{"chunk1", "chunk2", "chunk3"}
+	chunks := []types.ChunkHash{"chunk1", "chunk2", "chunk3"}
 	for _, chunkHash := range chunks {
 		chunk := &Chunk{
 			ChunkHash: chunkHash,
@@ -41,7 +43,7 @@ func TestBlobChunkRepository(t *testing.T) {
 	// Test Create
 	bc1 := &BlobChunk{
 		BlobID:    blob.ID,
-		ChunkHash: "chunk1",
+		ChunkHash: types.ChunkHash("chunk1"),
 		Offset:    0,
 		Length:    1024,
 	}
@@ -54,7 +56,7 @@ func TestBlobChunkRepository(t *testing.T) {
 	// Add more chunks to the same blob
 	bc2 := &BlobChunk{
 		BlobID:    blob.ID,
-		ChunkHash: "chunk2",
+		ChunkHash: types.ChunkHash("chunk2"),
 		Offset:    1024,
 		Length:    2048,
 	}
@@ -65,7 +67,7 @@ func TestBlobChunkRepository(t *testing.T) {
 
 	bc3 := &BlobChunk{
 		BlobID:    blob.ID,
-		ChunkHash: "chunk3",
+		ChunkHash: types.ChunkHash("chunk3"),
 		Offset:    3072,
 		Length:    512,
 	}
@@ -75,7 +77,7 @@ func TestBlobChunkRepository(t *testing.T) {
 	}
 
 	// Test GetByBlobID
-	blobChunks, err := repos.BlobChunks.GetByBlobID(ctx, blob.ID)
+	blobChunks, err := repos.BlobChunks.GetByBlobID(ctx, blob.ID.String())
 	if err != nil {
 		t.Fatalf("failed to get blob chunks: %v", err)
 	}
@@ -134,13 +136,13 @@ func TestBlobChunkRepositoryMultipleBlobs(t *testing.T) {
 
 	// Create blobs
 	blob1 := &Blob{
-		ID:        "blob1-uuid",
-		Hash:      "blob1-hash",
+		ID:        types.NewBlobID(),
+		Hash:      types.BlobHash("blob1-hash"),
 		CreatedTS: time.Now(),
 	}
 	blob2 := &Blob{
-		ID:        "blob2-uuid",
-		Hash:      "blob2-hash",
+		ID:        types.NewBlobID(),
+		Hash:      types.BlobHash("blob2-hash"),
 		CreatedTS: time.Now(),
 	}
 
@@ -154,7 +156,7 @@ func TestBlobChunkRepositoryMultipleBlobs(t *testing.T) {
 	}
 
 	// Create chunks
-	chunkHashes := []string{"chunk1", "chunk2", "chunk3"}
+	chunkHashes := []types.ChunkHash{"chunk1", "chunk2", "chunk3"}
 	for _, chunkHash := range chunkHashes {
 		chunk := &Chunk{
 			ChunkHash: chunkHash,
@@ -169,10 +171,10 @@ func TestBlobChunkRepositoryMultipleBlobs(t *testing.T) {
 	// Create chunks across multiple blobs
 	// Some chunks are shared between blobs (deduplication scenario)
 	blobChunks := []BlobChunk{
-		{BlobID: blob1.ID, ChunkHash: "chunk1", Offset: 0, Length: 1024},
-		{BlobID: blob1.ID, ChunkHash: "chunk2", Offset: 1024, Length: 1024},
-		{BlobID: blob2.ID, ChunkHash: "chunk2", Offset: 0, Length: 1024}, // chunk2 is shared
-		{BlobID: blob2.ID, ChunkHash: "chunk3", Offset: 1024, Length: 1024},
+		{BlobID: blob1.ID, ChunkHash: types.ChunkHash("chunk1"), Offset: 0, Length: 1024},
+		{BlobID: blob1.ID, ChunkHash: types.ChunkHash("chunk2"), Offset: 1024, Length: 1024},
+		{BlobID: blob2.ID, ChunkHash: types.ChunkHash("chunk2"), Offset: 0, Length: 1024}, // chunk2 is shared
+		{BlobID: blob2.ID, ChunkHash: types.ChunkHash("chunk3"), Offset: 1024, Length: 1024},
 	}
 
 	for _, bc := range blobChunks {
@@ -183,7 +185,7 @@ func TestBlobChunkRepositoryMultipleBlobs(t *testing.T) {
 	}
 
 	// Verify blob1 chunks
-	chunks, err := repos.BlobChunks.GetByBlobID(ctx, blob1.ID)
+	chunks, err := repos.BlobChunks.GetByBlobID(ctx, blob1.ID.String())
 	if err != nil {
 		t.Fatalf("failed to get blob1 chunks: %v", err)
 	}
@@ -192,7 +194,7 @@ func TestBlobChunkRepositoryMultipleBlobs(t *testing.T) {
 	}
 
 	// Verify blob2 chunks
-	chunks, err = repos.BlobChunks.GetByBlobID(ctx, blob2.ID)
+	chunks, err = repos.BlobChunks.GetByBlobID(ctx, blob2.ID.String())
 	if err != nil {
 		t.Fatalf("failed to get blob2 chunks: %v", err)
 	}

internal/database/blobs_test.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"testing"
 	"time"
+
+	"git.eeqj.de/sneak/vaultik/internal/types"
 )
 
 func TestBlobRepository(t *testing.T) {
@@ -15,8 +17,8 @@ func TestBlobRepository(t *testing.T) {
 
 	// Test Create
 	blob := &Blob{
-		ID:        "test-blob-id-123",
-		Hash:      "blobhash123",
+		ID:        types.NewBlobID(),
+		Hash:      types.BlobHash("blobhash123"),
 		CreatedTS: time.Now().Truncate(time.Second),
 	}
 
@@ -26,7 +28,7 @@ func TestBlobRepository(t *testing.T) {
 	}
 
 	// Test GetByHash
-	retrieved, err := repo.GetByHash(ctx, blob.Hash)
+	retrieved, err := repo.GetByHash(ctx, blob.Hash.String())
 	if err != nil {
 		t.Fatalf("failed to get blob: %v", err)
 	}
@@ -41,7 +43,7 @@ func TestBlobRepository(t *testing.T) {
 	}
 
 	// Test GetByID
-	retrievedByID, err := repo.GetByID(ctx, blob.ID)
+	retrievedByID, err := repo.GetByID(ctx, blob.ID.String())
 	if err != nil {
 		t.Fatalf("failed to get blob by ID: %v", err)
 	}
@@ -54,8 +56,8 @@ func TestBlobRepository(t *testing.T) {
 
 	// Test with second blob
 	blob2 := &Blob{
-		ID:        "test-blob-id-456",
-		Hash:      "blobhash456",
+		ID:        types.NewBlobID(),
+		Hash:      types.BlobHash("blobhash456"),
 		CreatedTS: time.Now().Truncate(time.Second),
 	}
 	err = repo.Create(ctx, nil, blob2)
@@ -65,13 +67,13 @@ func TestBlobRepository(t *testing.T) {
 
 	// Test UpdateFinished
 	now := time.Now()
-	err = repo.UpdateFinished(ctx, nil, blob.ID, blob.Hash, 1000, 500)
+	err = repo.UpdateFinished(ctx, nil, blob.ID.String(), blob.Hash.String(), 1000, 500)
 	if err != nil {
 		t.Fatalf("failed to update blob as finished: %v", err)
 	}
 
 	// Verify update
-	updated, err := repo.GetByID(ctx, blob.ID)
+	updated, err := repo.GetByID(ctx, blob.ID.String())
 	if err != nil {
 		t.Fatalf("failed to get updated blob: %v", err)
 	}
@@ -86,13 +88,13 @@ func TestBlobRepository(t *testing.T) {
 	}
 
 	// Test UpdateUploaded
-	err = repo.UpdateUploaded(ctx, nil, blob.ID)
+	err = repo.UpdateUploaded(ctx, nil, blob.ID.String())
 	if err != nil {
 		t.Fatalf("failed to update blob as uploaded: %v", err)
 	}
 
 	// Verify upload update
-	uploaded, err := repo.GetByID(ctx, blob.ID)
+	uploaded, err := repo.GetByID(ctx, blob.ID.String())
 	if err != nil {
 		t.Fatalf("failed to get uploaded blob: %v", err)
 	}
@@ -113,8 +115,8 @@ func TestBlobRepositoryDuplicate(t *testing.T) {
 	repo := NewBlobRepository(db)
 
 	blob := &Blob{
-		ID:        "duplicate-test-id",
-		Hash:      "duplicate_blob",
+		ID:        types.NewBlobID(),
+		Hash:      types.BlobHash("duplicate_blob"),
 		CreatedTS: time.Now().Truncate(time.Second),
 	}
 

internal/database/cascade_debug_test.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"testing"
 	"time"
+
+	"git.eeqj.de/sneak/vaultik/internal/types"
 )
 
 // TestCascadeDeleteDebug tests cascade delete with debug output
@@ -42,7 +44,7 @@ func TestCascadeDeleteDebug(t *testing.T) {
 	// Create chunks and file-chunk mappings
 	for i := 0; i < 3; i++ {
 		chunk := &Chunk{
-			ChunkHash: fmt.Sprintf("cascade-chunk-%d", i),
+			ChunkHash: types.ChunkHash(fmt.Sprintf("cascade-chunk-%d", i)),
 			Size:      1024,
 		}
 		err = repos.Chunks.Create(ctx, nil, chunk)

internal/database/chunk_files.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"database/sql"
 	"fmt"
+
+	"git.eeqj.de/sneak/vaultik/internal/types"
 )
 
 type ChunkFileRepository struct {
@@ -23,9 +25,9 @@ func (r *ChunkFileRepository) Create(ctx context.Context, tx *sql.Tx, cf *ChunkF
 
 	var err error
 	if tx != nil {
-		_, err = tx.ExecContext(ctx, query, cf.ChunkHash, cf.FileID, cf.FileOffset, cf.Length)
+		_, err = tx.ExecContext(ctx, query, cf.ChunkHash.String(), cf.FileID.String(), cf.FileOffset, cf.Length)
 	} else {
-		_, err = r.db.ExecWithLog(ctx, query, cf.ChunkHash, cf.FileID, cf.FileOffset, cf.Length)
+		_, err = r.db.ExecWithLog(ctx, query, cf.ChunkHash.String(), cf.FileID.String(), cf.FileOffset, cf.Length)
 	}
 
 	if err != nil {
@@ -35,30 +37,20 @@ func (r *ChunkFileRepository) Create(ctx context.Context, tx *sql.Tx, cf *ChunkF
 	return nil
 }
 
-func (r *ChunkFileRepository) GetByChunkHash(ctx context.Context, chunkHash string) ([]*ChunkFile, error) {
+func (r *ChunkFileRepository) GetByChunkHash(ctx context.Context, chunkHash types.ChunkHash) ([]*ChunkFile, error) {
 	query := `
 		SELECT chunk_hash, file_id, file_offset, length
 		FROM chunk_files
 		WHERE chunk_hash = ?
 	`
 
-	rows, err := r.db.conn.QueryContext(ctx, query, chunkHash)
+	rows, err := r.db.conn.QueryContext(ctx, query, chunkHash.String())
 	if err != nil {
 		return nil, fmt.Errorf("querying chunk files: %w", err)
 	}
 	defer CloseRows(rows)
 
-	var chunkFiles []*ChunkFile
-	for rows.Next() {
-		var cf ChunkFile
-		err := rows.Scan(&cf.ChunkHash, &cf.FileID, &cf.FileOffset, &cf.Length)
-		if err != nil {
-			return nil, fmt.Errorf("scanning chunk file: %w", err)
-		}
-		chunkFiles = append(chunkFiles, &cf)
-	}
-
-	return chunkFiles, rows.Err()
+	return r.scanChunkFiles(rows)
 }
 
 func (r *ChunkFileRepository) GetByFilePath(ctx context.Context, filePath string) ([]*ChunkFile, error) {
@@ -75,40 +67,41 @@ func (r *ChunkFileRepository) GetByFilePath(ctx context.Context, filePath string
 	}
 	defer CloseRows(rows)
 
-	var chunkFiles []*ChunkFile
-	for rows.Next() {
-		var cf ChunkFile
-		err := rows.Scan(&cf.ChunkHash, &cf.FileID, &cf.FileOffset, &cf.Length)
-		if err != nil {
-			return nil, fmt.Errorf("scanning chunk file: %w", err)
-		}
-		chunkFiles = append(chunkFiles, &cf)
-	}
-
-	return chunkFiles, rows.Err()
+	return r.scanChunkFiles(rows)
 }
 
 // GetByFileID retrieves chunk files by file ID
-func (r *ChunkFileRepository) GetByFileID(ctx context.Context, fileID string) ([]*ChunkFile, error) {
+func (r *ChunkFileRepository) GetByFileID(ctx context.Context, fileID types.FileID) ([]*ChunkFile, error) {
 	query := `
 		SELECT chunk_hash, file_id, file_offset, length
 		FROM chunk_files
 		WHERE file_id = ?
 	`
 
-	rows, err := r.db.conn.QueryContext(ctx, query, fileID)
+	rows, err := r.db.conn.QueryContext(ctx, query, fileID.String())
 	if err != nil {
 		return nil, fmt.Errorf("querying chunk files: %w", err)
 	}
 	defer CloseRows(rows)
 
+	return r.scanChunkFiles(rows)
+}
+
+// scanChunkFiles is a helper that scans chunk file rows
+func (r *ChunkFileRepository) scanChunkFiles(rows *sql.Rows) ([]*ChunkFile, error) {
 	var chunkFiles []*ChunkFile
 	for rows.Next() {
 		var cf ChunkFile
-		err := rows.Scan(&cf.ChunkHash, &cf.FileID, &cf.FileOffset, &cf.Length)
+		var chunkHashStr, fileIDStr string
+		err := rows.Scan(&chunkHashStr, &fileIDStr, &cf.FileOffset, &cf.Length)
 		if err != nil {
 			return nil, fmt.Errorf("scanning chunk file: %w", err)
 		}
+		cf.ChunkHash = types.ChunkHash(chunkHashStr)
+		cf.FileID, err = types.ParseFileID(fileIDStr)
+		if err != nil {
+			return nil, fmt.Errorf("parsing file ID: %w", err)
+		}
 		chunkFiles = append(chunkFiles, &cf)
 	}
 
@@ -116,14 +109,14 @@ func (r *ChunkFileRepository) GetByFileID(ctx context.Context, fileID string) ([
 }
 
 // DeleteByFileID deletes all chunk_files entries for a given file ID
-func (r *ChunkFileRepository) DeleteByFileID(ctx context.Context, tx *sql.Tx, fileID string) error {
+func (r *ChunkFileRepository) DeleteByFileID(ctx context.Context, tx *sql.Tx, fileID types.FileID) error {
 	query := `DELETE FROM chunk_files WHERE file_id = ?`
 
 	var err error
 	if tx != nil {
-		_, err = tx.ExecContext(ctx, query, fileID)
+		_, err = tx.ExecContext(ctx, query, fileID.String())
 	} else {
-		_, err = r.db.ExecWithLog(ctx, query, fileID)
+		_, err = r.db.ExecWithLog(ctx, query, fileID.String())
 	}
 
 	if err != nil {
@@ -134,7 +127,7 @@ func (r *ChunkFileRepository) DeleteByFileID(ctx context.Context, tx *sql.Tx, fi
 }
 
 // DeleteByFileIDs deletes all chunk_files for multiple files in a single statement.
-func (r *ChunkFileRepository) DeleteByFileIDs(ctx context.Context, tx *sql.Tx, fileIDs []string) error {
+func (r *ChunkFileRepository) DeleteByFileIDs(ctx context.Context, tx *sql.Tx, fileIDs []types.FileID) error {
 	if len(fileIDs) == 0 {
 		return nil
 	}
@@ -152,7 +145,7 @@ func (r *ChunkFileRepository) DeleteByFileIDs(ctx context.Context, tx *sql.Tx, f
 		query := "DELETE FROM chunk_files WHERE file_id IN (?" + repeatPlaceholder(len(batch)-1) + ")"
 		args := make([]interface{}, len(batch))
 		for j, id := range batch {
-			args[j] = id
+			args[j] = id.String()
 		}
 
 		var err error
@@ -192,7 +185,7 @@ func (r *ChunkFileRepository) CreateBatch(ctx context.Context, tx *sql.Tx, cfs [
 				query += ", "
 			}
 			query += "(?, ?, ?, ?)"
-			args = append(args, cf.ChunkHash, cf.FileID, cf.FileOffset, cf.Length)
+			args = append(args, cf.ChunkHash.String(), cf.FileID.String(), cf.FileOffset, cf.Length)
 		}
 		query += " ON CONFLICT(chunk_hash, file_id) DO NOTHING"
 

internal/database/chunk_files_test.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"testing"
 	"time"
+
+	"git.eeqj.de/sneak/vaultik/internal/types"
 )
 
 func TestChunkFileRepository(t *testing.T) {
@@ -49,7 +51,7 @@ func TestChunkFileRepository(t *testing.T) {
 
 	// Create chunk first
 	chunk := &Chunk{
-		ChunkHash: "chunk1",
+		ChunkHash: types.ChunkHash("chunk1"),
 		Size:      1024,
 	}
 	err = chunksRepo.Create(ctx, nil, chunk)
@@ -59,7 +61,7 @@ func TestChunkFileRepository(t *testing.T) {
 
 	// Test Create
 	cf1 := &ChunkFile{
-		ChunkHash:  "chunk1",
+		ChunkHash:  types.ChunkHash("chunk1"),
 		FileID:     file1.ID,
 		FileOffset: 0,
 		Length:     1024,
@@ -72,7 +74,7 @@ func TestChunkFileRepository(t *testing.T) {
 
 	// Add same chunk in different file (deduplication scenario)
 	cf2 := &ChunkFile{
-		ChunkHash:  "chunk1",
+		ChunkHash:  types.ChunkHash("chunk1"),
 		FileID:     file2.ID,
 		FileOffset: 2048,
 		Length:     1024,
@@ -114,7 +116,7 @@ func TestChunkFileRepository(t *testing.T) {
 	if len(chunkFiles) != 1 {
 		t.Errorf("expected 1 chunk for file, got %d", len(chunkFiles))
 	}
-	if chunkFiles[0].ChunkHash != "chunk1" {
+	if chunkFiles[0].ChunkHash != types.ChunkHash("chunk1") {
 		t.Errorf("wrong chunk hash: expected chunk1, got %s", chunkFiles[0].ChunkHash)
 	}
 
@@ -151,7 +153,7 @@ func TestChunkFileRepositoryComplexDeduplication(t *testing.T) {
 	}
 
 	// Create chunks first
-	chunks := []string{"chunk1", "chunk2", "chunk3", "chunk4"}
+	chunks := []types.ChunkHash{"chunk1", "chunk2", "chunk3", "chunk4"}
 	for _, chunkHash := range chunks {
 		chunk := &Chunk{
 			ChunkHash: chunkHash,
@@ -170,16 +172,16 @@ func TestChunkFileRepositoryComplexDeduplication(t *testing.T) {
 
 	chunkFiles := []ChunkFile{
 		// File1
-		{ChunkHash: "chunk1", FileID: file1.ID, FileOffset: 0, Length: 1024},
-		{ChunkHash: "chunk2", FileID: file1.ID, FileOffset: 1024, Length: 1024},
-		{ChunkHash: "chunk3", FileID: file1.ID, FileOffset: 2048, Length: 1024},
+		{ChunkHash: types.ChunkHash("chunk1"), FileID: file1.ID, FileOffset: 0, Length: 1024},
+		{ChunkHash: types.ChunkHash("chunk2"), FileID: file1.ID, FileOffset: 1024, Length: 1024},
+		{ChunkHash: types.ChunkHash("chunk3"), FileID: file1.ID, FileOffset: 2048, Length: 1024},
 		// File2
-		{ChunkHash: "chunk2", FileID: file2.ID, FileOffset: 0, Length: 1024},
-		{ChunkHash: "chunk3", FileID: file2.ID, FileOffset: 1024, Length: 1024},
-		{ChunkHash: "chunk4", FileID: file2.ID, FileOffset: 2048, Length: 1024},
+		{ChunkHash: types.ChunkHash("chunk2"), FileID: file2.ID, FileOffset: 0, Length: 1024},
+		{ChunkHash: types.ChunkHash("chunk3"), FileID: file2.ID, FileOffset: 1024, Length: 1024},
+		{ChunkHash: types.ChunkHash("chunk4"), FileID: file2.ID, FileOffset: 2048, Length: 1024},
 		// File3
-		{ChunkHash: "chunk1", FileID: file3.ID, FileOffset: 0, Length: 1024},
-		{ChunkHash: "chunk4", FileID: file3.ID, FileOffset: 1024, Length: 1024},
+		{ChunkHash: types.ChunkHash("chunk1"), FileID: file3.ID, FileOffset: 0, Length: 1024},
+		{ChunkHash: types.ChunkHash("chunk4"), FileID: file3.ID, FileOffset: 1024, Length: 1024},
 	}
 
 	for _, cf := range chunkFiles {

internal/database/chunks_test.go

@@ -3,6 +3,8 @@ package database
 import (
 	"context"
 	"testing"
+
+	"git.eeqj.de/sneak/vaultik/internal/types"
 )
 
 func TestChunkRepository(t *testing.T) {
@@ -14,7 +16,7 @@ func TestChunkRepository(t *testing.T) {
 
 	// Test Create
 	chunk := &Chunk{
-		ChunkHash: "chunkhash123",
+		ChunkHash: types.ChunkHash("chunkhash123"),
 		Size:      4096,
 	}
 
@@ -24,7 +26,7 @@ func TestChunkRepository(t *testing.T) {
 	}
 
 	// Test GetByHash
-	retrieved, err := repo.GetByHash(ctx, chunk.ChunkHash)
+	retrieved, err := repo.GetByHash(ctx, chunk.ChunkHash.String())
 	if err != nil {
 		t.Fatalf("failed to get chunk: %v", err)
 	}
@@ -46,7 +48,7 @@ func TestChunkRepository(t *testing.T) {
 
 	// Test GetByHashes
 	chunk2 := &Chunk{
-		ChunkHash: "chunkhash456",
+		ChunkHash: types.ChunkHash("chunkhash456"),
 		Size:      8192,
 	}
 	err = repo.Create(ctx, nil, chunk2)
@@ -54,7 +56,7 @@ func TestChunkRepository(t *testing.T) {
 		t.Fatalf("failed to create second chunk: %v", err)
 	}
 
-	chunks, err := repo.GetByHashes(ctx, []string{chunk.ChunkHash, chunk2.ChunkHash})
+	chunks, err := repo.GetByHashes(ctx, []string{chunk.ChunkHash.String(), chunk2.ChunkHash.String()})
 	if err != nil {
 		t.Fatalf("failed to get chunks by hashes: %v", err)
 	}

internal/database/database.go

@@ -154,6 +154,11 @@ func (db *DB) Conn() *sql.DB {
 	return db.conn
 }
 
+// Path returns the path to the database file.
+func (db *DB) Path() string {
+	return db.path
+}
+
 // BeginTx starts a new database transaction with the given options.
 // The caller is responsible for committing or rolling back the transaction.
 // For write transactions, consider using the Repositories.WithTx method instead,

internal/database/file_chunks.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"database/sql"
 	"fmt"
+
+	"git.eeqj.de/sneak/vaultik/internal/types"
 )
 
 type FileChunkRepository struct {
@@ -23,9 +25,9 @@ func (r *FileChunkRepository) Create(ctx context.Context, tx *sql.Tx, fc *FileCh
 
 	var err error
 	if tx != nil {
-		_, err = tx.ExecContext(ctx, query, fc.FileID, fc.Idx, fc.ChunkHash)
+		_, err = tx.ExecContext(ctx, query, fc.FileID.String(), fc.Idx, fc.ChunkHash.String())
 	} else {
-		_, err = r.db.ExecWithLog(ctx, query, fc.FileID, fc.Idx, fc.ChunkHash)
+		_, err = r.db.ExecWithLog(ctx, query, fc.FileID.String(), fc.Idx, fc.ChunkHash.String())
 	}
 
 	if err != nil {
@@ -50,21 +52,11 @@ func (r *FileChunkRepository) GetByPath(ctx context.Context, path string) ([]*Fi
 	}
 	defer CloseRows(rows)
 
-	var fileChunks []*FileChunk
-	for rows.Next() {
-		var fc FileChunk
-		err := rows.Scan(&fc.FileID, &fc.Idx, &fc.ChunkHash)
-		if err != nil {
-			return nil, fmt.Errorf("scanning file chunk: %w", err)
-		}
-		fileChunks = append(fileChunks, &fc)
-	}
-
-	return fileChunks, rows.Err()
+	return r.scanFileChunks(rows)
 }
 
 // GetByFileID retrieves file chunks by file ID
-func (r *FileChunkRepository) GetByFileID(ctx context.Context, fileID string) ([]*FileChunk, error) {
+func (r *FileChunkRepository) GetByFileID(ctx context.Context, fileID types.FileID) ([]*FileChunk, error) {
 	query := `
 		SELECT file_id, idx, chunk_hash
 		FROM file_chunks
@@ -72,23 +64,13 @@ func (r *FileChunkRepository) GetByFileID(ctx context.Context, fileID string) ([
 		ORDER BY idx
 	`
 
-	rows, err := r.db.conn.QueryContext(ctx, query, fileID)
+	rows, err := r.db.conn.QueryContext(ctx, query, fileID.String())
 	if err != nil {
 		return nil, fmt.Errorf("querying file chunks: %w", err)
 	}
 	defer CloseRows(rows)
 
-	var fileChunks []*FileChunk
-	for rows.Next() {
-		var fc FileChunk
-		err := rows.Scan(&fc.FileID, &fc.Idx, &fc.ChunkHash)
-		if err != nil {
-			return nil, fmt.Errorf("scanning file chunk: %w", err)
-		}
-		fileChunks = append(fileChunks, &fc)
-	}
-
-	return fileChunks, rows.Err()
+	return r.scanFileChunks(rows)
 }
 
 // GetByPathTx retrieves file chunks within a transaction
@@ -108,16 +90,28 @@ func (r *FileChunkRepository) GetByPathTx(ctx context.Context, tx *sql.Tx, path
 	}
 	defer CloseRows(rows)
 
+	fileChunks, err := r.scanFileChunks(rows)
+	LogSQL("GetByPathTx", "Complete", path, "count", len(fileChunks))
+	return fileChunks, err
+}
+
+// scanFileChunks is a helper that scans file chunk rows
+func (r *FileChunkRepository) scanFileChunks(rows *sql.Rows) ([]*FileChunk, error) {
 	var fileChunks []*FileChunk
 	for rows.Next() {
 		var fc FileChunk
-		err := rows.Scan(&fc.FileID, &fc.Idx, &fc.ChunkHash)
+		var fileIDStr, chunkHashStr string
+		err := rows.Scan(&fileIDStr, &fc.Idx, &chunkHashStr)
 		if err != nil {
 			return nil, fmt.Errorf("scanning file chunk: %w", err)
 		}
+		fc.FileID, err = types.ParseFileID(fileIDStr)
+		if err != nil {
+			return nil, fmt.Errorf("parsing file ID: %w", err)
+		}
+		fc.ChunkHash = types.ChunkHash(chunkHashStr)
 		fileChunks = append(fileChunks, &fc)
 	}
-	LogSQL("GetByPathTx", "Complete", path, "count", len(fileChunks))
 
 	return fileChunks, rows.Err()
 }
@@ -140,14 +134,14 @@ func (r *FileChunkRepository) DeleteByPath(ctx context.Context, tx *sql.Tx, path
 }
 
 // DeleteByFileID deletes all chunks for a file by its UUID
-func (r *FileChunkRepository) DeleteByFileID(ctx context.Context, tx *sql.Tx, fileID string) error {
+func (r *FileChunkRepository) DeleteByFileID(ctx context.Context, tx *sql.Tx, fileID types.FileID) error {
 	query := `DELETE FROM file_chunks WHERE file_id = ?`
 
 	var err error
 	if tx != nil {
-		_, err = tx.ExecContext(ctx, query, fileID)
+		_, err = tx.ExecContext(ctx, query, fileID.String())
 	} else {
-		_, err = r.db.ExecWithLog(ctx, query, fileID)
+		_, err = r.db.ExecWithLog(ctx, query, fileID.String())
 	}
 
 	if err != nil {
@@ -158,7 +152,7 @@ func (r *FileChunkRepository) DeleteByFileID(ctx context.Context, tx *sql.Tx, fi
 }
 
 // DeleteByFileIDs deletes all chunks for multiple files in a single statement.
-func (r *FileChunkRepository) DeleteByFileIDs(ctx context.Context, tx *sql.Tx, fileIDs []string) error {
+func (r *FileChunkRepository) DeleteByFileIDs(ctx context.Context, tx *sql.Tx, fileIDs []types.FileID) error {
 	if len(fileIDs) == 0 {
 		return nil
 	}
@@ -176,7 +170,7 @@ func (r *FileChunkRepository) DeleteByFileIDs(ctx context.Context, tx *sql.Tx, f
 		query := "DELETE FROM file_chunks WHERE file_id IN (?" + repeatPlaceholder(len(batch)-1) + ")"
 		args := make([]interface{}, len(batch))
 		for j, id := range batch {
-			args[j] = id
+			args[j] = id.String()
 		}
 
 		var err error
@@ -219,7 +213,7 @@ func (r *FileChunkRepository) CreateBatch(ctx context.Context, tx *sql.Tx, fcs [
 				query += ", "
 			}
 			query += "(?, ?, ?)"
-			args = append(args, fc.FileID, fc.Idx, fc.ChunkHash)
+			args = append(args, fc.FileID.String(), fc.Idx, fc.ChunkHash.String())
 		}
 		query += " ON CONFLICT(file_id, idx) DO NOTHING"
 

internal/database/file_chunks_test.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"testing"
 	"time"
+
+	"git.eeqj.de/sneak/vaultik/internal/types"
 )
 
 func TestFileChunkRepository(t *testing.T) {
@@ -33,7 +35,7 @@ func TestFileChunkRepository(t *testing.T) {
 	}
 
 	// Create chunks first
-	chunks := []string{"chunk1", "chunk2", "chunk3"}
+	chunks := []types.ChunkHash{"chunk1", "chunk2", "chunk3"}
 	chunkRepo := NewChunkRepository(db)
 	for _, chunkHash := range chunks {
 		chunk := &Chunk{
@@ -50,7 +52,7 @@ func TestFileChunkRepository(t *testing.T) {
 	fc1 := &FileChunk{
 		FileID:    file.ID,
 		Idx:       0,
-		ChunkHash: "chunk1",
+		ChunkHash: types.ChunkHash("chunk1"),
 	}
 
 	err = repo.Create(ctx, nil, fc1)
@@ -62,7 +64,7 @@ func TestFileChunkRepository(t *testing.T) {
 	fc2 := &FileChunk{
 		FileID:    file.ID,
 		Idx:       1,
-		ChunkHash: "chunk2",
+		ChunkHash: types.ChunkHash("chunk2"),
 	}
 	err = repo.Create(ctx, nil, fc2)
 	if err != nil {
@@ -72,7 +74,7 @@ func TestFileChunkRepository(t *testing.T) {
 	fc3 := &FileChunk{
 		FileID:    file.ID,
 		Idx:       2,
-		ChunkHash: "chunk3",
+		ChunkHash: types.ChunkHash("chunk3"),
 	}
 	err = repo.Create(ctx, nil, fc3)
 	if err != nil {
@@ -131,7 +133,7 @@ func TestFileChunkRepositoryMultipleFiles(t *testing.T) {
 
 	for i, path := range filePaths {
 		file := &File{
-			Path:       path,
+			Path:       types.FilePath(path),
 			MTime:      testTime,
 			CTime:      testTime,
 			Size:       2048,
@@ -151,7 +153,7 @@ func TestFileChunkRepositoryMultipleFiles(t *testing.T) {
 	chunkRepo := NewChunkRepository(db)
 	for i := range files {
 		for j := 0; j < 2; j++ {
-			chunkHash := fmt.Sprintf("file%d_chunk%d", i, j)
+			chunkHash := types.ChunkHash(fmt.Sprintf("file%d_chunk%d", i, j))
 			chunk := &Chunk{
 				ChunkHash: chunkHash,
 				Size:      1024,
@@ -169,7 +171,7 @@ func TestFileChunkRepositoryMultipleFiles(t *testing.T) {
 			fc := &FileChunk{
 				FileID:    file.ID,
 				Idx:       j,
-				ChunkHash: fmt.Sprintf("file%d_chunk%d", i, j),
+				ChunkHash: types.ChunkHash(fmt.Sprintf("file%d_chunk%d", i, j)),
 			}
 			err := repo.Create(ctx, nil, fc)
 			if err != nil {

internal/database/files.go

@@ -7,7 +7,7 @@ import (
 	"time"
 
 	"git.eeqj.de/sneak/vaultik/internal/log"
-	"github.com/google/uuid"
+	"git.eeqj.de/sneak/vaultik/internal/types"
 )
 
 type FileRepository struct {
@@ -20,14 +20,15 @@ func NewFileRepository(db *DB) *FileRepository {
 
 func (r *FileRepository) Create(ctx context.Context, tx *sql.Tx, file *File) error {
 	// Generate UUID if not provided
-	if file.ID == "" {
-		file.ID = uuid.New().String()
+	if file.ID.IsZero() {
+		file.ID = types.NewFileID()
 	}
 
 	query := `
-		INSERT INTO files (id, path, mtime, ctime, size, mode, uid, gid, link_target)
-		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+		INSERT INTO files (id, path, source_path, mtime, ctime, size, mode, uid, gid, link_target)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
 		ON CONFLICT(path) DO UPDATE SET
+			source_path = excluded.source_path,
 			mtime = excluded.mtime,
 			ctime = excluded.ctime,
 			size = excluded.size,
@@ -38,44 +39,36 @@ func (r *FileRepository) Create(ctx context.Context, tx *sql.Tx, file *File) err
 		RETURNING id
 	`
 
+	var idStr string
 	var err error
 	if tx != nil {
-		LogSQL("Execute", query, file.ID, file.Path, file.MTime.Unix(), file.CTime.Unix(), file.Size, file.Mode, file.UID, file.GID, file.LinkTarget)
-		err = tx.QueryRowContext(ctx, query, file.ID, file.Path, file.MTime.Unix(), file.CTime.Unix(), file.Size, file.Mode, file.UID, file.GID, file.LinkTarget).Scan(&file.ID)
+		LogSQL("Execute", query, file.ID.String(), file.Path.String(), file.SourcePath.String(), file.MTime.Unix(), file.CTime.Unix(), file.Size, file.Mode, file.UID, file.GID, file.LinkTarget.String())
+		err = tx.QueryRowContext(ctx, query, file.ID.String(), file.Path.String(), file.SourcePath.String(), file.MTime.Unix(), file.CTime.Unix(), file.Size, file.Mode, file.UID, file.GID, file.LinkTarget.String()).Scan(&idStr)
 	} else {
-		err = r.db.QueryRowWithLog(ctx, query, file.ID, file.Path, file.MTime.Unix(), file.CTime.Unix(), file.Size, file.Mode, file.UID, file.GID, file.LinkTarget).Scan(&file.ID)
+		err = r.db.QueryRowWithLog(ctx, query, file.ID.String(), file.Path.String(), file.SourcePath.String(), file.MTime.Unix(), file.CTime.Unix(), file.Size, file.Mode, file.UID, file.GID, file.LinkTarget.String()).Scan(&idStr)
 	}
 
 	if err != nil {
 		return fmt.Errorf("inserting file: %w", err)
 	}
 
+	// Parse the returned ID
+	file.ID, err = types.ParseFileID(idStr)
+	if err != nil {
+		return fmt.Errorf("parsing file ID: %w", err)
+	}
+
 	return nil
 }
 
 func (r *FileRepository) GetByPath(ctx context.Context, path string) (*File, error) {
 	query := `
-		SELECT id, path, mtime, ctime, size, mode, uid, gid, link_target
+		SELECT id, path, source_path, mtime, ctime, size, mode, uid, gid, link_target
 		FROM files
 		WHERE path = ?
 	`
 
-	var file File
-	var mtimeUnix, ctimeUnix int64
-	var linkTarget sql.NullString
-
-	err := r.db.conn.QueryRowContext(ctx, query, path).Scan(
-		&file.ID,
-		&file.Path,
-		&mtimeUnix,
-		&ctimeUnix,
-		&file.Size,
-		&file.Mode,
-		&file.UID,
-		&file.GID,
-		&linkTarget,
-	)
-
+	file, err := r.scanFile(r.db.conn.QueryRowContext(ctx, query, path))
 	if err == sql.ErrNoRows {
 		return nil, nil
 	}
@@ -83,39 +76,18 @@ func (r *FileRepository) GetByPath(ctx context.Context, path string) (*File, err
 		return nil, fmt.Errorf("querying file: %w", err)
 	}
 
-	file.MTime = time.Unix(mtimeUnix, 0).UTC()
-	file.CTime = time.Unix(ctimeUnix, 0).UTC()
-	if linkTarget.Valid {
-		file.LinkTarget = linkTarget.String
-	}
-
-	return &file, nil
+	return file, nil
 }
 
 // GetByID retrieves a file by its UUID
-func (r *FileRepository) GetByID(ctx context.Context, id string) (*File, error) {
+func (r *FileRepository) GetByID(ctx context.Context, id types.FileID) (*File, error) {
 	query := `
-		SELECT id, path, mtime, ctime, size, mode, uid, gid, link_target
+		SELECT id, path, source_path, mtime, ctime, size, mode, uid, gid, link_target
 		FROM files
 		WHERE id = ?
 	`
 
-	var file File
-	var mtimeUnix, ctimeUnix int64
-	var linkTarget sql.NullString
-
-	err := r.db.conn.QueryRowContext(ctx, query, id).Scan(
-		&file.ID,
-		&file.Path,
-		&mtimeUnix,
-		&ctimeUnix,
-		&file.Size,
-		&file.Mode,
-		&file.UID,
-		&file.GID,
-		&linkTarget,
-	)
-
+	file, err := r.scanFile(r.db.conn.QueryRowContext(ctx, query, id.String()))
 	if err == sql.ErrNoRows {
 		return nil, nil
 	}
@@ -123,38 +95,18 @@ func (r *FileRepository) GetByID(ctx context.Context, id string) (*File, error)
 		return nil, fmt.Errorf("querying file: %w", err)
 	}
 
-	file.MTime = time.Unix(mtimeUnix, 0).UTC()
-	file.CTime = time.Unix(ctimeUnix, 0).UTC()
-	if linkTarget.Valid {
-		file.LinkTarget = linkTarget.String
-	}
-
-	return &file, nil
+	return file, nil
 }
 
 func (r *FileRepository) GetByPathTx(ctx context.Context, tx *sql.Tx, path string) (*File, error) {
 	query := `
-		SELECT id, path, mtime, ctime, size, mode, uid, gid, link_target
+		SELECT id, path, source_path, mtime, ctime, size, mode, uid, gid, link_target
 		FROM files
 		WHERE path = ?
 	`
 
-	var file File
-	var mtimeUnix, ctimeUnix int64
-	var linkTarget sql.NullString
-
 	LogSQL("GetByPathTx QueryRowContext", query, path)
-	err := tx.QueryRowContext(ctx, query, path).Scan(
-		&file.ID,
-		&file.Path,
-		&mtimeUnix,
-		&ctimeUnix,
-		&file.Size,
-		&file.Mode,
-		&file.UID,
-		&file.GID,
-		&linkTarget,
-	)
+	file, err := r.scanFile(tx.QueryRowContext(ctx, query, path))
 	LogSQL("GetByPathTx Scan complete", query, path)
 
 	if err == sql.ErrNoRows {
@@ -164,10 +116,80 @@ func (r *FileRepository) GetByPathTx(ctx context.Context, tx *sql.Tx, path strin
 		return nil, fmt.Errorf("querying file: %w", err)
 	}
 
+	return file, nil
+}
+
+// scanFile is a helper that scans a single file row
+func (r *FileRepository) scanFile(row *sql.Row) (*File, error) {
+	var file File
+	var idStr, pathStr, sourcePathStr string
+	var mtimeUnix, ctimeUnix int64
+	var linkTarget sql.NullString
+
+	err := row.Scan(
+		&idStr,
+		&pathStr,
+		&sourcePathStr,
+		&mtimeUnix,
+		&ctimeUnix,
+		&file.Size,
+		&file.Mode,
+		&file.UID,
+		&file.GID,
+		&linkTarget,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	file.ID, err = types.ParseFileID(idStr)
+	if err != nil {
+		return nil, fmt.Errorf("parsing file ID: %w", err)
+	}
+	file.Path = types.FilePath(pathStr)
+	file.SourcePath = types.SourcePath(sourcePathStr)
 	file.MTime = time.Unix(mtimeUnix, 0).UTC()
 	file.CTime = time.Unix(ctimeUnix, 0).UTC()
 	if linkTarget.Valid {
-		file.LinkTarget = linkTarget.String
+		file.LinkTarget = types.FilePath(linkTarget.String)
+	}
+
+	return &file, nil
+}
+
+// scanFileRows is a helper that scans a file row from rows iterator
+func (r *FileRepository) scanFileRows(rows *sql.Rows) (*File, error) {
+	var file File
+	var idStr, pathStr, sourcePathStr string
+	var mtimeUnix, ctimeUnix int64
+	var linkTarget sql.NullString
+
+	err := rows.Scan(
+		&idStr,
+		&pathStr,
+		&sourcePathStr,
+		&mtimeUnix,
+		&ctimeUnix,
+		&file.Size,
+		&file.Mode,
+		&file.UID,
+		&file.GID,
+		&linkTarget,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	file.ID, err = types.ParseFileID(idStr)
+	if err != nil {
+		return nil, fmt.Errorf("parsing file ID: %w", err)
+	}
+	file.Path = types.FilePath(pathStr)
+	file.SourcePath = types.SourcePath(sourcePathStr)
+	file.MTime = time.Unix(mtimeUnix, 0).UTC()
+	file.CTime = time.Unix(ctimeUnix, 0).UTC()
+	if linkTarget.Valid {
+		file.LinkTarget = types.FilePath(linkTarget.String)
 	}
 
 	return &file, nil
@@ -175,7 +197,7 @@ func (r *FileRepository) GetByPathTx(ctx context.Context, tx *sql.Tx, path strin
 
 func (r *FileRepository) ListModifiedSince(ctx context.Context, since time.Time) ([]*File, error) {
 	query := `
-		SELECT id, path, mtime, ctime, size, mode, uid, gid, link_target
+		SELECT id, path, source_path, mtime, ctime, size, mode, uid, gid, link_target
 		FROM files
 		WHERE mtime >= ?
 		ORDER BY path
@@ -189,32 +211,11 @@ func (r *FileRepository) ListModifiedSince(ctx context.Context, since time.Time)
 
 	var files []*File
 	for rows.Next() {
-		var file File
-		var mtimeUnix, ctimeUnix int64
-		var linkTarget sql.NullString
-
-		err := rows.Scan(
-			&file.ID,
-			&file.Path,
-			&mtimeUnix,
-			&ctimeUnix,
-			&file.Size,
-			&file.Mode,
-			&file.UID,
-			&file.GID,
-			&linkTarget,
-		)
+		file, err := r.scanFileRows(rows)
 		if err != nil {
 			return nil, fmt.Errorf("scanning file: %w", err)
 		}
-
-		file.MTime = time.Unix(mtimeUnix, 0)
-		file.CTime = time.Unix(ctimeUnix, 0)
-		if linkTarget.Valid {
-			file.LinkTarget = linkTarget.String
-		}
-
-		files = append(files, &file)
+		files = append(files, file)
 	}
 
 	return files, rows.Err()
@@ -238,14 +239,14 @@ func (r *FileRepository) Delete(ctx context.Context, tx *sql.Tx, path string) er
 }
 
 // DeleteByID deletes a file by its UUID
-func (r *FileRepository) DeleteByID(ctx context.Context, tx *sql.Tx, id string) error {
+func (r *FileRepository) DeleteByID(ctx context.Context, tx *sql.Tx, id types.FileID) error {
 	query := `DELETE FROM files WHERE id = ?`
 
 	var err error
 	if tx != nil {
-		_, err = tx.ExecContext(ctx, query, id)
+		_, err = tx.ExecContext(ctx, query, id.String())
 	} else {
-		_, err = r.db.ExecWithLog(ctx, query, id)
+		_, err = r.db.ExecWithLog(ctx, query, id.String())
 	}
 
 	if err != nil {
@@ -257,7 +258,7 @@ func (r *FileRepository) DeleteByID(ctx context.Context, tx *sql.Tx, id string)
 
 func (r *FileRepository) ListByPrefix(ctx context.Context, prefix string) ([]*File, error) {
 	query := `
-		SELECT id, path, mtime, ctime, size, mode, uid, gid, link_target
+		SELECT id, path, source_path, mtime, ctime, size, mode, uid, gid, link_target
 		FROM files
 		WHERE path LIKE ? || '%'
 		ORDER BY path
@@ -271,32 +272,37 @@ func (r *FileRepository) ListByPrefix(ctx context.Context, prefix string) ([]*Fi
 
 	var files []*File
 	for rows.Next() {
-		var file File
-		var mtimeUnix, ctimeUnix int64
-		var linkTarget sql.NullString
-
-		err := rows.Scan(
-			&file.ID,
-			&file.Path,
-			&mtimeUnix,
-			&ctimeUnix,
-			&file.Size,
-			&file.Mode,
-			&file.UID,
-			&file.GID,
-			&linkTarget,
-		)
+		file, err := r.scanFileRows(rows)
 		if err != nil {
 			return nil, fmt.Errorf("scanning file: %w", err)
 		}
+		files = append(files, file)
+	}
 
-		file.MTime = time.Unix(mtimeUnix, 0)
-		file.CTime = time.Unix(ctimeUnix, 0)
-		if linkTarget.Valid {
-			file.LinkTarget = linkTarget.String
+	return files, rows.Err()
+}
+
+// ListAll returns all files in the database
+func (r *FileRepository) ListAll(ctx context.Context) ([]*File, error) {
+	query := `
+		SELECT id, path, source_path, mtime, ctime, size, mode, uid, gid, link_target
+		FROM files
+		ORDER BY path
+	`
+
+	rows, err := r.db.conn.QueryContext(ctx, query)
+	if err != nil {
+		return nil, fmt.Errorf("querying files: %w", err)
+	}
+	defer CloseRows(rows)
+
+	var files []*File
+	for rows.Next() {
+		file, err := r.scanFileRows(rows)
+		if err != nil {
+			return nil, fmt.Errorf("scanning file: %w", err)
 		}
-
-		files = append(files, &file)
+		files = append(files, file)
 	}
 
 	return files, rows.Err()
@@ -309,7 +315,7 @@ func (r *FileRepository) CreateBatch(ctx context.Context, tx *sql.Tx, files []*F
 		return nil
 	}
 
-	// Each File has 9 values, so batch at 100 to be safe with SQLite's variable limit
+	// Each File has 10 values, so batch at 100 to be safe with SQLite's variable limit
 	const batchSize = 100
 
 	for i := 0; i < len(files); i += batchSize {
@@ -319,16 +325,17 @@ func (r *FileRepository) CreateBatch(ctx context.Context, tx *sql.Tx, files []*F
 		}
 		batch := files[i:end]
 
-		query := `INSERT INTO files (id, path, mtime, ctime, size, mode, uid, gid, link_target) VALUES `
-		args := make([]interface{}, 0, len(batch)*9)
+		query := `INSERT INTO files (id, path, source_path, mtime, ctime, size, mode, uid, gid, link_target) VALUES `
+		args := make([]interface{}, 0, len(batch)*10)
 		for j, f := range batch {
 			if j > 0 {
 				query += ", "
 			}
-			query += "(?, ?, ?, ?, ?, ?, ?, ?, ?)"
-			args = append(args, f.ID, f.Path, f.MTime.Unix(), f.CTime.Unix(), f.Size, f.Mode, f.UID, f.GID, f.LinkTarget)
+			query += "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
+			args = append(args, f.ID.String(), f.Path.String(), f.SourcePath.String(), f.MTime.Unix(), f.CTime.Unix(), f.Size, f.Mode, f.UID, f.GID, f.LinkTarget.String())
 		}
 		query += ` ON CONFLICT(path) DO UPDATE SET
+			source_path = excluded.source_path,
 			mtime = excluded.mtime,
 			ctime = excluded.ctime,
 			size = excluded.size,
@@ -354,9 +361,9 @@ func (r *FileRepository) CreateBatch(ctx context.Context, tx *sql.Tx, files []*F
 // DeleteOrphaned deletes files that are not referenced by any snapshot
 func (r *FileRepository) DeleteOrphaned(ctx context.Context) error {
 	query := `
-		DELETE FROM files 
+		DELETE FROM files
 		WHERE NOT EXISTS (
-			SELECT 1 FROM snapshot_files 
+			SELECT 1 FROM snapshot_files
 			WHERE snapshot_files.file_id = files.id
 		)
 	`

internal/database/files_test.go

@@ -53,7 +53,7 @@ func TestFileRepository(t *testing.T) {
 	}
 
 	// Test GetByPath
-	retrieved, err := repo.GetByPath(ctx, file.Path)
+	retrieved, err := repo.GetByPath(ctx, file.Path.String())
 	if err != nil {
 		t.Fatalf("failed to get file: %v", err)
 	}
@@ -81,7 +81,7 @@ func TestFileRepository(t *testing.T) {
 		t.Fatalf("failed to update file: %v", err)
 	}
 
-	retrieved, err = repo.GetByPath(ctx, file.Path)
+	retrieved, err = repo.GetByPath(ctx, file.Path.String())
 	if err != nil {
 		t.Fatalf("failed to get updated file: %v", err)
 	}
@@ -99,12 +99,12 @@ func TestFileRepository(t *testing.T) {
 	}
 
 	// Test Delete
-	err = repo.Delete(ctx, nil, file.Path)
+	err = repo.Delete(ctx, nil, file.Path.String())
 	if err != nil {
 		t.Fatalf("failed to delete file: %v", err)
 	}
 
-	retrieved, err = repo.GetByPath(ctx, file.Path)
+	retrieved, err = repo.GetByPath(ctx, file.Path.String())
 	if err != nil {
 		t.Fatalf("error getting deleted file: %v", err)
 	}
@@ -137,7 +137,7 @@ func TestFileRepositorySymlink(t *testing.T) {
 		t.Fatalf("failed to create symlink: %v", err)
 	}
 
-	retrieved, err := repo.GetByPath(ctx, symlink.Path)
+	retrieved, err := repo.GetByPath(ctx, symlink.Path.String())
 	if err != nil {
 		t.Fatalf("failed to get symlink: %v", err)
 	}

internal/database/models.go

@@ -2,22 +2,27 @@
 // It includes types for files, chunks, blobs, snapshots, and their relationships.
 package database
 
-import "time"
+import (
+	"time"
+
+	"git.eeqj.de/sneak/vaultik/internal/types"
+)
 
 // File represents a file or directory in the backup system.
 // It stores metadata about files including timestamps, permissions, ownership,
 // and symlink targets. This information is used to restore files with their
 // original attributes.
 type File struct {
-	ID         string // UUID primary key
-	Path       string
+	ID         types.FileID     // UUID primary key
+	Path       types.FilePath   // Absolute path of the file
+	SourcePath types.SourcePath // The source directory this file came from (for restore path stripping)
 	MTime      time.Time
 	CTime      time.Time
 	Size       int64
 	Mode       uint32
 	UID        uint32
 	GID        uint32
-	LinkTarget string // empty for regular files, target path for symlinks
+	LinkTarget types.FilePath // empty for regular files, target path for symlinks
 }
 
 // IsSymlink returns true if this file is a symbolic link.
@@ -30,16 +35,16 @@ func (f *File) IsSymlink() bool {
 // Large files are split into multiple chunks for efficient deduplication and storage.
 // The Idx field maintains the order of chunks within a file.
 type FileChunk struct {
-	FileID    string
+	FileID    types.FileID
 	Idx       int
-	ChunkHash string
+	ChunkHash types.ChunkHash
 }
 
 // Chunk represents a data chunk in the deduplication system.
 // Files are split into chunks which are content-addressed by their hash.
 // The ChunkHash is the SHA256 hash of the chunk content, used for deduplication.
 type Chunk struct {
-	ChunkHash string
+	ChunkHash types.ChunkHash
 	Size      int64
 }
 
@@ -51,13 +56,13 @@ type Chunk struct {
 // The blob creation process is: chunks are accumulated -> compressed with zstd
 // -> encrypted with age -> hashed -> uploaded to S3 with the hash as filename.
 type Blob struct {
-	ID               string     // UUID assigned when blob creation starts
-	Hash             string     // SHA256 of final compressed+encrypted content (empty until finalized)
-	CreatedTS        time.Time  // When blob creation started
-	FinishedTS       *time.Time // When blob was finalized (nil if still packing)
-	UncompressedSize int64      // Total size of raw chunks before compression
-	CompressedSize   int64      // Size after compression and encryption
-	UploadedTS       *time.Time // When blob was uploaded to S3 (nil if not uploaded)
+	ID               types.BlobID   // UUID assigned when blob creation starts
+	Hash             types.BlobHash // SHA256 of final compressed+encrypted content (empty until finalized)
+	CreatedTS        time.Time      // When blob creation started
+	FinishedTS       *time.Time     // When blob was finalized (nil if still packing)
+	UncompressedSize int64          // Total size of raw chunks before compression
+	CompressedSize   int64          // Size after compression and encryption
+	UploadedTS       *time.Time     // When blob was uploaded to S3 (nil if not uploaded)
 }
 
 // BlobChunk represents the mapping between blobs and the chunks they contain.
@@ -65,8 +70,8 @@ type Blob struct {
 // their position and size within the blob. The offset and length fields
 // enable extracting specific chunks from a blob without processing the entire blob.
 type BlobChunk struct {
-	BlobID    string
-	ChunkHash string
+	BlobID    types.BlobID
+	ChunkHash types.ChunkHash
 	Offset    int64
 	Length    int64
 }
@@ -75,18 +80,18 @@ type BlobChunk struct {
 // This is used during deduplication to identify all files that share a chunk,
 // which is important for garbage collection and integrity verification.
 type ChunkFile struct {
-	ChunkHash  string
-	FileID     string
+	ChunkHash  types.ChunkHash
+	FileID     types.FileID
 	FileOffset int64
 	Length     int64
 }
 
 // Snapshot represents a snapshot record in the database
 type Snapshot struct {
-	ID                   string
-	Hostname             string
-	VaultikVersion       string
-	VaultikGitRevision   string
+	ID                   types.SnapshotID
+	Hostname             types.Hostname
+	VaultikVersion       types.Version
+	VaultikGitRevision   types.GitRevision
 	StartedAt            time.Time
 	CompletedAt          *time.Time // nil if still in progress
 	FileCount            int64
@@ -108,13 +113,13 @@ func (s *Snapshot) IsComplete() bool {
 
 // SnapshotFile represents the mapping between snapshots and files
 type SnapshotFile struct {
-	SnapshotID string
-	FileID     string
+	SnapshotID types.SnapshotID
+	FileID     types.FileID
 }
 
 // SnapshotBlob represents the mapping between snapshots and blobs
 type SnapshotBlob struct {
-	SnapshotID string
-	BlobID     string
-	BlobHash   string // Denormalized for easier manifest generation
+	SnapshotID types.SnapshotID
+	BlobID     types.BlobID
+	BlobHash   types.BlobHash // Denormalized for easier manifest generation
 }

internal/database/repositories.go

@@ -75,6 +75,11 @@ func (r *Repositories) WithTx(ctx context.Context, fn TxFunc) error {
 	return tx.Commit()
 }
 
+// DB returns the underlying database for direct queries
+func (r *Repositories) DB() *DB {
+	return r.db
+}
+
 // WithReadTx executes a function within a read-only transaction.
 // Read transactions can run concurrently with other read transactions
 // but will be blocked by write transactions. The transaction is

internal/database/repositories_test.go

@@ -6,6 +6,8 @@ import (
 	"fmt"
 	"testing"
 	"time"
+
+	"git.eeqj.de/sneak/vaultik/internal/types"
 )
 
 func TestRepositoriesTransaction(t *testing.T) {
@@ -33,7 +35,7 @@ func TestRepositoriesTransaction(t *testing.T) {
 
 		// Create chunks
 		chunk1 := &Chunk{
-			ChunkHash: "tx_chunk1",
+			ChunkHash: types.ChunkHash("tx_chunk1"),
 			Size:      512,
 		}
 		if err := repos.Chunks.Create(ctx, tx, chunk1); err != nil {
@@ -41,7 +43,7 @@ func TestRepositoriesTransaction(t *testing.T) {
 		}
 
 		chunk2 := &Chunk{
-			ChunkHash: "tx_chunk2",
+			ChunkHash: types.ChunkHash("tx_chunk2"),
 			Size:      512,
 		}
 		if err := repos.Chunks.Create(ctx, tx, chunk2); err != nil {
@@ -69,8 +71,8 @@ func TestRepositoriesTransaction(t *testing.T) {
 
 		// Create blob
 		blob := &Blob{
-			ID:        "tx-blob-id-1",
-			Hash:      "tx_blob1",
+			ID:        types.NewBlobID(),
+			Hash:      types.BlobHash("tx_blob1"),
 			CreatedTS: time.Now().Truncate(time.Second),
 		}
 		if err := repos.Blobs.Create(ctx, tx, blob); err != nil {
@@ -156,7 +158,7 @@ func TestRepositoriesTransactionRollback(t *testing.T) {
 
 		// Create a chunk
 		chunk := &Chunk{
-			ChunkHash: "rollback_chunk",
+			ChunkHash: types.ChunkHash("rollback_chunk"),
 			Size:      1024,
 		}
 		if err := repos.Chunks.Create(ctx, tx, chunk); err != nil {

internal/database/repository_comprehensive_test.go

@@ -6,6 +6,8 @@ import (
 	"fmt"
 	"testing"
 	"time"
+
+	"git.eeqj.de/sneak/vaultik/internal/types"
 )
 
 // TestFileRepositoryUUIDGeneration tests that files get unique UUIDs
@@ -46,15 +48,15 @@ func TestFileRepositoryUUIDGeneration(t *testing.T) {
 		}
 
 		// Check UUID was generated
-		if file.ID == "" {
+		if file.ID.IsZero() {
 			t.Error("file ID was not generated")
 		}
 
 		// Check UUID is unique
-		if uuids[file.ID] {
+		if uuids[file.ID.String()] {
 			t.Errorf("duplicate UUID generated: %s", file.ID)
 		}
-		uuids[file.ID] = true
+		uuids[file.ID.String()] = true
 	}
 }
 
@@ -96,7 +98,8 @@ func TestFileRepositoryGetByID(t *testing.T) {
 	}
 
 	// Test non-existent ID
-	nonExistent, err := repo.GetByID(ctx, "non-existent-uuid")
+	nonExistentID := types.NewFileID() // Generate a new UUID that won't exist in the database
+	nonExistent, err := repo.GetByID(ctx, nonExistentID)
 	if err != nil {
 		t.Fatalf("GetByID should not return error for non-existent ID: %v", err)
 	}
@@ -154,7 +157,7 @@ func TestOrphanedFileCleanup(t *testing.T) {
 	}
 
 	// Add file2 to snapshot
-	err = repos.Snapshots.AddFileByID(ctx, nil, snapshot.ID, file2.ID)
+	err = repos.Snapshots.AddFileByID(ctx, nil, snapshot.ID.String(), file2.ID)
 	if err != nil {
 		t.Fatalf("failed to add file to snapshot: %v", err)
 	}
@@ -194,11 +197,11 @@ func TestOrphanedChunkCleanup(t *testing.T) {
 
 	// Create chunks
 	chunk1 := &Chunk{
-		ChunkHash: "orphaned-chunk",
+		ChunkHash: types.ChunkHash("orphaned-chunk"),
 		Size:      1024,
 	}
 	chunk2 := &Chunk{
-		ChunkHash: "referenced-chunk",
+		ChunkHash: types.ChunkHash("referenced-chunk"),
 		Size:      1024,
 	}
 
@@ -244,7 +247,7 @@ func TestOrphanedChunkCleanup(t *testing.T) {
 	}
 
 	// Check that orphaned chunk is gone
-	orphanedChunk, err := repos.Chunks.GetByHash(ctx, chunk1.ChunkHash)
+	orphanedChunk, err := repos.Chunks.GetByHash(ctx, chunk1.ChunkHash.String())
 	if err != nil {
 		t.Fatalf("error getting chunk: %v", err)
 	}
@@ -253,7 +256,7 @@ func TestOrphanedChunkCleanup(t *testing.T) {
 	}
 
 	// Check that referenced chunk still exists
-	referencedChunk, err := repos.Chunks.GetByHash(ctx, chunk2.ChunkHash)
+	referencedChunk, err := repos.Chunks.GetByHash(ctx, chunk2.ChunkHash.String())
 	if err != nil {
 		t.Fatalf("error getting chunk: %v", err)
 	}
@@ -272,13 +275,13 @@ func TestOrphanedBlobCleanup(t *testing.T) {
 
 	// Create blobs
 	blob1 := &Blob{
-		ID:        "orphaned-blob-id",
-		Hash:      "orphaned-blob",
+		ID:        types.NewBlobID(),
+		Hash:      types.BlobHash("orphaned-blob"),
 		CreatedTS: time.Now().Truncate(time.Second),
 	}
 	blob2 := &Blob{
-		ID:        "referenced-blob-id",
-		Hash:      "referenced-blob",
+		ID:        types.NewBlobID(),
+		Hash:      types.BlobHash("referenced-blob"),
 		CreatedTS: time.Now().Truncate(time.Second),
 	}
 
@@ -303,7 +306,7 @@ func TestOrphanedBlobCleanup(t *testing.T) {
 	}
 
 	// Add blob2 to snapshot
-	err = repos.Snapshots.AddBlob(ctx, nil, snapshot.ID, blob2.ID, blob2.Hash)
+	err = repos.Snapshots.AddBlob(ctx, nil, snapshot.ID.String(), blob2.ID, blob2.Hash)
 	if err != nil {
 		t.Fatalf("failed to add blob to snapshot: %v", err)
 	}
@@ -315,7 +318,7 @@ func TestOrphanedBlobCleanup(t *testing.T) {
 	}
 
 	// Check that orphaned blob is gone
-	orphanedBlob, err := repos.Blobs.GetByID(ctx, blob1.ID)
+	orphanedBlob, err := repos.Blobs.GetByID(ctx, blob1.ID.String())
 	if err != nil {
 		t.Fatalf("error getting blob: %v", err)
 	}
@@ -324,7 +327,7 @@ func TestOrphanedBlobCleanup(t *testing.T) {
 	}
 
 	// Check that referenced blob still exists
-	referencedBlob, err := repos.Blobs.GetByID(ctx, blob2.ID)
+	referencedBlob, err := repos.Blobs.GetByID(ctx, blob2.ID.String())
 	if err != nil {
 		t.Fatalf("error getting blob: %v", err)
 	}
@@ -357,7 +360,7 @@ func TestFileChunkRepositoryWithUUIDs(t *testing.T) {
 	}
 
 	// Create chunks
-	chunks := []string{"chunk1", "chunk2", "chunk3"}
+	chunks := []types.ChunkHash{"chunk1", "chunk2", "chunk3"}
 	for i, chunkHash := range chunks {
 		chunk := &Chunk{
 			ChunkHash: chunkHash,
@@ -443,7 +446,7 @@ func TestChunkFileRepositoryWithUUIDs(t *testing.T) {
 
 	// Create a chunk that appears in both files (deduplication)
 	chunk := &Chunk{
-		ChunkHash: "shared-chunk",
+		ChunkHash: types.ChunkHash("shared-chunk"),
 		Size:      1024,
 	}
 	err = repos.Chunks.Create(ctx, nil, chunk)
@@ -526,7 +529,7 @@ func TestSnapshotRepositoryExtendedFields(t *testing.T) {
 	}
 
 	// Retrieve and verify
-	retrieved, err := repo.GetByID(ctx, snapshot.ID)
+	retrieved, err := repo.GetByID(ctx, snapshot.ID.String())
 	if err != nil {
 		t.Fatalf("failed to get snapshot: %v", err)
 	}
@@ -581,7 +584,7 @@ func TestComplexOrphanedDataScenario(t *testing.T) {
 	files := make([]*File, 3)
 	for i := range files {
 		files[i] = &File{
-			Path:  fmt.Sprintf("/file%d.txt", i),
+			Path:  types.FilePath(fmt.Sprintf("/file%d.txt", i)),
 			MTime: time.Now().Truncate(time.Second),
 			CTime: time.Now().Truncate(time.Second),
 			Size:  1024,
@@ -601,29 +604,29 @@ func TestComplexOrphanedDataScenario(t *testing.T) {
 	// file0: only in snapshot1
 	// file1: in both snapshots
 	// file2: only in snapshot2
-	err = repos.Snapshots.AddFileByID(ctx, nil, snapshot1.ID, files[0].ID)
+	err = repos.Snapshots.AddFileByID(ctx, nil, snapshot1.ID.String(), files[0].ID)
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = repos.Snapshots.AddFileByID(ctx, nil, snapshot1.ID, files[1].ID)
+	err = repos.Snapshots.AddFileByID(ctx, nil, snapshot1.ID.String(), files[1].ID)
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = repos.Snapshots.AddFileByID(ctx, nil, snapshot2.ID, files[1].ID)
+	err = repos.Snapshots.AddFileByID(ctx, nil, snapshot2.ID.String(), files[1].ID)
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = repos.Snapshots.AddFileByID(ctx, nil, snapshot2.ID, files[2].ID)
+	err = repos.Snapshots.AddFileByID(ctx, nil, snapshot2.ID.String(), files[2].ID)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	// Delete snapshot1
-	err = repos.Snapshots.DeleteSnapshotFiles(ctx, snapshot1.ID)
+	err = repos.Snapshots.DeleteSnapshotFiles(ctx, snapshot1.ID.String())
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = repos.Snapshots.Delete(ctx, snapshot1.ID)
+	err = repos.Snapshots.Delete(ctx, snapshot1.ID.String())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -689,7 +692,7 @@ func TestCascadeDelete(t *testing.T) {
 	// Create chunks and file-chunk mappings
 	for i := 0; i < 3; i++ {
 		chunk := &Chunk{
-			ChunkHash: fmt.Sprintf("cascade-chunk-%d", i),
+			ChunkHash: types.ChunkHash(fmt.Sprintf("cascade-chunk-%d", i)),
 			Size:      1024,
 		}
 		err = repos.Chunks.Create(ctx, nil, chunk)
@@ -807,7 +810,7 @@ func TestConcurrentOrphanedCleanup(t *testing.T) {
 	// Create many files, some orphaned
 	for i := 0; i < 20; i++ {
 		file := &File{
-			Path:  fmt.Sprintf("/concurrent-%d.txt", i),
+			Path:  types.FilePath(fmt.Sprintf("/concurrent-%d.txt", i)),
 			MTime: time.Now().Truncate(time.Second),
 			CTime: time.Now().Truncate(time.Second),
 			Size:  1024,
@@ -822,7 +825,7 @@ func TestConcurrentOrphanedCleanup(t *testing.T) {
 
 		// Add even-numbered files to snapshot
 		if i%2 == 0 {
-			err = repos.Snapshots.AddFileByID(ctx, nil, snapshot.ID, file.ID)
+			err = repos.Snapshots.AddFileByID(ctx, nil, snapshot.ID.String(), file.ID)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -860,7 +863,7 @@ func TestConcurrentOrphanedCleanup(t *testing.T) {
 	// Verify all remaining files are even-numbered
 	for _, file := range files {
 		var num int
-		_, err := fmt.Sscanf(file.Path, "/concurrent-%d.txt", &num)
+		_, err := fmt.Sscanf(file.Path.String(), "/concurrent-%d.txt", &num)
 		if err != nil {
 			t.Logf("failed to parse file number from %s: %v", file.Path, err)
 		}

internal/database/repository_debug_test.go

@@ -67,7 +67,7 @@ func TestOrphanedFileCleanupDebug(t *testing.T) {
 	t.Logf("snapshot_files count before add: %d", count)
 
 	// Add file2 to snapshot
-	err = repos.Snapshots.AddFileByID(ctx, nil, snapshot.ID, file2.ID)
+	err = repos.Snapshots.AddFileByID(ctx, nil, snapshot.ID.String(), file2.ID)
 	if err != nil {
 		t.Fatalf("failed to add file to snapshot: %v", err)
 	}

internal/database/repository_edge_cases_test.go

@@ -6,6 +6,8 @@ import (
 	"strings"
 	"testing"
 	"time"
+
+	"git.eeqj.de/sneak/vaultik/internal/types"
 )
 
 // TestFileRepositoryEdgeCases tests edge cases for file repository
@@ -38,7 +40,7 @@ func TestFileRepositoryEdgeCases(t *testing.T) {
 		{
 			name: "very long path",
 			file: &File{
-				Path:  "/" + strings.Repeat("a", 4096),
+				Path:  types.FilePath("/" + strings.Repeat("a", 4096)),
 				MTime: time.Now(),
 				CTime: time.Now(),
 				Size:  1024,
@@ -94,7 +96,7 @@ func TestFileRepositoryEdgeCases(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			// Add a unique suffix to paths to avoid UNIQUE constraint violations
 			if tt.file.Path != "" {
-				tt.file.Path = fmt.Sprintf("%s_%d_%d", tt.file.Path, i, time.Now().UnixNano())
+				tt.file.Path = types.FilePath(fmt.Sprintf("%s_%d_%d", tt.file.Path, i, time.Now().UnixNano()))
 			}
 
 			err := repo.Create(ctx, nil, tt.file)
@@ -169,7 +171,7 @@ func TestDuplicateHandling(t *testing.T) {
 	// Test duplicate chunk hashes
 	t.Run("duplicate chunk hashes", func(t *testing.T) {
 		chunk := &Chunk{
-			ChunkHash: "duplicate-chunk",
+			ChunkHash: types.ChunkHash("duplicate-chunk"),
 			Size:      1024,
 		}
 
@@ -202,7 +204,7 @@ func TestDuplicateHandling(t *testing.T) {
 		}
 
 		chunk := &Chunk{
-			ChunkHash: "test-chunk-dup",
+			ChunkHash: types.ChunkHash("test-chunk-dup"),
 			Size:      1024,
 		}
 		err = repos.Chunks.Create(ctx, nil, chunk)
@@ -279,7 +281,7 @@ func TestNullHandling(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		retrieved, err := repos.Snapshots.GetByID(ctx, snapshot.ID)
+		retrieved, err := repos.Snapshots.GetByID(ctx, snapshot.ID.String())
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -292,8 +294,8 @@ func TestNullHandling(t *testing.T) {
 	// Test blob with NULL uploaded_ts
 	t.Run("blob not uploaded", func(t *testing.T) {
 		blob := &Blob{
-			ID:         "not-uploaded",
-			Hash:       "test-hash",
+			ID:         types.NewBlobID(),
+			Hash:       types.BlobHash("test-hash"),
 			CreatedTS:  time.Now(),
 			UploadedTS: nil, // Not uploaded yet
 		}
@@ -303,7 +305,7 @@ func TestNullHandling(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		retrieved, err := repos.Blobs.GetByID(ctx, blob.ID)
+		retrieved, err := repos.Blobs.GetByID(ctx, blob.ID.String())
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -339,13 +341,13 @@ func TestLargeDatasets(t *testing.T) {
 
 	// Create many files
 	const fileCount = 1000
-	fileIDs := make([]string, fileCount)
+	fileIDs := make([]types.FileID, fileCount)
 
 	t.Run("create many files", func(t *testing.T) {
 		start := time.Now()
 		for i := 0; i < fileCount; i++ {
 			file := &File{
-				Path:  fmt.Sprintf("/large/file%05d.txt", i),
+				Path:  types.FilePath(fmt.Sprintf("/large/file%05d.txt", i)),
 				MTime: time.Now(),
 				CTime: time.Now(),
 				Size:  int64(i * 1024),
@@ -361,7 +363,7 @@ func TestLargeDatasets(t *testing.T) {
 
 			// Add half to snapshot
 			if i%2 == 0 {
-				err = repos.Snapshots.AddFileByID(ctx, nil, snapshot.ID, file.ID)
+				err = repos.Snapshots.AddFileByID(ctx, nil, snapshot.ID.String(), file.ID)
 				if err != nil {
 					t.Fatal(err)
 				}
@@ -413,7 +415,7 @@ func TestErrorPropagation(t *testing.T) {
 
 	// Test GetByID with non-existent ID
 	t.Run("GetByID non-existent", func(t *testing.T) {
-		file, err := repos.Files.GetByID(ctx, "non-existent-uuid")
+		file, err := repos.Files.GetByID(ctx, types.NewFileID())
 		if err != nil {
 			t.Errorf("GetByID should not return error for non-existent ID, got: %v", err)
 		}
@@ -436,9 +438,9 @@ func TestErrorPropagation(t *testing.T) {
 	// Test invalid foreign key reference
 	t.Run("invalid foreign key", func(t *testing.T) {
 		fc := &FileChunk{
-			FileID:    "non-existent-file-id",
+			FileID:    types.NewFileID(),
 			Idx:       0,
-			ChunkHash: "some-chunk",
+			ChunkHash: types.ChunkHash("some-chunk"),
 		}
 		err := repos.FileChunks.Create(ctx, nil, fc)
 		if err == nil {
@@ -470,7 +472,7 @@ func TestQueryInjection(t *testing.T) {
 		t.Run("injection attempt", func(t *testing.T) {
 			// Try injection in file path
 			file := &File{
-				Path:  injection,
+				Path:  types.FilePath(injection),
 				MTime: time.Now(),
 				CTime: time.Now(),
 				Size:  1024,

internal/database/schema.sql

@@ -6,6 +6,7 @@
 CREATE TABLE IF NOT EXISTS files (
     id TEXT PRIMARY KEY,  -- UUID
     path TEXT NOT NULL UNIQUE,
+    source_path TEXT NOT NULL DEFAULT '',  -- The source directory this file came from (for restore path stripping)
     mtime INTEGER NOT NULL,
     ctime INTEGER NOT NULL,
     size INTEGER NOT NULL,

internal/database/snapshots.go

@@ -5,6 +5,8 @@ import (
 	"database/sql"
 	"fmt"
 	"time"
+
+	"git.eeqj.de/sneak/vaultik/internal/types"
 )
 
 type SnapshotRepository struct {
@@ -269,7 +271,7 @@ func (r *SnapshotRepository) AddFile(ctx context.Context, tx *sql.Tx, snapshotID
 }
 
 // AddFileByID adds a file to a snapshot by file ID
-func (r *SnapshotRepository) AddFileByID(ctx context.Context, tx *sql.Tx, snapshotID string, fileID string) error {
+func (r *SnapshotRepository) AddFileByID(ctx context.Context, tx *sql.Tx, snapshotID string, fileID types.FileID) error {
 	query := `
 		INSERT OR IGNORE INTO snapshot_files (snapshot_id, file_id)
 		VALUES (?, ?)
@@ -277,9 +279,9 @@ func (r *SnapshotRepository) AddFileByID(ctx context.Context, tx *sql.Tx, snapsh
 
 	var err error
 	if tx != nil {
-		_, err = tx.ExecContext(ctx, query, snapshotID, fileID)
+		_, err = tx.ExecContext(ctx, query, snapshotID, fileID.String())
 	} else {
-		_, err = r.db.ExecWithLog(ctx, query, snapshotID, fileID)
+		_, err = r.db.ExecWithLog(ctx, query, snapshotID, fileID.String())
 	}
 
 	if err != nil {
@@ -290,7 +292,7 @@ func (r *SnapshotRepository) AddFileByID(ctx context.Context, tx *sql.Tx, snapsh
 }
 
 // AddFilesByIDBatch adds multiple files to a snapshot in batched inserts
-func (r *SnapshotRepository) AddFilesByIDBatch(ctx context.Context, tx *sql.Tx, snapshotID string, fileIDs []string) error {
+func (r *SnapshotRepository) AddFilesByIDBatch(ctx context.Context, tx *sql.Tx, snapshotID string, fileIDs []types.FileID) error {
 	if len(fileIDs) == 0 {
 		return nil
 	}
@@ -312,7 +314,7 @@ func (r *SnapshotRepository) AddFilesByIDBatch(ctx context.Context, tx *sql.Tx,
 				query += ", "
 			}
 			query += "(?, ?)"
-			args = append(args, snapshotID, fileID)
+			args = append(args, snapshotID, fileID.String())
 		}
 
 		var err error
@@ -330,7 +332,7 @@ func (r *SnapshotRepository) AddFilesByIDBatch(ctx context.Context, tx *sql.Tx,
 }
 
 // AddBlob adds a blob to a snapshot
-func (r *SnapshotRepository) AddBlob(ctx context.Context, tx *sql.Tx, snapshotID string, blobID string, blobHash string) error {
+func (r *SnapshotRepository) AddBlob(ctx context.Context, tx *sql.Tx, snapshotID string, blobID types.BlobID, blobHash types.BlobHash) error {
 	query := `
 		INSERT OR IGNORE INTO snapshot_blobs (snapshot_id, blob_id, blob_hash)
 		VALUES (?, ?, ?)
@@ -338,9 +340,9 @@ func (r *SnapshotRepository) AddBlob(ctx context.Context, tx *sql.Tx, snapshotID
 
 	var err error
 	if tx != nil {
-		_, err = tx.ExecContext(ctx, query, snapshotID, blobID, blobHash)
+		_, err = tx.ExecContext(ctx, query, snapshotID, blobID.String(), blobHash.String())
 	} else {
-		_, err = r.db.ExecWithLog(ctx, query, snapshotID, blobID, blobHash)
+		_, err = r.db.ExecWithLog(ctx, query, snapshotID, blobID.String(), blobHash.String())
 	}
 
 	if err != nil {

internal/database/snapshots_test.go

@@ -6,6 +6,8 @@ import (
 	"math"
 	"testing"
 	"time"
+
+	"git.eeqj.de/sneak/vaultik/internal/types"
 )
 
 const (
@@ -46,7 +48,7 @@ func TestSnapshotRepository(t *testing.T) {
 	}
 
 	// Test GetByID
-	retrieved, err := repo.GetByID(ctx, snapshot.ID)
+	retrieved, err := repo.GetByID(ctx, snapshot.ID.String())
 	if err != nil {
 		t.Fatalf("failed to get snapshot: %v", err)
 	}
@@ -64,12 +66,12 @@ func TestSnapshotRepository(t *testing.T) {
 	}
 
 	// Test UpdateCounts
-	err = repo.UpdateCounts(ctx, nil, snapshot.ID, 200, 1000, 20, twoHundredMebibytes, sixtyMebibytes)
+	err = repo.UpdateCounts(ctx, nil, snapshot.ID.String(), 200, 1000, 20, twoHundredMebibytes, sixtyMebibytes)
 	if err != nil {
 		t.Fatalf("failed to update counts: %v", err)
 	}
 
-	retrieved, err = repo.GetByID(ctx, snapshot.ID)
+	retrieved, err = repo.GetByID(ctx, snapshot.ID.String())
 	if err != nil {
 		t.Fatalf("failed to get updated snapshot: %v", err)
 	}
@@ -97,7 +99,7 @@ func TestSnapshotRepository(t *testing.T) {
 	// Add more snapshots
 	for i := 2; i <= 5; i++ {
 		s := &Snapshot{
-			ID:             fmt.Sprintf("2024-01-0%dT12:00:00Z", i),
+			ID:             types.SnapshotID(fmt.Sprintf("2024-01-0%dT12:00:00Z", i)),
 			Hostname:       "test-host",
 			VaultikVersion: "1.0.0",
 			StartedAt:      time.Now().Add(time.Duration(i) * time.Hour).Truncate(time.Second),