refactor: add Context to the persistence layer

persistence/mock_persistence.go

@@ -1,6 +1,10 @@
 package persistence
 
-import "github.com/deluan/navidrome/model"
+import (
+	"context"
+
+	"github.com/deluan/navidrome/model"
+)
 
 type MockDataStore struct {
 	MockedGenre     model.GenreRepository
@@ -10,54 +14,54 @@ type MockDataStore struct {
 	MockedUser      model.UserRepository
 }
 
-func (db *MockDataStore) Album() model.AlbumRepository {
+func (db *MockDataStore) Album(context.Context) model.AlbumRepository {
 	if db.MockedAlbum == nil {
 		db.MockedAlbum = CreateMockAlbumRepo()
 	}
 	return db.MockedAlbum
 }
 
-func (db *MockDataStore) Artist() model.ArtistRepository {
+func (db *MockDataStore) Artist(context.Context) model.ArtistRepository {
 	if db.MockedArtist == nil {
 		db.MockedArtist = CreateMockArtistRepo()
 	}
 	return db.MockedArtist
 }
 
-func (db *MockDataStore) MediaFile() model.MediaFileRepository {
+func (db *MockDataStore) MediaFile(context.Context) model.MediaFileRepository {
 	if db.MockedMediaFile == nil {
 		db.MockedMediaFile = CreateMockMediaFileRepo()
 	}
 	return db.MockedMediaFile
 }
 
-func (db *MockDataStore) MediaFolder() model.MediaFolderRepository {
+func (db *MockDataStore) MediaFolder(context.Context) model.MediaFolderRepository {
 	return struct{ model.MediaFolderRepository }{}
 }
 
-func (db *MockDataStore) Genre() model.GenreRepository {
+func (db *MockDataStore) Genre(context.Context) model.GenreRepository {
 	if db.MockedGenre != nil {
 		return db.MockedGenre
 	}
 	return struct{ model.GenreRepository }{}
 }
 
-func (db *MockDataStore) Playlist() model.PlaylistRepository {
+func (db *MockDataStore) Playlist(context.Context) model.PlaylistRepository {
 	return struct{ model.PlaylistRepository }{}
 }
 
-func (db *MockDataStore) Property() model.PropertyRepository {
+func (db *MockDataStore) Property(context.Context) model.PropertyRepository {
 	return struct{ model.PropertyRepository }{}
 }
 
-func (db *MockDataStore) User() model.UserRepository {
+func (db *MockDataStore) User(context.Context) model.UserRepository {
 	if db.MockedUser == nil {
 		db.MockedUser = &mockedUserRepo{}
 	}
 	return db.MockedUser
 }
 
-func (db *MockDataStore) Annotation() model.AnnotationRepository {
+func (db *MockDataStore) Annotation(context.Context) model.AnnotationRepository {
 	return struct{ model.AnnotationRepository }{}
 }
 
@@ -65,7 +69,7 @@ func (db *MockDataStore) WithTx(block func(db model.DataStore) error) error {
 	return block(db)
 }
 
-func (db *MockDataStore) Resource(m interface{}) model.ResourceRepository {
+func (db *MockDataStore) Resource(ctx context.Context, m interface{}) model.ResourceRepository {
 	return struct{ model.ResourceRepository }{}
 }
 

persistence/persistence.go

@@ -1,6 +1,7 @@
 package persistence
 
 import (
+	"context"
 	"reflect"
 	"strings"
 	"sync"
@@ -41,43 +42,43 @@ func New() model.DataStore {
 	return &SQLStore{}
 }
 
-func (db *SQLStore) Album() model.AlbumRepository {
+func (db *SQLStore) Album(context.Context) model.AlbumRepository {
 	return NewAlbumRepository(db.getOrmer())
 }
 
-func (db *SQLStore) Artist() model.ArtistRepository {
+func (db *SQLStore) Artist(context.Context) model.ArtistRepository {
 	return NewArtistRepository(db.getOrmer())
 }
 
-func (db *SQLStore) MediaFile() model.MediaFileRepository {
+func (db *SQLStore) MediaFile(context.Context) model.MediaFileRepository {
 	return NewMediaFileRepository(db.getOrmer())
 }
 
-func (db *SQLStore) MediaFolder() model.MediaFolderRepository {
+func (db *SQLStore) MediaFolder(context.Context) model.MediaFolderRepository {
 	return NewMediaFolderRepository(db.getOrmer())
 }
 
-func (db *SQLStore) Genre() model.GenreRepository {
+func (db *SQLStore) Genre(context.Context) model.GenreRepository {
 	return NewGenreRepository(db.getOrmer())
 }
 
-func (db *SQLStore) Playlist() model.PlaylistRepository {
+func (db *SQLStore) Playlist(context.Context) model.PlaylistRepository {
 	return NewPlaylistRepository(db.getOrmer())
 }
 
-func (db *SQLStore) Property() model.PropertyRepository {
+func (db *SQLStore) Property(context.Context) model.PropertyRepository {
 	return NewPropertyRepository(db.getOrmer())
 }
 
-func (db *SQLStore) User() model.UserRepository {
+func (db *SQLStore) User(context.Context) model.UserRepository {
 	return NewUserRepository(db.getOrmer())
 }
 
-func (db *SQLStore) Annotation() model.AnnotationRepository {
+func (db *SQLStore) Annotation(context.Context) model.AnnotationRepository {
 	return NewAnnotationRepository(db.getOrmer())
 }
 
-func (db *SQLStore) Resource(model interface{}) model.ResourceRepository {
+func (db *SQLStore) Resource(ctx context.Context, model interface{}) model.ResourceRepository {
 	return NewResource(db.getOrmer(), model, getMappedModel(model))
 }
 

persistence/persistence_suite_test.go

@@ -63,21 +63,21 @@ var _ = Describe("Initialize test DB", func() {
 	BeforeSuite(func() {
 		conf.Server.DbPath = ":memory:"
 		ds := New()
-		artistRepo := ds.Artist()
+		artistRepo := ds.Artist(nil)
 		for _, a := range testArtists {
 			err := artistRepo.Put(&a)
 			if err != nil {
 				panic(err)
 			}
 		}
-		albumRepository := ds.Album()
+		albumRepository := ds.Album(nil)
 		for _, a := range testAlbums {
 			err := albumRepository.Put(&a)
 			if err != nil {
 				panic(err)
 			}
 		}
-		mediaFileRepository := ds.MediaFile()
+		mediaFileRepository := ds.MediaFile(nil)
 		for _, s := range testSongs {
 			err := mediaFileRepository.Put(&s)
 			if err != nil {