diff --git a/cmd/root.go b/cmd/root.go
index 30dbc8d6..dbac4b2d 100644
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -16,6 +16,7 @@ var (
 	cfg        config.Config
 	db         *gorm.DB
 	store      *storage.SqlStorage
+	stores     storage.Stores
 
 	log = logger.GetWithPackage("cmd")
 
@@ -43,6 +44,7 @@ func initConfig() {
 		log.WithError(err).Fatal("could not connect to database")
 	}
 	store = storage.NewSqlStorage(db, cfg.Upload.Path)
+	stores = storage.NewStores(store)
 	if err := storage.MigrateDB(db); err != nil {
 		log.WithError(err).Fatal("could not migrate database")
 	}
diff --git a/cmd/run.go b/cmd/run.go
index 6d66623c..fc927be3 100644
--- a/cmd/run.go
+++ b/cmd/run.go
@@ -33,7 +33,7 @@ var (
 				log.Fatal(http.ListenAndServe(cfg.MetricsListen, nil))
 			}()
 
-			apiServer := api.API(cfg, store)
+			apiServer := api.API(cfg, stores)
 			server := &http.Server{
 				Addr:    cfg.Listen,
 				Handler: apiServer.Router,
diff --git a/internal/api/api.go b/internal/api/api.go
index e92772da..0ad3270d 100644
--- a/internal/api/api.go
+++ b/internal/api/api.go
@@ -33,13 +33,13 @@ type Server struct {
 
 type handler struct {
 	config   config.Config
-	storage  storage.Storage
+	stores   storage.Stores
 	bridges  bridge.Bridges
 	cache    *cache.Cache
 	realtime *realtime.Engine
 }
 
-func API(config config.Config, store storage.Storage) *Server {
+func API(config config.Config, stores storage.Stores) *Server {
 	inMemoryCache := cache.NewCache(5 * time.Minute)
 
 	ws := realtime.New()
@@ -47,8 +47,8 @@ func API(config config.Config, store storage.Storage) *Server {
 
 	handler := handler{
 		config:   config,
-		storage:  store,
-		bridges:  bridge.RegisterBridges(config, store),
+		stores:   stores,
+		bridges:  bridge.RegisterBridges(config, stores),
 		cache:    inMemoryCache,
 		realtime: ws,
 	}
@@ -63,11 +63,11 @@ func API(config config.Config, store storage.Storage) *Server {
 	r.Use(limits.RequestSizeLimiter(1024 * 1024 * 10))
 
 	// the jwt middleware
-	authMiddleware := auth.AuthMiddleware(store, config.Secret)
+	authMiddleware := auth.AuthMiddleware(stores.Users, config.Secret)
 
 	admin := r.Group("/v1/admin")
 	{
-		meMiddleware := me.MeMiddleware(store)
+		meMiddleware := me.MeMiddleware(stores.Users)
 		admin.Use(authMiddleware.MiddlewareFunc())
 		admin.Use(meMiddleware)
 
@@ -76,39 +76,39 @@ func API(config config.Config, store storage.Storage) *Server {
 		admin.GET("/features", handler.GetFeatures)
 
 		admin.GET(`/tickers`, handler.GetTickers)
-		admin.GET(`/tickers/:tickerID`, ticker.PrefetchTicker(store, storage.WithPreload()), handler.GetTicker)
+		admin.GET(`/tickers/:tickerID`, ticker.PrefetchTicker(stores.Tickers, storage.WithPreload()), handler.GetTicker)
 		admin.POST(`/tickers`, user.NeedAdmin(), handler.PostTicker)
-		admin.PUT(`/tickers/:tickerID`, ticker.PrefetchTicker(store, storage.WithPreload()), handler.PutTicker)
-		admin.DELETE(`/tickers/:tickerID/websites`, ticker.PrefetchTicker(store, storage.WithPreload()), handler.DeleteTickerWebsites)
-		admin.PUT(`/tickers/:tickerID/websites`, ticker.PrefetchTicker(store, storage.WithPreload()), handler.PutTickerWebsites)
-		admin.PUT(`/tickers/:tickerID/telegram`, ticker.PrefetchTicker(store, storage.WithPreload()), handler.PutTickerTelegram)
-		admin.DELETE(`/tickers/:tickerID/telegram`, ticker.PrefetchTicker(store, storage.WithPreload()), handler.DeleteTickerTelegram)
-		admin.PUT(`/tickers/:tickerID/mastodon`, ticker.PrefetchTicker(store, storage.WithPreload()), handler.PutTickerMastodon)
-		admin.DELETE(`/tickers/:tickerID/mastodon`, ticker.PrefetchTicker(store, storage.WithPreload()), handler.DeleteTickerMastodon)
-		admin.PUT(`/tickers/:tickerID/bluesky`, ticker.PrefetchTicker(store, storage.WithPreload()), handler.PutTickerBluesky)
-		admin.DELETE(`/tickers/:tickerID/bluesky`, ticker.PrefetchTicker(store, storage.WithPreload()), handler.DeleteTickerBluesky)
-		admin.PUT(`/tickers/:tickerID/signal_group`, ticker.PrefetchTicker(store, storage.WithPreload()), handler.PutTickerSignalGroup)
-		admin.DELETE(`/tickers/:tickerID/signal_group`, ticker.PrefetchTicker(store, storage.WithPreload()), handler.DeleteTickerSignalGroup)
-		admin.PUT(`/tickers/:tickerID/signal_group/admin`, ticker.PrefetchTicker(store, storage.WithPreload()), handler.PutTickerSignalGroupAdmin)
-		admin.DELETE(`/tickers/:tickerID`, user.NeedAdmin(), ticker.PrefetchTicker(store), handler.DeleteTicker)
-		admin.PUT(`/tickers/:tickerID/reset`, ticker.PrefetchTicker(store, storage.WithPreload()), ticker.PrefetchTicker(store), handler.ResetTicker)
-		admin.GET(`/tickers/:tickerID/users`, ticker.PrefetchTicker(store), handler.GetTickerUsers)
-		admin.PUT(`/tickers/:tickerID/users`, user.NeedAdmin(), ticker.PrefetchTicker(store), handler.PutTickerUsers)
-		admin.DELETE(`/tickers/:tickerID/users/:userID`, user.NeedAdmin(), ticker.PrefetchTicker(store), handler.DeleteTickerUser)
-
-		admin.GET(`/tickers/:tickerID/messages`, ticker.PrefetchTicker(store, storage.WithPreload()), handler.GetMessages)
-		admin.GET(`/tickers/:tickerID/messages/:messageID`, ticker.PrefetchTicker(store, storage.WithPreload()), message.PrefetchMessage(store), handler.GetMessage)
-		admin.POST(`/tickers/:tickerID/messages`, ticker.PrefetchTicker(store, storage.WithPreload()), handler.PostMessage)
-		admin.DELETE(`/tickers/:tickerID/messages/:messageID`, ticker.PrefetchTicker(store, storage.WithPreload()), message.PrefetchMessage(store), handler.DeleteMessage)
+		admin.PUT(`/tickers/:tickerID`, ticker.PrefetchTicker(stores.Tickers, storage.WithPreload()), handler.PutTicker)
+		admin.DELETE(`/tickers/:tickerID/websites`, ticker.PrefetchTicker(stores.Tickers, storage.WithPreload()), handler.DeleteTickerWebsites)
+		admin.PUT(`/tickers/:tickerID/websites`, ticker.PrefetchTicker(stores.Tickers, storage.WithPreload()), handler.PutTickerWebsites)
+		admin.PUT(`/tickers/:tickerID/telegram`, ticker.PrefetchTicker(stores.Tickers, storage.WithPreload()), handler.PutTickerTelegram)
+		admin.DELETE(`/tickers/:tickerID/telegram`, ticker.PrefetchTicker(stores.Tickers, storage.WithPreload()), handler.DeleteTickerTelegram)
+		admin.PUT(`/tickers/:tickerID/mastodon`, ticker.PrefetchTicker(stores.Tickers, storage.WithPreload()), handler.PutTickerMastodon)
+		admin.DELETE(`/tickers/:tickerID/mastodon`, ticker.PrefetchTicker(stores.Tickers, storage.WithPreload()), handler.DeleteTickerMastodon)
+		admin.PUT(`/tickers/:tickerID/bluesky`, ticker.PrefetchTicker(stores.Tickers, storage.WithPreload()), handler.PutTickerBluesky)
+		admin.DELETE(`/tickers/:tickerID/bluesky`, ticker.PrefetchTicker(stores.Tickers, storage.WithPreload()), handler.DeleteTickerBluesky)
+		admin.PUT(`/tickers/:tickerID/signal_group`, ticker.PrefetchTicker(stores.Tickers, storage.WithPreload()), handler.PutTickerSignalGroup)
+		admin.DELETE(`/tickers/:tickerID/signal_group`, ticker.PrefetchTicker(stores.Tickers, storage.WithPreload()), handler.DeleteTickerSignalGroup)
+		admin.PUT(`/tickers/:tickerID/signal_group/admin`, ticker.PrefetchTicker(stores.Tickers, storage.WithPreload()), handler.PutTickerSignalGroupAdmin)
+		admin.DELETE(`/tickers/:tickerID`, user.NeedAdmin(), ticker.PrefetchTicker(stores.Tickers), handler.DeleteTicker)
+		admin.PUT(`/tickers/:tickerID/reset`, ticker.PrefetchTicker(stores.Tickers, storage.WithPreload()), ticker.PrefetchTicker(stores.Tickers), handler.ResetTicker)
+		admin.GET(`/tickers/:tickerID/users`, ticker.PrefetchTicker(stores.Tickers), handler.GetTickerUsers)
+		admin.PUT(`/tickers/:tickerID/users`, user.NeedAdmin(), ticker.PrefetchTicker(stores.Tickers), handler.PutTickerUsers)
+		admin.DELETE(`/tickers/:tickerID/users/:userID`, user.NeedAdmin(), ticker.PrefetchTicker(stores.Tickers), handler.DeleteTickerUser)
+
+		admin.GET(`/tickers/:tickerID/messages`, ticker.PrefetchTicker(stores.Tickers, storage.WithPreload()), handler.GetMessages)
+		admin.GET(`/tickers/:tickerID/messages/:messageID`, ticker.PrefetchTicker(stores.Tickers, storage.WithPreload()), message.PrefetchMessage(stores.Messages), handler.GetMessage)
+		admin.POST(`/tickers/:tickerID/messages`, ticker.PrefetchTicker(stores.Tickers, storage.WithPreload()), handler.PostMessage)
+		admin.DELETE(`/tickers/:tickerID/messages/:messageID`, ticker.PrefetchTicker(stores.Tickers, storage.WithPreload()), message.PrefetchMessage(stores.Messages), handler.DeleteMessage)
 
 		admin.POST(`/upload`, handler.PostUpload)
 
 		admin.GET(`/users`, user.NeedAdmin(), handler.GetUsers)
-		admin.GET(`/users/:userID`, user.PrefetchUser(store), handler.GetUser)
+		admin.GET(`/users/:userID`, user.PrefetchUser(stores.Users), handler.GetUser)
 		admin.POST(`/users`, user.NeedAdmin(), handler.PostUser)
 		admin.PUT(`/users/me`, handler.PutMe)
-		admin.PUT(`/users/:userID`, user.NeedAdmin(), user.PrefetchUser(store), handler.PutUser)
-		admin.DELETE(`/users/:userID`, user.NeedAdmin(), user.PrefetchUser(store), handler.DeleteUser)
+		admin.PUT(`/users/:userID`, user.NeedAdmin(), user.PrefetchUser(stores.Users), handler.PutUser)
+		admin.DELETE(`/users/:userID`, user.NeedAdmin(), user.PrefetchUser(stores.Users), handler.DeleteUser)
 
 		admin.GET(`/settings/:name`, user.NeedAdmin(), handler.GetSetting)
 		admin.PUT(`/settings/inactive_settings`, user.NeedAdmin(), handler.PutInactiveSettings)
@@ -121,10 +121,10 @@ func API(config config.Config, store storage.Storage) *Server {
 		public.POST(`/admin/login`, authMiddleware.LoginHandler)
 
 		public.GET(`/init`, response_cache.CachePage(inMemoryCache, 5*time.Minute, handler.GetInit))
-		public.GET(`/manifest.json`, ticker.PrefetchTickerFromRequest(store), handler.HandleManifest)
-		public.GET(`/timeline`, ticker.PrefetchTickerFromRequest(store), response_cache.CachePage(inMemoryCache, 10*time.Second, handler.GetTimeline))
-		public.GET(`/feed`, ticker.PrefetchTickerFromRequest(store), response_cache.CachePage(inMemoryCache, 5*time.Minute, handler.GetFeed))
-		public.GET(`/ws`, ticker.PrefetchTickerFromRequest(store), handler.HandleWebSocket)
+		public.GET(`/manifest.json`, ticker.PrefetchTickerFromRequest(stores.Tickers), handler.HandleManifest)
+		public.GET(`/timeline`, ticker.PrefetchTickerFromRequest(stores.Tickers), response_cache.CachePage(inMemoryCache, 10*time.Second, handler.GetTimeline))
+		public.GET(`/feed`, ticker.PrefetchTickerFromRequest(stores.Tickers), response_cache.CachePage(inMemoryCache, 5*time.Minute, handler.GetFeed))
+		public.GET(`/ws`, ticker.PrefetchTickerFromRequest(stores.Tickers), handler.HandleWebSocket)
 	}
 
 	r.GET(`/media/:fileName`, handler.GetMedia)
diff --git a/internal/api/api_test.go b/internal/api/api_test.go
index 45eddb29..828978fe 100644
--- a/internal/api/api_test.go
+++ b/internal/api/api_test.go
@@ -30,11 +30,11 @@ func (s *APITestSuite) SetupTest() {
 	logrus.SetOutput(io.Discard)
 
 	s.cfg = config.LoadConfig("")
-	s.store = &storage.MockStorage{}
+	s.store = storage.NewMockStorage()
 }
 
 func (s *APITestSuite) TestHealthz() {
-	server := API(s.cfg, s.store)
+	server := API(s.cfg, s.store.Stores())
 	req := httptest.NewRequest(http.MethodGet, "/healthz", nil)
 	w := httptest.NewRecorder()
 	server.Router.ServeHTTP(w, req)
@@ -47,8 +47,8 @@ func (s *APITestSuite) TestLogin() {
 	s.Run("when password is wrong", func() {
 		user, err := storage.NewUser("user@systemli.org", "password")
 		s.NoError(err)
-		s.store.On("FindUserByEmail", mock.Anything, mock.Anything).Return(user, nil)
-		server := API(s.cfg, s.store)
+		s.store.Users.On("FindUserByEmail", mock.Anything, mock.Anything).Return(user, nil)
+		server := API(s.cfg, s.store.Stores())
 
 		body := `{"username":"louis@systemli.org","password":"WRONG"}`
 		req := httptest.NewRequest(http.MethodPost, "/v1/admin/login", strings.NewReader(body))
@@ -69,9 +69,9 @@ func (s *APITestSuite) TestLogin() {
 	s.Run("when login is successful", func() {
 		user, err := storage.NewUser("user@systemli.org", "password")
 		s.NoError(err)
-		s.store.On("FindUserByEmail", mock.Anything, mock.Anything).Return(user, nil)
-		s.store.On("SaveUser", mock.Anything).Return(nil)
-		server := API(s.cfg, s.store)
+		s.store.Users.On("FindUserByEmail", mock.Anything, mock.Anything).Return(user, nil)
+		s.store.Users.On("SaveUser", mock.Anything).Return(nil)
+		server := API(s.cfg, s.store.Stores())
 
 		body := `{"username":"louis@systemli.org","password":"password"}`
 		req := httptest.NewRequest(http.MethodPost, "/v1/admin/login", strings.NewReader(body))
@@ -96,10 +96,10 @@ func (s *APITestSuite) TestLogin() {
 	s.Run("when save user fails", func() {
 		user, err := storage.NewUser("user@systemli.org", "password")
 		s.NoError(err)
-		s.store.On("FindUserByEmail", mock.Anything, mock.Anything).Return(user, nil)
-		s.store.On("SaveUser", mock.Anything).Return(errors.New("failed to save user"))
+		s.store.Users.On("FindUserByEmail", mock.Anything, mock.Anything).Return(user, nil)
+		s.store.Users.On("SaveUser", mock.Anything).Return(errors.New("failed to save user"))
 
-		server := API(s.cfg, s.store)
+		server := API(s.cfg, s.store.Stores())
 
 		body := `{"username":"louis@systemli.org","password":"password"}`
 		req := httptest.NewRequest(http.MethodPost, "/v1/admin/login", strings.NewReader(body))
diff --git a/internal/api/features.go b/internal/api/features.go
index d147903e..540005a1 100644
--- a/internal/api/features.go
+++ b/internal/api/features.go
@@ -10,9 +10,9 @@ import (
 
 type FeaturesResponse map[string]bool
 
-func NewFeaturesResponse(storage storage.Storage) FeaturesResponse {
-	telegramSettings := storage.GetTelegramSettings()
-	signalGroupSettings := storage.GetSignalGroupSettings()
+func NewFeaturesResponse(settings storage.SettingsStore) FeaturesResponse {
+	telegramSettings := storage.GetSettings(settings, storage.TelegramSetting)
+	signalGroupSettings := storage.GetSettings(settings, storage.SignalGroupSetting)
 	return FeaturesResponse{
 		"telegramEnabled":    telegramSettings.Token != "",
 		"signalGroupEnabled": signalGroupSettings.Enabled(),
@@ -20,6 +20,6 @@ func NewFeaturesResponse(storage storage.Storage) FeaturesResponse {
 }
 
 func (h *handler) GetFeatures(c *gin.Context) {
-	features := NewFeaturesResponse(h.storage)
+	features := NewFeaturesResponse(h.stores.Settings)
 	c.JSON(http.StatusOK, response.SuccessResponse(map[string]interface{}{"features": features}))
 }
diff --git a/internal/api/features_test.go b/internal/api/features_test.go
index 2173ba30..64fa5f0a 100644
--- a/internal/api/features_test.go
+++ b/internal/api/features_test.go
@@ -22,16 +22,16 @@ func (s *FeaturesTestSuite) SetupTest() {
 func (s *FeaturesTestSuite) TestGetFeatures() {
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
-	store := &storage.MockStorage{}
+	store := storage.NewMockStorage()
 
 	// Mock GetTelegramSettings to return empty token (disabled)
-	store.On("GetTelegramSettings").Return(storage.TelegramSettings{Token: ""})
+	store.Settings.MockGetTelegram(storage.TelegramSettings{Token: ""})
 	// Mock GetSignalGroupSettings to return empty settings (disabled)
-	store.On("GetSignalGroupSettings").Return(storage.DefaultSignalGroupSettings())
+	store.Settings.MockGetSignalGroup(storage.DefaultSignalGroupSettings())
 
 	h := handler{
-		storage: store,
-		config:  config.LoadConfig(""),
+		stores: store.Stores(),
+		config: config.LoadConfig(""),
 	}
 
 	h.GetFeatures(c)
diff --git a/internal/api/feed.go b/internal/api/feed.go
index 9f85a6c8..ff2a58c8 100644
--- a/internal/api/feed.go
+++ b/internal/api/feed.go
@@ -22,7 +22,7 @@ func (h *handler) GetFeed(c *gin.Context) {
 	}
 
 	pagination := pagination.NewPagination(c)
-	messages, err := h.storage.FindMessagesByTickerAndPagination(ticker, *pagination)
+	messages, err := h.stores.Messages.FindMessagesByTickerAndPagination(ticker, *pagination)
 	if err != nil {
 		c.JSON(http.StatusOK, response.ErrorResponse(response.CodeDefault, response.MessageFetchError))
 		return
diff --git a/internal/api/feed_test.go b/internal/api/feed_test.go
index c384d9f2..e046352f 100644
--- a/internal/api/feed_test.go
+++ b/internal/api/feed_test.go
@@ -27,7 +27,7 @@ func (s *FeedTestSuite) SetupTest() {
 
 	s.w = httptest.NewRecorder()
 	s.ctx, _ = gin.CreateTestContext(s.w)
-	s.store = &storage.MockStorage{}
+	s.store = storage.NewMockStorage()
 	s.cfg = config.LoadConfig("")
 }
 
@@ -43,7 +43,7 @@ func (s *FeedTestSuite) TestGetFeed() {
 
 	s.Run("when fetching messages fails", func() {
 		s.ctx.Set("ticker", storage.Ticker{})
-		s.store.On("FindMessagesByTickerAndPagination", mock.Anything, mock.Anything).Return([]storage.Message{}, errors.New("storage error")).Once()
+		s.store.Messages.On("FindMessagesByTickerAndPagination", mock.Anything, mock.Anything).Return([]storage.Message{}, errors.New("storage error")).Once()
 
 		h := s.handler()
 		h.GetFeed(s.ctx)
@@ -69,7 +69,7 @@ func (s *FeedTestSuite) TestGetFeed() {
 			TickerID: ticker.ID,
 			Text:     "Text",
 		}
-		s.store.On("FindMessagesByTickerAndPagination", mock.Anything, mock.Anything).Return([]storage.Message{message}, nil).Once()
+		s.store.Messages.On("FindMessagesByTickerAndPagination", mock.Anything, mock.Anything).Return([]storage.Message{message}, nil).Once()
 
 		h := s.handler()
 		h.GetFeed(s.ctx)
@@ -81,8 +81,8 @@ func (s *FeedTestSuite) TestGetFeed() {
 
 func (s *FeedTestSuite) handler() handler {
 	return handler{
-		storage: s.store,
-		config:  s.cfg,
+		stores: s.store.Stores(),
+		config: s.cfg,
 	}
 }
 
diff --git a/internal/api/init.go b/internal/api/init.go
index 539fe7e9..60e0d318 100644
--- a/internal/api/init.go
+++ b/internal/api/init.go
@@ -6,6 +6,7 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/systemli/ticker/internal/api/helper"
 	"github.com/systemli/ticker/internal/api/response"
+	"github.com/systemli/ticker/internal/storage"
 )
 
 func (h *handler) GetInit(c *gin.Context) {
@@ -16,9 +17,9 @@ func (h *handler) GetInit(c *gin.Context) {
 		return
 	}
 
-	ticker, err := h.storage.FindTickerByOrigin(origin)
+	ticker, err := h.stores.Tickers.FindTickerByOrigin(origin)
 	if err != nil || !ticker.Active {
-		settings.InactiveSettings = h.storage.GetInactiveSettings()
+		settings.InactiveSettings = storage.GetSettings(h.stores.Settings, storage.InactiveSetting)
 		c.JSON(http.StatusOK, response.SuccessResponse(map[string]interface{}{"ticker": nil, "settings": settings}))
 		return
 	}
diff --git a/internal/api/init_test.go b/internal/api/init_test.go
index 2eba5681..d0a2e7f9 100644
--- a/internal/api/init_test.go
+++ b/internal/api/init_test.go
@@ -26,7 +26,7 @@ func (s *InitTestSuite) SetupTest() {
 
 	s.w = httptest.NewRecorder()
 	s.ctx, _ = gin.CreateTestContext(s.w)
-	s.store = &storage.MockStorage{}
+	s.store = storage.NewMockStorage()
 	s.cfg = config.LoadConfig("")
 }
 
@@ -38,20 +38,20 @@ func (s *InitTestSuite) TestGetInit() {
 
 		s.Equal(http.StatusOK, s.w.Code)
 		s.Equal(`{"data":{"settings":{},"ticker":null},"status":"success","error":{}}`, s.w.Body.String())
-		s.store.AssertNotCalled(s.T(), "FindTickerByOrigin", "", mock.Anything)
+		s.store.Tickers.AssertNotCalled(s.T(), "FindTickerByOrigin", "", mock.Anything)
 		s.store.AssertExpectations(s.T())
 	})
 
 	s.Run("when database returns error", func() {
 		s.ctx.Request = httptest.NewRequest(http.MethodGet, "/v1/init?origin=https://demoticker.org", nil)
-		s.store.On("FindTickerByOrigin", "https://demoticker.org", mock.Anything).Return(storage.Ticker{}, errors.New("storage error")).Once()
-		s.store.On("GetInactiveSettings").Return(storage.DefaultInactiveSettings()).Once()
+		s.store.Tickers.On("FindTickerByOrigin", "https://demoticker.org", mock.Anything).Return(storage.Ticker{}, errors.New("storage error")).Once()
+		s.store.Settings.MockGetInactive(storage.DefaultInactiveSettings()).Once()
 		h := s.handler()
 		h.GetInit(s.ctx)
 
 		s.Equal(http.StatusOK, s.w.Code)
 		s.Contains(s.w.Body.String(), `"ticker":null`)
-		s.store.AssertCalled(s.T(), "FindTickerByOrigin", "https://demoticker.org", mock.Anything)
+		s.store.Tickers.AssertCalled(s.T(), "FindTickerByOrigin", "https://demoticker.org", mock.Anything)
 		s.store.AssertExpectations(s.T())
 	})
 
@@ -59,34 +59,34 @@ func (s *InitTestSuite) TestGetInit() {
 		s.ctx.Request = httptest.NewRequest(http.MethodGet, "/v1/init?origin=https://demoticker.org", nil)
 		ticker := storage.NewTicker()
 		ticker.Active = false
-		s.store.On("FindTickerByOrigin", "https://demoticker.org", mock.Anything).Return(ticker, nil).Once()
-		s.store.On("GetInactiveSettings").Return(storage.DefaultInactiveSettings()).Once()
+		s.store.Tickers.On("FindTickerByOrigin", "https://demoticker.org", mock.Anything).Return(ticker, nil).Once()
+		s.store.Settings.MockGetInactive(storage.DefaultInactiveSettings()).Once()
 		h := s.handler()
 		h.GetInit(s.ctx)
 
 		s.Equal(http.StatusOK, s.w.Code)
 		s.Contains(s.w.Body.String(), `"ticker":null`)
-		s.store.AssertCalled(s.T(), "FindTickerByOrigin", "https://demoticker.org", mock.Anything)
+		s.store.Tickers.AssertCalled(s.T(), "FindTickerByOrigin", "https://demoticker.org", mock.Anything)
 	})
 
 	s.Run("when database returns an active ticker", func() {
 		s.ctx.Request = httptest.NewRequest(http.MethodGet, "/v1/init?origin=https://demoticker.org", nil)
 		ticker := storage.NewTicker()
 		ticker.Active = true
-		s.store.On("FindTickerByOrigin", "https://demoticker.org", mock.Anything).Return(ticker, nil).Once()
-		s.store.On("GetInactiveSettings").Return(storage.DefaultInactiveSettings()).Once()
+		s.store.Tickers.On("FindTickerByOrigin", "https://demoticker.org", mock.Anything).Return(ticker, nil).Once()
+		s.store.Settings.MockGetInactive(storage.DefaultInactiveSettings()).Once()
 		h := s.handler()
 		h.GetInit(s.ctx)
 
 		s.Equal(http.StatusOK, s.w.Code)
-		s.store.AssertCalled(s.T(), "FindTickerByOrigin", "https://demoticker.org", mock.Anything)
+		s.store.Tickers.AssertCalled(s.T(), "FindTickerByOrigin", "https://demoticker.org", mock.Anything)
 	})
 }
 
 func (s *InitTestSuite) handler() handler {
 	return handler{
-		storage: s.store,
-		config:  s.cfg,
+		stores: s.store.Stores(),
+		config: s.cfg,
 	}
 }
 
diff --git a/internal/api/manifest_test.go b/internal/api/manifest_test.go
index ba914b69..25beb311 100644
--- a/internal/api/manifest_test.go
+++ b/internal/api/manifest_test.go
@@ -25,7 +25,7 @@ func (s *ManifestTestSuite) SetupTest() {
 
 	s.w = httptest.NewRecorder()
 	s.ctx, _ = gin.CreateTestContext(s.w)
-	s.store = &storage.MockStorage{}
+	s.store = storage.NewMockStorage()
 	s.cfg = config.LoadConfig("")
 }
 
@@ -72,8 +72,8 @@ func (s *ManifestTestSuite) TestHandleManifest() {
 
 func (s *ManifestTestSuite) handler() handler {
 	return handler{
-		storage: s.store,
-		config:  s.cfg,
+		stores: s.store.Stores(),
+		config: s.cfg,
 	}
 }
 
diff --git a/internal/api/media.go b/internal/api/media.go
index 51511b9a..aa48918c 100644
--- a/internal/api/media.go
+++ b/internal/api/media.go
@@ -11,7 +11,7 @@ import (
 
 func (h *handler) GetMedia(c *gin.Context) {
 	parts := strings.Split(c.Param("fileName"), ".")
-	upload, err := h.storage.FindUploadByUUID(parts[0])
+	upload, err := h.stores.Uploads.FindUploadByUUID(parts[0])
 	if err != nil {
 		c.String(http.StatusNotFound, "%s", err.Error())
 		return
@@ -23,5 +23,5 @@ func (h *handler) GetMedia(c *gin.Context) {
 
 	c.Header("Cache-Control", cacheControl)
 	c.Header("Expires", expires)
-	c.File(upload.FullPath(h.storage.UploadPath()))
+	c.File(upload.FullPath(h.stores.Uploads.UploadPath()))
 }
diff --git a/internal/api/media_test.go b/internal/api/media_test.go
index 96ab9797..a72f0df6 100644
--- a/internal/api/media_test.go
+++ b/internal/api/media_test.go
@@ -27,13 +27,13 @@ func (s *MediaTestSuite) SetupTest() {
 	s.w = httptest.NewRecorder()
 	s.ctx, _ = gin.CreateTestContext(s.w)
 	s.ctx.Request = httptest.NewRequest(http.MethodGet, "/media", nil)
-	s.store = &storage.MockStorage{}
+	s.store = storage.NewMockStorage()
 	s.cfg = config.LoadConfig("")
 }
 
 func (s *MediaTestSuite) TestGetMedia() {
 	s.Run("when upload not found", func() {
-		s.store.On("FindUploadByUUID", mock.Anything).Return(storage.Upload{}, errors.New("not found")).Once()
+		s.store.Uploads.On("FindUploadByUUID", mock.Anything).Return(storage.Upload{}, errors.New("not found")).Once()
 		h := s.handler()
 		h.GetMedia(s.ctx)
 
@@ -43,8 +43,8 @@ func (s *MediaTestSuite) TestGetMedia() {
 
 	s.Run("when upload found", func() {
 		upload := storage.NewUpload("image.jpg", "image/jpeg", 1)
-		s.store.On("FindUploadByUUID", mock.Anything).Return(upload, nil).Once()
-		s.store.On("UploadPath").Return("./uploads").Once()
+		s.store.Uploads.On("FindUploadByUUID", mock.Anything).Return(upload, nil).Once()
+		s.store.Uploads.On("UploadPath").Return("./uploads").Once()
 
 		h := s.handler()
 		h.GetMedia(s.ctx)
@@ -56,8 +56,8 @@ func (s *MediaTestSuite) TestGetMedia() {
 
 func (s *MediaTestSuite) handler() handler {
 	return handler{
-		storage: s.store,
-		config:  s.cfg,
+		stores: s.store.Stores(),
+		config: s.cfg,
 	}
 }
 
diff --git a/internal/api/messages.go b/internal/api/messages.go
index 0bc5a25b..3e621d64 100644
--- a/internal/api/messages.go
+++ b/internal/api/messages.go
@@ -21,7 +21,7 @@ func (h *handler) GetMessages(c *gin.Context) {
 	}
 
 	pagination := pagination.NewPagination(c)
-	messages, err := h.storage.FindMessagesByTickerAndPagination(ticker, *pagination, storage.WithAttachments())
+	messages, err := h.stores.Messages.FindMessagesByTickerAndPagination(ticker, *pagination, storage.WithAttachments())
 	if err != nil {
 		c.JSON(http.StatusNotFound, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
@@ -61,7 +61,7 @@ func (h *handler) PostMessage(c *gin.Context) {
 
 	var uploads []storage.Upload
 	if len(body.Attachments) > 0 {
-		uploads, err = h.storage.FindUploadsByIDs(body.Attachments)
+		uploads, err = h.stores.Uploads.FindUploadsByIDs(body.Attachments)
 		if err != nil {
 			c.JSON(http.StatusNotFound, response.ErrorResponse(response.CodeNotFound, response.UploadsNotFound))
 			return
@@ -75,7 +75,7 @@ func (h *handler) PostMessage(c *gin.Context) {
 
 	_ = h.bridges.Send(ticker, &message)
 
-	err = h.storage.SaveMessage(&message)
+	err = h.stores.Messages.SaveMessage(&message)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
@@ -109,7 +109,7 @@ func (h *handler) DeleteMessage(c *gin.Context) {
 
 	_ = h.bridges.Delete(ticker, &message)
 
-	err = h.storage.DeleteMessage(message)
+	err = h.stores.Messages.DeleteMessage(message)
 	if err != nil {
 		c.JSON(http.StatusNotFound, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
diff --git a/internal/api/messages_test.go b/internal/api/messages_test.go
index 1692f585..9d20cc6e 100644
--- a/internal/api/messages_test.go
+++ b/internal/api/messages_test.go
@@ -34,7 +34,7 @@ func (s *MessagesTestSuite) Run(name string, subtest func()) {
 	s.T().Run(name, func(t *testing.T) {
 		s.w = httptest.NewRecorder()
 		s.ctx, _ = gin.CreateTestContext(s.w)
-		s.store = &storage.MockStorage{}
+		s.store = storage.NewMockStorage()
 		s.cfg = config.LoadConfig("")
 		s.cache = cache.NewCache(time.Minute)
 
@@ -54,7 +54,7 @@ func (s *MessagesTestSuite) TestGetMessages() {
 	s.Run("when database returns error", func() {
 		ticker := storage.Ticker{ID: 1}
 		s.ctx.Set("ticker", ticker)
-		s.store.On("FindMessagesByTickerAndPagination", ticker, mock.Anything, mock.Anything).Return([]storage.Message{}, errors.New("storage error")).Once()
+		s.store.Messages.On("FindMessagesByTickerAndPagination", ticker, mock.Anything, mock.Anything).Return([]storage.Message{}, errors.New("storage error")).Once()
 		h := s.handler()
 		h.GetMessages(s.ctx)
 
@@ -65,7 +65,7 @@ func (s *MessagesTestSuite) TestGetMessages() {
 	s.Run("when database returns messages", func() {
 		ticker := storage.Ticker{ID: 1}
 		s.ctx.Set("ticker", ticker)
-		s.store.On("FindMessagesByTickerAndPagination", ticker, mock.Anything, mock.Anything).Return([]storage.Message{}, nil).Once()
+		s.store.Messages.On("FindMessagesByTickerAndPagination", ticker, mock.Anything, mock.Anything).Return([]storage.Message{}, nil).Once()
 		h := s.handler()
 		h.GetMessages(s.ctx)
 
@@ -120,7 +120,7 @@ func (s *MessagesTestSuite) TestPostMessage() {
 		json := `{"text":"text","attachments":[1]}`
 		s.ctx.Request = httptest.NewRequest(http.MethodPost, "/v1/messages", strings.NewReader(json))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("FindUploadsByIDs", []int{1}).Return([]storage.Upload{}, errors.New("storage error")).Once()
+		s.store.Uploads.On("FindUploadsByIDs", []int{1}).Return([]storage.Upload{}, errors.New("storage error")).Once()
 		h := s.handler()
 		h.PostMessage(s.ctx)
 
@@ -135,8 +135,8 @@ func (s *MessagesTestSuite) TestPostMessage() {
 		s.ctx.Request = httptest.NewRequest(http.MethodPost, "/v1/messages", strings.NewReader(json))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
 		s.ctx.AddParam("tickerID", "1")
-		s.store.On("FindUploadsByIDs", []int{1}).Return([]storage.Upload{}, nil).Once()
-		s.store.On("SaveMessage", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Uploads.On("FindUploadsByIDs", []int{1}).Return([]storage.Upload{}, nil).Once()
+		s.store.Messages.On("SaveMessage", mock.Anything).Return(errors.New("storage error")).Once()
 		h := s.handler()
 		h.PostMessage(s.ctx)
 
@@ -151,8 +151,8 @@ func (s *MessagesTestSuite) TestPostMessage() {
 		s.ctx.Request = httptest.NewRequest(http.MethodPost, "/v1/messages", strings.NewReader(json))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
 		s.ctx.AddParam("tickerID", "1")
-		s.store.On("FindUploadsByIDs", []int{1}).Return([]storage.Upload{}, nil).Once()
-		s.store.On("SaveMessage", mock.Anything).Return(nil).Once()
+		s.store.Uploads.On("FindUploadsByIDs", []int{1}).Return([]storage.Upload{}, nil).Once()
+		s.store.Messages.On("SaveMessage", mock.Anything).Return(nil).Once()
 		h := s.handler()
 		h.PostMessage(s.ctx)
 
@@ -185,7 +185,7 @@ func (s *MessagesTestSuite) TestDeleteMessage() {
 		message := storage.Message{ID: 1}
 		s.ctx.Set("ticker", ticker)
 		s.ctx.Set("message", message)
-		s.store.On("DeleteMessage", message).Return(errors.New("storage error")).Once()
+		s.store.Messages.On("DeleteMessage", message).Return(errors.New("storage error")).Once()
 		h := s.handler()
 		h.DeleteMessage(s.ctx)
 
@@ -201,7 +201,7 @@ func (s *MessagesTestSuite) TestDeleteMessage() {
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
 		s.ctx.Set("ticker", ticker)
 		s.ctx.Set("message", message)
-		s.store.On("DeleteMessage", message).Return(nil).Once()
+		s.store.Messages.On("DeleteMessage", message).Return(nil).Once()
 		h := s.handler()
 		h.DeleteMessage(s.ctx)
 
@@ -213,7 +213,7 @@ func (s *MessagesTestSuite) TestDeleteMessage() {
 
 func (s *MessagesTestSuite) handler() handler {
 	return handler{
-		storage:  s.store,
+		stores:   s.store.Stores(),
 		config:   s.cfg,
 		cache:    s.cache,
 		realtime: realtime.New(),
diff --git a/internal/api/middleware/auth/auth.go b/internal/api/middleware/auth/auth.go
index e014477d..41fb6420 100644
--- a/internal/api/middleware/auth/auth.go
+++ b/internal/api/middleware/auth/auth.go
@@ -13,7 +13,7 @@ import (
 
 var log = logger.GetWithPackage("auth")
 
-func AuthMiddleware(s storage.Storage, secret string) *jwt.GinJWTMiddleware {
+func AuthMiddleware(s storage.UserStore, secret string) *jwt.GinJWTMiddleware {
 	config := &jwt.GinJWTMiddleware{
 		Realm:         "ticker admin",
 		Key:           []byte(secret),
@@ -36,7 +36,7 @@ func AuthMiddleware(s storage.Storage, secret string) *jwt.GinJWTMiddleware {
 	return middleware
 }
 
-func Authenticator(s storage.Storage) func(c *gin.Context) (interface{}, error) {
+func Authenticator(s storage.UserStore) func(c *gin.Context) (interface{}, error) {
 	return func(c *gin.Context) (interface{}, error) {
 		type login struct {
 			Username string `form:"username" json:"username" binding:"required"`
@@ -67,7 +67,7 @@ func Authenticator(s storage.Storage) func(c *gin.Context) (interface{}, error)
 	}
 }
 
-func Authorizator(s storage.Storage) func(data interface{}, c *gin.Context) bool {
+func Authorizator(s storage.UserStore) func(data interface{}, c *gin.Context) bool {
 	return func(data interface{}, c *gin.Context) bool {
 		id := int(data.(float64))
 
diff --git a/internal/api/middleware/auth/auth_test.go b/internal/api/middleware/auth/auth_test.go
index b35e8e0d..e39faec1 100644
--- a/internal/api/middleware/auth/auth_test.go
+++ b/internal/api/middleware/auth/auth_test.go
@@ -26,7 +26,7 @@ func (s *AuthTestSuite) SetupTest() {
 
 func (s *AuthTestSuite) TestAuthenticator() {
 	s.Run("when form is empty", func() {
-		mockStorage := &storage.MockStorage{}
+		mockStorage := &storage.MockUserStore{}
 		authenticator := Authenticator(mockStorage)
 		c, _ := gin.CreateTestContext(httptest.NewRecorder())
 		c.Request = httptest.NewRequest(http.MethodPost, "/login", strings.NewReader(`{}`))
@@ -37,7 +37,7 @@ func (s *AuthTestSuite) TestAuthenticator() {
 	})
 
 	s.Run("when user is not found", func() {
-		mockStorage := &storage.MockStorage{}
+		mockStorage := &storage.MockUserStore{}
 		mockStorage.On("FindUserByEmail", mock.Anything, mock.Anything).Return(storage.User{}, errors.New("not found"))
 
 		authenticator := Authenticator(mockStorage)
@@ -54,7 +54,7 @@ func (s *AuthTestSuite) TestAuthenticator() {
 		user, err := storage.NewUser("user@systemli.org", "password")
 		s.NoError(err)
 
-		mockStorage := &storage.MockStorage{}
+		mockStorage := &storage.MockUserStore{}
 		mockStorage.On("FindUserByEmail", mock.Anything, mock.Anything).Return(user, nil)
 		mockStorage.On("SaveUser", mock.Anything).Return(nil)
 		authenticator := Authenticator(mockStorage)
@@ -84,7 +84,7 @@ func (s *AuthTestSuite) TestAuthenticator() {
 
 func (s *AuthTestSuite) TestAuthorizator() {
 	s.Run("when user is not found", func() {
-		mockStorage := &storage.MockStorage{}
+		mockStorage := &storage.MockUserStore{}
 		mockStorage.On("FindUserByID", mock.Anything).Return(storage.User{}, errors.New("not found"))
 		authorizator := Authorizator(mockStorage)
 		c, _ := gin.CreateTestContext(httptest.NewRecorder())
@@ -94,7 +94,7 @@ func (s *AuthTestSuite) TestAuthorizator() {
 	})
 
 	s.Run("when user is found", func() {
-		mockStorage := &storage.MockStorage{}
+		mockStorage := &storage.MockUserStore{}
 		mockStorage.On("FindUserByID", mock.Anything).Return(storage.User{ID: 1}, nil)
 		authorizator := Authorizator(mockStorage)
 		c, _ := gin.CreateTestContext(httptest.NewRecorder())
diff --git a/internal/api/middleware/me/me.go b/internal/api/middleware/me/me.go
index 46f1fa22..c6d81a8b 100644
--- a/internal/api/middleware/me/me.go
+++ b/internal/api/middleware/me/me.go
@@ -8,7 +8,7 @@ import (
 	"github.com/systemli/ticker/internal/storage"
 )
 
-func MeMiddleware(store storage.Storage) gin.HandlerFunc {
+func MeMiddleware(store storage.UserStore) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		userID, exists := c.Get("id")
 		if !exists {
diff --git a/internal/api/middleware/me/me_test.go b/internal/api/middleware/me/me_test.go
index b38e9230..8d4dd739 100644
--- a/internal/api/middleware/me/me_test.go
+++ b/internal/api/middleware/me/me_test.go
@@ -22,7 +22,7 @@ func (s *MeTestSuite) SetupTest() {
 
 func (s *MeTestSuite) TestMeMiddleware() {
 	s.Run("when id is not present", func() {
-		mockStorage := &storage.MockStorage{}
+		mockStorage := &storage.MockUserStore{}
 		mw := MeMiddleware(mockStorage)
 		w := httptest.NewRecorder()
 		c, _ := gin.CreateTestContext(w)
@@ -34,7 +34,7 @@ func (s *MeTestSuite) TestMeMiddleware() {
 
 	s.Run("when id is present", func() {
 		s.Run("when user is not found", func() {
-			mockStorage := &storage.MockStorage{}
+			mockStorage := &storage.MockUserStore{}
 			mockStorage.On("FindUserByID", mock.Anything, mock.Anything).Return(storage.User{}, errors.New("not found"))
 			mw := MeMiddleware(mockStorage)
 			w := httptest.NewRecorder()
@@ -47,7 +47,7 @@ func (s *MeTestSuite) TestMeMiddleware() {
 		})
 
 		s.Run("when user is found", func() {
-			mockStorage := &storage.MockStorage{}
+			mockStorage := &storage.MockUserStore{}
 			mockStorage.On("FindUserByID", mock.Anything, mock.Anything).Return(storage.User{ID: 1}, nil)
 			mw := MeMiddleware(mockStorage)
 			w := httptest.NewRecorder()
diff --git a/internal/api/middleware/message/message.go b/internal/api/middleware/message/message.go
index 8aeef79b..cb0ed59b 100644
--- a/internal/api/middleware/message/message.go
+++ b/internal/api/middleware/message/message.go
@@ -10,7 +10,7 @@ import (
 	"github.com/systemli/ticker/internal/storage"
 )
 
-func PrefetchMessage(s storage.Storage) gin.HandlerFunc {
+func PrefetchMessage(s storage.MessageStore) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		ticker, _ := helper.Ticker(c)
 
diff --git a/internal/api/middleware/message/message_test.go b/internal/api/middleware/message/message_test.go
index 0398baed..21ef3f94 100644
--- a/internal/api/middleware/message/message_test.go
+++ b/internal/api/middleware/message/message_test.go
@@ -25,7 +25,7 @@ func (s *MessageTestSuite) TestMessage() {
 		w := httptest.NewRecorder()
 		c, _ := gin.CreateTestContext(w)
 		c.Set("ticker", storage.Ticker{})
-		store := &storage.MockStorage{}
+		store := &storage.MockMessageStore{}
 		mw := PrefetchMessage(store)
 
 		mw(c)
@@ -38,7 +38,7 @@ func (s *MessageTestSuite) TestMessage() {
 		c, _ := gin.CreateTestContext(w)
 		c.AddParam("messageID", "1")
 		c.Set("ticker", storage.Ticker{})
-		store := &storage.MockStorage{}
+		store := &storage.MockMessageStore{}
 		store.On("FindMessage", mock.Anything, mock.Anything, mock.Anything).Return(storage.Message{}, errors.New("storage error"))
 		mw := PrefetchMessage(store)
 
@@ -52,7 +52,7 @@ func (s *MessageTestSuite) TestMessage() {
 		c, _ := gin.CreateTestContext(w)
 		c.AddParam("messageID", "1")
 		c.Set("ticker", storage.Ticker{})
-		store := &storage.MockStorage{}
+		store := &storage.MockMessageStore{}
 		message := storage.Message{ID: 1}
 		store.On("FindMessage", mock.Anything, mock.Anything, mock.Anything).Return(message, nil)
 		mw := PrefetchMessage(store)
diff --git a/internal/api/middleware/ticker/ticker.go b/internal/api/middleware/ticker/ticker.go
index 8df87eee..8f77d5b8 100644
--- a/internal/api/middleware/ticker/ticker.go
+++ b/internal/api/middleware/ticker/ticker.go
@@ -8,10 +8,9 @@ import (
 	"github.com/systemli/ticker/internal/api/helper"
 	"github.com/systemli/ticker/internal/api/response"
 	"github.com/systemli/ticker/internal/storage"
-	"gorm.io/gorm"
 )
 
-func PrefetchTicker(s storage.Storage, opts ...func(*gorm.DB) *gorm.DB) gin.HandlerFunc {
+func PrefetchTicker(s storage.TickerStore, opts ...storage.QueryOpt) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		user, _ := helper.Me(c)
 		tickerID, err := strconv.Atoi(c.Param("tickerID"))
@@ -30,7 +29,7 @@ func PrefetchTicker(s storage.Storage, opts ...func(*gorm.DB) *gorm.DB) gin.Hand
 	}
 }
 
-func PrefetchTickerFromRequest(s storage.Storage, opts ...func(*gorm.DB) *gorm.DB) gin.HandlerFunc {
+func PrefetchTickerFromRequest(s storage.TickerStore, opts ...storage.QueryOpt) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		origin, err := helper.GetOrigin(c)
 		if err != nil {
diff --git a/internal/api/middleware/ticker/ticker_test.go b/internal/api/middleware/ticker/ticker_test.go
index 0ce9ab34..41b45e3b 100644
--- a/internal/api/middleware/ticker/ticker_test.go
+++ b/internal/api/middleware/ticker/ticker_test.go
@@ -24,7 +24,7 @@ func (s *TickerTestSuite) TestPrefetchTicker() {
 	s.Run("when param is missing", func() {
 		w := httptest.NewRecorder()
 		c, _ := gin.CreateTestContext(w)
-		store := &storage.MockStorage{}
+		store := &storage.MockTickerStore{}
 		mw := PrefetchTicker(store)
 
 		mw(c)
@@ -36,7 +36,7 @@ func (s *TickerTestSuite) TestPrefetchTicker() {
 		w := httptest.NewRecorder()
 		c, _ := gin.CreateTestContext(w)
 		c.AddParam("tickerID", "1")
-		store := &storage.MockStorage{}
+		store := &storage.MockTickerStore{}
 		store.On("FindTickerByUserAndID", mock.Anything, mock.Anything, mock.Anything).Return(storage.Ticker{}, errors.New("storage error"))
 		mw := PrefetchTicker(store)
 
@@ -49,7 +49,7 @@ func (s *TickerTestSuite) TestPrefetchTicker() {
 		w := httptest.NewRecorder()
 		c, _ := gin.CreateTestContext(w)
 		c.AddParam("tickerID", "1")
-		store := &storage.MockStorage{}
+		store := &storage.MockTickerStore{}
 		ticker := storage.Ticker{ID: 1}
 		store.On("FindTickerByUserAndID", mock.Anything, mock.Anything, mock.Anything).Return(ticker, nil)
 		mw := PrefetchTicker(store)
@@ -67,7 +67,7 @@ func (s *TickerTestSuite) TestPrefetchTickerFromRequest() {
 		w := httptest.NewRecorder()
 		c, _ := gin.CreateTestContext(w)
 		c.Request = httptest.NewRequest(http.MethodGet, "/v1/timeline", nil)
-		store := &storage.MockStorage{}
+		store := &storage.MockTickerStore{}
 		mw := PrefetchTickerFromRequest(store)
 
 		mw(c)
@@ -83,7 +83,7 @@ func (s *TickerTestSuite) TestPrefetchTickerFromRequest() {
 		c, _ := gin.CreateTestContext(w)
 		c.Request = httptest.NewRequest(http.MethodGet, "/v1/timeline", nil)
 		c.Request.Header.Set("Origin", "https://demoticker.org")
-		store := &storage.MockStorage{}
+		store := &storage.MockTickerStore{}
 		store.On("FindTickerByOrigin", mock.Anything).Return(storage.Ticker{}, errors.New("not found"))
 		mw := PrefetchTickerFromRequest(store)
 
@@ -100,7 +100,7 @@ func (s *TickerTestSuite) TestPrefetchTickerFromRequest() {
 		c, _ := gin.CreateTestContext(w)
 		c.Request = httptest.NewRequest(http.MethodGet, "/v1/timeline", nil)
 		c.Request.Header.Set("Origin", "https://demoticker.org")
-		store := &storage.MockStorage{}
+		store := &storage.MockTickerStore{}
 		store.On("FindTickerByOrigin", mock.Anything).Return(storage.Ticker{}, nil)
 		mw := PrefetchTickerFromRequest(store)
 
diff --git a/internal/api/middleware/user/user.go b/internal/api/middleware/user/user.go
index e008489b..09dd63ec 100644
--- a/internal/api/middleware/user/user.go
+++ b/internal/api/middleware/user/user.go
@@ -9,7 +9,7 @@ import (
 	"github.com/systemli/ticker/internal/storage"
 )
 
-func PrefetchUser(s storage.Storage) gin.HandlerFunc {
+func PrefetchUser(s storage.UserStore) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		userID, err := strconv.Atoi(c.Param("userID"))
 		if err != nil {
diff --git a/internal/api/middleware/user/user_test.go b/internal/api/middleware/user/user_test.go
index ed1f1155..21b06323 100644
--- a/internal/api/middleware/user/user_test.go
+++ b/internal/api/middleware/user/user_test.go
@@ -24,7 +24,7 @@ func (s *UserTestSuite) TestPrefetchUser() {
 	s.Run("when param is missing", func() {
 		w := httptest.NewRecorder()
 		c, _ := gin.CreateTestContext(w)
-		store := &storage.MockStorage{}
+		store := &storage.MockUserStore{}
 		mw := PrefetchUser(store)
 
 		mw(c)
@@ -36,7 +36,7 @@ func (s *UserTestSuite) TestPrefetchUser() {
 		w := httptest.NewRecorder()
 		c, _ := gin.CreateTestContext(w)
 		c.AddParam("userID", "1")
-		store := &storage.MockStorage{}
+		store := &storage.MockUserStore{}
 		store.On("FindUserByID", mock.Anything, mock.Anything).Return(storage.User{}, errors.New("storage error"))
 		mw := PrefetchUser(store)
 
@@ -49,7 +49,7 @@ func (s *UserTestSuite) TestPrefetchUser() {
 		w := httptest.NewRecorder()
 		c, _ := gin.CreateTestContext(w)
 		c.AddParam("userID", "1")
-		store := &storage.MockStorage{}
+		store := &storage.MockUserStore{}
 		user := storage.User{ID: 1}
 		store.On("FindUserByID", mock.Anything, mock.Anything).Return(user, nil)
 		mw := PrefetchUser(store)
diff --git a/internal/api/settings.go b/internal/api/settings.go
index 155dfb9d..eb23155d 100644
--- a/internal/api/settings.go
+++ b/internal/api/settings.go
@@ -18,21 +18,21 @@ func (h *handler) GetSetting(c *gin.Context) {
 	}
 
 	if c.Param("name") == storage.SettingInactiveName {
-		setting := h.storage.GetInactiveSettings()
+		setting := storage.GetSettings(h.stores.Settings, storage.InactiveSetting)
 		data := map[string]interface{}{"setting": response.InactiveSettingsResponse(setting)}
 		c.JSON(http.StatusOK, response.SuccessResponse(data))
 		return
 	}
 
 	if c.Param("name") == storage.SettingTelegramName {
-		setting := h.storage.GetTelegramSettings()
+		setting := storage.GetSettings(h.stores.Settings, storage.TelegramSetting)
 		data := map[string]interface{}{"setting": response.TelegramSettingsResponse(setting)}
 		c.JSON(http.StatusOK, response.SuccessResponse(data))
 		return
 	}
 
 	if c.Param("name") == storage.SettingSignalGroupName {
-		setting := h.storage.GetSignalGroupSettings()
+		setting := storage.GetSettings(h.stores.Settings, storage.SignalGroupSetting)
 		data := map[string]interface{}{"setting": response.SignalGroupSettingsResponse(setting)}
 		c.JSON(http.StatusOK, response.SuccessResponse(data))
 		return
@@ -49,13 +49,13 @@ func (h *handler) PutInactiveSettings(c *gin.Context) {
 		return
 	}
 
-	err = h.storage.SaveInactiveSettings(value)
+	err = storage.SaveSettings(h.stores.Settings, storage.InactiveSetting, value)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
 	}
 
-	setting := h.storage.GetInactiveSettings()
+	setting := storage.GetSettings(h.stores.Settings, storage.InactiveSetting)
 	data := map[string]interface{}{"setting": response.InactiveSettingsResponse(setting)}
 	c.JSON(http.StatusOK, response.SuccessResponse(data))
 }
@@ -78,13 +78,13 @@ func (h *handler) PutTelegramSettings(c *gin.Context) {
 		value.BotUsername = botUser.UserName
 	}
 
-	err = h.storage.SaveTelegramSettings(value)
+	err = storage.SaveSettings(h.stores.Settings, storage.TelegramSetting, value)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
 	}
 
-	setting := h.storage.GetTelegramSettings()
+	setting := storage.GetSettings(h.stores.Settings, storage.TelegramSetting)
 	data := map[string]interface{}{"setting": response.TelegramSettingsResponse(setting)}
 	c.JSON(http.StatusOK, response.SuccessResponse(data))
 }
@@ -107,13 +107,13 @@ func (h *handler) PutSignalGroupSettings(c *gin.Context) {
 		}
 	}
 
-	err = h.storage.SaveSignalGroupSettings(value)
+	err = storage.SaveSettings(h.stores.Settings, storage.SignalGroupSetting, value)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
 	}
 
-	setting := h.storage.GetSignalGroupSettings()
+	setting := storage.GetSettings(h.stores.Settings, storage.SignalGroupSetting)
 	data := map[string]interface{}{"setting": response.SignalGroupSettingsResponse(setting)}
 	c.JSON(http.StatusOK, response.SuccessResponse(data))
 }
diff --git a/internal/api/settings_test.go b/internal/api/settings_test.go
index dd994046..adf1ddf9 100644
--- a/internal/api/settings_test.go
+++ b/internal/api/settings_test.go
@@ -10,7 +10,6 @@ import (
 
 	"github.com/gin-gonic/gin"
 	"github.com/goccy/go-json"
-	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
 	"github.com/systemli/ticker/internal/config"
 	"github.com/systemli/ticker/internal/storage"
@@ -33,7 +32,7 @@ func (s *SettingsTestSuite) Run(name string, subtest func()) {
 		s.w = httptest.NewRecorder()
 		s.ctx, _ = gin.CreateTestContext(s.w)
 		s.ctx.Set("me", storage.User{ID: 1, IsSuperAdmin: true})
-		s.store = &storage.MockStorage{}
+		s.store = storage.NewMockStorage()
 		s.cfg = config.LoadConfig("")
 
 		subtest()
@@ -51,7 +50,7 @@ func (s *SettingsTestSuite) TestGetSetting() {
 
 	s.Run("get inactive settings", func() {
 		s.ctx.AddParam("name", storage.SettingInactiveName)
-		s.store.On("GetInactiveSettings").Return(storage.InactiveSettings{}).Once()
+		s.store.Settings.MockGetInactive(storage.InactiveSettings{}).Once()
 		h := s.handler()
 		h.GetSetting(s.ctx)
 
@@ -62,7 +61,7 @@ func (s *SettingsTestSuite) TestGetSetting() {
 	s.Run("get telegram settings", func() {
 		s.ctx.AddParam("name", storage.SettingTelegramName)
 		expectedSettings := storage.TelegramSettings{Token: "123456789:ABCdefGHIjklMNOpqrsTUVwxyz", BotUsername: "test_bot"}
-		s.store.On("GetTelegramSettings").Return(expectedSettings).Once()
+		s.store.Settings.MockGetTelegram(expectedSettings).Once()
 		h := s.handler()
 		h.GetSetting(s.ctx)
 
@@ -82,7 +81,7 @@ func (s *SettingsTestSuite) TestGetSetting() {
 			Account: "0123456789",
 			Avatar:  "/path/to/avatar.png",
 		}
-		s.store.On("GetSignalGroupSettings").Return(expectedSettings).Once()
+		s.store.Settings.MockGetSignalGroup(expectedSettings).Once()
 		h := s.handler()
 		h.GetSetting(s.ctx)
 
@@ -119,7 +118,7 @@ func (s *SettingsTestSuite) TestPutInactiveSetting() {
 		body, _ := json.Marshal(setting)
 		s.ctx.Request = httptest.NewRequest(http.MethodPost, "/v1/admin/settings", bytes.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveInactiveSettings", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Settings.MockSaveInactive(errors.New("storage error")).Once()
 		h := s.handler()
 		h.PutInactiveSettings(s.ctx)
 
@@ -132,8 +131,8 @@ func (s *SettingsTestSuite) TestPutInactiveSetting() {
 		body, _ := json.Marshal(setting)
 		s.ctx.Request = httptest.NewRequest(http.MethodPost, "/v1/admin/settings", bytes.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveInactiveSettings", mock.Anything).Return(nil).Once()
-		s.store.On("GetInactiveSettings").Return(setting)
+		s.store.Settings.MockSaveInactive(nil).Once()
+		s.store.Settings.MockGetInactive(setting)
 		h := s.handler()
 		h.PutInactiveSettings(s.ctx)
 
@@ -158,7 +157,7 @@ func (s *SettingsTestSuite) TestPutTelegramSettings() {
 		body, _ := json.Marshal(setting)
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/settings/telegram_settings", bytes.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveTelegramSettings", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Settings.MockSaveTelegram(errors.New("storage error")).Once()
 		h := s.handler()
 		h.PutTelegramSettings(s.ctx)
 
@@ -171,8 +170,8 @@ func (s *SettingsTestSuite) TestPutTelegramSettings() {
 		body, _ := json.Marshal(setting)
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/settings/telegram_settings", bytes.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveTelegramSettings", mock.Anything).Return(nil).Once()
-		s.store.On("GetTelegramSettings").Return(setting)
+		s.store.Settings.MockSaveTelegram(nil).Once()
+		s.store.Settings.MockGetTelegram(setting)
 		h := s.handler()
 		h.PutTelegramSettings(s.ctx)
 
@@ -199,7 +198,7 @@ func (s *SettingsTestSuite) TestPutSignalGroupSettings() {
 		body, _ := json.Marshal(setting)
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/settings/signal_group_settings", bytes.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveSignalGroupSettings", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Settings.MockSaveSignalGroup(errors.New("storage error")).Once()
 		h := s.handler()
 		h.PutSignalGroupSettings(s.ctx)
 
@@ -212,8 +211,8 @@ func (s *SettingsTestSuite) TestPutSignalGroupSettings() {
 		body, _ := json.Marshal(setting)
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/settings/signal_group_settings", bytes.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveSignalGroupSettings", mock.Anything).Return(nil).Once()
-		s.store.On("GetSignalGroupSettings").Return(setting)
+		s.store.Settings.MockSaveSignalGroup(nil).Once()
+		s.store.Settings.MockGetSignalGroup(setting)
 		h := s.handler()
 		h.PutSignalGroupSettings(s.ctx)
 
@@ -225,8 +224,8 @@ func (s *SettingsTestSuite) TestPutSignalGroupSettings() {
 
 func (s *SettingsTestSuite) handler() handler {
 	return handler{
-		storage: s.store,
-		config:  s.cfg,
+		stores: s.store.Stores(),
+		config: s.cfg,
 	}
 }
 
diff --git a/internal/api/tickers.go b/internal/api/tickers.go
index 7752da26..ab9b0c75 100644
--- a/internal/api/tickers.go
+++ b/internal/api/tickers.go
@@ -65,7 +65,7 @@ func (h *handler) GetTickers(c *gin.Context) {
 	}
 
 	filter := storage.NewTickerFilter(c.Request)
-	tickers, err := h.storage.FindTickersByUser(me, filter, storage.WithPreload())
+	tickers, err := h.stores.Tickers.FindTickersByUser(me, filter, storage.WithPreload())
 	if err != nil {
 		c.JSON(http.StatusNotFound, response.ErrorResponse(response.CodeDefault, response.TickerNotFound))
 		return
@@ -91,7 +91,7 @@ func (h *handler) GetTickerUsers(c *gin.Context) {
 		return
 	}
 
-	users, _ := h.storage.FindUsersByTicker(ticker)
+	users, _ := h.stores.Tickers.FindUsersByTicker(ticker)
 
 	c.JSON(http.StatusOK, response.SuccessResponse(map[string]interface{}{"users": response.UsersResponse(users)}))
 }
@@ -104,7 +104,7 @@ func (h *handler) PostTicker(c *gin.Context) {
 		return
 	}
 
-	err = h.storage.SaveTicker(&ticker)
+	err = h.stores.Tickers.SaveTicker(&ticker)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
@@ -133,7 +133,7 @@ func (h *handler) PutTicker(c *gin.Context) {
 		return
 	}
 
-	err = h.storage.SaveTicker(&ticker)
+	err = h.stores.Tickers.SaveTicker(&ticker)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
@@ -162,14 +162,14 @@ func (h *handler) PutTickerUsers(c *gin.Context) {
 	for _, user := range body.Users {
 		userIds = append(userIds, user.ID)
 	}
-	users, err := h.storage.FindUsersByIDs(userIds)
+	users, err := h.stores.Users.FindUsersByIDs(userIds)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
 	}
 
 	ticker.Users = users
-	err = h.storage.SaveTicker(&ticker)
+	err = h.stores.Tickers.SaveTicker(&ticker)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
@@ -201,9 +201,9 @@ func (h *handler) PutTickerWebsites(c *gin.Context) {
 	}
 
 	if len(websites) == 0 {
-		err = h.storage.DeleteTickerWebsites(&ticker)
+		err = h.stores.Tickers.DeleteTickerWebsites(&ticker)
 	} else {
-		err = h.storage.SaveTickerWebsites(&ticker, websites)
+		err = h.stores.Tickers.SaveTickerWebsites(&ticker, websites)
 	}
 	if err != nil {
 		c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.StorageError))
@@ -222,7 +222,7 @@ func (h *handler) DeleteTickerWebsites(c *gin.Context) {
 		return
 	}
 
-	err = h.storage.DeleteTickerWebsites(&ticker)
+	err = h.stores.Tickers.DeleteTickerWebsites(&ticker)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
@@ -252,7 +252,7 @@ func (h *handler) PutTickerTelegram(c *gin.Context) {
 		ticker.Telegram.ChannelName = body.ChannelName
 	}
 
-	err = h.storage.SaveTicker(&ticker)
+	err = h.stores.Tickers.SaveTicker(&ticker)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
@@ -268,7 +268,7 @@ func (h *handler) DeleteTickerTelegram(c *gin.Context) {
 		return
 	}
 
-	err = h.storage.DeleteTelegram(&ticker)
+	err = h.stores.Tickers.ClearIntegration(&ticker, storage.IntegrationTelegram)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
@@ -318,7 +318,7 @@ func (h *handler) PutTickerMastodon(c *gin.Context) {
 
 	ticker.Mastodon.Active = body.Active
 
-	err = h.storage.SaveTicker(&ticker)
+	err = h.stores.Tickers.SaveTicker(&ticker)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
@@ -334,7 +334,7 @@ func (h *handler) DeleteTickerMastodon(c *gin.Context) {
 		return
 	}
 
-	err = h.storage.DeleteMastodon(&ticker)
+	err = h.stores.Tickers.ClearIntegration(&ticker, storage.IntegrationMastodon)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
@@ -370,7 +370,7 @@ func (h *handler) PutTickerBluesky(c *gin.Context) {
 	ticker.Bluesky.Active = body.Active
 	ticker.Bluesky.ReplyRestriction = body.ReplyRestriction
 
-	err = h.storage.SaveTicker(&ticker)
+	err = h.stores.Tickers.SaveTicker(&ticker)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
@@ -386,7 +386,7 @@ func (h *handler) DeleteTickerBluesky(c *gin.Context) {
 		return
 	}
 
-	err = h.storage.DeleteBluesky(&ticker)
+	err = h.stores.Tickers.ClearIntegration(&ticker, storage.IntegrationBluesky)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
@@ -409,7 +409,7 @@ func (h *handler) PutTickerSignalGroup(c *gin.Context) {
 		return
 	}
 
-	settings := h.storage.GetSignalGroupSettings()
+	settings := storage.GetSettings(h.stores.Settings, storage.SignalGroupSetting)
 	groupClient := signal.NewGroupClientFromSettings(settings)
 	err = groupClient.CreateOrUpdateGroup(&ticker)
 	if err != nil {
@@ -419,7 +419,7 @@ func (h *handler) PutTickerSignalGroup(c *gin.Context) {
 	}
 	ticker.SignalGroup.Active = body.Active
 
-	err = h.storage.SaveTicker(&ticker)
+	err = h.stores.Tickers.SaveTicker(&ticker)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
@@ -435,7 +435,7 @@ func (h *handler) DeleteTickerSignalGroup(c *gin.Context) {
 		return
 	}
 
-	settings := h.storage.GetSignalGroupSettings()
+	settings := storage.GetSettings(h.stores.Settings, storage.SignalGroupSetting)
 	groupClient := signal.NewGroupClientFromSettings(settings)
 
 	// Remove all members except the account number
@@ -452,7 +452,7 @@ func (h *handler) DeleteTickerSignalGroup(c *gin.Context) {
 		return
 	}
 
-	err = h.storage.DeleteSignalGroup(&ticker)
+	err = h.stores.Tickers.ClearIntegration(&ticker, storage.IntegrationSignalGroup)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
@@ -478,7 +478,7 @@ func (h *handler) PutTickerSignalGroupAdmin(c *gin.Context) {
 		return
 	}
 
-	settings := h.storage.GetSignalGroupSettings()
+	settings := storage.GetSettings(h.stores.Settings, storage.SignalGroupSetting)
 	groupClient := signal.NewGroupClientFromSettings(settings)
 	err = groupClient.AddAdminMember(ticker.SignalGroup.GroupID, body.Number)
 	if err != nil {
@@ -497,7 +497,7 @@ func (h *handler) DeleteTicker(c *gin.Context) {
 		return
 	}
 
-	err = h.storage.DeleteTicker(&ticker)
+	err = h.stores.Tickers.DeleteTicker(&ticker)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
@@ -521,13 +521,13 @@ func (h *handler) DeleteTickerUser(c *gin.Context) {
 		return
 	}
 
-	user, err := h.storage.FindUserByID(userID)
+	user, err := h.stores.Users.FindUserByID(userID)
 	if err != nil {
 		c.JSON(http.StatusNotFound, response.ErrorResponse(response.CodeDefault, response.UserNotFound))
 		return
 	}
 
-	err = h.storage.DeleteTickerUser(&ticker, &user)
+	err = h.stores.Tickers.DeleteTickerUser(&ticker, &user)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
@@ -543,7 +543,7 @@ func (h *handler) ResetTicker(c *gin.Context) {
 		return
 	}
 
-	err = h.storage.ResetTicker(&ticker)
+	err = h.stores.Tickers.ResetTicker(&ticker)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
@@ -594,6 +594,6 @@ func updateTicker(t *storage.Ticker, c *gin.Context) error {
 
 // getBotUsername retrieves the Telegram bot username from settings
 func (h *handler) getBotUsername() string {
-	telegramSettings := h.storage.GetTelegramSettings()
+	telegramSettings := storage.GetSettings(h.stores.Settings, storage.TelegramSetting)
 	return telegramSettings.BotUsername
 }
diff --git a/internal/api/tickers_test.go b/internal/api/tickers_test.go
index ef40f9cb..93061a13 100644
--- a/internal/api/tickers_test.go
+++ b/internal/api/tickers_test.go
@@ -40,12 +40,12 @@ func (s *TickerTestSuite) Run(name string, subtest func()) {
 	s.T().Run(name, func(t *testing.T) {
 		s.w = httptest.NewRecorder()
 		s.ctx, _ = gin.CreateTestContext(s.w)
-		s.store = &storage.MockStorage{}
+		s.store = storage.NewMockStorage()
 
 		// Add default mock expectation for GetTelegramSettings which is called by getBotUsername
-		s.store.On("GetTelegramSettings").Return(storage.TelegramSettings{Token: "", BotUsername: ""}).Maybe()
+		s.store.Settings.MockGetTelegram(storage.TelegramSettings{Token: "", BotUsername: ""}).Maybe()
 		// Add default mock expectation for GetSignalGroupSettings which is called by signal group handlers
-		s.store.On("GetSignalGroupSettings").Return(storage.SignalGroupSettings{
+		s.store.Settings.MockGetSignalGroup(storage.SignalGroupSettings{
 			ApiUrl:  "https://signal-cli.example.org/api/v1/rpc",
 			Account: "+1234567890",
 		}).Maybe()
@@ -68,7 +68,7 @@ func (s *TickerTestSuite) TestGetTickers() {
 
 	s.Run("when storage returns an error", func() {
 		s.ctx.Set("me", storage.User{IsSuperAdmin: true})
-		s.store.On("FindTickersByUser", mock.Anything, mock.Anything, mock.Anything).Return([]storage.Ticker{}, errors.New("storage error")).Once()
+		s.store.Tickers.On("FindTickersByUser", mock.Anything, mock.Anything, mock.Anything).Return([]storage.Ticker{}, errors.New("storage error")).Once()
 		h := s.handler()
 		h.GetTickers(s.ctx)
 
@@ -78,7 +78,7 @@ func (s *TickerTestSuite) TestGetTickers() {
 
 	s.Run("when storage returns tickers", func() {
 		s.ctx.Set("me", storage.User{IsSuperAdmin: true})
-		s.store.On("FindTickersByUser", mock.Anything, mock.Anything, mock.Anything).Return([]storage.Ticker{}, nil).Once()
+		s.store.Tickers.On("FindTickersByUser", mock.Anything, mock.Anything, mock.Anything).Return([]storage.Ticker{}, nil).Once()
 		h := s.handler()
 		h.GetTickers(s.ctx)
 
@@ -117,7 +117,7 @@ func (s *TickerTestSuite) TestGetTickerUsers() {
 
 	s.Run("when ticker found", func() {
 		s.ctx.Set("ticker", storage.Ticker{})
-		s.store.On("FindUsersByTicker", mock.Anything, mock.Anything).Return([]storage.User{}, nil).Once()
+		s.store.Tickers.On("FindUsersByTicker", mock.Anything, mock.Anything).Return([]storage.User{}, nil).Once()
 		h := s.handler()
 		h.GetTickerUsers(s.ctx)
 
@@ -140,7 +140,7 @@ func (s *TickerTestSuite) TestPostTicker() {
 		body := `{"title":"title","description":"description"}`
 		s.ctx.Request = httptest.NewRequest(http.MethodPost, "/v1/admin/tickers", strings.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveTicker", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Tickers.On("SaveTicker", mock.Anything).Return(errors.New("storage error")).Once()
 		h := s.handler()
 		h.PostTicker(s.ctx)
 
@@ -196,7 +196,7 @@ func (s *TickerTestSuite) TestPostTicker() {
 				Lon: 1,
 			},
 		}
-		s.store.On("SaveTicker", &ticker).Return(nil).Once()
+		s.store.Tickers.On("SaveTicker", &ticker).Return(nil).Once()
 		h := s.handler()
 		h.PostTicker(s.ctx)
 
@@ -230,7 +230,7 @@ func (s *TickerTestSuite) TestPutTicker() {
 		body := `{"title":"title","description":"description"}`
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/tickers/1", strings.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveTicker", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Tickers.On("SaveTicker", mock.Anything).Return(errors.New("storage error")).Once()
 		h := s.handler()
 		h.PutTicker(s.ctx)
 
@@ -245,7 +245,7 @@ func (s *TickerTestSuite) TestPutTicker() {
 		body := `{"title":"title","description":"description"}`
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/tickers/1", strings.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveTicker", mock.Anything).Return(nil).Once()
+		s.store.Tickers.On("SaveTicker", mock.Anything).Return(nil).Once()
 		h := s.handler()
 		h.PutTicker(s.ctx)
 
@@ -280,7 +280,7 @@ func (s *TickerTestSuite) TestPutTickerUsers() {
 		body := `{"users":[{"id":1},{"id":2},{"id":3}]}`
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/tickers/1/user", strings.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("FindUsersByIDs", mock.Anything).Return(nil, errors.New("storage error")).Once()
+		s.store.Users.On("FindUsersByIDs", mock.Anything).Return(nil, errors.New("storage error")).Once()
 		h := s.handler()
 		h.PutTickerUsers(s.ctx)
 
@@ -293,8 +293,8 @@ func (s *TickerTestSuite) TestPutTickerUsers() {
 		body := `{"users":[{"id":1},{"id":2},{"id":3}]}`
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/tickers/1/user", strings.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("FindUsersByIDs", mock.Anything).Return([]storage.User{{ID: 1}, {ID: 2}, {ID: 3}}, nil).Once()
-		s.store.On("SaveTicker", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Users.On("FindUsersByIDs", mock.Anything).Return([]storage.User{{ID: 1}, {ID: 2}, {ID: 3}}, nil).Once()
+		s.store.Tickers.On("SaveTicker", mock.Anything).Return(errors.New("storage error")).Once()
 		h := s.handler()
 		h.PutTickerUsers(s.ctx)
 
@@ -307,8 +307,8 @@ func (s *TickerTestSuite) TestPutTickerUsers() {
 		body := `{"users":[{"id":1},{"id":2},{"id":3}]}`
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/tickers/1/user", strings.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("FindUsersByIDs", mock.Anything).Return([]storage.User{{ID: 1}, {ID: 2}, {ID: 3}}, nil).Once()
-		s.store.On("SaveTicker", mock.Anything).Return(nil).Once()
+		s.store.Users.On("FindUsersByIDs", mock.Anything).Return([]storage.User{{ID: 1}, {ID: 2}, {ID: 3}}, nil).Once()
+		s.store.Tickers.On("SaveTicker", mock.Anything).Return(nil).Once()
 		h := s.handler()
 		h.PutTickerUsers(s.ctx)
 
@@ -346,7 +346,7 @@ func (s *TickerTestSuite) TestPutTickerWebsites() {
 		s.NoError(err)
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/tickers/1/websites", bytes.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveTickerWebsites", mock.Anything, mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Tickers.On("SaveTickerWebsites", mock.Anything, mock.Anything).Return(errors.New("storage error")).Once()
 
 		h := s.handler()
 		h.PutTickerWebsites(s.ctx)
@@ -365,7 +365,7 @@ func (s *TickerTestSuite) TestPutTickerWebsites() {
 		s.NoError(err)
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/tickers/1/websites", bytes.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveTickerWebsites", mock.Anything, mock.Anything).Return(nil).Once()
+		s.store.Tickers.On("SaveTickerWebsites", mock.Anything, mock.Anything).Return(nil).Once()
 
 		h := s.handler()
 		h.PutTickerWebsites(s.ctx)
@@ -385,7 +385,7 @@ func (s *TickerTestSuite) TestPutTickerWebsites() {
 		s.NoError(err)
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/tickers/1/websites", bytes.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("DeleteTickerWebsites", mock.Anything).Return(nil).Once()
+		s.store.Tickers.On("DeleteTickerWebsites", mock.Anything).Return(nil).Once()
 
 		h := s.handler()
 		h.PutTickerWebsites(s.ctx)
@@ -409,7 +409,7 @@ func (s *TickerTestSuite) TestDeleteTickerWebsites() {
 		s.ctx.Set("ticker", storage.Ticker{})
 		s.ctx.Request = httptest.NewRequest(http.MethodDelete, "/v1/admin/tickers/1/websites/https://example.org", nil)
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("DeleteTickerWebsites", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Tickers.On("DeleteTickerWebsites", mock.Anything).Return(errors.New("storage error")).Once()
 
 		h := s.handler()
 		h.DeleteTickerWebsites(s.ctx)
@@ -423,7 +423,7 @@ func (s *TickerTestSuite) TestDeleteTickerWebsites() {
 		s.ctx.Set("ticker", storage.Ticker{Websites: []storage.TickerWebsite{{Origin: "http://example.org"}}})
 		s.ctx.Request = httptest.NewRequest(http.MethodDelete, "/v1/admin/tickers/1/websites/https://example.org", nil)
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("DeleteTickerWebsites", mock.Anything).Return(nil).Once()
+		s.store.Tickers.On("DeleteTickerWebsites", mock.Anything).Return(nil).Once()
 
 		h := s.handler()
 		h.DeleteTickerWebsites(s.ctx)
@@ -459,7 +459,7 @@ func (s *TickerTestSuite) TestPutTickerTelegram() {
 		body := `{"active":true,"channelName":"@channel_name"}`
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/tickers/1/telegram", strings.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveTicker", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Tickers.On("SaveTicker", mock.Anything).Return(errors.New("storage error")).Once()
 		h := s.handler()
 		h.PutTickerTelegram(s.ctx)
 
@@ -472,7 +472,7 @@ func (s *TickerTestSuite) TestPutTickerTelegram() {
 		body := `{"active":true,"channelName":"@channel_name"}`
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/tickers/1/telegram", strings.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveTicker", mock.Anything).Return(nil).Once()
+		s.store.Tickers.On("SaveTicker", mock.Anything).Return(nil).Once()
 		h := s.handler()
 		h.PutTickerTelegram(s.ctx)
 
@@ -492,7 +492,7 @@ func (s *TickerTestSuite) TestDeleteTickerTelegram() {
 
 	s.Run("when storage returns error", func() {
 		s.ctx.Set("ticker", storage.Ticker{})
-		s.store.On("DeleteTelegram", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Tickers.On("ClearIntegration", mock.Anything, storage.IntegrationTelegram).Return(errors.New("storage error")).Once()
 		h := s.handler()
 		h.DeleteTickerTelegram(s.ctx)
 
@@ -502,7 +502,7 @@ func (s *TickerTestSuite) TestDeleteTickerTelegram() {
 
 	s.Run("when storage returns ticker", func() {
 		s.ctx.Set("ticker", storage.Ticker{})
-		s.store.On("DeleteTelegram", mock.Anything).Return(nil).Once()
+		s.store.Tickers.On("ClearIntegration", mock.Anything, storage.IntegrationTelegram).Return(nil).Once()
 		h := s.handler()
 		h.DeleteTickerTelegram(s.ctx)
 
@@ -554,7 +554,7 @@ func (s *TickerTestSuite) TestPutTickerMastodon() {
 		body := fmt.Sprintf(`{"server":"%s","token":"token","secret":"secret","accessToken":"access_toklen"}`, server.URL)
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/tickers/1/mastodon", strings.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveTicker", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Tickers.On("SaveTicker", mock.Anything).Return(errors.New("storage error")).Once()
 		h := s.handler()
 		h.PutTickerMastodon(s.ctx)
 
@@ -573,7 +573,7 @@ func (s *TickerTestSuite) TestPutTickerMastodon() {
 		body := fmt.Sprintf(`{"server":"%s","token":"token","secret":"secret","accessToken":"access_toklen"}`, server.URL)
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/tickers/1/mastodon", strings.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveTicker", mock.Anything).Return(nil).Once()
+		s.store.Tickers.On("SaveTicker", mock.Anything).Return(nil).Once()
 		h := s.handler()
 		h.PutTickerMastodon(s.ctx)
 
@@ -593,7 +593,7 @@ func (s *TickerTestSuite) TestDeleteTickerMastodon() {
 
 	s.Run("when storage returns error", func() {
 		s.ctx.Set("ticker", storage.Ticker{})
-		s.store.On("DeleteMastodon", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Tickers.On("ClearIntegration", mock.Anything, storage.IntegrationMastodon).Return(errors.New("storage error")).Once()
 		h := s.handler()
 		h.DeleteTickerMastodon(s.ctx)
 
@@ -603,7 +603,7 @@ func (s *TickerTestSuite) TestDeleteTickerMastodon() {
 
 	s.Run("when storage returns ticker", func() {
 		s.ctx.Set("ticker", storage.Ticker{})
-		s.store.On("DeleteMastodon", mock.Anything).Return(nil).Once()
+		s.store.Tickers.On("ClearIntegration", mock.Anything, storage.IntegrationMastodon).Return(nil).Once()
 		h := s.handler()
 		h.DeleteTickerMastodon(s.ctx)
 
@@ -637,7 +637,7 @@ func (s *TickerTestSuite) TestPutTickerBluesky() {
 		body := `{"active":true}`
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/tickers/1/bluesky", strings.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveTicker", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Tickers.On("SaveTicker", mock.Anything).Return(errors.New("storage error")).Once()
 
 		h := s.handler()
 		h.PutTickerBluesky(s.ctx)
@@ -651,7 +651,7 @@ func (s *TickerTestSuite) TestPutTickerBluesky() {
 		body := `{"active":true}`
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/tickers/1/bluesky", strings.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveTicker", mock.Anything).Return(nil).Once()
+		s.store.Tickers.On("SaveTicker", mock.Anything).Return(nil).Once()
 
 		h := s.handler()
 		h.PutTickerBluesky(s.ctx)
@@ -676,7 +676,7 @@ func (s *TickerTestSuite) TestPutTickerBluesky() {
 		body := `{"active":true,"handle":"bluesky","appKey":"appKey"}`
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/tickers/1/bluesky", strings.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveTicker", mock.Anything).Return(nil).Once()
+		s.store.Tickers.On("SaveTicker", mock.Anything).Return(nil).Once()
 
 		h := s.handler()
 		h.PutTickerBluesky(s.ctx)
@@ -701,7 +701,7 @@ func (s *TickerTestSuite) TestPutTickerBluesky() {
 		body := `{"active":true,"handle":"bluesky","appKey":"appKey","replyRestriction":"followers"}`
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/tickers/1/bluesky", strings.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveTicker", mock.AnythingOfType("*storage.Ticker")).Run(func(args mock.Arguments) {
+		s.store.Tickers.On("SaveTicker", mock.AnythingOfType("*storage.Ticker")).Run(func(args mock.Arguments) {
 			ticker := args.Get(0).(*storage.Ticker)
 			s.Equal("followers", ticker.Bluesky.ReplyRestriction)
 		}).Return(nil).Once()
@@ -748,7 +748,7 @@ func (s *TickerTestSuite) TestDeleteTickerBluesky() {
 
 	s.Run("when storage returns error", func() {
 		s.ctx.Set("ticker", storage.Ticker{})
-		s.store.On("DeleteBluesky", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Tickers.On("ClearIntegration", mock.Anything, storage.IntegrationBluesky).Return(errors.New("storage error")).Once()
 		h := s.handler()
 		h.DeleteTickerBluesky(s.ctx)
 
@@ -758,7 +758,7 @@ func (s *TickerTestSuite) TestDeleteTickerBluesky() {
 
 	s.Run("when storage returns ticker", func() {
 		s.ctx.Set("ticker", storage.Ticker{})
-		s.store.On("DeleteBluesky", mock.Anything).Return(nil).Once()
+		s.store.Tickers.On("ClearIntegration", mock.Anything, storage.IntegrationBluesky).Return(nil).Once()
 		h := s.handler()
 		h.DeleteTickerBluesky(s.ctx)
 
@@ -947,7 +947,7 @@ func (s *TickerTestSuite) TestPutTickerSignalGroup() {
 		body := `{"active":true}`
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/tickers/1/signal_group", strings.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveTicker", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Tickers.On("SaveTicker", mock.Anything).Return(errors.New("storage error")).Once()
 
 		h := s.handler()
 		h.PutTickerSignalGroup(s.ctx)
@@ -992,7 +992,7 @@ func (s *TickerTestSuite) TestPutTickerSignalGroup() {
 		body := `{"active":true}`
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/tickers/1/signal_group", strings.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveTicker", mock.Anything).Return(nil).Once()
+		s.store.Tickers.On("SaveTicker", mock.Anything).Return(nil).Once()
 
 		h := s.handler()
 		h.PutTickerSignalGroup(s.ctx)
@@ -1038,7 +1038,7 @@ func (s *TickerTestSuite) TestPutTickerSignalGroup() {
 		body := `{"active":true}`
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/tickers/1/signal_group", strings.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveTicker", mock.Anything).Return(nil).Once()
+		s.store.Tickers.On("SaveTicker", mock.Anything).Return(nil).Once()
 
 		h := s.handler()
 		h.PutTickerSignalGroup(s.ctx)
@@ -1084,7 +1084,7 @@ func (s *TickerTestSuite) TestPutTickerSignalGroup() {
 		body := `{"active":true}`
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/tickers/1/signal_group", strings.NewReader(body))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveTicker", mock.Anything).Return(nil).Once()
+		s.store.Tickers.On("SaveTicker", mock.Anything).Return(nil).Once()
 
 		h := s.handler()
 		h.PutTickerSignalGroup(s.ctx)
@@ -1175,7 +1175,7 @@ func (s *TickerTestSuite) TestDeleteTickerSignalGroup() {
 		})
 		s.ctx.Request = httptest.NewRequest(http.MethodDelete, "/v1/admin/tickers/1/signal_group", nil)
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("DeleteSignalGroup", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Tickers.On("ClearIntegration", mock.Anything, storage.IntegrationSignalGroup).Return(errors.New("storage error")).Once()
 		h := s.handler()
 		h.DeleteTickerSignalGroup(s.ctx)
 
@@ -1254,7 +1254,7 @@ func (s *TickerTestSuite) TestDeleteTickerSignalGroup() {
 		})
 		s.ctx.Request = httptest.NewRequest(http.MethodDelete, "/v1/admin/tickers/1/signal_group", nil)
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("DeleteSignalGroup", mock.Anything).Return(nil).Once()
+		s.store.Tickers.On("ClearIntegration", mock.Anything, storage.IntegrationSignalGroup).Return(nil).Once()
 		h := s.handler()
 		h.DeleteTickerSignalGroup(s.ctx)
 
@@ -1349,7 +1349,7 @@ func (s *TickerTestSuite) TestDeleteTicker() {
 
 	s.Run("when storage returns error", func() {
 		s.ctx.Set("ticker", storage.Ticker{})
-		s.store.On("DeleteTicker", mock.Anything).Return(errors.New("storage error"))
+		s.store.Tickers.On("DeleteTicker", mock.Anything).Return(errors.New("storage error"))
 		h := s.handler()
 		h.DeleteTicker(s.ctx)
 
@@ -1360,7 +1360,7 @@ func (s *TickerTestSuite) TestDeleteTicker() {
 	s.Run("happy path", func() {
 		s.cache.Set("response:localhost:/v1/init", true, time.Minute)
 		s.ctx.Set("ticker", storage.Ticker{Websites: []storage.TickerWebsite{{Origin: "localhost"}}})
-		s.store.On("DeleteTicker", mock.Anything).Return(nil)
+		s.store.Tickers.On("DeleteTicker", mock.Anything).Return(nil)
 		h := s.handler()
 		h.DeleteTicker(s.ctx)
 
@@ -1393,7 +1393,7 @@ func (s *TickerTestSuite) TestDeleteTickerUser() {
 	s.Run("when user not found", func() {
 		s.ctx.Set("ticker", storage.Ticker{})
 		s.ctx.AddParam("userID", "1")
-		s.store.On("FindUserByID", mock.Anything).Return(storage.User{}, errors.New("not found")).Once()
+		s.store.Users.On("FindUserByID", mock.Anything).Return(storage.User{}, errors.New("not found")).Once()
 		h := s.handler()
 		h.DeleteTickerUser(s.ctx)
 
@@ -1404,8 +1404,8 @@ func (s *TickerTestSuite) TestDeleteTickerUser() {
 	s.Run("when storage returns error", func() {
 		s.ctx.Set("ticker", storage.Ticker{})
 		s.ctx.AddParam("userID", "1")
-		s.store.On("FindUserByID", mock.Anything).Return(storage.User{}, nil).Once()
-		s.store.On("DeleteTickerUser", mock.Anything, mock.Anything).Return(errors.New("storage error"))
+		s.store.Users.On("FindUserByID", mock.Anything).Return(storage.User{}, nil).Once()
+		s.store.Tickers.On("DeleteTickerUser", mock.Anything, mock.Anything).Return(errors.New("storage error"))
 		h := s.handler()
 		h.DeleteTickerUser(s.ctx)
 
@@ -1416,8 +1416,8 @@ func (s *TickerTestSuite) TestDeleteTickerUser() {
 	s.Run("when storage returns ticker", func() {
 		s.ctx.Set("ticker", storage.Ticker{})
 		s.ctx.AddParam("userID", "1")
-		s.store.On("FindUserByID", mock.Anything).Return(storage.User{}, nil).Once()
-		s.store.On("DeleteTickerUser", mock.Anything, mock.Anything).Return(nil)
+		s.store.Users.On("FindUserByID", mock.Anything).Return(storage.User{}, nil).Once()
+		s.store.Tickers.On("DeleteTickerUser", mock.Anything, mock.Anything).Return(nil)
 		h := s.handler()
 		h.DeleteTickerUser(s.ctx)
 
@@ -1437,7 +1437,7 @@ func (s *TickerTestSuite) TestResetTicker() {
 
 	s.Run("when storage returns error", func() {
 		s.ctx.Set("ticker", storage.Ticker{})
-		s.store.On("ResetTicker", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Tickers.On("ResetTicker", mock.Anything).Return(errors.New("storage error")).Once()
 		h := s.handler()
 		h.ResetTicker(s.ctx)
 
@@ -1448,7 +1448,7 @@ func (s *TickerTestSuite) TestResetTicker() {
 	s.Run("happy path", func() {
 		s.cache.Set("response:localhost:/v1/init", true, time.Minute)
 		s.ctx.Set("ticker", storage.Ticker{Websites: []storage.TickerWebsite{{Origin: "localhost"}}})
-		s.store.On("ResetTicker", mock.Anything).Return(nil).Once()
+		s.store.Tickers.On("ResetTicker", mock.Anything).Return(nil).Once()
 		h := s.handler()
 		h.ResetTicker(s.ctx)
 
@@ -1462,9 +1462,9 @@ func (s *TickerTestSuite) TestResetTicker() {
 
 func (s *TickerTestSuite) handler() handler {
 	return handler{
-		storage: s.store,
-		config:  s.cfg,
-		cache:   s.cache,
+		stores: s.store.Stores(),
+		config: s.cfg,
+		cache:  s.cache,
 	}
 }
 
diff --git a/internal/api/timeline.go b/internal/api/timeline.go
index 5c69abe3..ac68022f 100644
--- a/internal/api/timeline.go
+++ b/internal/api/timeline.go
@@ -20,7 +20,7 @@ func (h *handler) GetTimeline(c *gin.Context) {
 	messages := make([]storage.Message, 0)
 	if ticker.Active {
 		pagination := pagination.NewPagination(c)
-		messages, err = h.storage.FindMessagesByTickerAndPagination(ticker, *pagination, storage.WithAttachments())
+		messages, err = h.stores.Messages.FindMessagesByTickerAndPagination(ticker, *pagination, storage.WithAttachments())
 		if err != nil {
 			c.JSON(http.StatusOK, response.ErrorResponse(response.CodeDefault, response.MessageFetchError))
 			return
diff --git a/internal/api/timeline_test.go b/internal/api/timeline_test.go
index f017a6af..0e2ff23c 100644
--- a/internal/api/timeline_test.go
+++ b/internal/api/timeline_test.go
@@ -30,7 +30,7 @@ func (s *TimelineTestSuite) Run(name string, subtest func()) {
 	s.T().Run(name, func(t *testing.T) {
 		s.w = httptest.NewRecorder()
 		s.ctx, _ = gin.CreateTestContext(s.w)
-		s.store = &storage.MockStorage{}
+		s.store = storage.NewMockStorage()
 		s.cfg = config.LoadConfig("")
 
 		subtest()
@@ -51,7 +51,7 @@ func (s *TimelineTestSuite) TestGetTimeline() {
 	s.Run("when storage returns an error", func() {
 		s.ctx.Request = httptest.NewRequest(http.MethodGet, "/v1/timeline", nil)
 		s.ctx.Set("ticker", storage.Ticker{Active: true})
-		s.store.On("FindMessagesByTickerAndPagination", mock.Anything, mock.Anything, mock.Anything).Return([]storage.Message{}, errors.New("storage error")).Once()
+		s.store.Messages.On("FindMessagesByTickerAndPagination", mock.Anything, mock.Anything, mock.Anything).Return([]storage.Message{}, errors.New("storage error")).Once()
 		h := s.handler()
 		h.GetTimeline(s.ctx)
 
@@ -63,7 +63,7 @@ func (s *TimelineTestSuite) TestGetTimeline() {
 	s.Run("when storage returns messages", func() {
 		s.ctx.Request = httptest.NewRequest(http.MethodGet, "/v1/timeline", nil)
 		s.ctx.Set("ticker", storage.Ticker{Active: true})
-		s.store.On("FindMessagesByTickerAndPagination", mock.Anything, mock.Anything, mock.Anything).Return([]storage.Message{}, nil).Once()
+		s.store.Messages.On("FindMessagesByTickerAndPagination", mock.Anything, mock.Anything, mock.Anything).Return([]storage.Message{}, nil).Once()
 		h := s.handler()
 		h.GetTimeline(s.ctx)
 
@@ -74,8 +74,8 @@ func (s *TimelineTestSuite) TestGetTimeline() {
 
 func (s *TimelineTestSuite) handler() handler {
 	return handler{
-		storage: s.store,
-		config:  s.cfg,
+		stores: s.store.Stores(),
+		config: s.cfg,
 	}
 }
 
diff --git a/internal/api/upload.go b/internal/api/upload.go
index 0121e86a..65b7b87f 100644
--- a/internal/api/upload.go
+++ b/internal/api/upload.go
@@ -41,7 +41,7 @@ func (h *handler) PostUpload(c *gin.Context) {
 		return
 	}
 
-	ticker, err := h.storage.FindTickerByUserAndID(me, tickerID)
+	ticker, err := h.stores.Tickers.FindTickerByUserAndID(me, tickerID)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.TickerNotFound))
 		return
@@ -72,7 +72,7 @@ func (h *handler) PostUpload(c *gin.Context) {
 		}
 
 		u := storage.NewUpload(fileHeader.Filename, contentType, ticker.ID)
-		err = h.storage.SaveUpload(&u)
+		err = h.stores.Uploads.SaveUpload(&u)
 		if err != nil {
 			c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.FormError))
 			return
diff --git a/internal/api/upload_test.go b/internal/api/upload_test.go
index 18574c4e..0243c0a8 100644
--- a/internal/api/upload_test.go
+++ b/internal/api/upload_test.go
@@ -33,7 +33,7 @@ func (s *UploadTestSuite) Run(name string, subtest func()) {
 	s.T().Run(name, func(t *testing.T) {
 		s.w = httptest.NewRecorder()
 		s.ctx, _ = gin.CreateTestContext(s.w)
-		s.store = &storage.MockStorage{}
+		s.store = storage.NewMockStorage()
 		s.cfg = config.LoadConfig("")
 
 		subtest()
@@ -97,7 +97,7 @@ func (s *UploadTestSuite) TestPostUpload() {
 		s.ctx.Request = httptest.NewRequest(http.MethodPost, "/upload", body)
 		s.ctx.Request.Header.Add("Content-Type", writer.FormDataContentType())
 		s.ctx.Set("me", storage.User{IsSuperAdmin: true})
-		s.store.On("FindTickerByUserAndID", mock.Anything, 1).Return(storage.Ticker{}, errors.New("not found")).Once()
+		s.store.Tickers.On("FindTickerByUserAndID", mock.Anything, 1).Return(storage.Ticker{}, errors.New("not found")).Once()
 		h := s.handler()
 		h.PostUpload(s.ctx)
 
@@ -113,7 +113,7 @@ func (s *UploadTestSuite) TestPostUpload() {
 		s.ctx.Request = httptest.NewRequest(http.MethodPost, "/upload", body)
 		s.ctx.Request.Header.Add("Content-Type", writer.FormDataContentType())
 		s.ctx.Set("me", storage.User{IsSuperAdmin: true})
-		s.store.On("FindTickerByUserAndID", mock.Anything, 1).Return(storage.Ticker{}, nil).Once()
+		s.store.Tickers.On("FindTickerByUserAndID", mock.Anything, 1).Return(storage.Ticker{}, nil).Once()
 		h := s.handler()
 		h.PostUpload(s.ctx)
 
@@ -140,7 +140,7 @@ func (s *UploadTestSuite) TestPostUpload() {
 		s.ctx.Request = httptest.NewRequest(http.MethodPost, "/upload", body)
 		s.ctx.Request.Header.Add("Content-Type", writer.FormDataContentType())
 		s.ctx.Set("me", storage.User{IsSuperAdmin: true})
-		s.store.On("FindTickerByUserAndID", mock.Anything, 1).Return(storage.Ticker{}, nil).Once()
+		s.store.Tickers.On("FindTickerByUserAndID", mock.Anything, 1).Return(storage.Ticker{}, nil).Once()
 		h := s.handler()
 		h.PostUpload(s.ctx)
 
@@ -160,7 +160,7 @@ func (s *UploadTestSuite) TestPostUpload() {
 		s.ctx.Request = httptest.NewRequest(http.MethodPost, "/upload", body)
 		s.ctx.Request.Header.Add("Content-Type", writer.FormDataContentType())
 		s.ctx.Set("me", storage.User{IsSuperAdmin: true})
-		s.store.On("FindTickerByUserAndID", mock.Anything, 1).Return(storage.Ticker{}, nil).Once()
+		s.store.Tickers.On("FindTickerByUserAndID", mock.Anything, 1).Return(storage.Ticker{}, nil).Once()
 		h := s.handler()
 		h.PostUpload(s.ctx)
 
@@ -180,8 +180,8 @@ func (s *UploadTestSuite) TestPostUpload() {
 		s.ctx.Request = httptest.NewRequest(http.MethodPost, "/upload", body)
 		s.ctx.Request.Header.Add("Content-Type", writer.FormDataContentType())
 		s.ctx.Set("me", storage.User{IsSuperAdmin: true})
-		s.store.On("FindTickerByUserAndID", mock.Anything, 1).Return(storage.Ticker{}, nil).Once()
-		s.store.On("SaveUpload", mock.Anything).Return(nil).Once()
+		s.store.Tickers.On("FindTickerByUserAndID", mock.Anything, 1).Return(storage.Ticker{}, nil).Once()
+		s.store.Uploads.On("SaveUpload", mock.Anything).Return(nil).Once()
 		h := s.handler()
 		h.PostUpload(s.ctx)
 
@@ -201,8 +201,8 @@ func (s *UploadTestSuite) TestPostUpload() {
 		s.ctx.Request = httptest.NewRequest(http.MethodPost, "/upload", body)
 		s.ctx.Request.Header.Add("Content-Type", writer.FormDataContentType())
 		s.ctx.Set("me", storage.User{IsSuperAdmin: true})
-		s.store.On("FindTickerByUserAndID", mock.Anything, 1).Return(storage.Ticker{}, nil).Once()
-		s.store.On("SaveUpload", mock.Anything).Return(errors.New("save error")).Once()
+		s.store.Tickers.On("FindTickerByUserAndID", mock.Anything, 1).Return(storage.Ticker{}, nil).Once()
+		s.store.Uploads.On("SaveUpload", mock.Anything).Return(errors.New("save error")).Once()
 		h := s.handler()
 		h.PostUpload(s.ctx)
 
@@ -222,8 +222,8 @@ func (s *UploadTestSuite) TestPostUpload() {
 		s.ctx.Request = httptest.NewRequest(http.MethodPost, "/upload", body)
 		s.ctx.Request.Header.Add("Content-Type", writer.FormDataContentType())
 		s.ctx.Set("me", storage.User{IsSuperAdmin: true})
-		s.store.On("FindTickerByUserAndID", mock.Anything, 1).Return(storage.Ticker{}, nil).Once()
-		s.store.On("SaveUpload", mock.Anything).Return(nil).Once()
+		s.store.Tickers.On("FindTickerByUserAndID", mock.Anything, 1).Return(storage.Ticker{}, nil).Once()
+		s.store.Uploads.On("SaveUpload", mock.Anything).Return(nil).Once()
 		h := s.handler()
 		h.PostUpload(s.ctx)
 
@@ -234,8 +234,8 @@ func (s *UploadTestSuite) TestPostUpload() {
 
 func (s *UploadTestSuite) handler() handler {
 	return handler{
-		storage: s.store,
-		config:  s.cfg,
+		stores: s.store.Stores(),
+		config: s.cfg,
 	}
 }
 
diff --git a/internal/api/user.go b/internal/api/user.go
index 77029ed0..f6c7a6d2 100644
--- a/internal/api/user.go
+++ b/internal/api/user.go
@@ -12,7 +12,7 @@ import (
 func (h *handler) GetUsers(c *gin.Context) {
 	//TODO: Discuss need of Pagination
 	filter := storage.NewUserFilter(c.Request)
-	users, err := h.storage.FindUsers(filter, storage.WithTickers())
+	users, err := h.stores.Users.FindUsers(filter, storage.WithTickers())
 	if err != nil {
 		c.JSON(http.StatusNotFound, response.ErrorResponse(response.CodeDefault, response.UserNotFound))
 		return
@@ -61,7 +61,7 @@ func (h *handler) PostUser(c *gin.Context) {
 	user.IsSuperAdmin = body.IsSuperAdmin
 	user.Tickers = body.Tickers
 
-	err = h.storage.SaveUser(&user)
+	err = h.stores.Users.SaveUser(&user)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
@@ -105,7 +105,7 @@ func (h *handler) PutUser(c *gin.Context) {
 		user.IsSuperAdmin = body.IsSuperAdmin
 	}
 
-	err = h.storage.SaveUser(&user)
+	err = h.stores.Users.SaveUser(&user)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
@@ -128,7 +128,7 @@ func (h *handler) DeleteUser(c *gin.Context) {
 		return
 	}
 
-	err = h.storage.DeleteUser(user)
+	err = h.stores.Users.DeleteUser(user)
 	if err != nil {
 		c.JSON(http.StatusNotFound, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
@@ -162,7 +162,7 @@ func (h *handler) PutMe(c *gin.Context) {
 
 	me.UpdatePassword(body.NewPassword)
 
-	err = h.storage.SaveUser(&me)
+	err = h.stores.Users.SaveUser(&me)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, response.ErrorResponse(response.CodeDefault, response.StorageError))
 		return
diff --git a/internal/api/user_test.go b/internal/api/user_test.go
index 40d98cee..0a02d9f5 100644
--- a/internal/api/user_test.go
+++ b/internal/api/user_test.go
@@ -30,7 +30,7 @@ func (s *UserTestSuite) Run(name string, subtest func()) {
 	s.T().Run(name, func(t *testing.T) {
 		s.w = httptest.NewRecorder()
 		s.ctx, _ = gin.CreateTestContext(s.w)
-		s.store = &storage.MockStorage{}
+		s.store = storage.NewMockStorage()
 		s.cfg = config.LoadConfig("")
 
 		subtest()
@@ -40,7 +40,7 @@ func (s *UserTestSuite) Run(name string, subtest func()) {
 func (s *UserTestSuite) TestGetUsers() {
 	s.Run("when storage returns an error", func() {
 		s.ctx.Set("me", storage.User{IsSuperAdmin: true})
-		s.store.On("FindUsers", mock.Anything, mock.Anything).Return([]storage.User{}, errors.New("storage error")).Once()
+		s.store.Users.On("FindUsers", mock.Anything, mock.Anything).Return([]storage.User{}, errors.New("storage error")).Once()
 		h := s.handler()
 		h.GetUsers(s.ctx)
 
@@ -50,7 +50,7 @@ func (s *UserTestSuite) TestGetUsers() {
 
 	s.Run("when storage returns users", func() {
 		s.ctx.Set("me", storage.User{IsSuperAdmin: true})
-		s.store.On("FindUsers", mock.Anything, mock.Anything).Return([]storage.User{}, nil).Once()
+		s.store.Users.On("FindUsers", mock.Anything, mock.Anything).Return([]storage.User{}, nil).Once()
 		h := s.handler()
 		h.GetUsers(s.ctx)
 
@@ -126,7 +126,7 @@ func (s *UserTestSuite) TestPostUser() {
 		s.ctx.Request = httptest.NewRequest(http.MethodPost, "/v1/admin/users", strings.NewReader(`{"email":"user@systemli.org","password":"password1234"}`))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
 		s.ctx.Set("me", storage.User{IsSuperAdmin: true})
-		s.store.On("SaveUser", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Users.On("SaveUser", mock.Anything).Return(errors.New("storage error")).Once()
 		h := s.handler()
 		h.PostUser(s.ctx)
 
@@ -138,7 +138,7 @@ func (s *UserTestSuite) TestPostUser() {
 		s.ctx.Request = httptest.NewRequest(http.MethodPost, "/v1/admin/users", strings.NewReader(`{"email":"user@systemli.org","password":"password1234"}`))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
 		s.ctx.Set("me", storage.User{IsSuperAdmin: true})
-		s.store.On("SaveUser", mock.Anything).Return(nil).Once()
+		s.store.Users.On("SaveUser", mock.Anything).Return(nil).Once()
 		h := s.handler()
 		h.PostUser(s.ctx)
 
@@ -174,7 +174,7 @@ func (s *UserTestSuite) TestPutUser() {
 		s.ctx.Set("me", storage.User{IsSuperAdmin: true})
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/users", strings.NewReader(`{"email":"louis@systemli.org","password":"password1234","isSuperAdmin":true,"tickers":[{"id":1}]}`))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveUser", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Users.On("SaveUser", mock.Anything).Return(errors.New("storage error")).Once()
 		h := s.handler()
 		h.PutUser(s.ctx)
 
@@ -187,7 +187,7 @@ func (s *UserTestSuite) TestPutUser() {
 		s.ctx.Set("me", storage.User{IsSuperAdmin: true})
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/users", strings.NewReader(`{"email":"louis@systemli.org","password":"password1234","isSuperAdmin":true,"tickers":[{"id":1}]}`))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveUser", mock.Anything).Return(nil).Once()
+		s.store.Users.On("SaveUser", mock.Anything).Return(nil).Once()
 		h := s.handler()
 		h.PutUser(s.ctx)
 
@@ -219,7 +219,7 @@ func (s *UserTestSuite) TestDeleteUser() {
 	s.Run("when storage returns an error", func() {
 		s.ctx.Set("user", storage.User{ID: 1})
 		s.ctx.Set("me", storage.User{ID: 2, IsSuperAdmin: true})
-		s.store.On("DeleteUser", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Users.On("DeleteUser", mock.Anything).Return(errors.New("storage error")).Once()
 		h := s.handler()
 		h.DeleteUser(s.ctx)
 
@@ -230,7 +230,7 @@ func (s *UserTestSuite) TestDeleteUser() {
 	s.Run("when delete is successful", func() {
 		s.ctx.Set("user", storage.User{ID: 1})
 		s.ctx.Set("me", storage.User{ID: 2, IsSuperAdmin: true})
-		s.store.On("DeleteUser", mock.Anything).Return(nil).Once()
+		s.store.Users.On("DeleteUser", mock.Anything).Return(nil).Once()
 		h := s.handler()
 		h.DeleteUser(s.ctx)
 
@@ -277,7 +277,7 @@ func (s *UserTestSuite) TestPutMe() {
 		s.ctx.Set("me", user)
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/users/me", strings.NewReader(`{"password":"password1234","newPassword":"password5678"}`))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveUser", mock.Anything).Return(errors.New("storage error")).Once()
+		s.store.Users.On("SaveUser", mock.Anything).Return(errors.New("storage error")).Once()
 		h := s.handler()
 		h.PutMe(s.ctx)
 
@@ -290,7 +290,7 @@ func (s *UserTestSuite) TestPutMe() {
 		s.ctx.Set("me", user)
 		s.ctx.Request = httptest.NewRequest(http.MethodPut, "/v1/admin/users/me", strings.NewReader(`{"password":"password1234","newPassword":"password5678"}`))
 		s.ctx.Request.Header.Add("Content-Type", "application/json")
-		s.store.On("SaveUser", mock.Anything).Return(nil).Once()
+		s.store.Users.On("SaveUser", mock.Anything).Return(nil).Once()
 		h := s.handler()
 		h.PutMe(s.ctx)
 
@@ -301,8 +301,8 @@ func (s *UserTestSuite) TestPutMe() {
 
 func (s *UserTestSuite) handler() handler {
 	return handler{
-		storage: s.store,
-		config:  s.cfg,
+		stores: s.store.Stores(),
+		config: s.cfg,
 	}
 }
 
diff --git a/internal/api/websocket_test.go b/internal/api/websocket_test.go
index 072e7dcb..c85f1de0 100644
--- a/internal/api/websocket_test.go
+++ b/internal/api/websocket_test.go
@@ -32,7 +32,7 @@ func (s *WebSocketTestSuite) Run(name string, subtest func()) {
 	s.T().Run(name, func(t *testing.T) {
 		s.w = httptest.NewRecorder()
 		s.ctx, _ = gin.CreateTestContext(s.w)
-		s.store = &storage.MockStorage{}
+		s.store = storage.NewMockStorage()
 		s.cfg = config.LoadConfig("")
 		s.realtime = realtime.New()
 
@@ -51,7 +51,7 @@ func (s *WebSocketTestSuite) setupWebSocketServer(ticker storage.Ticker) (*httpt
 	// Create a real HTTP server with the WebSocket handler
 	router := gin.New()
 	h := handler{
-		storage:  s.store,
+		stores:   s.store.Stores(),
 		config:   s.cfg,
 		realtime: realtimeEngine, // Use the test-specific engine
 	}
@@ -286,7 +286,7 @@ func (s *WebSocketTestSuite) TestUpgraderConfiguration() {
 
 func (s *WebSocketTestSuite) handler() handler {
 	return handler{
-		storage:  s.store,
+		stores:   s.store.Stores(),
 		config:   s.cfg,
 		realtime: s.realtime,
 	}
diff --git a/internal/bridge/bluesky.go b/internal/bridge/bluesky.go
index b244c014..dd9a6d51 100644
--- a/internal/bridge/bluesky.go
+++ b/internal/bridge/bluesky.go
@@ -21,7 +21,7 @@ import (
 
 type BlueskyBridge struct {
 	config  config.Config
-	storage storage.Storage
+	uploads storage.UploadStore
 }
 
 func (bb *BlueskyBridge) Update(ticker storage.Ticker) error {
@@ -87,7 +87,7 @@ func (bb *BlueskyBridge) Send(ticker storage.Ticker, message *storage.Message) e
 		var images []*bsky.EmbedImages_Image
 
 		for _, attachment := range message.Attachments {
-			upload, err := bb.storage.FindUploadByUUID(attachment.UUID)
+			upload, err := bb.uploads.FindUploadByUUID(attachment.UUID)
 			if err != nil {
 				log.WithError(err).Error("failed to find upload")
 				continue
diff --git a/internal/bridge/bluesky_test.go b/internal/bridge/bluesky_test.go
index 23a15268..31dabf43 100644
--- a/internal/bridge/bluesky_test.go
+++ b/internal/bridge/bluesky_test.go
@@ -10,7 +10,7 @@ import (
 
 func (s *BridgeTestSuite) TestBlueskyUpdate() {
 	s.Run("does nothing", func() {
-		bridge := s.blueskyBridge(config.Config{}, &storage.MockStorage{})
+		bridge := s.blueskyBridge(config.Config{}, storage.NewMockStorage())
 
 		err := bridge.Update(tickerWithBridges)
 		s.NoError(err)
@@ -19,14 +19,14 @@ func (s *BridgeTestSuite) TestBlueskyUpdate() {
 
 func (s *BridgeTestSuite) TestBlueskySend() {
 	s.Run("when bluesky is inactive", func() {
-		bridge := s.blueskyBridge(config.Config{}, &storage.MockStorage{})
+		bridge := s.blueskyBridge(config.Config{}, storage.NewMockStorage())
 
 		err := bridge.Send(tickerWithoutBridges, &messageWithoutBridges)
 		s.NoError(err)
 	})
 
 	s.Run("when bluesky is active but login fails", func() {
-		bridge := s.blueskyBridge(config.Config{}, &storage.MockStorage{})
+		bridge := s.blueskyBridge(config.Config{}, storage.NewMockStorage())
 
 		gock.DisableNetworking()
 		defer gock.Off()
@@ -41,8 +41,8 @@ func (s *BridgeTestSuite) TestBlueskySend() {
 	})
 
 	s.Run("when bluesky is active and login succeeds", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("FindUploadByUUID", "123").Return(storage.Upload{}, nil).Once()
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Uploads.On("FindUploadByUUID", "123").Return(storage.Upload{}, nil).Once()
 		bridge := s.blueskyBridge(config.Config{}, mockStorage)
 
 		gock.DisableNetworking()
@@ -76,8 +76,8 @@ func (s *BridgeTestSuite) TestBlueskySend() {
 	})
 
 	s.Run("when bluesky is active and upload is not found", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("FindUploadByUUID", "123").Return(storage.Upload{}, errors.New("not found")).Once()
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Uploads.On("FindUploadByUUID", "123").Return(storage.Upload{}, errors.New("not found")).Once()
 		bridge := s.blueskyBridge(config.Config{}, mockStorage)
 
 		gock.DisableNetworking()
@@ -111,8 +111,8 @@ func (s *BridgeTestSuite) TestBlueskySend() {
 	})
 
 	s.Run("when bluesky is active but bluesky responds with error", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("FindUploadByUUID", "123").Return(storage.Upload{}, nil).Once()
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Uploads.On("FindUploadByUUID", "123").Return(storage.Upload{}, nil).Once()
 		bridge := s.blueskyBridge(config.Config{}, mockStorage)
 
 		gock.DisableNetworking()
@@ -140,28 +140,28 @@ func (s *BridgeTestSuite) TestBlueskySend() {
 
 func (s *BridgeTestSuite) TestBlueskyDelete() {
 	s.Run("when bluesky not connected", func() {
-		bridge := s.blueskyBridge(config.Config{}, &storage.MockStorage{})
+		bridge := s.blueskyBridge(config.Config{}, storage.NewMockStorage())
 
 		err := bridge.Delete(tickerWithoutBridges, &messageWithoutBridges)
 		s.NoError(err)
 	})
 
 	s.Run("when message has no bluesky meta", func() {
-		bridge := s.blueskyBridge(config.Config{}, &storage.MockStorage{})
+		bridge := s.blueskyBridge(config.Config{}, storage.NewMockStorage())
 
 		err := bridge.Delete(tickerWithBridges, &messageWithoutBridges)
 		s.NoError(err)
 	})
 
 	s.Run("when bluesky is inactive", func() {
-		bridge := s.blueskyBridge(config.Config{}, &storage.MockStorage{})
+		bridge := s.blueskyBridge(config.Config{}, storage.NewMockStorage())
 
 		err := bridge.Delete(tickerWithBridges, &messageWithoutBridges)
 		s.NoError(err)
 	})
 
 	s.Run("when bluesky is active but login fails", func() {
-		bridge := s.blueskyBridge(config.Config{}, &storage.MockStorage{})
+		bridge := s.blueskyBridge(config.Config{}, storage.NewMockStorage())
 
 		gock.New("https://bsky.social").
 			Post("/xrpc/com.atproto.server.createSession").
@@ -173,7 +173,7 @@ func (s *BridgeTestSuite) TestBlueskyDelete() {
 	})
 
 	s.Run("when delete fails", func() {
-		bridge := s.blueskyBridge(config.Config{}, &storage.MockStorage{})
+		bridge := s.blueskyBridge(config.Config{}, storage.NewMockStorage())
 
 		gock.New("https://bsky.social").
 			Post("/xrpc/com.atproto.server.createSession").
@@ -201,7 +201,7 @@ func (s *BridgeTestSuite) TestBlueskyDelete() {
 	})
 
 	s.Run("happy path", func() {
-		bridge := s.blueskyBridge(config.Config{}, &storage.MockStorage{})
+		bridge := s.blueskyBridge(config.Config{}, storage.NewMockStorage())
 
 		gock.New("https://bsky.social").
 			Post("/xrpc/com.atproto.server.createSession").
@@ -230,10 +230,10 @@ func (s *BridgeTestSuite) TestBlueskyDelete() {
 	})
 }
 
-func (s *BridgeTestSuite) blueskyBridge(config config.Config, storage storage.Storage) *BlueskyBridge {
+func (s *BridgeTestSuite) blueskyBridge(config config.Config, m *storage.MockStorage) *BlueskyBridge {
 	return &BlueskyBridge{
 		config:  config,
-		storage: storage,
+		uploads: m.Uploads,
 	}
 }
 
@@ -285,8 +285,8 @@ func (s *BridgeTestSuite) TestBuildAllowRules() {
 
 func (s *BridgeTestSuite) TestBlueskySendWithThreadGate() {
 	s.Run("when reply restriction is set to followers", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("FindUploadByUUID", "123").Return(storage.Upload{}, nil).Once()
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Uploads.On("FindUploadByUUID", "123").Return(storage.Upload{}, nil).Once()
 		bridge := s.blueskyBridge(config.Config{}, mockStorage)
 
 		gock.DisableNetworking()
@@ -345,8 +345,8 @@ func (s *BridgeTestSuite) TestBlueskySendWithThreadGate() {
 	})
 
 	s.Run("when thread gate creation fails", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("FindUploadByUUID", "123").Return(storage.Upload{}, nil).Once()
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Uploads.On("FindUploadByUUID", "123").Return(storage.Upload{}, nil).Once()
 		bridge := s.blueskyBridge(config.Config{}, mockStorage)
 
 		gock.DisableNetworking()
@@ -402,7 +402,7 @@ func (s *BridgeTestSuite) TestBlueskySendWithThreadGate() {
 
 func (s *BridgeTestSuite) TestBlueskyDeleteWithThreadGate() {
 	s.Run("happy path with thread gate deletion", func() {
-		bridge := s.blueskyBridge(config.Config{}, &storage.MockStorage{})
+		bridge := s.blueskyBridge(config.Config{}, storage.NewMockStorage())
 
 		gock.New("https://bsky.social").
 			Post("/xrpc/com.atproto.server.createSession").
diff --git a/internal/bridge/bridge.go b/internal/bridge/bridge.go
index b2466eb0..ec51b1b0 100644
--- a/internal/bridge/bridge.go
+++ b/internal/bridge/bridge.go
@@ -16,11 +16,11 @@ type Bridge interface {
 
 type Bridges map[string]Bridge
 
-func RegisterBridges(config config.Config, storage storage.Storage) Bridges {
-	telegram := TelegramBridge{config, storage}
-	mastodon := MastodonBridge{config, storage}
-	bluesky := BlueskyBridge{config, storage}
-	signalGroup := SignalGroupBridge{config, storage}
+func RegisterBridges(config config.Config, stores storage.Stores) Bridges {
+	telegram := TelegramBridge{config: config, uploads: stores.Uploads, settings: stores.Settings}
+	mastodon := MastodonBridge{config: config, uploads: stores.Uploads}
+	bluesky := BlueskyBridge{config: config, uploads: stores.Uploads}
+	signalGroup := SignalGroupBridge{config: config, uploads: stores.Uploads, settings: stores.Settings}
 
 	return Bridges{"telegram": &telegram, "mastodon": &mastodon, "bluesky": &bluesky, "signalGroup": &signalGroup}
 }
diff --git a/internal/bridge/bridge_test.go b/internal/bridge/bridge_test.go
index 792e3887..6795ed6f 100644
--- a/internal/bridge/bridge_test.go
+++ b/internal/bridge/bridge_test.go
@@ -170,7 +170,7 @@ func (s *BridgeTestSuite) TestDelete() {
 }
 
 func (s *BridgeTestSuite) TestRegisterBridges() {
-	bridges := RegisterBridges(config.Config{}, nil)
+	bridges := RegisterBridges(config.Config{}, storage.Stores{})
 	s.Equal(4, len(bridges))
 }
 
diff --git a/internal/bridge/mastodon.go b/internal/bridge/mastodon.go
index 06f23614..3d44c4a6 100644
--- a/internal/bridge/mastodon.go
+++ b/internal/bridge/mastodon.go
@@ -11,7 +11,7 @@ import (
 
 type MastodonBridge struct {
 	config  config.Config
-	storage storage.Storage
+	uploads storage.UploadStore
 }
 
 func (mb *MastodonBridge) Update(ticker storage.Ticker) error {
@@ -29,7 +29,7 @@ func (mb *MastodonBridge) Send(ticker storage.Ticker, message *storage.Message)
 	var mediaIDs []mastodon.ID
 	if len(message.Attachments) > 0 {
 		for _, attachment := range message.Attachments {
-			upload, err := mb.storage.FindUploadByUUID(attachment.UUID)
+			upload, err := mb.uploads.FindUploadByUUID(attachment.UUID)
 			if err != nil {
 				log.WithError(err).Error("failed to find upload")
 				continue
diff --git a/internal/bridge/mastodon_test.go b/internal/bridge/mastodon_test.go
index eb53f373..fed9a9a3 100644
--- a/internal/bridge/mastodon_test.go
+++ b/internal/bridge/mastodon_test.go
@@ -10,7 +10,7 @@ import (
 
 func (s *BridgeTestSuite) TestMastodonUpdate() {
 	s.Run("does nothing", func() {
-		bridge := s.mastodonBridge(config.Config{}, &storage.MockStorage{})
+		bridge := s.mastodonBridge(config.Config{}, storage.NewMockStorage())
 
 		err := bridge.Update(tickerWithBridges)
 		s.NoError(err)
@@ -19,15 +19,15 @@ func (s *BridgeTestSuite) TestMastodonUpdate() {
 
 func (s *BridgeTestSuite) TestMastodonSend() {
 	s.Run("when mastodon is inactive", func() {
-		bridge := s.mastodonBridge(config.Config{}, &storage.MockStorage{})
+		bridge := s.mastodonBridge(config.Config{}, storage.NewMockStorage())
 
 		err := bridge.Send(tickerWithoutBridges, &messageWithoutBridges)
 		s.NoError(err)
 	})
 
 	s.Run("when mastodon is active but upload cant not found", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("FindUploadByUUID", "123").Return(storage.Upload{}, nil).Once()
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Uploads.On("FindUploadByUUID", "123").Return(storage.Upload{}, nil).Once()
 		bridge := s.mastodonBridge(config.Config{}, mockStorage)
 
 		gock.New("https://systemli.social").
@@ -49,8 +49,8 @@ func (s *BridgeTestSuite) TestMastodonSend() {
 	})
 
 	s.Run("when mastodon is active and upload is not found", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("FindUploadByUUID", "123").Return(storage.Upload{}, errors.New("upload not found")).Once()
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Uploads.On("FindUploadByUUID", "123").Return(storage.Upload{}, errors.New("upload not found")).Once()
 		bridge := s.mastodonBridge(config.Config{}, mockStorage)
 
 		gock.New("https://systemli.social").
@@ -72,8 +72,8 @@ func (s *BridgeTestSuite) TestMastodonSend() {
 	})
 
 	s.Run("when mastodon is active but post status fails", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("FindUploadByUUID", "123").Return(storage.Upload{}, nil).Once()
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Uploads.On("FindUploadByUUID", "123").Return(storage.Upload{}, nil).Once()
 		bridge := s.mastodonBridge(config.Config{}, mockStorage)
 
 		gock.New("https://systemli.social").
@@ -89,14 +89,14 @@ func (s *BridgeTestSuite) TestMastodonSend() {
 
 func (s *BridgeTestSuite) TestMastodonDelete() {
 	s.Run("when message has no mastodon meta", func() {
-		bridge := s.mastodonBridge(config.Config{}, &storage.MockStorage{})
+		bridge := s.mastodonBridge(config.Config{}, storage.NewMockStorage())
 
 		err := bridge.Delete(tickerWithBridges, &messageWithoutBridges)
 		s.NoError(err)
 	})
 
 	s.Run("when mastodon is inactive", func() {
-		bridge := s.mastodonBridge(config.Config{}, &storage.MockStorage{})
+		bridge := s.mastodonBridge(config.Config{}, storage.NewMockStorage())
 
 		err := bridge.Delete(tickerWithoutBridges, &messageWithBridges)
 		s.Error(err)
@@ -104,7 +104,7 @@ func (s *BridgeTestSuite) TestMastodonDelete() {
 	})
 
 	s.Run("when mastodon is active", func() {
-		bridge := s.mastodonBridge(config.Config{}, &storage.MockStorage{})
+		bridge := s.mastodonBridge(config.Config{}, storage.NewMockStorage())
 
 		gock.New("https://systemli.social").
 			Delete("/api/v1/statuses/123").
@@ -116,9 +116,9 @@ func (s *BridgeTestSuite) TestMastodonDelete() {
 	})
 }
 
-func (s *BridgeTestSuite) mastodonBridge(config config.Config, storage storage.Storage) *MastodonBridge {
+func (s *BridgeTestSuite) mastodonBridge(config config.Config, m *storage.MockStorage) *MastodonBridge {
 	return &MastodonBridge{
 		config:  config,
-		storage: storage,
+		uploads: m.Uploads,
 	}
 }
diff --git a/internal/bridge/signal_group.go b/internal/bridge/signal_group.go
index e3665bd2..3e102ded 100644
--- a/internal/bridge/signal_group.go
+++ b/internal/bridge/signal_group.go
@@ -13,8 +13,9 @@ import (
 )
 
 type SignalGroupBridge struct {
-	config  config.Config
-	storage storage.Storage
+	config   config.Config
+	uploads  storage.UploadStore
+	settings storage.SettingsStore
 }
 
 type SignalGroupResponse struct {
@@ -22,7 +23,7 @@ type SignalGroupResponse struct {
 }
 
 func (sb *SignalGroupBridge) Update(ticker storage.Ticker) error {
-	settings := sb.storage.GetSignalGroupSettings()
+	settings := storage.GetSettings(sb.settings, storage.SignalGroupSetting)
 	if !settings.Enabled() || !ticker.SignalGroup.Connected() {
 		return nil
 	}
@@ -37,7 +38,7 @@ func (sb *SignalGroupBridge) Update(ticker storage.Ticker) error {
 }
 
 func (sb *SignalGroupBridge) Send(ticker storage.Ticker, message *storage.Message) error {
-	settings := sb.storage.GetSignalGroupSettings()
+	settings := storage.GetSettings(sb.settings, storage.SignalGroupSetting)
 	if !settings.Enabled() || !ticker.SignalGroup.Connected() || !ticker.SignalGroup.Active {
 		return nil
 	}
@@ -48,7 +49,7 @@ func (sb *SignalGroupBridge) Send(ticker storage.Ticker, message *storage.Messag
 	var attachments []string
 	if len(message.Attachments) > 0 {
 		for _, attachment := range message.Attachments {
-			upload, err := sb.storage.FindUploadByUUID(attachment.UUID)
+			upload, err := sb.uploads.FindUploadByUUID(attachment.UUID)
 			if err != nil {
 				log.WithError(err).Error("failed to find upload")
 				continue
@@ -94,7 +95,7 @@ func (sb *SignalGroupBridge) Send(ticker storage.Ticker, message *storage.Messag
 }
 
 func (sb *SignalGroupBridge) Delete(ticker storage.Ticker, message *storage.Message) error {
-	settings := sb.storage.GetSignalGroupSettings()
+	settings := storage.GetSettings(sb.settings, storage.SignalGroupSetting)
 	if !settings.Enabled() || !ticker.SignalGroup.Connected() || !ticker.SignalGroup.Active || message.SignalGroup.Timestamp == 0 {
 		return nil
 	}
diff --git a/internal/bridge/signal_group_test.go b/internal/bridge/signal_group_test.go
index 768e680f..9389a5e8 100644
--- a/internal/bridge/signal_group_test.go
+++ b/internal/bridge/signal_group_test.go
@@ -10,8 +10,8 @@ import (
 
 func (s *BridgeTestSuite) TestSignalGroupUpdate() {
 	s.Run("when signalGroup is inactive", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetSignalGroupSettings").Return(storage.DefaultSignalGroupSettings())
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetSignalGroup(storage.DefaultSignalGroupSettings())
 		bridge := s.signalGroupBridge(config.Config{}, mockStorage)
 
 		err := bridge.Update(tickerWithoutBridges)
@@ -20,8 +20,8 @@ func (s *BridgeTestSuite) TestSignalGroupUpdate() {
 	})
 
 	s.Run("when signalGroup is active but signal-cli api fails", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetSignalGroupSettings").Return(storage.SignalGroupSettings{
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetSignalGroup(storage.SignalGroupSettings{
 			ApiUrl:  "https://signal-cli.example.org/api/v1/rpc",
 			Account: "0123456789",
 		})
@@ -38,8 +38,8 @@ func (s *BridgeTestSuite) TestSignalGroupUpdate() {
 	})
 
 	s.Run("happy path", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetSignalGroupSettings").Return(storage.SignalGroupSettings{
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetSignalGroup(storage.SignalGroupSettings{
 			ApiUrl:  "https://signal-cli.example.org/api/v1/rpc",
 			Account: "0123456789",
 		})
@@ -85,8 +85,8 @@ func (s *BridgeTestSuite) TestSignalGroupUpdate() {
 
 func (s *BridgeTestSuite) TestSignalGroupSend() {
 	s.Run("when signalGroup is inactive", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetSignalGroupSettings").Return(storage.DefaultSignalGroupSettings())
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetSignalGroup(storage.DefaultSignalGroupSettings())
 		bridge := s.signalGroupBridge(config.Config{}, mockStorage)
 
 		err := bridge.Send(tickerWithoutBridges, &messageWithoutBridges)
@@ -95,8 +95,8 @@ func (s *BridgeTestSuite) TestSignalGroupSend() {
 	})
 
 	s.Run("when signalGroup is active but signal-cli api fails", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetSignalGroupSettings").Return(storage.SignalGroupSettings{
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetSignalGroup(storage.SignalGroupSettings{
 			ApiUrl:  "https://signal-cli.example.org/api/v1/rpc",
 			Account: "0123456789",
 		})
@@ -113,8 +113,8 @@ func (s *BridgeTestSuite) TestSignalGroupSend() {
 	})
 
 	s.Run("when response timestamp == 0", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetSignalGroupSettings").Return(storage.SignalGroupSettings{
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetSignalGroup(storage.SignalGroupSettings{
 			ApiUrl:  "https://signal-cli.example.org/api/v1/rpc",
 			Account: "0123456789",
 		})
@@ -138,13 +138,13 @@ func (s *BridgeTestSuite) TestSignalGroupSend() {
 	})
 
 	s.Run("send message with attachment failed to find upload", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetSignalGroupSettings").Return(storage.SignalGroupSettings{
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetSignalGroup(storage.SignalGroupSettings{
 			ApiUrl:  "https://signal-cli.example.org/api/v1/rpc",
 			Account: "0123456789",
 		})
-		mockStorage.On("FindUploadByUUID", "123").Return(storage.Upload{}, errors.New("failed to find upload")).Once()
-		mockStorage.On("FindUploadByUUID", "456").Return(storage.Upload{}, errors.New("failed to find upload")).Once()
+		mockStorage.Uploads.On("FindUploadByUUID", "123").Return(storage.Upload{}, errors.New("failed to find upload")).Once()
+		mockStorage.Uploads.On("FindUploadByUUID", "456").Return(storage.Upload{}, errors.New("failed to find upload")).Once()
 		bridge := s.signalGroupBridge(config.Config{}, mockStorage)
 
 		gock.New("https://signal-cli.example.org").
@@ -165,13 +165,13 @@ func (s *BridgeTestSuite) TestSignalGroupSend() {
 	})
 
 	s.Run("send message with attachment failed to read file", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetSignalGroupSettings").Return(storage.SignalGroupSettings{
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetSignalGroup(storage.SignalGroupSettings{
 			ApiUrl:  "https://signal-cli.example.org/api/v1/rpc",
 			Account: "0123456789",
 		})
-		mockStorage.On("FindUploadByUUID", "123").Return(storage.Upload{UUID: "123", ContentType: "image/gif"}, nil).Once()
-		mockStorage.On("FindUploadByUUID", "456").Return(storage.Upload{UUID: "456", ContentType: "image/jpeg"}, nil).Once()
+		mockStorage.Uploads.On("FindUploadByUUID", "123").Return(storage.Upload{UUID: "123", ContentType: "image/gif"}, nil).Once()
+		mockStorage.Uploads.On("FindUploadByUUID", "456").Return(storage.Upload{UUID: "456", ContentType: "image/jpeg"}, nil).Once()
 		bridge := s.signalGroupBridge(config.Config{}, mockStorage)
 
 		gock.New("https://signal-cli.example.org").
@@ -192,8 +192,8 @@ func (s *BridgeTestSuite) TestSignalGroupSend() {
 	})
 
 	s.Run("send message without attachments", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetSignalGroupSettings").Return(storage.SignalGroupSettings{
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetSignalGroup(storage.SignalGroupSettings{
 			ApiUrl:  "https://signal-cli.example.org/api/v1/rpc",
 			Account: "0123456789",
 		})
@@ -219,8 +219,8 @@ func (s *BridgeTestSuite) TestSignalGroupSend() {
 
 func (s *BridgeTestSuite) TestSignalDelete() {
 	s.Run("when signal not connected", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetSignalGroupSettings").Return(storage.DefaultSignalGroupSettings())
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetSignalGroup(storage.DefaultSignalGroupSettings())
 		bridge := s.signalGroupBridge(config.Config{}, mockStorage)
 
 		err := bridge.Delete(tickerWithoutBridges, &messageWithoutBridges)
@@ -229,8 +229,8 @@ func (s *BridgeTestSuite) TestSignalDelete() {
 	})
 
 	s.Run("when message has no signal meta", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetSignalGroupSettings").Return(storage.SignalGroupSettings{
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetSignalGroup(storage.SignalGroupSettings{
 			ApiUrl:  "https://signal-cli.example.org/api/v1/rpc",
 			Account: "0123456789",
 		})
@@ -242,8 +242,8 @@ func (s *BridgeTestSuite) TestSignalDelete() {
 	})
 
 	s.Run("when signal is inactive", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetSignalGroupSettings").Return(storage.DefaultSignalGroupSettings())
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetSignalGroup(storage.DefaultSignalGroupSettings())
 		bridge := s.signalGroupBridge(config.Config{}, mockStorage)
 
 		err := bridge.Delete(tickerWithBridges, &messageWithoutBridges)
@@ -252,8 +252,8 @@ func (s *BridgeTestSuite) TestSignalDelete() {
 	})
 
 	s.Run("when delete fails", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetSignalGroupSettings").Return(storage.SignalGroupSettings{
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetSignalGroup(storage.SignalGroupSettings{
 			ApiUrl:  "https://signal-cli.example.org/api/v1/rpc",
 			Account: "0123456789",
 		})
@@ -270,8 +270,8 @@ func (s *BridgeTestSuite) TestSignalDelete() {
 	})
 
 	s.Run("happy path", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetSignalGroupSettings").Return(storage.SignalGroupSettings{
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetSignalGroup(storage.SignalGroupSettings{
 			ApiUrl:  "https://signal-cli.example.org/api/v1/rpc",
 			Account: "0123456789",
 		})
@@ -295,9 +295,10 @@ func (s *BridgeTestSuite) TestSignalDelete() {
 	})
 }
 
-func (s *BridgeTestSuite) signalGroupBridge(config config.Config, storage storage.Storage) *SignalGroupBridge {
+func (s *BridgeTestSuite) signalGroupBridge(config config.Config, m *storage.MockStorage) *SignalGroupBridge {
 	return &SignalGroupBridge{
-		config:  config,
-		storage: storage,
+		config:   config,
+		uploads:  m.Uploads,
+		settings: m.Settings,
 	}
 }
diff --git a/internal/bridge/telegram.go b/internal/bridge/telegram.go
index 0bec3e73..0c74cb48 100644
--- a/internal/bridge/telegram.go
+++ b/internal/bridge/telegram.go
@@ -7,8 +7,9 @@ import (
 )
 
 type TelegramBridge struct {
-	config  config.Config
-	storage storage.Storage
+	config   config.Config
+	uploads  storage.UploadStore
+	settings storage.SettingsStore
 }
 
 func (tb *TelegramBridge) Update(ticker storage.Ticker) error {
@@ -21,7 +22,7 @@ func (tb *TelegramBridge) Send(ticker storage.Ticker, message *storage.Message)
 	}
 
 	// Get Telegram token from database settings
-	telegramSettings := tb.storage.GetTelegramSettings()
+	telegramSettings := storage.GetSettings(tb.settings, storage.TelegramSetting)
 	if telegramSettings.Token == "" {
 		return nil
 	}
@@ -41,7 +42,7 @@ func (tb *TelegramBridge) Send(ticker storage.Ticker, message *storage.Message)
 	} else {
 		var photos []interface{}
 		for i, attachment := range message.Attachments {
-			upload, err := tb.storage.FindUploadByUUID(attachment.UUID)
+			upload, err := tb.uploads.FindUploadByUUID(attachment.UUID)
 			if err != nil {
 				log.WithError(err).Error("failed to find upload")
 				continue
@@ -88,7 +89,7 @@ func (tb *TelegramBridge) Delete(ticker storage.Ticker, message *storage.Message
 	}
 
 	// Get Telegram token from database settings
-	telegramSettings := tb.storage.GetTelegramSettings()
+	telegramSettings := storage.GetSettings(tb.settings, storage.TelegramSetting)
 	if telegramSettings.Token == "" {
 		return nil
 	}
diff --git a/internal/bridge/telegram_test.go b/internal/bridge/telegram_test.go
index 7b5587c7..30e0ca3b 100644
--- a/internal/bridge/telegram_test.go
+++ b/internal/bridge/telegram_test.go
@@ -11,7 +11,7 @@ import (
 
 func (s *BridgeTestSuite) TestTelegramUpdate() {
 	s.Run("does nothing", func() {
-		bridge := s.telegramBridge(config.Config{}, &storage.MockStorage{})
+		bridge := s.telegramBridge(config.Config{}, storage.NewMockStorage())
 
 		err := bridge.Update(tickerWithBridges)
 		s.NoError(err)
@@ -20,7 +20,7 @@ func (s *BridgeTestSuite) TestTelegramUpdate() {
 
 func (s *BridgeTestSuite) TestTelegramSend() {
 	s.Run("when telegram is inactive", func() {
-		mockStorage := &storage.MockStorage{}
+		mockStorage := storage.NewMockStorage()
 		// No expectation for GetTelegramSettings since ChannelName is empty
 		bridge := s.telegramBridge(config.Config{}, mockStorage)
 
@@ -30,8 +30,8 @@ func (s *BridgeTestSuite) TestTelegramSend() {
 	})
 
 	s.Run("when telegram is active but token is empty", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetTelegramSettings").Return(storage.TelegramSettings{Token: ""})
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetTelegram(storage.TelegramSettings{Token: ""})
 		bridge := s.telegramBridge(config.Config{}, mockStorage)
 
 		err := bridge.Send(tickerWithBridges, &messageWithoutBridges)
@@ -40,8 +40,8 @@ func (s *BridgeTestSuite) TestTelegramSend() {
 	})
 
 	s.Run("when telegram is active but bot api fails", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetTelegramSettings").Return(storage.TelegramSettings{Token: "123"})
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetTelegram(storage.TelegramSettings{Token: "123"})
 		bridge := s.telegramBridge(config.Config{}, mockStorage)
 
 		gock.New("https://api.telegram.org").
@@ -55,8 +55,8 @@ func (s *BridgeTestSuite) TestTelegramSend() {
 	})
 
 	s.Run("when telegram is active but send message fails", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetTelegramSettings").Return(storage.TelegramSettings{Token: "123"})
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetTelegram(storage.TelegramSettings{Token: "123"})
 		bridge := s.telegramBridge(config.Config{}, mockStorage)
 
 		gock.New("https://api.telegram.org").
@@ -77,8 +77,8 @@ func (s *BridgeTestSuite) TestTelegramSend() {
 	})
 
 	s.Run("when telegram is active without attachments", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetTelegramSettings").Return(storage.TelegramSettings{Token: "123"})
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetTelegram(storage.TelegramSettings{Token: "123"})
 		bridge := s.telegramBridge(config.Config{}, mockStorage)
 
 		gock.New("https://api.telegram.org").
@@ -107,10 +107,10 @@ func (s *BridgeTestSuite) TestTelegramSend() {
 	})
 
 	s.Run("when telegram is active with attachments", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetTelegramSettings").Return(storage.TelegramSettings{Token: "123"})
-		mockStorage.On("FindUploadByUUID", "123").Return(storage.Upload{UUID: "123", ContentType: "image/gif"}, nil).Once()
-		mockStorage.On("FindUploadByUUID", "456").Return(storage.Upload{UUID: "456", ContentType: "image/jpeg"}, nil).Once()
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetTelegram(storage.TelegramSettings{Token: "123"})
+		mockStorage.Uploads.On("FindUploadByUUID", "123").Return(storage.Upload{UUID: "123", ContentType: "image/gif"}, nil).Once()
+		mockStorage.Uploads.On("FindUploadByUUID", "456").Return(storage.Upload{UUID: "456", ContentType: "image/jpeg"}, nil).Once()
 		bridge := s.telegramBridge(config.Config{}, mockStorage)
 
 		gock.New("https://api.telegram.org").
@@ -140,10 +140,10 @@ func (s *BridgeTestSuite) TestTelegramSend() {
 	})
 
 	s.Run("when telegram is active but send media group fails", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetTelegramSettings").Return(storage.TelegramSettings{Token: "123"})
-		mockStorage.On("FindUploadByUUID", "123").Return(storage.Upload{UUID: "123", ContentType: "image/gif"}, nil).Once()
-		mockStorage.On("FindUploadByUUID", "456").Return(storage.Upload{UUID: "456", ContentType: "image/jpeg"}, nil).Once()
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetTelegram(storage.TelegramSettings{Token: "123"})
+		mockStorage.Uploads.On("FindUploadByUUID", "123").Return(storage.Upload{UUID: "123", ContentType: "image/gif"}, nil).Once()
+		mockStorage.Uploads.On("FindUploadByUUID", "456").Return(storage.Upload{UUID: "456", ContentType: "image/jpeg"}, nil).Once()
 		bridge := s.telegramBridge(config.Config{}, mockStorage)
 
 		gock.New("https://api.telegram.org").
@@ -165,10 +165,10 @@ func (s *BridgeTestSuite) TestTelegramSend() {
 	})
 
 	s.Run("when telegram is active but find upload fails", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetTelegramSettings").Return(storage.TelegramSettings{Token: "123"})
-		mockStorage.On("FindUploadByUUID", "123").Return(storage.Upload{}, errors.New("failed to find upload")).Once()
-		mockStorage.On("FindUploadByUUID", "456").Return(storage.Upload{}, errors.New("failed to find upload")).Once()
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetTelegram(storage.TelegramSettings{Token: "123"})
+		mockStorage.Uploads.On("FindUploadByUUID", "123").Return(storage.Upload{}, errors.New("failed to find upload")).Once()
+		mockStorage.Uploads.On("FindUploadByUUID", "456").Return(storage.Upload{}, errors.New("failed to find upload")).Once()
 		bridge := s.telegramBridge(config.Config{}, mockStorage)
 
 		gock.New("https://api.telegram.org").
@@ -188,7 +188,7 @@ func (s *BridgeTestSuite) TestTelegramSend() {
 
 func (s *BridgeTestSuite) TestTelegramDelete() {
 	s.Run("when telegram is inactive", func() {
-		mockStorage := &storage.MockStorage{}
+		mockStorage := storage.NewMockStorage()
 		// No expectation for GetTelegramSettings since ChannelName is empty
 		bridge := s.telegramBridge(config.Config{}, mockStorage)
 
@@ -198,7 +198,7 @@ func (s *BridgeTestSuite) TestTelegramDelete() {
 	})
 
 	s.Run("when token is empty", func() {
-		mockStorage := &storage.MockStorage{}
+		mockStorage := storage.NewMockStorage()
 		// No GetTelegramSettings expectation because ChannelName is empty, causing early return
 		bridge := s.telegramBridge(config.Config{}, mockStorage)
 
@@ -208,7 +208,7 @@ func (s *BridgeTestSuite) TestTelegramDelete() {
 	})
 
 	s.Run("when message has no telegram meta", func() {
-		mockStorage := &storage.MockStorage{}
+		mockStorage := storage.NewMockStorage()
 		// No GetTelegramSettings expectation because message has no Telegram metadata, causing early return
 		bridge := s.telegramBridge(config.Config{}, mockStorage)
 
@@ -218,8 +218,8 @@ func (s *BridgeTestSuite) TestTelegramDelete() {
 	})
 
 	s.Run("when telegram is active but bot api fails", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetTelegramSettings").Return(storage.TelegramSettings{Token: "123"})
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetTelegram(storage.TelegramSettings{Token: "123"})
 		bridge := s.telegramBridge(config.Config{}, mockStorage)
 
 		gock.New("https://api.telegram.org").
@@ -233,8 +233,8 @@ func (s *BridgeTestSuite) TestTelegramDelete() {
 	})
 
 	s.Run("when telegram is active but delete message fails", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetTelegramSettings").Return(storage.TelegramSettings{Token: "123"})
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetTelegram(storage.TelegramSettings{Token: "123"})
 		bridge := s.telegramBridge(config.Config{}, mockStorage)
 
 		gock.New("https://api.telegram.org").
@@ -254,8 +254,8 @@ func (s *BridgeTestSuite) TestTelegramDelete() {
 	})
 
 	s.Run("when telegram is active and deletion is successful", func() {
-		mockStorage := &storage.MockStorage{}
-		mockStorage.On("GetTelegramSettings").Return(storage.TelegramSettings{Token: "123"})
+		mockStorage := storage.NewMockStorage()
+		mockStorage.Settings.MockGetTelegram(storage.TelegramSettings{Token: "123"})
 		bridge := s.telegramBridge(config.Config{}, mockStorage)
 
 		gock.New("https://api.telegram.org").
@@ -308,9 +308,10 @@ func (s *BridgeTestSuite) TestBotUser() {
 	})
 }
 
-func (s *BridgeTestSuite) telegramBridge(config config.Config, storage storage.Storage) *TelegramBridge {
+func (s *BridgeTestSuite) telegramBridge(config config.Config, m *storage.MockStorage) *TelegramBridge {
 	return &TelegramBridge{
-		config:  config,
-		storage: storage,
+		config:   config,
+		uploads:  m.Uploads,
+		settings: m.Settings,
 	}
 }
diff --git a/internal/storage/integration.go b/internal/storage/integration.go
new file mode 100644
index 00000000..be4e520e
--- /dev/null
+++ b/internal/storage/integration.go
@@ -0,0 +1,21 @@
+package storage
+
+// Integration identifies an outbound platform configured on a Ticker
+// (Telegram / Mastodon / Bluesky / SignalGroup).
+type Integration string
+
+const (
+	IntegrationTelegram    Integration = "telegram"
+	IntegrationMastodon    Integration = "mastodon"
+	IntegrationBluesky     Integration = "bluesky"
+	IntegrationSignalGroup Integration = "signal_group"
+)
+
+// AllIntegrations lists every supported integration; useful for ClearIntegrations
+// and for iterating across known platforms.
+var AllIntegrations = []Integration{
+	IntegrationTelegram,
+	IntegrationMastodon,
+	IntegrationBluesky,
+	IntegrationSignalGroup,
+}
diff --git a/internal/storage/message_store.go b/internal/storage/message_store.go
new file mode 100644
index 00000000..31815d9a
--- /dev/null
+++ b/internal/storage/message_store.go
@@ -0,0 +1,15 @@
+package storage
+
+import (
+	"github.com/systemli/ticker/internal/api/pagination"
+)
+
+// MessageStore covers Message lookups, paginated reads, and writes.
+type MessageStore interface {
+	FindMessage(tickerID, messageID int, opts ...QueryOpt) (Message, error)
+	FindMessagesByTicker(ticker Ticker, opts ...QueryOpt) ([]Message, error)
+	FindMessagesByTickerAndPagination(ticker Ticker, p pagination.Pagination, opts ...QueryOpt) ([]Message, error)
+	SaveMessage(message *Message) error
+	DeleteMessage(message Message) error
+	DeleteMessages(ticker *Ticker) error
+}
diff --git a/internal/storage/mock_MessageStore.go b/internal/storage/mock_MessageStore.go
new file mode 100644
index 00000000..86c47b3b
--- /dev/null
+++ b/internal/storage/mock_MessageStore.go
@@ -0,0 +1,431 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package storage
+
+import (
+	mock "github.com/stretchr/testify/mock"
+	"github.com/systemli/ticker/internal/api/pagination"
+)
+
+// NewMockMessageStore creates a new instance of MockMessageStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockMessageStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockMessageStore {
+	mock := &MockMessageStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockMessageStore is an autogenerated mock type for the MessageStore type
+type MockMessageStore struct {
+	mock.Mock
+}
+
+type MockMessageStore_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockMessageStore) EXPECT() *MockMessageStore_Expecter {
+	return &MockMessageStore_Expecter{mock: &_m.Mock}
+}
+
+// DeleteMessage provides a mock function for the type MockMessageStore
+func (_mock *MockMessageStore) DeleteMessage(message Message) error {
+	ret := _mock.Called(message)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteMessage")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(Message) error); ok {
+		r0 = returnFunc(message)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockMessageStore_DeleteMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMessage'
+type MockMessageStore_DeleteMessage_Call struct {
+	*mock.Call
+}
+
+// DeleteMessage is a helper method to define mock.On call
+//   - message Message
+func (_e *MockMessageStore_Expecter) DeleteMessage(message interface{}) *MockMessageStore_DeleteMessage_Call {
+	return &MockMessageStore_DeleteMessage_Call{Call: _e.mock.On("DeleteMessage", message)}
+}
+
+func (_c *MockMessageStore_DeleteMessage_Call) Run(run func(message Message)) *MockMessageStore_DeleteMessage_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 Message
+		if args[0] != nil {
+			arg0 = args[0].(Message)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockMessageStore_DeleteMessage_Call) Return(err error) *MockMessageStore_DeleteMessage_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockMessageStore_DeleteMessage_Call) RunAndReturn(run func(message Message) error) *MockMessageStore_DeleteMessage_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// DeleteMessages provides a mock function for the type MockMessageStore
+func (_mock *MockMessageStore) DeleteMessages(ticker *Ticker) error {
+	ret := _mock.Called(ticker)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteMessages")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*Ticker) error); ok {
+		r0 = returnFunc(ticker)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockMessageStore_DeleteMessages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMessages'
+type MockMessageStore_DeleteMessages_Call struct {
+	*mock.Call
+}
+
+// DeleteMessages is a helper method to define mock.On call
+//   - ticker *Ticker
+func (_e *MockMessageStore_Expecter) DeleteMessages(ticker interface{}) *MockMessageStore_DeleteMessages_Call {
+	return &MockMessageStore_DeleteMessages_Call{Call: _e.mock.On("DeleteMessages", ticker)}
+}
+
+func (_c *MockMessageStore_DeleteMessages_Call) Run(run func(ticker *Ticker)) *MockMessageStore_DeleteMessages_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *Ticker
+		if args[0] != nil {
+			arg0 = args[0].(*Ticker)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockMessageStore_DeleteMessages_Call) Return(err error) *MockMessageStore_DeleteMessages_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockMessageStore_DeleteMessages_Call) RunAndReturn(run func(ticker *Ticker) error) *MockMessageStore_DeleteMessages_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindMessage provides a mock function for the type MockMessageStore
+func (_mock *MockMessageStore) FindMessage(tickerID int, messageID int, opts ...QueryOpt) (Message, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(tickerID, messageID, opts)
+	} else {
+		tmpRet = _mock.Called(tickerID, messageID)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindMessage")
+	}
+
+	var r0 Message
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(int, int, ...QueryOpt) (Message, error)); ok {
+		return returnFunc(tickerID, messageID, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(int, int, ...QueryOpt) Message); ok {
+		r0 = returnFunc(tickerID, messageID, opts...)
+	} else {
+		r0 = ret.Get(0).(Message)
+	}
+	if returnFunc, ok := ret.Get(1).(func(int, int, ...QueryOpt) error); ok {
+		r1 = returnFunc(tickerID, messageID, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockMessageStore_FindMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindMessage'
+type MockMessageStore_FindMessage_Call struct {
+	*mock.Call
+}
+
+// FindMessage is a helper method to define mock.On call
+//   - tickerID int
+//   - messageID int
+//   - opts ...QueryOpt
+func (_e *MockMessageStore_Expecter) FindMessage(tickerID interface{}, messageID interface{}, opts ...interface{}) *MockMessageStore_FindMessage_Call {
+	return &MockMessageStore_FindMessage_Call{Call: _e.mock.On("FindMessage",
+		append([]interface{}{tickerID, messageID}, opts...)...)}
+}
+
+func (_c *MockMessageStore_FindMessage_Call) Run(run func(tickerID int, messageID int, opts ...QueryOpt)) *MockMessageStore_FindMessage_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 int
+		if args[0] != nil {
+			arg0 = args[0].(int)
+		}
+		var arg1 int
+		if args[1] != nil {
+			arg1 = args[1].(int)
+		}
+		var arg2 []QueryOpt
+		var variadicArgs []QueryOpt
+		if len(args) > 2 {
+			variadicArgs = args[2].([]QueryOpt)
+		}
+		arg2 = variadicArgs
+		run(
+			arg0,
+			arg1,
+			arg2...,
+		)
+	})
+	return _c
+}
+
+func (_c *MockMessageStore_FindMessage_Call) Return(message Message, err error) *MockMessageStore_FindMessage_Call {
+	_c.Call.Return(message, err)
+	return _c
+}
+
+func (_c *MockMessageStore_FindMessage_Call) RunAndReturn(run func(tickerID int, messageID int, opts ...QueryOpt) (Message, error)) *MockMessageStore_FindMessage_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindMessagesByTicker provides a mock function for the type MockMessageStore
+func (_mock *MockMessageStore) FindMessagesByTicker(ticker Ticker, opts ...QueryOpt) ([]Message, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(ticker, opts)
+	} else {
+		tmpRet = _mock.Called(ticker)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindMessagesByTicker")
+	}
+
+	var r0 []Message
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(Ticker, ...QueryOpt) ([]Message, error)); ok {
+		return returnFunc(ticker, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(Ticker, ...QueryOpt) []Message); ok {
+		r0 = returnFunc(ticker, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]Message)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(Ticker, ...QueryOpt) error); ok {
+		r1 = returnFunc(ticker, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockMessageStore_FindMessagesByTicker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindMessagesByTicker'
+type MockMessageStore_FindMessagesByTicker_Call struct {
+	*mock.Call
+}
+
+// FindMessagesByTicker is a helper method to define mock.On call
+//   - ticker Ticker
+//   - opts ...QueryOpt
+func (_e *MockMessageStore_Expecter) FindMessagesByTicker(ticker interface{}, opts ...interface{}) *MockMessageStore_FindMessagesByTicker_Call {
+	return &MockMessageStore_FindMessagesByTicker_Call{Call: _e.mock.On("FindMessagesByTicker",
+		append([]interface{}{ticker}, opts...)...)}
+}
+
+func (_c *MockMessageStore_FindMessagesByTicker_Call) Run(run func(ticker Ticker, opts ...QueryOpt)) *MockMessageStore_FindMessagesByTicker_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 Ticker
+		if args[0] != nil {
+			arg0 = args[0].(Ticker)
+		}
+		var arg1 []QueryOpt
+		var variadicArgs []QueryOpt
+		if len(args) > 1 {
+			variadicArgs = args[1].([]QueryOpt)
+		}
+		arg1 = variadicArgs
+		run(
+			arg0,
+			arg1...,
+		)
+	})
+	return _c
+}
+
+func (_c *MockMessageStore_FindMessagesByTicker_Call) Return(messages []Message, err error) *MockMessageStore_FindMessagesByTicker_Call {
+	_c.Call.Return(messages, err)
+	return _c
+}
+
+func (_c *MockMessageStore_FindMessagesByTicker_Call) RunAndReturn(run func(ticker Ticker, opts ...QueryOpt) ([]Message, error)) *MockMessageStore_FindMessagesByTicker_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindMessagesByTickerAndPagination provides a mock function for the type MockMessageStore
+func (_mock *MockMessageStore) FindMessagesByTickerAndPagination(ticker Ticker, p pagination.Pagination, opts ...QueryOpt) ([]Message, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(ticker, p, opts)
+	} else {
+		tmpRet = _mock.Called(ticker, p)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindMessagesByTickerAndPagination")
+	}
+
+	var r0 []Message
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(Ticker, pagination.Pagination, ...QueryOpt) ([]Message, error)); ok {
+		return returnFunc(ticker, p, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(Ticker, pagination.Pagination, ...QueryOpt) []Message); ok {
+		r0 = returnFunc(ticker, p, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]Message)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(Ticker, pagination.Pagination, ...QueryOpt) error); ok {
+		r1 = returnFunc(ticker, p, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockMessageStore_FindMessagesByTickerAndPagination_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindMessagesByTickerAndPagination'
+type MockMessageStore_FindMessagesByTickerAndPagination_Call struct {
+	*mock.Call
+}
+
+// FindMessagesByTickerAndPagination is a helper method to define mock.On call
+//   - ticker Ticker
+//   - p pagination.Pagination
+//   - opts ...QueryOpt
+func (_e *MockMessageStore_Expecter) FindMessagesByTickerAndPagination(ticker interface{}, p interface{}, opts ...interface{}) *MockMessageStore_FindMessagesByTickerAndPagination_Call {
+	return &MockMessageStore_FindMessagesByTickerAndPagination_Call{Call: _e.mock.On("FindMessagesByTickerAndPagination",
+		append([]interface{}{ticker, p}, opts...)...)}
+}
+
+func (_c *MockMessageStore_FindMessagesByTickerAndPagination_Call) Run(run func(ticker Ticker, p pagination.Pagination, opts ...QueryOpt)) *MockMessageStore_FindMessagesByTickerAndPagination_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 Ticker
+		if args[0] != nil {
+			arg0 = args[0].(Ticker)
+		}
+		var arg1 pagination.Pagination
+		if args[1] != nil {
+			arg1 = args[1].(pagination.Pagination)
+		}
+		var arg2 []QueryOpt
+		var variadicArgs []QueryOpt
+		if len(args) > 2 {
+			variadicArgs = args[2].([]QueryOpt)
+		}
+		arg2 = variadicArgs
+		run(
+			arg0,
+			arg1,
+			arg2...,
+		)
+	})
+	return _c
+}
+
+func (_c *MockMessageStore_FindMessagesByTickerAndPagination_Call) Return(messages []Message, err error) *MockMessageStore_FindMessagesByTickerAndPagination_Call {
+	_c.Call.Return(messages, err)
+	return _c
+}
+
+func (_c *MockMessageStore_FindMessagesByTickerAndPagination_Call) RunAndReturn(run func(ticker Ticker, p pagination.Pagination, opts ...QueryOpt) ([]Message, error)) *MockMessageStore_FindMessagesByTickerAndPagination_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SaveMessage provides a mock function for the type MockMessageStore
+func (_mock *MockMessageStore) SaveMessage(message *Message) error {
+	ret := _mock.Called(message)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveMessage")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*Message) error); ok {
+		r0 = returnFunc(message)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockMessageStore_SaveMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveMessage'
+type MockMessageStore_SaveMessage_Call struct {
+	*mock.Call
+}
+
+// SaveMessage is a helper method to define mock.On call
+//   - message *Message
+func (_e *MockMessageStore_Expecter) SaveMessage(message interface{}) *MockMessageStore_SaveMessage_Call {
+	return &MockMessageStore_SaveMessage_Call{Call: _e.mock.On("SaveMessage", message)}
+}
+
+func (_c *MockMessageStore_SaveMessage_Call) Run(run func(message *Message)) *MockMessageStore_SaveMessage_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *Message
+		if args[0] != nil {
+			arg0 = args[0].(*Message)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockMessageStore_SaveMessage_Call) Return(err error) *MockMessageStore_SaveMessage_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockMessageStore_SaveMessage_Call) RunAndReturn(run func(message *Message) error) *MockMessageStore_SaveMessage_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/internal/storage/mock_SettingsStore.go b/internal/storage/mock_SettingsStore.go
new file mode 100644
index 00000000..fb18d809
--- /dev/null
+++ b/internal/storage/mock_SettingsStore.go
@@ -0,0 +1,147 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package storage
+
+import (
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewMockSettingsStore creates a new instance of MockSettingsStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockSettingsStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockSettingsStore {
+	mock := &MockSettingsStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockSettingsStore is an autogenerated mock type for the SettingsStore type
+type MockSettingsStore struct {
+	mock.Mock
+}
+
+type MockSettingsStore_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockSettingsStore) EXPECT() *MockSettingsStore_Expecter {
+	return &MockSettingsStore_Expecter{mock: &_m.Mock}
+}
+
+// GetSetting provides a mock function for the type MockSettingsStore
+func (_mock *MockSettingsStore) GetSetting(name string) (Setting, error) {
+	ret := _mock.Called(name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetSetting")
+	}
+
+	var r0 Setting
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(string) (Setting, error)); ok {
+		return returnFunc(name)
+	}
+	if returnFunc, ok := ret.Get(0).(func(string) Setting); ok {
+		r0 = returnFunc(name)
+	} else {
+		r0 = ret.Get(0).(Setting)
+	}
+	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
+		r1 = returnFunc(name)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockSettingsStore_GetSetting_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSetting'
+type MockSettingsStore_GetSetting_Call struct {
+	*mock.Call
+}
+
+// GetSetting is a helper method to define mock.On call
+//   - name string
+func (_e *MockSettingsStore_Expecter) GetSetting(name interface{}) *MockSettingsStore_GetSetting_Call {
+	return &MockSettingsStore_GetSetting_Call{Call: _e.mock.On("GetSetting", name)}
+}
+
+func (_c *MockSettingsStore_GetSetting_Call) Run(run func(name string)) *MockSettingsStore_GetSetting_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockSettingsStore_GetSetting_Call) Return(setting Setting, err error) *MockSettingsStore_GetSetting_Call {
+	_c.Call.Return(setting, err)
+	return _c
+}
+
+func (_c *MockSettingsStore_GetSetting_Call) RunAndReturn(run func(name string) (Setting, error)) *MockSettingsStore_GetSetting_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SaveSetting provides a mock function for the type MockSettingsStore
+func (_mock *MockSettingsStore) SaveSetting(setting *Setting) error {
+	ret := _mock.Called(setting)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveSetting")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*Setting) error); ok {
+		r0 = returnFunc(setting)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockSettingsStore_SaveSetting_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveSetting'
+type MockSettingsStore_SaveSetting_Call struct {
+	*mock.Call
+}
+
+// SaveSetting is a helper method to define mock.On call
+//   - setting *Setting
+func (_e *MockSettingsStore_Expecter) SaveSetting(setting interface{}) *MockSettingsStore_SaveSetting_Call {
+	return &MockSettingsStore_SaveSetting_Call{Call: _e.mock.On("SaveSetting", setting)}
+}
+
+func (_c *MockSettingsStore_SaveSetting_Call) Run(run func(setting *Setting)) *MockSettingsStore_SaveSetting_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *Setting
+		if args[0] != nil {
+			arg0 = args[0].(*Setting)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockSettingsStore_SaveSetting_Call) Return(err error) *MockSettingsStore_SaveSetting_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockSettingsStore_SaveSetting_Call) RunAndReturn(run func(setting *Setting) error) *MockSettingsStore_SaveSetting_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/internal/storage/mock_Storage.go b/internal/storage/mock_Storage.go
deleted file mode 100644
index 059b8df9..00000000
--- a/internal/storage/mock_Storage.go
+++ /dev/null
@@ -1,2631 +0,0 @@
-// Code generated by mockery; DO NOT EDIT.
-// github.com/vektra/mockery
-// template: testify
-
-package storage
-
-import (
-	mock "github.com/stretchr/testify/mock"
-	"github.com/systemli/ticker/internal/api/pagination"
-	"gorm.io/gorm"
-)
-
-// NewMockStorage creates a new instance of MockStorage. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewMockStorage(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *MockStorage {
-	mock := &MockStorage{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
-
-// MockStorage is an autogenerated mock type for the Storage type
-type MockStorage struct {
-	mock.Mock
-}
-
-type MockStorage_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *MockStorage) EXPECT() *MockStorage_Expecter {
-	return &MockStorage_Expecter{mock: &_m.Mock}
-}
-
-// AddTickerUser provides a mock function for the type MockStorage
-func (_mock *MockStorage) AddTickerUser(ticker *Ticker, user *User) error {
-	ret := _mock.Called(ticker, user)
-
-	if len(ret) == 0 {
-		panic("no return value specified for AddTickerUser")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(*Ticker, *User) error); ok {
-		r0 = returnFunc(ticker, user)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_AddTickerUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddTickerUser'
-type MockStorage_AddTickerUser_Call struct {
-	*mock.Call
-}
-
-// AddTickerUser is a helper method to define mock.On call
-//   - ticker *Ticker
-//   - user *User
-func (_e *MockStorage_Expecter) AddTickerUser(ticker interface{}, user interface{}) *MockStorage_AddTickerUser_Call {
-	return &MockStorage_AddTickerUser_Call{Call: _e.mock.On("AddTickerUser", ticker, user)}
-}
-
-func (_c *MockStorage_AddTickerUser_Call) Run(run func(ticker *Ticker, user *User)) *MockStorage_AddTickerUser_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 *Ticker
-		if args[0] != nil {
-			arg0 = args[0].(*Ticker)
-		}
-		var arg1 *User
-		if args[1] != nil {
-			arg1 = args[1].(*User)
-		}
-		run(
-			arg0,
-			arg1,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_AddTickerUser_Call) Return(err error) *MockStorage_AddTickerUser_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_AddTickerUser_Call) RunAndReturn(run func(ticker *Ticker, user *User) error) *MockStorage_AddTickerUser_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBluesky provides a mock function for the type MockStorage
-func (_mock *MockStorage) DeleteBluesky(ticker *Ticker) error {
-	ret := _mock.Called(ticker)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBluesky")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(*Ticker) error); ok {
-		r0 = returnFunc(ticker)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_DeleteBluesky_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBluesky'
-type MockStorage_DeleteBluesky_Call struct {
-	*mock.Call
-}
-
-// DeleteBluesky is a helper method to define mock.On call
-//   - ticker *Ticker
-func (_e *MockStorage_Expecter) DeleteBluesky(ticker interface{}) *MockStorage_DeleteBluesky_Call {
-	return &MockStorage_DeleteBluesky_Call{Call: _e.mock.On("DeleteBluesky", ticker)}
-}
-
-func (_c *MockStorage_DeleteBluesky_Call) Run(run func(ticker *Ticker)) *MockStorage_DeleteBluesky_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 *Ticker
-		if args[0] != nil {
-			arg0 = args[0].(*Ticker)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_DeleteBluesky_Call) Return(err error) *MockStorage_DeleteBluesky_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_DeleteBluesky_Call) RunAndReturn(run func(ticker *Ticker) error) *MockStorage_DeleteBluesky_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteIntegrations provides a mock function for the type MockStorage
-func (_mock *MockStorage) DeleteIntegrations(ticker *Ticker) error {
-	ret := _mock.Called(ticker)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteIntegrations")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(*Ticker) error); ok {
-		r0 = returnFunc(ticker)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_DeleteIntegrations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteIntegrations'
-type MockStorage_DeleteIntegrations_Call struct {
-	*mock.Call
-}
-
-// DeleteIntegrations is a helper method to define mock.On call
-//   - ticker *Ticker
-func (_e *MockStorage_Expecter) DeleteIntegrations(ticker interface{}) *MockStorage_DeleteIntegrations_Call {
-	return &MockStorage_DeleteIntegrations_Call{Call: _e.mock.On("DeleteIntegrations", ticker)}
-}
-
-func (_c *MockStorage_DeleteIntegrations_Call) Run(run func(ticker *Ticker)) *MockStorage_DeleteIntegrations_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 *Ticker
-		if args[0] != nil {
-			arg0 = args[0].(*Ticker)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_DeleteIntegrations_Call) Return(err error) *MockStorage_DeleteIntegrations_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_DeleteIntegrations_Call) RunAndReturn(run func(ticker *Ticker) error) *MockStorage_DeleteIntegrations_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteMastodon provides a mock function for the type MockStorage
-func (_mock *MockStorage) DeleteMastodon(ticker *Ticker) error {
-	ret := _mock.Called(ticker)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteMastodon")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(*Ticker) error); ok {
-		r0 = returnFunc(ticker)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_DeleteMastodon_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMastodon'
-type MockStorage_DeleteMastodon_Call struct {
-	*mock.Call
-}
-
-// DeleteMastodon is a helper method to define mock.On call
-//   - ticker *Ticker
-func (_e *MockStorage_Expecter) DeleteMastodon(ticker interface{}) *MockStorage_DeleteMastodon_Call {
-	return &MockStorage_DeleteMastodon_Call{Call: _e.mock.On("DeleteMastodon", ticker)}
-}
-
-func (_c *MockStorage_DeleteMastodon_Call) Run(run func(ticker *Ticker)) *MockStorage_DeleteMastodon_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 *Ticker
-		if args[0] != nil {
-			arg0 = args[0].(*Ticker)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_DeleteMastodon_Call) Return(err error) *MockStorage_DeleteMastodon_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_DeleteMastodon_Call) RunAndReturn(run func(ticker *Ticker) error) *MockStorage_DeleteMastodon_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteMessage provides a mock function for the type MockStorage
-func (_mock *MockStorage) DeleteMessage(message Message) error {
-	ret := _mock.Called(message)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteMessage")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(Message) error); ok {
-		r0 = returnFunc(message)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_DeleteMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMessage'
-type MockStorage_DeleteMessage_Call struct {
-	*mock.Call
-}
-
-// DeleteMessage is a helper method to define mock.On call
-//   - message Message
-func (_e *MockStorage_Expecter) DeleteMessage(message interface{}) *MockStorage_DeleteMessage_Call {
-	return &MockStorage_DeleteMessage_Call{Call: _e.mock.On("DeleteMessage", message)}
-}
-
-func (_c *MockStorage_DeleteMessage_Call) Run(run func(message Message)) *MockStorage_DeleteMessage_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 Message
-		if args[0] != nil {
-			arg0 = args[0].(Message)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_DeleteMessage_Call) Return(err error) *MockStorage_DeleteMessage_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_DeleteMessage_Call) RunAndReturn(run func(message Message) error) *MockStorage_DeleteMessage_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteMessages provides a mock function for the type MockStorage
-func (_mock *MockStorage) DeleteMessages(ticker *Ticker) error {
-	ret := _mock.Called(ticker)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteMessages")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(*Ticker) error); ok {
-		r0 = returnFunc(ticker)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_DeleteMessages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMessages'
-type MockStorage_DeleteMessages_Call struct {
-	*mock.Call
-}
-
-// DeleteMessages is a helper method to define mock.On call
-//   - ticker *Ticker
-func (_e *MockStorage_Expecter) DeleteMessages(ticker interface{}) *MockStorage_DeleteMessages_Call {
-	return &MockStorage_DeleteMessages_Call{Call: _e.mock.On("DeleteMessages", ticker)}
-}
-
-func (_c *MockStorage_DeleteMessages_Call) Run(run func(ticker *Ticker)) *MockStorage_DeleteMessages_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 *Ticker
-		if args[0] != nil {
-			arg0 = args[0].(*Ticker)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_DeleteMessages_Call) Return(err error) *MockStorage_DeleteMessages_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_DeleteMessages_Call) RunAndReturn(run func(ticker *Ticker) error) *MockStorage_DeleteMessages_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteSignalGroup provides a mock function for the type MockStorage
-func (_mock *MockStorage) DeleteSignalGroup(ticker *Ticker) error {
-	ret := _mock.Called(ticker)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteSignalGroup")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(*Ticker) error); ok {
-		r0 = returnFunc(ticker)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_DeleteSignalGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSignalGroup'
-type MockStorage_DeleteSignalGroup_Call struct {
-	*mock.Call
-}
-
-// DeleteSignalGroup is a helper method to define mock.On call
-//   - ticker *Ticker
-func (_e *MockStorage_Expecter) DeleteSignalGroup(ticker interface{}) *MockStorage_DeleteSignalGroup_Call {
-	return &MockStorage_DeleteSignalGroup_Call{Call: _e.mock.On("DeleteSignalGroup", ticker)}
-}
-
-func (_c *MockStorage_DeleteSignalGroup_Call) Run(run func(ticker *Ticker)) *MockStorage_DeleteSignalGroup_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 *Ticker
-		if args[0] != nil {
-			arg0 = args[0].(*Ticker)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_DeleteSignalGroup_Call) Return(err error) *MockStorage_DeleteSignalGroup_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_DeleteSignalGroup_Call) RunAndReturn(run func(ticker *Ticker) error) *MockStorage_DeleteSignalGroup_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteTelegram provides a mock function for the type MockStorage
-func (_mock *MockStorage) DeleteTelegram(ticker *Ticker) error {
-	ret := _mock.Called(ticker)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteTelegram")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(*Ticker) error); ok {
-		r0 = returnFunc(ticker)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_DeleteTelegram_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTelegram'
-type MockStorage_DeleteTelegram_Call struct {
-	*mock.Call
-}
-
-// DeleteTelegram is a helper method to define mock.On call
-//   - ticker *Ticker
-func (_e *MockStorage_Expecter) DeleteTelegram(ticker interface{}) *MockStorage_DeleteTelegram_Call {
-	return &MockStorage_DeleteTelegram_Call{Call: _e.mock.On("DeleteTelegram", ticker)}
-}
-
-func (_c *MockStorage_DeleteTelegram_Call) Run(run func(ticker *Ticker)) *MockStorage_DeleteTelegram_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 *Ticker
-		if args[0] != nil {
-			arg0 = args[0].(*Ticker)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_DeleteTelegram_Call) Return(err error) *MockStorage_DeleteTelegram_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_DeleteTelegram_Call) RunAndReturn(run func(ticker *Ticker) error) *MockStorage_DeleteTelegram_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteTicker provides a mock function for the type MockStorage
-func (_mock *MockStorage) DeleteTicker(ticker *Ticker) error {
-	ret := _mock.Called(ticker)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteTicker")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(*Ticker) error); ok {
-		r0 = returnFunc(ticker)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_DeleteTicker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTicker'
-type MockStorage_DeleteTicker_Call struct {
-	*mock.Call
-}
-
-// DeleteTicker is a helper method to define mock.On call
-//   - ticker *Ticker
-func (_e *MockStorage_Expecter) DeleteTicker(ticker interface{}) *MockStorage_DeleteTicker_Call {
-	return &MockStorage_DeleteTicker_Call{Call: _e.mock.On("DeleteTicker", ticker)}
-}
-
-func (_c *MockStorage_DeleteTicker_Call) Run(run func(ticker *Ticker)) *MockStorage_DeleteTicker_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 *Ticker
-		if args[0] != nil {
-			arg0 = args[0].(*Ticker)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_DeleteTicker_Call) Return(err error) *MockStorage_DeleteTicker_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_DeleteTicker_Call) RunAndReturn(run func(ticker *Ticker) error) *MockStorage_DeleteTicker_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteTickerUser provides a mock function for the type MockStorage
-func (_mock *MockStorage) DeleteTickerUser(ticker *Ticker, user *User) error {
-	ret := _mock.Called(ticker, user)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteTickerUser")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(*Ticker, *User) error); ok {
-		r0 = returnFunc(ticker, user)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_DeleteTickerUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTickerUser'
-type MockStorage_DeleteTickerUser_Call struct {
-	*mock.Call
-}
-
-// DeleteTickerUser is a helper method to define mock.On call
-//   - ticker *Ticker
-//   - user *User
-func (_e *MockStorage_Expecter) DeleteTickerUser(ticker interface{}, user interface{}) *MockStorage_DeleteTickerUser_Call {
-	return &MockStorage_DeleteTickerUser_Call{Call: _e.mock.On("DeleteTickerUser", ticker, user)}
-}
-
-func (_c *MockStorage_DeleteTickerUser_Call) Run(run func(ticker *Ticker, user *User)) *MockStorage_DeleteTickerUser_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 *Ticker
-		if args[0] != nil {
-			arg0 = args[0].(*Ticker)
-		}
-		var arg1 *User
-		if args[1] != nil {
-			arg1 = args[1].(*User)
-		}
-		run(
-			arg0,
-			arg1,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_DeleteTickerUser_Call) Return(err error) *MockStorage_DeleteTickerUser_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_DeleteTickerUser_Call) RunAndReturn(run func(ticker *Ticker, user *User) error) *MockStorage_DeleteTickerUser_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteTickerUsers provides a mock function for the type MockStorage
-func (_mock *MockStorage) DeleteTickerUsers(ticker *Ticker) error {
-	ret := _mock.Called(ticker)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteTickerUsers")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(*Ticker) error); ok {
-		r0 = returnFunc(ticker)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_DeleteTickerUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTickerUsers'
-type MockStorage_DeleteTickerUsers_Call struct {
-	*mock.Call
-}
-
-// DeleteTickerUsers is a helper method to define mock.On call
-//   - ticker *Ticker
-func (_e *MockStorage_Expecter) DeleteTickerUsers(ticker interface{}) *MockStorage_DeleteTickerUsers_Call {
-	return &MockStorage_DeleteTickerUsers_Call{Call: _e.mock.On("DeleteTickerUsers", ticker)}
-}
-
-func (_c *MockStorage_DeleteTickerUsers_Call) Run(run func(ticker *Ticker)) *MockStorage_DeleteTickerUsers_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 *Ticker
-		if args[0] != nil {
-			arg0 = args[0].(*Ticker)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_DeleteTickerUsers_Call) Return(err error) *MockStorage_DeleteTickerUsers_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_DeleteTickerUsers_Call) RunAndReturn(run func(ticker *Ticker) error) *MockStorage_DeleteTickerUsers_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteTickerWebsites provides a mock function for the type MockStorage
-func (_mock *MockStorage) DeleteTickerWebsites(ticker *Ticker) error {
-	ret := _mock.Called(ticker)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteTickerWebsites")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(*Ticker) error); ok {
-		r0 = returnFunc(ticker)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_DeleteTickerWebsites_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTickerWebsites'
-type MockStorage_DeleteTickerWebsites_Call struct {
-	*mock.Call
-}
-
-// DeleteTickerWebsites is a helper method to define mock.On call
-//   - ticker *Ticker
-func (_e *MockStorage_Expecter) DeleteTickerWebsites(ticker interface{}) *MockStorage_DeleteTickerWebsites_Call {
-	return &MockStorage_DeleteTickerWebsites_Call{Call: _e.mock.On("DeleteTickerWebsites", ticker)}
-}
-
-func (_c *MockStorage_DeleteTickerWebsites_Call) Run(run func(ticker *Ticker)) *MockStorage_DeleteTickerWebsites_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 *Ticker
-		if args[0] != nil {
-			arg0 = args[0].(*Ticker)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_DeleteTickerWebsites_Call) Return(err error) *MockStorage_DeleteTickerWebsites_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_DeleteTickerWebsites_Call) RunAndReturn(run func(ticker *Ticker) error) *MockStorage_DeleteTickerWebsites_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteUpload provides a mock function for the type MockStorage
-func (_mock *MockStorage) DeleteUpload(upload Upload) error {
-	ret := _mock.Called(upload)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteUpload")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(Upload) error); ok {
-		r0 = returnFunc(upload)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_DeleteUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUpload'
-type MockStorage_DeleteUpload_Call struct {
-	*mock.Call
-}
-
-// DeleteUpload is a helper method to define mock.On call
-//   - upload Upload
-func (_e *MockStorage_Expecter) DeleteUpload(upload interface{}) *MockStorage_DeleteUpload_Call {
-	return &MockStorage_DeleteUpload_Call{Call: _e.mock.On("DeleteUpload", upload)}
-}
-
-func (_c *MockStorage_DeleteUpload_Call) Run(run func(upload Upload)) *MockStorage_DeleteUpload_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 Upload
-		if args[0] != nil {
-			arg0 = args[0].(Upload)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_DeleteUpload_Call) Return(err error) *MockStorage_DeleteUpload_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_DeleteUpload_Call) RunAndReturn(run func(upload Upload) error) *MockStorage_DeleteUpload_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteUploads provides a mock function for the type MockStorage
-func (_mock *MockStorage) DeleteUploads(uploads []Upload) {
-	_mock.Called(uploads)
-	return
-}
-
-// MockStorage_DeleteUploads_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUploads'
-type MockStorage_DeleteUploads_Call struct {
-	*mock.Call
-}
-
-// DeleteUploads is a helper method to define mock.On call
-//   - uploads []Upload
-func (_e *MockStorage_Expecter) DeleteUploads(uploads interface{}) *MockStorage_DeleteUploads_Call {
-	return &MockStorage_DeleteUploads_Call{Call: _e.mock.On("DeleteUploads", uploads)}
-}
-
-func (_c *MockStorage_DeleteUploads_Call) Run(run func(uploads []Upload)) *MockStorage_DeleteUploads_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 []Upload
-		if args[0] != nil {
-			arg0 = args[0].([]Upload)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_DeleteUploads_Call) Return() *MockStorage_DeleteUploads_Call {
-	_c.Call.Return()
-	return _c
-}
-
-func (_c *MockStorage_DeleteUploads_Call) RunAndReturn(run func(uploads []Upload)) *MockStorage_DeleteUploads_Call {
-	_c.Run(run)
-	return _c
-}
-
-// DeleteUploadsByTicker provides a mock function for the type MockStorage
-func (_mock *MockStorage) DeleteUploadsByTicker(ticker *Ticker) error {
-	ret := _mock.Called(ticker)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteUploadsByTicker")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(*Ticker) error); ok {
-		r0 = returnFunc(ticker)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_DeleteUploadsByTicker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUploadsByTicker'
-type MockStorage_DeleteUploadsByTicker_Call struct {
-	*mock.Call
-}
-
-// DeleteUploadsByTicker is a helper method to define mock.On call
-//   - ticker *Ticker
-func (_e *MockStorage_Expecter) DeleteUploadsByTicker(ticker interface{}) *MockStorage_DeleteUploadsByTicker_Call {
-	return &MockStorage_DeleteUploadsByTicker_Call{Call: _e.mock.On("DeleteUploadsByTicker", ticker)}
-}
-
-func (_c *MockStorage_DeleteUploadsByTicker_Call) Run(run func(ticker *Ticker)) *MockStorage_DeleteUploadsByTicker_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 *Ticker
-		if args[0] != nil {
-			arg0 = args[0].(*Ticker)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_DeleteUploadsByTicker_Call) Return(err error) *MockStorage_DeleteUploadsByTicker_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_DeleteUploadsByTicker_Call) RunAndReturn(run func(ticker *Ticker) error) *MockStorage_DeleteUploadsByTicker_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteUser provides a mock function for the type MockStorage
-func (_mock *MockStorage) DeleteUser(user User) error {
-	ret := _mock.Called(user)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteUser")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(User) error); ok {
-		r0 = returnFunc(user)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_DeleteUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUser'
-type MockStorage_DeleteUser_Call struct {
-	*mock.Call
-}
-
-// DeleteUser is a helper method to define mock.On call
-//   - user User
-func (_e *MockStorage_Expecter) DeleteUser(user interface{}) *MockStorage_DeleteUser_Call {
-	return &MockStorage_DeleteUser_Call{Call: _e.mock.On("DeleteUser", user)}
-}
-
-func (_c *MockStorage_DeleteUser_Call) Run(run func(user User)) *MockStorage_DeleteUser_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 User
-		if args[0] != nil {
-			arg0 = args[0].(User)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_DeleteUser_Call) Return(err error) *MockStorage_DeleteUser_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_DeleteUser_Call) RunAndReturn(run func(user User) error) *MockStorage_DeleteUser_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FindMessage provides a mock function for the type MockStorage
-func (_mock *MockStorage) FindMessage(tickerID int, messageID int, opts ...func(*gorm.DB) *gorm.DB) (Message, error) {
-	var tmpRet mock.Arguments
-	if len(opts) > 0 {
-		tmpRet = _mock.Called(tickerID, messageID, opts)
-	} else {
-		tmpRet = _mock.Called(tickerID, messageID)
-	}
-	ret := tmpRet
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindMessage")
-	}
-
-	var r0 Message
-	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(int, int, ...func(*gorm.DB) *gorm.DB) (Message, error)); ok {
-		return returnFunc(tickerID, messageID, opts...)
-	}
-	if returnFunc, ok := ret.Get(0).(func(int, int, ...func(*gorm.DB) *gorm.DB) Message); ok {
-		r0 = returnFunc(tickerID, messageID, opts...)
-	} else {
-		r0 = ret.Get(0).(Message)
-	}
-	if returnFunc, ok := ret.Get(1).(func(int, int, ...func(*gorm.DB) *gorm.DB) error); ok {
-		r1 = returnFunc(tickerID, messageID, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-	return r0, r1
-}
-
-// MockStorage_FindMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindMessage'
-type MockStorage_FindMessage_Call struct {
-	*mock.Call
-}
-
-// FindMessage is a helper method to define mock.On call
-//   - tickerID int
-//   - messageID int
-//   - opts ...func(*gorm.DB) *gorm.DB
-func (_e *MockStorage_Expecter) FindMessage(tickerID interface{}, messageID interface{}, opts ...interface{}) *MockStorage_FindMessage_Call {
-	return &MockStorage_FindMessage_Call{Call: _e.mock.On("FindMessage",
-		append([]interface{}{tickerID, messageID}, opts...)...)}
-}
-
-func (_c *MockStorage_FindMessage_Call) Run(run func(tickerID int, messageID int, opts ...func(*gorm.DB) *gorm.DB)) *MockStorage_FindMessage_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 int
-		if args[0] != nil {
-			arg0 = args[0].(int)
-		}
-		var arg1 int
-		if args[1] != nil {
-			arg1 = args[1].(int)
-		}
-		var arg2 []func(*gorm.DB) *gorm.DB
-		var variadicArgs []func(*gorm.DB) *gorm.DB
-		if len(args) > 2 {
-			variadicArgs = args[2].([]func(*gorm.DB) *gorm.DB)
-		}
-		arg2 = variadicArgs
-		run(
-			arg0,
-			arg1,
-			arg2...,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_FindMessage_Call) Return(message Message, err error) *MockStorage_FindMessage_Call {
-	_c.Call.Return(message, err)
-	return _c
-}
-
-func (_c *MockStorage_FindMessage_Call) RunAndReturn(run func(tickerID int, messageID int, opts ...func(*gorm.DB) *gorm.DB) (Message, error)) *MockStorage_FindMessage_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FindMessagesByTicker provides a mock function for the type MockStorage
-func (_mock *MockStorage) FindMessagesByTicker(ticker Ticker, opts ...func(*gorm.DB) *gorm.DB) ([]Message, error) {
-	var tmpRet mock.Arguments
-	if len(opts) > 0 {
-		tmpRet = _mock.Called(ticker, opts)
-	} else {
-		tmpRet = _mock.Called(ticker)
-	}
-	ret := tmpRet
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindMessagesByTicker")
-	}
-
-	var r0 []Message
-	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(Ticker, ...func(*gorm.DB) *gorm.DB) ([]Message, error)); ok {
-		return returnFunc(ticker, opts...)
-	}
-	if returnFunc, ok := ret.Get(0).(func(Ticker, ...func(*gorm.DB) *gorm.DB) []Message); ok {
-		r0 = returnFunc(ticker, opts...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]Message)
-		}
-	}
-	if returnFunc, ok := ret.Get(1).(func(Ticker, ...func(*gorm.DB) *gorm.DB) error); ok {
-		r1 = returnFunc(ticker, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-	return r0, r1
-}
-
-// MockStorage_FindMessagesByTicker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindMessagesByTicker'
-type MockStorage_FindMessagesByTicker_Call struct {
-	*mock.Call
-}
-
-// FindMessagesByTicker is a helper method to define mock.On call
-//   - ticker Ticker
-//   - opts ...func(*gorm.DB) *gorm.DB
-func (_e *MockStorage_Expecter) FindMessagesByTicker(ticker interface{}, opts ...interface{}) *MockStorage_FindMessagesByTicker_Call {
-	return &MockStorage_FindMessagesByTicker_Call{Call: _e.mock.On("FindMessagesByTicker",
-		append([]interface{}{ticker}, opts...)...)}
-}
-
-func (_c *MockStorage_FindMessagesByTicker_Call) Run(run func(ticker Ticker, opts ...func(*gorm.DB) *gorm.DB)) *MockStorage_FindMessagesByTicker_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 Ticker
-		if args[0] != nil {
-			arg0 = args[0].(Ticker)
-		}
-		var arg1 []func(*gorm.DB) *gorm.DB
-		var variadicArgs []func(*gorm.DB) *gorm.DB
-		if len(args) > 1 {
-			variadicArgs = args[1].([]func(*gorm.DB) *gorm.DB)
-		}
-		arg1 = variadicArgs
-		run(
-			arg0,
-			arg1...,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_FindMessagesByTicker_Call) Return(messages []Message, err error) *MockStorage_FindMessagesByTicker_Call {
-	_c.Call.Return(messages, err)
-	return _c
-}
-
-func (_c *MockStorage_FindMessagesByTicker_Call) RunAndReturn(run func(ticker Ticker, opts ...func(*gorm.DB) *gorm.DB) ([]Message, error)) *MockStorage_FindMessagesByTicker_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FindMessagesByTickerAndPagination provides a mock function for the type MockStorage
-func (_mock *MockStorage) FindMessagesByTickerAndPagination(ticker Ticker, pagination1 pagination.Pagination, opts ...func(*gorm.DB) *gorm.DB) ([]Message, error) {
-	var tmpRet mock.Arguments
-	if len(opts) > 0 {
-		tmpRet = _mock.Called(ticker, pagination1, opts)
-	} else {
-		tmpRet = _mock.Called(ticker, pagination1)
-	}
-	ret := tmpRet
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindMessagesByTickerAndPagination")
-	}
-
-	var r0 []Message
-	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(Ticker, pagination.Pagination, ...func(*gorm.DB) *gorm.DB) ([]Message, error)); ok {
-		return returnFunc(ticker, pagination1, opts...)
-	}
-	if returnFunc, ok := ret.Get(0).(func(Ticker, pagination.Pagination, ...func(*gorm.DB) *gorm.DB) []Message); ok {
-		r0 = returnFunc(ticker, pagination1, opts...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]Message)
-		}
-	}
-	if returnFunc, ok := ret.Get(1).(func(Ticker, pagination.Pagination, ...func(*gorm.DB) *gorm.DB) error); ok {
-		r1 = returnFunc(ticker, pagination1, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-	return r0, r1
-}
-
-// MockStorage_FindMessagesByTickerAndPagination_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindMessagesByTickerAndPagination'
-type MockStorage_FindMessagesByTickerAndPagination_Call struct {
-	*mock.Call
-}
-
-// FindMessagesByTickerAndPagination is a helper method to define mock.On call
-//   - ticker Ticker
-//   - pagination1 pagination.Pagination
-//   - opts ...func(*gorm.DB) *gorm.DB
-func (_e *MockStorage_Expecter) FindMessagesByTickerAndPagination(ticker interface{}, pagination1 interface{}, opts ...interface{}) *MockStorage_FindMessagesByTickerAndPagination_Call {
-	return &MockStorage_FindMessagesByTickerAndPagination_Call{Call: _e.mock.On("FindMessagesByTickerAndPagination",
-		append([]interface{}{ticker, pagination1}, opts...)...)}
-}
-
-func (_c *MockStorage_FindMessagesByTickerAndPagination_Call) Run(run func(ticker Ticker, pagination1 pagination.Pagination, opts ...func(*gorm.DB) *gorm.DB)) *MockStorage_FindMessagesByTickerAndPagination_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 Ticker
-		if args[0] != nil {
-			arg0 = args[0].(Ticker)
-		}
-		var arg1 pagination.Pagination
-		if args[1] != nil {
-			arg1 = args[1].(pagination.Pagination)
-		}
-		var arg2 []func(*gorm.DB) *gorm.DB
-		var variadicArgs []func(*gorm.DB) *gorm.DB
-		if len(args) > 2 {
-			variadicArgs = args[2].([]func(*gorm.DB) *gorm.DB)
-		}
-		arg2 = variadicArgs
-		run(
-			arg0,
-			arg1,
-			arg2...,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_FindMessagesByTickerAndPagination_Call) Return(messages []Message, err error) *MockStorage_FindMessagesByTickerAndPagination_Call {
-	_c.Call.Return(messages, err)
-	return _c
-}
-
-func (_c *MockStorage_FindMessagesByTickerAndPagination_Call) RunAndReturn(run func(ticker Ticker, pagination1 pagination.Pagination, opts ...func(*gorm.DB) *gorm.DB) ([]Message, error)) *MockStorage_FindMessagesByTickerAndPagination_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FindTickerByID provides a mock function for the type MockStorage
-func (_mock *MockStorage) FindTickerByID(id int, opts ...func(*gorm.DB) *gorm.DB) (Ticker, error) {
-	var tmpRet mock.Arguments
-	if len(opts) > 0 {
-		tmpRet = _mock.Called(id, opts)
-	} else {
-		tmpRet = _mock.Called(id)
-	}
-	ret := tmpRet
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindTickerByID")
-	}
-
-	var r0 Ticker
-	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(int, ...func(*gorm.DB) *gorm.DB) (Ticker, error)); ok {
-		return returnFunc(id, opts...)
-	}
-	if returnFunc, ok := ret.Get(0).(func(int, ...func(*gorm.DB) *gorm.DB) Ticker); ok {
-		r0 = returnFunc(id, opts...)
-	} else {
-		r0 = ret.Get(0).(Ticker)
-	}
-	if returnFunc, ok := ret.Get(1).(func(int, ...func(*gorm.DB) *gorm.DB) error); ok {
-		r1 = returnFunc(id, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-	return r0, r1
-}
-
-// MockStorage_FindTickerByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTickerByID'
-type MockStorage_FindTickerByID_Call struct {
-	*mock.Call
-}
-
-// FindTickerByID is a helper method to define mock.On call
-//   - id int
-//   - opts ...func(*gorm.DB) *gorm.DB
-func (_e *MockStorage_Expecter) FindTickerByID(id interface{}, opts ...interface{}) *MockStorage_FindTickerByID_Call {
-	return &MockStorage_FindTickerByID_Call{Call: _e.mock.On("FindTickerByID",
-		append([]interface{}{id}, opts...)...)}
-}
-
-func (_c *MockStorage_FindTickerByID_Call) Run(run func(id int, opts ...func(*gorm.DB) *gorm.DB)) *MockStorage_FindTickerByID_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 int
-		if args[0] != nil {
-			arg0 = args[0].(int)
-		}
-		var arg1 []func(*gorm.DB) *gorm.DB
-		var variadicArgs []func(*gorm.DB) *gorm.DB
-		if len(args) > 1 {
-			variadicArgs = args[1].([]func(*gorm.DB) *gorm.DB)
-		}
-		arg1 = variadicArgs
-		run(
-			arg0,
-			arg1...,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_FindTickerByID_Call) Return(ticker Ticker, err error) *MockStorage_FindTickerByID_Call {
-	_c.Call.Return(ticker, err)
-	return _c
-}
-
-func (_c *MockStorage_FindTickerByID_Call) RunAndReturn(run func(id int, opts ...func(*gorm.DB) *gorm.DB) (Ticker, error)) *MockStorage_FindTickerByID_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FindTickerByOrigin provides a mock function for the type MockStorage
-func (_mock *MockStorage) FindTickerByOrigin(origin string, opts ...func(*gorm.DB) *gorm.DB) (Ticker, error) {
-	var tmpRet mock.Arguments
-	if len(opts) > 0 {
-		tmpRet = _mock.Called(origin, opts)
-	} else {
-		tmpRet = _mock.Called(origin)
-	}
-	ret := tmpRet
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindTickerByOrigin")
-	}
-
-	var r0 Ticker
-	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(string, ...func(*gorm.DB) *gorm.DB) (Ticker, error)); ok {
-		return returnFunc(origin, opts...)
-	}
-	if returnFunc, ok := ret.Get(0).(func(string, ...func(*gorm.DB) *gorm.DB) Ticker); ok {
-		r0 = returnFunc(origin, opts...)
-	} else {
-		r0 = ret.Get(0).(Ticker)
-	}
-	if returnFunc, ok := ret.Get(1).(func(string, ...func(*gorm.DB) *gorm.DB) error); ok {
-		r1 = returnFunc(origin, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-	return r0, r1
-}
-
-// MockStorage_FindTickerByOrigin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTickerByOrigin'
-type MockStorage_FindTickerByOrigin_Call struct {
-	*mock.Call
-}
-
-// FindTickerByOrigin is a helper method to define mock.On call
-//   - origin string
-//   - opts ...func(*gorm.DB) *gorm.DB
-func (_e *MockStorage_Expecter) FindTickerByOrigin(origin interface{}, opts ...interface{}) *MockStorage_FindTickerByOrigin_Call {
-	return &MockStorage_FindTickerByOrigin_Call{Call: _e.mock.On("FindTickerByOrigin",
-		append([]interface{}{origin}, opts...)...)}
-}
-
-func (_c *MockStorage_FindTickerByOrigin_Call) Run(run func(origin string, opts ...func(*gorm.DB) *gorm.DB)) *MockStorage_FindTickerByOrigin_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 string
-		if args[0] != nil {
-			arg0 = args[0].(string)
-		}
-		var arg1 []func(*gorm.DB) *gorm.DB
-		var variadicArgs []func(*gorm.DB) *gorm.DB
-		if len(args) > 1 {
-			variadicArgs = args[1].([]func(*gorm.DB) *gorm.DB)
-		}
-		arg1 = variadicArgs
-		run(
-			arg0,
-			arg1...,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_FindTickerByOrigin_Call) Return(ticker Ticker, err error) *MockStorage_FindTickerByOrigin_Call {
-	_c.Call.Return(ticker, err)
-	return _c
-}
-
-func (_c *MockStorage_FindTickerByOrigin_Call) RunAndReturn(run func(origin string, opts ...func(*gorm.DB) *gorm.DB) (Ticker, error)) *MockStorage_FindTickerByOrigin_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FindTickerByUserAndID provides a mock function for the type MockStorage
-func (_mock *MockStorage) FindTickerByUserAndID(user User, id int, opts ...func(*gorm.DB) *gorm.DB) (Ticker, error) {
-	var tmpRet mock.Arguments
-	if len(opts) > 0 {
-		tmpRet = _mock.Called(user, id, opts)
-	} else {
-		tmpRet = _mock.Called(user, id)
-	}
-	ret := tmpRet
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindTickerByUserAndID")
-	}
-
-	var r0 Ticker
-	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(User, int, ...func(*gorm.DB) *gorm.DB) (Ticker, error)); ok {
-		return returnFunc(user, id, opts...)
-	}
-	if returnFunc, ok := ret.Get(0).(func(User, int, ...func(*gorm.DB) *gorm.DB) Ticker); ok {
-		r0 = returnFunc(user, id, opts...)
-	} else {
-		r0 = ret.Get(0).(Ticker)
-	}
-	if returnFunc, ok := ret.Get(1).(func(User, int, ...func(*gorm.DB) *gorm.DB) error); ok {
-		r1 = returnFunc(user, id, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-	return r0, r1
-}
-
-// MockStorage_FindTickerByUserAndID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTickerByUserAndID'
-type MockStorage_FindTickerByUserAndID_Call struct {
-	*mock.Call
-}
-
-// FindTickerByUserAndID is a helper method to define mock.On call
-//   - user User
-//   - id int
-//   - opts ...func(*gorm.DB) *gorm.DB
-func (_e *MockStorage_Expecter) FindTickerByUserAndID(user interface{}, id interface{}, opts ...interface{}) *MockStorage_FindTickerByUserAndID_Call {
-	return &MockStorage_FindTickerByUserAndID_Call{Call: _e.mock.On("FindTickerByUserAndID",
-		append([]interface{}{user, id}, opts...)...)}
-}
-
-func (_c *MockStorage_FindTickerByUserAndID_Call) Run(run func(user User, id int, opts ...func(*gorm.DB) *gorm.DB)) *MockStorage_FindTickerByUserAndID_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 User
-		if args[0] != nil {
-			arg0 = args[0].(User)
-		}
-		var arg1 int
-		if args[1] != nil {
-			arg1 = args[1].(int)
-		}
-		var arg2 []func(*gorm.DB) *gorm.DB
-		var variadicArgs []func(*gorm.DB) *gorm.DB
-		if len(args) > 2 {
-			variadicArgs = args[2].([]func(*gorm.DB) *gorm.DB)
-		}
-		arg2 = variadicArgs
-		run(
-			arg0,
-			arg1,
-			arg2...,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_FindTickerByUserAndID_Call) Return(ticker Ticker, err error) *MockStorage_FindTickerByUserAndID_Call {
-	_c.Call.Return(ticker, err)
-	return _c
-}
-
-func (_c *MockStorage_FindTickerByUserAndID_Call) RunAndReturn(run func(user User, id int, opts ...func(*gorm.DB) *gorm.DB) (Ticker, error)) *MockStorage_FindTickerByUserAndID_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FindTickersByIDs provides a mock function for the type MockStorage
-func (_mock *MockStorage) FindTickersByIDs(ids []int, opts ...func(*gorm.DB) *gorm.DB) ([]Ticker, error) {
-	var tmpRet mock.Arguments
-	if len(opts) > 0 {
-		tmpRet = _mock.Called(ids, opts)
-	} else {
-		tmpRet = _mock.Called(ids)
-	}
-	ret := tmpRet
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindTickersByIDs")
-	}
-
-	var r0 []Ticker
-	var r1 error
-	if returnFunc, ok := ret.Get(0).(func([]int, ...func(*gorm.DB) *gorm.DB) ([]Ticker, error)); ok {
-		return returnFunc(ids, opts...)
-	}
-	if returnFunc, ok := ret.Get(0).(func([]int, ...func(*gorm.DB) *gorm.DB) []Ticker); ok {
-		r0 = returnFunc(ids, opts...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]Ticker)
-		}
-	}
-	if returnFunc, ok := ret.Get(1).(func([]int, ...func(*gorm.DB) *gorm.DB) error); ok {
-		r1 = returnFunc(ids, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-	return r0, r1
-}
-
-// MockStorage_FindTickersByIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTickersByIDs'
-type MockStorage_FindTickersByIDs_Call struct {
-	*mock.Call
-}
-
-// FindTickersByIDs is a helper method to define mock.On call
-//   - ids []int
-//   - opts ...func(*gorm.DB) *gorm.DB
-func (_e *MockStorage_Expecter) FindTickersByIDs(ids interface{}, opts ...interface{}) *MockStorage_FindTickersByIDs_Call {
-	return &MockStorage_FindTickersByIDs_Call{Call: _e.mock.On("FindTickersByIDs",
-		append([]interface{}{ids}, opts...)...)}
-}
-
-func (_c *MockStorage_FindTickersByIDs_Call) Run(run func(ids []int, opts ...func(*gorm.DB) *gorm.DB)) *MockStorage_FindTickersByIDs_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 []int
-		if args[0] != nil {
-			arg0 = args[0].([]int)
-		}
-		var arg1 []func(*gorm.DB) *gorm.DB
-		var variadicArgs []func(*gorm.DB) *gorm.DB
-		if len(args) > 1 {
-			variadicArgs = args[1].([]func(*gorm.DB) *gorm.DB)
-		}
-		arg1 = variadicArgs
-		run(
-			arg0,
-			arg1...,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_FindTickersByIDs_Call) Return(tickers []Ticker, err error) *MockStorage_FindTickersByIDs_Call {
-	_c.Call.Return(tickers, err)
-	return _c
-}
-
-func (_c *MockStorage_FindTickersByIDs_Call) RunAndReturn(run func(ids []int, opts ...func(*gorm.DB) *gorm.DB) ([]Ticker, error)) *MockStorage_FindTickersByIDs_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FindTickersByUser provides a mock function for the type MockStorage
-func (_mock *MockStorage) FindTickersByUser(user User, filter TickerFilter, opts ...func(*gorm.DB) *gorm.DB) ([]Ticker, error) {
-	var tmpRet mock.Arguments
-	if len(opts) > 0 {
-		tmpRet = _mock.Called(user, filter, opts)
-	} else {
-		tmpRet = _mock.Called(user, filter)
-	}
-	ret := tmpRet
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindTickersByUser")
-	}
-
-	var r0 []Ticker
-	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(User, TickerFilter, ...func(*gorm.DB) *gorm.DB) ([]Ticker, error)); ok {
-		return returnFunc(user, filter, opts...)
-	}
-	if returnFunc, ok := ret.Get(0).(func(User, TickerFilter, ...func(*gorm.DB) *gorm.DB) []Ticker); ok {
-		r0 = returnFunc(user, filter, opts...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]Ticker)
-		}
-	}
-	if returnFunc, ok := ret.Get(1).(func(User, TickerFilter, ...func(*gorm.DB) *gorm.DB) error); ok {
-		r1 = returnFunc(user, filter, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-	return r0, r1
-}
-
-// MockStorage_FindTickersByUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTickersByUser'
-type MockStorage_FindTickersByUser_Call struct {
-	*mock.Call
-}
-
-// FindTickersByUser is a helper method to define mock.On call
-//   - user User
-//   - filter TickerFilter
-//   - opts ...func(*gorm.DB) *gorm.DB
-func (_e *MockStorage_Expecter) FindTickersByUser(user interface{}, filter interface{}, opts ...interface{}) *MockStorage_FindTickersByUser_Call {
-	return &MockStorage_FindTickersByUser_Call{Call: _e.mock.On("FindTickersByUser",
-		append([]interface{}{user, filter}, opts...)...)}
-}
-
-func (_c *MockStorage_FindTickersByUser_Call) Run(run func(user User, filter TickerFilter, opts ...func(*gorm.DB) *gorm.DB)) *MockStorage_FindTickersByUser_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 User
-		if args[0] != nil {
-			arg0 = args[0].(User)
-		}
-		var arg1 TickerFilter
-		if args[1] != nil {
-			arg1 = args[1].(TickerFilter)
-		}
-		var arg2 []func(*gorm.DB) *gorm.DB
-		var variadicArgs []func(*gorm.DB) *gorm.DB
-		if len(args) > 2 {
-			variadicArgs = args[2].([]func(*gorm.DB) *gorm.DB)
-		}
-		arg2 = variadicArgs
-		run(
-			arg0,
-			arg1,
-			arg2...,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_FindTickersByUser_Call) Return(tickers []Ticker, err error) *MockStorage_FindTickersByUser_Call {
-	_c.Call.Return(tickers, err)
-	return _c
-}
-
-func (_c *MockStorage_FindTickersByUser_Call) RunAndReturn(run func(user User, filter TickerFilter, opts ...func(*gorm.DB) *gorm.DB) ([]Ticker, error)) *MockStorage_FindTickersByUser_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FindUploadByUUID provides a mock function for the type MockStorage
-func (_mock *MockStorage) FindUploadByUUID(uuid string) (Upload, error) {
-	ret := _mock.Called(uuid)
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindUploadByUUID")
-	}
-
-	var r0 Upload
-	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(string) (Upload, error)); ok {
-		return returnFunc(uuid)
-	}
-	if returnFunc, ok := ret.Get(0).(func(string) Upload); ok {
-		r0 = returnFunc(uuid)
-	} else {
-		r0 = ret.Get(0).(Upload)
-	}
-	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
-		r1 = returnFunc(uuid)
-	} else {
-		r1 = ret.Error(1)
-	}
-	return r0, r1
-}
-
-// MockStorage_FindUploadByUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindUploadByUUID'
-type MockStorage_FindUploadByUUID_Call struct {
-	*mock.Call
-}
-
-// FindUploadByUUID is a helper method to define mock.On call
-//   - uuid string
-func (_e *MockStorage_Expecter) FindUploadByUUID(uuid interface{}) *MockStorage_FindUploadByUUID_Call {
-	return &MockStorage_FindUploadByUUID_Call{Call: _e.mock.On("FindUploadByUUID", uuid)}
-}
-
-func (_c *MockStorage_FindUploadByUUID_Call) Run(run func(uuid string)) *MockStorage_FindUploadByUUID_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 string
-		if args[0] != nil {
-			arg0 = args[0].(string)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_FindUploadByUUID_Call) Return(upload Upload, err error) *MockStorage_FindUploadByUUID_Call {
-	_c.Call.Return(upload, err)
-	return _c
-}
-
-func (_c *MockStorage_FindUploadByUUID_Call) RunAndReturn(run func(uuid string) (Upload, error)) *MockStorage_FindUploadByUUID_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FindUploadsByIDs provides a mock function for the type MockStorage
-func (_mock *MockStorage) FindUploadsByIDs(ids []int) ([]Upload, error) {
-	ret := _mock.Called(ids)
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindUploadsByIDs")
-	}
-
-	var r0 []Upload
-	var r1 error
-	if returnFunc, ok := ret.Get(0).(func([]int) ([]Upload, error)); ok {
-		return returnFunc(ids)
-	}
-	if returnFunc, ok := ret.Get(0).(func([]int) []Upload); ok {
-		r0 = returnFunc(ids)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]Upload)
-		}
-	}
-	if returnFunc, ok := ret.Get(1).(func([]int) error); ok {
-		r1 = returnFunc(ids)
-	} else {
-		r1 = ret.Error(1)
-	}
-	return r0, r1
-}
-
-// MockStorage_FindUploadsByIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindUploadsByIDs'
-type MockStorage_FindUploadsByIDs_Call struct {
-	*mock.Call
-}
-
-// FindUploadsByIDs is a helper method to define mock.On call
-//   - ids []int
-func (_e *MockStorage_Expecter) FindUploadsByIDs(ids interface{}) *MockStorage_FindUploadsByIDs_Call {
-	return &MockStorage_FindUploadsByIDs_Call{Call: _e.mock.On("FindUploadsByIDs", ids)}
-}
-
-func (_c *MockStorage_FindUploadsByIDs_Call) Run(run func(ids []int)) *MockStorage_FindUploadsByIDs_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 []int
-		if args[0] != nil {
-			arg0 = args[0].([]int)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_FindUploadsByIDs_Call) Return(uploads []Upload, err error) *MockStorage_FindUploadsByIDs_Call {
-	_c.Call.Return(uploads, err)
-	return _c
-}
-
-func (_c *MockStorage_FindUploadsByIDs_Call) RunAndReturn(run func(ids []int) ([]Upload, error)) *MockStorage_FindUploadsByIDs_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FindUserByEmail provides a mock function for the type MockStorage
-func (_mock *MockStorage) FindUserByEmail(email string, opts ...func(*gorm.DB) *gorm.DB) (User, error) {
-	var tmpRet mock.Arguments
-	if len(opts) > 0 {
-		tmpRet = _mock.Called(email, opts)
-	} else {
-		tmpRet = _mock.Called(email)
-	}
-	ret := tmpRet
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindUserByEmail")
-	}
-
-	var r0 User
-	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(string, ...func(*gorm.DB) *gorm.DB) (User, error)); ok {
-		return returnFunc(email, opts...)
-	}
-	if returnFunc, ok := ret.Get(0).(func(string, ...func(*gorm.DB) *gorm.DB) User); ok {
-		r0 = returnFunc(email, opts...)
-	} else {
-		r0 = ret.Get(0).(User)
-	}
-	if returnFunc, ok := ret.Get(1).(func(string, ...func(*gorm.DB) *gorm.DB) error); ok {
-		r1 = returnFunc(email, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-	return r0, r1
-}
-
-// MockStorage_FindUserByEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindUserByEmail'
-type MockStorage_FindUserByEmail_Call struct {
-	*mock.Call
-}
-
-// FindUserByEmail is a helper method to define mock.On call
-//   - email string
-//   - opts ...func(*gorm.DB) *gorm.DB
-func (_e *MockStorage_Expecter) FindUserByEmail(email interface{}, opts ...interface{}) *MockStorage_FindUserByEmail_Call {
-	return &MockStorage_FindUserByEmail_Call{Call: _e.mock.On("FindUserByEmail",
-		append([]interface{}{email}, opts...)...)}
-}
-
-func (_c *MockStorage_FindUserByEmail_Call) Run(run func(email string, opts ...func(*gorm.DB) *gorm.DB)) *MockStorage_FindUserByEmail_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 string
-		if args[0] != nil {
-			arg0 = args[0].(string)
-		}
-		var arg1 []func(*gorm.DB) *gorm.DB
-		var variadicArgs []func(*gorm.DB) *gorm.DB
-		if len(args) > 1 {
-			variadicArgs = args[1].([]func(*gorm.DB) *gorm.DB)
-		}
-		arg1 = variadicArgs
-		run(
-			arg0,
-			arg1...,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_FindUserByEmail_Call) Return(user User, err error) *MockStorage_FindUserByEmail_Call {
-	_c.Call.Return(user, err)
-	return _c
-}
-
-func (_c *MockStorage_FindUserByEmail_Call) RunAndReturn(run func(email string, opts ...func(*gorm.DB) *gorm.DB) (User, error)) *MockStorage_FindUserByEmail_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FindUserByID provides a mock function for the type MockStorage
-func (_mock *MockStorage) FindUserByID(id int, opts ...func(*gorm.DB) *gorm.DB) (User, error) {
-	var tmpRet mock.Arguments
-	if len(opts) > 0 {
-		tmpRet = _mock.Called(id, opts)
-	} else {
-		tmpRet = _mock.Called(id)
-	}
-	ret := tmpRet
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindUserByID")
-	}
-
-	var r0 User
-	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(int, ...func(*gorm.DB) *gorm.DB) (User, error)); ok {
-		return returnFunc(id, opts...)
-	}
-	if returnFunc, ok := ret.Get(0).(func(int, ...func(*gorm.DB) *gorm.DB) User); ok {
-		r0 = returnFunc(id, opts...)
-	} else {
-		r0 = ret.Get(0).(User)
-	}
-	if returnFunc, ok := ret.Get(1).(func(int, ...func(*gorm.DB) *gorm.DB) error); ok {
-		r1 = returnFunc(id, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-	return r0, r1
-}
-
-// MockStorage_FindUserByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindUserByID'
-type MockStorage_FindUserByID_Call struct {
-	*mock.Call
-}
-
-// FindUserByID is a helper method to define mock.On call
-//   - id int
-//   - opts ...func(*gorm.DB) *gorm.DB
-func (_e *MockStorage_Expecter) FindUserByID(id interface{}, opts ...interface{}) *MockStorage_FindUserByID_Call {
-	return &MockStorage_FindUserByID_Call{Call: _e.mock.On("FindUserByID",
-		append([]interface{}{id}, opts...)...)}
-}
-
-func (_c *MockStorage_FindUserByID_Call) Run(run func(id int, opts ...func(*gorm.DB) *gorm.DB)) *MockStorage_FindUserByID_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 int
-		if args[0] != nil {
-			arg0 = args[0].(int)
-		}
-		var arg1 []func(*gorm.DB) *gorm.DB
-		var variadicArgs []func(*gorm.DB) *gorm.DB
-		if len(args) > 1 {
-			variadicArgs = args[1].([]func(*gorm.DB) *gorm.DB)
-		}
-		arg1 = variadicArgs
-		run(
-			arg0,
-			arg1...,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_FindUserByID_Call) Return(user User, err error) *MockStorage_FindUserByID_Call {
-	_c.Call.Return(user, err)
-	return _c
-}
-
-func (_c *MockStorage_FindUserByID_Call) RunAndReturn(run func(id int, opts ...func(*gorm.DB) *gorm.DB) (User, error)) *MockStorage_FindUserByID_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FindUsers provides a mock function for the type MockStorage
-func (_mock *MockStorage) FindUsers(filter UserFilter, opts ...func(*gorm.DB) *gorm.DB) ([]User, error) {
-	var tmpRet mock.Arguments
-	if len(opts) > 0 {
-		tmpRet = _mock.Called(filter, opts)
-	} else {
-		tmpRet = _mock.Called(filter)
-	}
-	ret := tmpRet
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindUsers")
-	}
-
-	var r0 []User
-	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(UserFilter, ...func(*gorm.DB) *gorm.DB) ([]User, error)); ok {
-		return returnFunc(filter, opts...)
-	}
-	if returnFunc, ok := ret.Get(0).(func(UserFilter, ...func(*gorm.DB) *gorm.DB) []User); ok {
-		r0 = returnFunc(filter, opts...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]User)
-		}
-	}
-	if returnFunc, ok := ret.Get(1).(func(UserFilter, ...func(*gorm.DB) *gorm.DB) error); ok {
-		r1 = returnFunc(filter, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-	return r0, r1
-}
-
-// MockStorage_FindUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindUsers'
-type MockStorage_FindUsers_Call struct {
-	*mock.Call
-}
-
-// FindUsers is a helper method to define mock.On call
-//   - filter UserFilter
-//   - opts ...func(*gorm.DB) *gorm.DB
-func (_e *MockStorage_Expecter) FindUsers(filter interface{}, opts ...interface{}) *MockStorage_FindUsers_Call {
-	return &MockStorage_FindUsers_Call{Call: _e.mock.On("FindUsers",
-		append([]interface{}{filter}, opts...)...)}
-}
-
-func (_c *MockStorage_FindUsers_Call) Run(run func(filter UserFilter, opts ...func(*gorm.DB) *gorm.DB)) *MockStorage_FindUsers_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 UserFilter
-		if args[0] != nil {
-			arg0 = args[0].(UserFilter)
-		}
-		var arg1 []func(*gorm.DB) *gorm.DB
-		var variadicArgs []func(*gorm.DB) *gorm.DB
-		if len(args) > 1 {
-			variadicArgs = args[1].([]func(*gorm.DB) *gorm.DB)
-		}
-		arg1 = variadicArgs
-		run(
-			arg0,
-			arg1...,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_FindUsers_Call) Return(users []User, err error) *MockStorage_FindUsers_Call {
-	_c.Call.Return(users, err)
-	return _c
-}
-
-func (_c *MockStorage_FindUsers_Call) RunAndReturn(run func(filter UserFilter, opts ...func(*gorm.DB) *gorm.DB) ([]User, error)) *MockStorage_FindUsers_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FindUsersByIDs provides a mock function for the type MockStorage
-func (_mock *MockStorage) FindUsersByIDs(ids []int, opts ...func(*gorm.DB) *gorm.DB) ([]User, error) {
-	var tmpRet mock.Arguments
-	if len(opts) > 0 {
-		tmpRet = _mock.Called(ids, opts)
-	} else {
-		tmpRet = _mock.Called(ids)
-	}
-	ret := tmpRet
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindUsersByIDs")
-	}
-
-	var r0 []User
-	var r1 error
-	if returnFunc, ok := ret.Get(0).(func([]int, ...func(*gorm.DB) *gorm.DB) ([]User, error)); ok {
-		return returnFunc(ids, opts...)
-	}
-	if returnFunc, ok := ret.Get(0).(func([]int, ...func(*gorm.DB) *gorm.DB) []User); ok {
-		r0 = returnFunc(ids, opts...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]User)
-		}
-	}
-	if returnFunc, ok := ret.Get(1).(func([]int, ...func(*gorm.DB) *gorm.DB) error); ok {
-		r1 = returnFunc(ids, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-	return r0, r1
-}
-
-// MockStorage_FindUsersByIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindUsersByIDs'
-type MockStorage_FindUsersByIDs_Call struct {
-	*mock.Call
-}
-
-// FindUsersByIDs is a helper method to define mock.On call
-//   - ids []int
-//   - opts ...func(*gorm.DB) *gorm.DB
-func (_e *MockStorage_Expecter) FindUsersByIDs(ids interface{}, opts ...interface{}) *MockStorage_FindUsersByIDs_Call {
-	return &MockStorage_FindUsersByIDs_Call{Call: _e.mock.On("FindUsersByIDs",
-		append([]interface{}{ids}, opts...)...)}
-}
-
-func (_c *MockStorage_FindUsersByIDs_Call) Run(run func(ids []int, opts ...func(*gorm.DB) *gorm.DB)) *MockStorage_FindUsersByIDs_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 []int
-		if args[0] != nil {
-			arg0 = args[0].([]int)
-		}
-		var arg1 []func(*gorm.DB) *gorm.DB
-		var variadicArgs []func(*gorm.DB) *gorm.DB
-		if len(args) > 1 {
-			variadicArgs = args[1].([]func(*gorm.DB) *gorm.DB)
-		}
-		arg1 = variadicArgs
-		run(
-			arg0,
-			arg1...,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_FindUsersByIDs_Call) Return(users []User, err error) *MockStorage_FindUsersByIDs_Call {
-	_c.Call.Return(users, err)
-	return _c
-}
-
-func (_c *MockStorage_FindUsersByIDs_Call) RunAndReturn(run func(ids []int, opts ...func(*gorm.DB) *gorm.DB) ([]User, error)) *MockStorage_FindUsersByIDs_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FindUsersByTicker provides a mock function for the type MockStorage
-func (_mock *MockStorage) FindUsersByTicker(ticker Ticker, opts ...func(*gorm.DB) *gorm.DB) ([]User, error) {
-	var tmpRet mock.Arguments
-	if len(opts) > 0 {
-		tmpRet = _mock.Called(ticker, opts)
-	} else {
-		tmpRet = _mock.Called(ticker)
-	}
-	ret := tmpRet
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindUsersByTicker")
-	}
-
-	var r0 []User
-	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(Ticker, ...func(*gorm.DB) *gorm.DB) ([]User, error)); ok {
-		return returnFunc(ticker, opts...)
-	}
-	if returnFunc, ok := ret.Get(0).(func(Ticker, ...func(*gorm.DB) *gorm.DB) []User); ok {
-		r0 = returnFunc(ticker, opts...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]User)
-		}
-	}
-	if returnFunc, ok := ret.Get(1).(func(Ticker, ...func(*gorm.DB) *gorm.DB) error); ok {
-		r1 = returnFunc(ticker, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-	return r0, r1
-}
-
-// MockStorage_FindUsersByTicker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindUsersByTicker'
-type MockStorage_FindUsersByTicker_Call struct {
-	*mock.Call
-}
-
-// FindUsersByTicker is a helper method to define mock.On call
-//   - ticker Ticker
-//   - opts ...func(*gorm.DB) *gorm.DB
-func (_e *MockStorage_Expecter) FindUsersByTicker(ticker interface{}, opts ...interface{}) *MockStorage_FindUsersByTicker_Call {
-	return &MockStorage_FindUsersByTicker_Call{Call: _e.mock.On("FindUsersByTicker",
-		append([]interface{}{ticker}, opts...)...)}
-}
-
-func (_c *MockStorage_FindUsersByTicker_Call) Run(run func(ticker Ticker, opts ...func(*gorm.DB) *gorm.DB)) *MockStorage_FindUsersByTicker_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 Ticker
-		if args[0] != nil {
-			arg0 = args[0].(Ticker)
-		}
-		var arg1 []func(*gorm.DB) *gorm.DB
-		var variadicArgs []func(*gorm.DB) *gorm.DB
-		if len(args) > 1 {
-			variadicArgs = args[1].([]func(*gorm.DB) *gorm.DB)
-		}
-		arg1 = variadicArgs
-		run(
-			arg0,
-			arg1...,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_FindUsersByTicker_Call) Return(users []User, err error) *MockStorage_FindUsersByTicker_Call {
-	_c.Call.Return(users, err)
-	return _c
-}
-
-func (_c *MockStorage_FindUsersByTicker_Call) RunAndReturn(run func(ticker Ticker, opts ...func(*gorm.DB) *gorm.DB) ([]User, error)) *MockStorage_FindUsersByTicker_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetInactiveSettings provides a mock function for the type MockStorage
-func (_mock *MockStorage) GetInactiveSettings() InactiveSettings {
-	ret := _mock.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetInactiveSettings")
-	}
-
-	var r0 InactiveSettings
-	if returnFunc, ok := ret.Get(0).(func() InactiveSettings); ok {
-		r0 = returnFunc()
-	} else {
-		r0 = ret.Get(0).(InactiveSettings)
-	}
-	return r0
-}
-
-// MockStorage_GetInactiveSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInactiveSettings'
-type MockStorage_GetInactiveSettings_Call struct {
-	*mock.Call
-}
-
-// GetInactiveSettings is a helper method to define mock.On call
-func (_e *MockStorage_Expecter) GetInactiveSettings() *MockStorage_GetInactiveSettings_Call {
-	return &MockStorage_GetInactiveSettings_Call{Call: _e.mock.On("GetInactiveSettings")}
-}
-
-func (_c *MockStorage_GetInactiveSettings_Call) Run(run func()) *MockStorage_GetInactiveSettings_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *MockStorage_GetInactiveSettings_Call) Return(inactiveSettings InactiveSettings) *MockStorage_GetInactiveSettings_Call {
-	_c.Call.Return(inactiveSettings)
-	return _c
-}
-
-func (_c *MockStorage_GetInactiveSettings_Call) RunAndReturn(run func() InactiveSettings) *MockStorage_GetInactiveSettings_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetSignalGroupSettings provides a mock function for the type MockStorage
-func (_mock *MockStorage) GetSignalGroupSettings() SignalGroupSettings {
-	ret := _mock.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetSignalGroupSettings")
-	}
-
-	var r0 SignalGroupSettings
-	if returnFunc, ok := ret.Get(0).(func() SignalGroupSettings); ok {
-		r0 = returnFunc()
-	} else {
-		r0 = ret.Get(0).(SignalGroupSettings)
-	}
-	return r0
-}
-
-// MockStorage_GetSignalGroupSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSignalGroupSettings'
-type MockStorage_GetSignalGroupSettings_Call struct {
-	*mock.Call
-}
-
-// GetSignalGroupSettings is a helper method to define mock.On call
-func (_e *MockStorage_Expecter) GetSignalGroupSettings() *MockStorage_GetSignalGroupSettings_Call {
-	return &MockStorage_GetSignalGroupSettings_Call{Call: _e.mock.On("GetSignalGroupSettings")}
-}
-
-func (_c *MockStorage_GetSignalGroupSettings_Call) Run(run func()) *MockStorage_GetSignalGroupSettings_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *MockStorage_GetSignalGroupSettings_Call) Return(signalGroupSettings SignalGroupSettings) *MockStorage_GetSignalGroupSettings_Call {
-	_c.Call.Return(signalGroupSettings)
-	return _c
-}
-
-func (_c *MockStorage_GetSignalGroupSettings_Call) RunAndReturn(run func() SignalGroupSettings) *MockStorage_GetSignalGroupSettings_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetTelegramSettings provides a mock function for the type MockStorage
-func (_mock *MockStorage) GetTelegramSettings() TelegramSettings {
-	ret := _mock.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetTelegramSettings")
-	}
-
-	var r0 TelegramSettings
-	if returnFunc, ok := ret.Get(0).(func() TelegramSettings); ok {
-		r0 = returnFunc()
-	} else {
-		r0 = ret.Get(0).(TelegramSettings)
-	}
-	return r0
-}
-
-// MockStorage_GetTelegramSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTelegramSettings'
-type MockStorage_GetTelegramSettings_Call struct {
-	*mock.Call
-}
-
-// GetTelegramSettings is a helper method to define mock.On call
-func (_e *MockStorage_Expecter) GetTelegramSettings() *MockStorage_GetTelegramSettings_Call {
-	return &MockStorage_GetTelegramSettings_Call{Call: _e.mock.On("GetTelegramSettings")}
-}
-
-func (_c *MockStorage_GetTelegramSettings_Call) Run(run func()) *MockStorage_GetTelegramSettings_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *MockStorage_GetTelegramSettings_Call) Return(telegramSettings TelegramSettings) *MockStorage_GetTelegramSettings_Call {
-	_c.Call.Return(telegramSettings)
-	return _c
-}
-
-func (_c *MockStorage_GetTelegramSettings_Call) RunAndReturn(run func() TelegramSettings) *MockStorage_GetTelegramSettings_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ResetTicker provides a mock function for the type MockStorage
-func (_mock *MockStorage) ResetTicker(ticker *Ticker) error {
-	ret := _mock.Called(ticker)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ResetTicker")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(*Ticker) error); ok {
-		r0 = returnFunc(ticker)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_ResetTicker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetTicker'
-type MockStorage_ResetTicker_Call struct {
-	*mock.Call
-}
-
-// ResetTicker is a helper method to define mock.On call
-//   - ticker *Ticker
-func (_e *MockStorage_Expecter) ResetTicker(ticker interface{}) *MockStorage_ResetTicker_Call {
-	return &MockStorage_ResetTicker_Call{Call: _e.mock.On("ResetTicker", ticker)}
-}
-
-func (_c *MockStorage_ResetTicker_Call) Run(run func(ticker *Ticker)) *MockStorage_ResetTicker_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 *Ticker
-		if args[0] != nil {
-			arg0 = args[0].(*Ticker)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_ResetTicker_Call) Return(err error) *MockStorage_ResetTicker_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_ResetTicker_Call) RunAndReturn(run func(ticker *Ticker) error) *MockStorage_ResetTicker_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SaveInactiveSettings provides a mock function for the type MockStorage
-func (_mock *MockStorage) SaveInactiveSettings(inactiveSettings InactiveSettings) error {
-	ret := _mock.Called(inactiveSettings)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SaveInactiveSettings")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(InactiveSettings) error); ok {
-		r0 = returnFunc(inactiveSettings)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_SaveInactiveSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveInactiveSettings'
-type MockStorage_SaveInactiveSettings_Call struct {
-	*mock.Call
-}
-
-// SaveInactiveSettings is a helper method to define mock.On call
-//   - inactiveSettings InactiveSettings
-func (_e *MockStorage_Expecter) SaveInactiveSettings(inactiveSettings interface{}) *MockStorage_SaveInactiveSettings_Call {
-	return &MockStorage_SaveInactiveSettings_Call{Call: _e.mock.On("SaveInactiveSettings", inactiveSettings)}
-}
-
-func (_c *MockStorage_SaveInactiveSettings_Call) Run(run func(inactiveSettings InactiveSettings)) *MockStorage_SaveInactiveSettings_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 InactiveSettings
-		if args[0] != nil {
-			arg0 = args[0].(InactiveSettings)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_SaveInactiveSettings_Call) Return(err error) *MockStorage_SaveInactiveSettings_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_SaveInactiveSettings_Call) RunAndReturn(run func(inactiveSettings InactiveSettings) error) *MockStorage_SaveInactiveSettings_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SaveMessage provides a mock function for the type MockStorage
-func (_mock *MockStorage) SaveMessage(message *Message) error {
-	ret := _mock.Called(message)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SaveMessage")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(*Message) error); ok {
-		r0 = returnFunc(message)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_SaveMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveMessage'
-type MockStorage_SaveMessage_Call struct {
-	*mock.Call
-}
-
-// SaveMessage is a helper method to define mock.On call
-//   - message *Message
-func (_e *MockStorage_Expecter) SaveMessage(message interface{}) *MockStorage_SaveMessage_Call {
-	return &MockStorage_SaveMessage_Call{Call: _e.mock.On("SaveMessage", message)}
-}
-
-func (_c *MockStorage_SaveMessage_Call) Run(run func(message *Message)) *MockStorage_SaveMessage_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 *Message
-		if args[0] != nil {
-			arg0 = args[0].(*Message)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_SaveMessage_Call) Return(err error) *MockStorage_SaveMessage_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_SaveMessage_Call) RunAndReturn(run func(message *Message) error) *MockStorage_SaveMessage_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SaveSignalGroupSettings provides a mock function for the type MockStorage
-func (_mock *MockStorage) SaveSignalGroupSettings(signalGroupSettings SignalGroupSettings) error {
-	ret := _mock.Called(signalGroupSettings)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SaveSignalGroupSettings")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(SignalGroupSettings) error); ok {
-		r0 = returnFunc(signalGroupSettings)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_SaveSignalGroupSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveSignalGroupSettings'
-type MockStorage_SaveSignalGroupSettings_Call struct {
-	*mock.Call
-}
-
-// SaveSignalGroupSettings is a helper method to define mock.On call
-//   - signalGroupSettings SignalGroupSettings
-func (_e *MockStorage_Expecter) SaveSignalGroupSettings(signalGroupSettings interface{}) *MockStorage_SaveSignalGroupSettings_Call {
-	return &MockStorage_SaveSignalGroupSettings_Call{Call: _e.mock.On("SaveSignalGroupSettings", signalGroupSettings)}
-}
-
-func (_c *MockStorage_SaveSignalGroupSettings_Call) Run(run func(signalGroupSettings SignalGroupSettings)) *MockStorage_SaveSignalGroupSettings_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 SignalGroupSettings
-		if args[0] != nil {
-			arg0 = args[0].(SignalGroupSettings)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_SaveSignalGroupSettings_Call) Return(err error) *MockStorage_SaveSignalGroupSettings_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_SaveSignalGroupSettings_Call) RunAndReturn(run func(signalGroupSettings SignalGroupSettings) error) *MockStorage_SaveSignalGroupSettings_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SaveTelegramSettings provides a mock function for the type MockStorage
-func (_mock *MockStorage) SaveTelegramSettings(telegramSettings TelegramSettings) error {
-	ret := _mock.Called(telegramSettings)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SaveTelegramSettings")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(TelegramSettings) error); ok {
-		r0 = returnFunc(telegramSettings)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_SaveTelegramSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveTelegramSettings'
-type MockStorage_SaveTelegramSettings_Call struct {
-	*mock.Call
-}
-
-// SaveTelegramSettings is a helper method to define mock.On call
-//   - telegramSettings TelegramSettings
-func (_e *MockStorage_Expecter) SaveTelegramSettings(telegramSettings interface{}) *MockStorage_SaveTelegramSettings_Call {
-	return &MockStorage_SaveTelegramSettings_Call{Call: _e.mock.On("SaveTelegramSettings", telegramSettings)}
-}
-
-func (_c *MockStorage_SaveTelegramSettings_Call) Run(run func(telegramSettings TelegramSettings)) *MockStorage_SaveTelegramSettings_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 TelegramSettings
-		if args[0] != nil {
-			arg0 = args[0].(TelegramSettings)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_SaveTelegramSettings_Call) Return(err error) *MockStorage_SaveTelegramSettings_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_SaveTelegramSettings_Call) RunAndReturn(run func(telegramSettings TelegramSettings) error) *MockStorage_SaveTelegramSettings_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SaveTicker provides a mock function for the type MockStorage
-func (_mock *MockStorage) SaveTicker(ticker *Ticker) error {
-	ret := _mock.Called(ticker)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SaveTicker")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(*Ticker) error); ok {
-		r0 = returnFunc(ticker)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_SaveTicker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveTicker'
-type MockStorage_SaveTicker_Call struct {
-	*mock.Call
-}
-
-// SaveTicker is a helper method to define mock.On call
-//   - ticker *Ticker
-func (_e *MockStorage_Expecter) SaveTicker(ticker interface{}) *MockStorage_SaveTicker_Call {
-	return &MockStorage_SaveTicker_Call{Call: _e.mock.On("SaveTicker", ticker)}
-}
-
-func (_c *MockStorage_SaveTicker_Call) Run(run func(ticker *Ticker)) *MockStorage_SaveTicker_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 *Ticker
-		if args[0] != nil {
-			arg0 = args[0].(*Ticker)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_SaveTicker_Call) Return(err error) *MockStorage_SaveTicker_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_SaveTicker_Call) RunAndReturn(run func(ticker *Ticker) error) *MockStorage_SaveTicker_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SaveTickerWebsites provides a mock function for the type MockStorage
-func (_mock *MockStorage) SaveTickerWebsites(ticker *Ticker, websites []TickerWebsite) error {
-	ret := _mock.Called(ticker, websites)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SaveTickerWebsites")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(*Ticker, []TickerWebsite) error); ok {
-		r0 = returnFunc(ticker, websites)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_SaveTickerWebsites_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveTickerWebsites'
-type MockStorage_SaveTickerWebsites_Call struct {
-	*mock.Call
-}
-
-// SaveTickerWebsites is a helper method to define mock.On call
-//   - ticker *Ticker
-//   - websites []TickerWebsite
-func (_e *MockStorage_Expecter) SaveTickerWebsites(ticker interface{}, websites interface{}) *MockStorage_SaveTickerWebsites_Call {
-	return &MockStorage_SaveTickerWebsites_Call{Call: _e.mock.On("SaveTickerWebsites", ticker, websites)}
-}
-
-func (_c *MockStorage_SaveTickerWebsites_Call) Run(run func(ticker *Ticker, websites []TickerWebsite)) *MockStorage_SaveTickerWebsites_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 *Ticker
-		if args[0] != nil {
-			arg0 = args[0].(*Ticker)
-		}
-		var arg1 []TickerWebsite
-		if args[1] != nil {
-			arg1 = args[1].([]TickerWebsite)
-		}
-		run(
-			arg0,
-			arg1,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_SaveTickerWebsites_Call) Return(err error) *MockStorage_SaveTickerWebsites_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_SaveTickerWebsites_Call) RunAndReturn(run func(ticker *Ticker, websites []TickerWebsite) error) *MockStorage_SaveTickerWebsites_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SaveUpload provides a mock function for the type MockStorage
-func (_mock *MockStorage) SaveUpload(upload *Upload) error {
-	ret := _mock.Called(upload)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SaveUpload")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(*Upload) error); ok {
-		r0 = returnFunc(upload)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_SaveUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveUpload'
-type MockStorage_SaveUpload_Call struct {
-	*mock.Call
-}
-
-// SaveUpload is a helper method to define mock.On call
-//   - upload *Upload
-func (_e *MockStorage_Expecter) SaveUpload(upload interface{}) *MockStorage_SaveUpload_Call {
-	return &MockStorage_SaveUpload_Call{Call: _e.mock.On("SaveUpload", upload)}
-}
-
-func (_c *MockStorage_SaveUpload_Call) Run(run func(upload *Upload)) *MockStorage_SaveUpload_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 *Upload
-		if args[0] != nil {
-			arg0 = args[0].(*Upload)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_SaveUpload_Call) Return(err error) *MockStorage_SaveUpload_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_SaveUpload_Call) RunAndReturn(run func(upload *Upload) error) *MockStorage_SaveUpload_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SaveUser provides a mock function for the type MockStorage
-func (_mock *MockStorage) SaveUser(user *User) error {
-	ret := _mock.Called(user)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SaveUser")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(*User) error); ok {
-		r0 = returnFunc(user)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// MockStorage_SaveUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveUser'
-type MockStorage_SaveUser_Call struct {
-	*mock.Call
-}
-
-// SaveUser is a helper method to define mock.On call
-//   - user *User
-func (_e *MockStorage_Expecter) SaveUser(user interface{}) *MockStorage_SaveUser_Call {
-	return &MockStorage_SaveUser_Call{Call: _e.mock.On("SaveUser", user)}
-}
-
-func (_c *MockStorage_SaveUser_Call) Run(run func(user *User)) *MockStorage_SaveUser_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 *User
-		if args[0] != nil {
-			arg0 = args[0].(*User)
-		}
-		run(
-			arg0,
-		)
-	})
-	return _c
-}
-
-func (_c *MockStorage_SaveUser_Call) Return(err error) *MockStorage_SaveUser_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *MockStorage_SaveUser_Call) RunAndReturn(run func(user *User) error) *MockStorage_SaveUser_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// UploadPath provides a mock function for the type MockStorage
-func (_mock *MockStorage) UploadPath() string {
-	ret := _mock.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for UploadPath")
-	}
-
-	var r0 string
-	if returnFunc, ok := ret.Get(0).(func() string); ok {
-		r0 = returnFunc()
-	} else {
-		r0 = ret.Get(0).(string)
-	}
-	return r0
-}
-
-// MockStorage_UploadPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadPath'
-type MockStorage_UploadPath_Call struct {
-	*mock.Call
-}
-
-// UploadPath is a helper method to define mock.On call
-func (_e *MockStorage_Expecter) UploadPath() *MockStorage_UploadPath_Call {
-	return &MockStorage_UploadPath_Call{Call: _e.mock.On("UploadPath")}
-}
-
-func (_c *MockStorage_UploadPath_Call) Run(run func()) *MockStorage_UploadPath_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *MockStorage_UploadPath_Call) Return(s string) *MockStorage_UploadPath_Call {
-	_c.Call.Return(s)
-	return _c
-}
-
-func (_c *MockStorage_UploadPath_Call) RunAndReturn(run func() string) *MockStorage_UploadPath_Call {
-	_c.Call.Return(run)
-	return _c
-}
diff --git a/internal/storage/mock_TickerStore.go b/internal/storage/mock_TickerStore.go
new file mode 100644
index 00000000..f87f4f3f
--- /dev/null
+++ b/internal/storage/mock_TickerStore.go
@@ -0,0 +1,1038 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package storage
+
+import (
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewMockTickerStore creates a new instance of MockTickerStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockTickerStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockTickerStore {
+	mock := &MockTickerStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockTickerStore is an autogenerated mock type for the TickerStore type
+type MockTickerStore struct {
+	mock.Mock
+}
+
+type MockTickerStore_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockTickerStore) EXPECT() *MockTickerStore_Expecter {
+	return &MockTickerStore_Expecter{mock: &_m.Mock}
+}
+
+// AddTickerUser provides a mock function for the type MockTickerStore
+func (_mock *MockTickerStore) AddTickerUser(ticker *Ticker, user *User) error {
+	ret := _mock.Called(ticker, user)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AddTickerUser")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*Ticker, *User) error); ok {
+		r0 = returnFunc(ticker, user)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockTickerStore_AddTickerUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddTickerUser'
+type MockTickerStore_AddTickerUser_Call struct {
+	*mock.Call
+}
+
+// AddTickerUser is a helper method to define mock.On call
+//   - ticker *Ticker
+//   - user *User
+func (_e *MockTickerStore_Expecter) AddTickerUser(ticker interface{}, user interface{}) *MockTickerStore_AddTickerUser_Call {
+	return &MockTickerStore_AddTickerUser_Call{Call: _e.mock.On("AddTickerUser", ticker, user)}
+}
+
+func (_c *MockTickerStore_AddTickerUser_Call) Run(run func(ticker *Ticker, user *User)) *MockTickerStore_AddTickerUser_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *Ticker
+		if args[0] != nil {
+			arg0 = args[0].(*Ticker)
+		}
+		var arg1 *User
+		if args[1] != nil {
+			arg1 = args[1].(*User)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockTickerStore_AddTickerUser_Call) Return(err error) *MockTickerStore_AddTickerUser_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockTickerStore_AddTickerUser_Call) RunAndReturn(run func(ticker *Ticker, user *User) error) *MockTickerStore_AddTickerUser_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ClearIntegration provides a mock function for the type MockTickerStore
+func (_mock *MockTickerStore) ClearIntegration(ticker *Ticker, integration Integration) error {
+	ret := _mock.Called(ticker, integration)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ClearIntegration")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*Ticker, Integration) error); ok {
+		r0 = returnFunc(ticker, integration)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockTickerStore_ClearIntegration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearIntegration'
+type MockTickerStore_ClearIntegration_Call struct {
+	*mock.Call
+}
+
+// ClearIntegration is a helper method to define mock.On call
+//   - ticker *Ticker
+//   - integration Integration
+func (_e *MockTickerStore_Expecter) ClearIntegration(ticker interface{}, integration interface{}) *MockTickerStore_ClearIntegration_Call {
+	return &MockTickerStore_ClearIntegration_Call{Call: _e.mock.On("ClearIntegration", ticker, integration)}
+}
+
+func (_c *MockTickerStore_ClearIntegration_Call) Run(run func(ticker *Ticker, integration Integration)) *MockTickerStore_ClearIntegration_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *Ticker
+		if args[0] != nil {
+			arg0 = args[0].(*Ticker)
+		}
+		var arg1 Integration
+		if args[1] != nil {
+			arg1 = args[1].(Integration)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockTickerStore_ClearIntegration_Call) Return(err error) *MockTickerStore_ClearIntegration_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockTickerStore_ClearIntegration_Call) RunAndReturn(run func(ticker *Ticker, integration Integration) error) *MockTickerStore_ClearIntegration_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ClearIntegrations provides a mock function for the type MockTickerStore
+func (_mock *MockTickerStore) ClearIntegrations(ticker *Ticker) error {
+	ret := _mock.Called(ticker)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ClearIntegrations")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*Ticker) error); ok {
+		r0 = returnFunc(ticker)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockTickerStore_ClearIntegrations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearIntegrations'
+type MockTickerStore_ClearIntegrations_Call struct {
+	*mock.Call
+}
+
+// ClearIntegrations is a helper method to define mock.On call
+//   - ticker *Ticker
+func (_e *MockTickerStore_Expecter) ClearIntegrations(ticker interface{}) *MockTickerStore_ClearIntegrations_Call {
+	return &MockTickerStore_ClearIntegrations_Call{Call: _e.mock.On("ClearIntegrations", ticker)}
+}
+
+func (_c *MockTickerStore_ClearIntegrations_Call) Run(run func(ticker *Ticker)) *MockTickerStore_ClearIntegrations_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *Ticker
+		if args[0] != nil {
+			arg0 = args[0].(*Ticker)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockTickerStore_ClearIntegrations_Call) Return(err error) *MockTickerStore_ClearIntegrations_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockTickerStore_ClearIntegrations_Call) RunAndReturn(run func(ticker *Ticker) error) *MockTickerStore_ClearIntegrations_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// DeleteTicker provides a mock function for the type MockTickerStore
+func (_mock *MockTickerStore) DeleteTicker(ticker *Ticker) error {
+	ret := _mock.Called(ticker)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteTicker")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*Ticker) error); ok {
+		r0 = returnFunc(ticker)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockTickerStore_DeleteTicker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTicker'
+type MockTickerStore_DeleteTicker_Call struct {
+	*mock.Call
+}
+
+// DeleteTicker is a helper method to define mock.On call
+//   - ticker *Ticker
+func (_e *MockTickerStore_Expecter) DeleteTicker(ticker interface{}) *MockTickerStore_DeleteTicker_Call {
+	return &MockTickerStore_DeleteTicker_Call{Call: _e.mock.On("DeleteTicker", ticker)}
+}
+
+func (_c *MockTickerStore_DeleteTicker_Call) Run(run func(ticker *Ticker)) *MockTickerStore_DeleteTicker_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *Ticker
+		if args[0] != nil {
+			arg0 = args[0].(*Ticker)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockTickerStore_DeleteTicker_Call) Return(err error) *MockTickerStore_DeleteTicker_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockTickerStore_DeleteTicker_Call) RunAndReturn(run func(ticker *Ticker) error) *MockTickerStore_DeleteTicker_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// DeleteTickerUser provides a mock function for the type MockTickerStore
+func (_mock *MockTickerStore) DeleteTickerUser(ticker *Ticker, user *User) error {
+	ret := _mock.Called(ticker, user)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteTickerUser")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*Ticker, *User) error); ok {
+		r0 = returnFunc(ticker, user)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockTickerStore_DeleteTickerUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTickerUser'
+type MockTickerStore_DeleteTickerUser_Call struct {
+	*mock.Call
+}
+
+// DeleteTickerUser is a helper method to define mock.On call
+//   - ticker *Ticker
+//   - user *User
+func (_e *MockTickerStore_Expecter) DeleteTickerUser(ticker interface{}, user interface{}) *MockTickerStore_DeleteTickerUser_Call {
+	return &MockTickerStore_DeleteTickerUser_Call{Call: _e.mock.On("DeleteTickerUser", ticker, user)}
+}
+
+func (_c *MockTickerStore_DeleteTickerUser_Call) Run(run func(ticker *Ticker, user *User)) *MockTickerStore_DeleteTickerUser_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *Ticker
+		if args[0] != nil {
+			arg0 = args[0].(*Ticker)
+		}
+		var arg1 *User
+		if args[1] != nil {
+			arg1 = args[1].(*User)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockTickerStore_DeleteTickerUser_Call) Return(err error) *MockTickerStore_DeleteTickerUser_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockTickerStore_DeleteTickerUser_Call) RunAndReturn(run func(ticker *Ticker, user *User) error) *MockTickerStore_DeleteTickerUser_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// DeleteTickerUsers provides a mock function for the type MockTickerStore
+func (_mock *MockTickerStore) DeleteTickerUsers(ticker *Ticker) error {
+	ret := _mock.Called(ticker)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteTickerUsers")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*Ticker) error); ok {
+		r0 = returnFunc(ticker)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockTickerStore_DeleteTickerUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTickerUsers'
+type MockTickerStore_DeleteTickerUsers_Call struct {
+	*mock.Call
+}
+
+// DeleteTickerUsers is a helper method to define mock.On call
+//   - ticker *Ticker
+func (_e *MockTickerStore_Expecter) DeleteTickerUsers(ticker interface{}) *MockTickerStore_DeleteTickerUsers_Call {
+	return &MockTickerStore_DeleteTickerUsers_Call{Call: _e.mock.On("DeleteTickerUsers", ticker)}
+}
+
+func (_c *MockTickerStore_DeleteTickerUsers_Call) Run(run func(ticker *Ticker)) *MockTickerStore_DeleteTickerUsers_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *Ticker
+		if args[0] != nil {
+			arg0 = args[0].(*Ticker)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockTickerStore_DeleteTickerUsers_Call) Return(err error) *MockTickerStore_DeleteTickerUsers_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockTickerStore_DeleteTickerUsers_Call) RunAndReturn(run func(ticker *Ticker) error) *MockTickerStore_DeleteTickerUsers_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// DeleteTickerWebsites provides a mock function for the type MockTickerStore
+func (_mock *MockTickerStore) DeleteTickerWebsites(ticker *Ticker) error {
+	ret := _mock.Called(ticker)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteTickerWebsites")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*Ticker) error); ok {
+		r0 = returnFunc(ticker)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockTickerStore_DeleteTickerWebsites_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTickerWebsites'
+type MockTickerStore_DeleteTickerWebsites_Call struct {
+	*mock.Call
+}
+
+// DeleteTickerWebsites is a helper method to define mock.On call
+//   - ticker *Ticker
+func (_e *MockTickerStore_Expecter) DeleteTickerWebsites(ticker interface{}) *MockTickerStore_DeleteTickerWebsites_Call {
+	return &MockTickerStore_DeleteTickerWebsites_Call{Call: _e.mock.On("DeleteTickerWebsites", ticker)}
+}
+
+func (_c *MockTickerStore_DeleteTickerWebsites_Call) Run(run func(ticker *Ticker)) *MockTickerStore_DeleteTickerWebsites_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *Ticker
+		if args[0] != nil {
+			arg0 = args[0].(*Ticker)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockTickerStore_DeleteTickerWebsites_Call) Return(err error) *MockTickerStore_DeleteTickerWebsites_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockTickerStore_DeleteTickerWebsites_Call) RunAndReturn(run func(ticker *Ticker) error) *MockTickerStore_DeleteTickerWebsites_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindTickerByID provides a mock function for the type MockTickerStore
+func (_mock *MockTickerStore) FindTickerByID(id int, opts ...QueryOpt) (Ticker, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(id, opts)
+	} else {
+		tmpRet = _mock.Called(id)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindTickerByID")
+	}
+
+	var r0 Ticker
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(int, ...QueryOpt) (Ticker, error)); ok {
+		return returnFunc(id, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(int, ...QueryOpt) Ticker); ok {
+		r0 = returnFunc(id, opts...)
+	} else {
+		r0 = ret.Get(0).(Ticker)
+	}
+	if returnFunc, ok := ret.Get(1).(func(int, ...QueryOpt) error); ok {
+		r1 = returnFunc(id, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockTickerStore_FindTickerByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTickerByID'
+type MockTickerStore_FindTickerByID_Call struct {
+	*mock.Call
+}
+
+// FindTickerByID is a helper method to define mock.On call
+//   - id int
+//   - opts ...QueryOpt
+func (_e *MockTickerStore_Expecter) FindTickerByID(id interface{}, opts ...interface{}) *MockTickerStore_FindTickerByID_Call {
+	return &MockTickerStore_FindTickerByID_Call{Call: _e.mock.On("FindTickerByID",
+		append([]interface{}{id}, opts...)...)}
+}
+
+func (_c *MockTickerStore_FindTickerByID_Call) Run(run func(id int, opts ...QueryOpt)) *MockTickerStore_FindTickerByID_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 int
+		if args[0] != nil {
+			arg0 = args[0].(int)
+		}
+		var arg1 []QueryOpt
+		var variadicArgs []QueryOpt
+		if len(args) > 1 {
+			variadicArgs = args[1].([]QueryOpt)
+		}
+		arg1 = variadicArgs
+		run(
+			arg0,
+			arg1...,
+		)
+	})
+	return _c
+}
+
+func (_c *MockTickerStore_FindTickerByID_Call) Return(ticker Ticker, err error) *MockTickerStore_FindTickerByID_Call {
+	_c.Call.Return(ticker, err)
+	return _c
+}
+
+func (_c *MockTickerStore_FindTickerByID_Call) RunAndReturn(run func(id int, opts ...QueryOpt) (Ticker, error)) *MockTickerStore_FindTickerByID_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindTickerByOrigin provides a mock function for the type MockTickerStore
+func (_mock *MockTickerStore) FindTickerByOrigin(origin string, opts ...QueryOpt) (Ticker, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(origin, opts)
+	} else {
+		tmpRet = _mock.Called(origin)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindTickerByOrigin")
+	}
+
+	var r0 Ticker
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(string, ...QueryOpt) (Ticker, error)); ok {
+		return returnFunc(origin, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(string, ...QueryOpt) Ticker); ok {
+		r0 = returnFunc(origin, opts...)
+	} else {
+		r0 = ret.Get(0).(Ticker)
+	}
+	if returnFunc, ok := ret.Get(1).(func(string, ...QueryOpt) error); ok {
+		r1 = returnFunc(origin, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockTickerStore_FindTickerByOrigin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTickerByOrigin'
+type MockTickerStore_FindTickerByOrigin_Call struct {
+	*mock.Call
+}
+
+// FindTickerByOrigin is a helper method to define mock.On call
+//   - origin string
+//   - opts ...QueryOpt
+func (_e *MockTickerStore_Expecter) FindTickerByOrigin(origin interface{}, opts ...interface{}) *MockTickerStore_FindTickerByOrigin_Call {
+	return &MockTickerStore_FindTickerByOrigin_Call{Call: _e.mock.On("FindTickerByOrigin",
+		append([]interface{}{origin}, opts...)...)}
+}
+
+func (_c *MockTickerStore_FindTickerByOrigin_Call) Run(run func(origin string, opts ...QueryOpt)) *MockTickerStore_FindTickerByOrigin_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		var arg1 []QueryOpt
+		var variadicArgs []QueryOpt
+		if len(args) > 1 {
+			variadicArgs = args[1].([]QueryOpt)
+		}
+		arg1 = variadicArgs
+		run(
+			arg0,
+			arg1...,
+		)
+	})
+	return _c
+}
+
+func (_c *MockTickerStore_FindTickerByOrigin_Call) Return(ticker Ticker, err error) *MockTickerStore_FindTickerByOrigin_Call {
+	_c.Call.Return(ticker, err)
+	return _c
+}
+
+func (_c *MockTickerStore_FindTickerByOrigin_Call) RunAndReturn(run func(origin string, opts ...QueryOpt) (Ticker, error)) *MockTickerStore_FindTickerByOrigin_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindTickerByUserAndID provides a mock function for the type MockTickerStore
+func (_mock *MockTickerStore) FindTickerByUserAndID(user User, id int, opts ...QueryOpt) (Ticker, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(user, id, opts)
+	} else {
+		tmpRet = _mock.Called(user, id)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindTickerByUserAndID")
+	}
+
+	var r0 Ticker
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(User, int, ...QueryOpt) (Ticker, error)); ok {
+		return returnFunc(user, id, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(User, int, ...QueryOpt) Ticker); ok {
+		r0 = returnFunc(user, id, opts...)
+	} else {
+		r0 = ret.Get(0).(Ticker)
+	}
+	if returnFunc, ok := ret.Get(1).(func(User, int, ...QueryOpt) error); ok {
+		r1 = returnFunc(user, id, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockTickerStore_FindTickerByUserAndID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTickerByUserAndID'
+type MockTickerStore_FindTickerByUserAndID_Call struct {
+	*mock.Call
+}
+
+// FindTickerByUserAndID is a helper method to define mock.On call
+//   - user User
+//   - id int
+//   - opts ...QueryOpt
+func (_e *MockTickerStore_Expecter) FindTickerByUserAndID(user interface{}, id interface{}, opts ...interface{}) *MockTickerStore_FindTickerByUserAndID_Call {
+	return &MockTickerStore_FindTickerByUserAndID_Call{Call: _e.mock.On("FindTickerByUserAndID",
+		append([]interface{}{user, id}, opts...)...)}
+}
+
+func (_c *MockTickerStore_FindTickerByUserAndID_Call) Run(run func(user User, id int, opts ...QueryOpt)) *MockTickerStore_FindTickerByUserAndID_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 User
+		if args[0] != nil {
+			arg0 = args[0].(User)
+		}
+		var arg1 int
+		if args[1] != nil {
+			arg1 = args[1].(int)
+		}
+		var arg2 []QueryOpt
+		var variadicArgs []QueryOpt
+		if len(args) > 2 {
+			variadicArgs = args[2].([]QueryOpt)
+		}
+		arg2 = variadicArgs
+		run(
+			arg0,
+			arg1,
+			arg2...,
+		)
+	})
+	return _c
+}
+
+func (_c *MockTickerStore_FindTickerByUserAndID_Call) Return(ticker Ticker, err error) *MockTickerStore_FindTickerByUserAndID_Call {
+	_c.Call.Return(ticker, err)
+	return _c
+}
+
+func (_c *MockTickerStore_FindTickerByUserAndID_Call) RunAndReturn(run func(user User, id int, opts ...QueryOpt) (Ticker, error)) *MockTickerStore_FindTickerByUserAndID_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindTickersByIDs provides a mock function for the type MockTickerStore
+func (_mock *MockTickerStore) FindTickersByIDs(ids []int, opts ...QueryOpt) ([]Ticker, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(ids, opts)
+	} else {
+		tmpRet = _mock.Called(ids)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindTickersByIDs")
+	}
+
+	var r0 []Ticker
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func([]int, ...QueryOpt) ([]Ticker, error)); ok {
+		return returnFunc(ids, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func([]int, ...QueryOpt) []Ticker); ok {
+		r0 = returnFunc(ids, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]Ticker)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func([]int, ...QueryOpt) error); ok {
+		r1 = returnFunc(ids, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockTickerStore_FindTickersByIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTickersByIDs'
+type MockTickerStore_FindTickersByIDs_Call struct {
+	*mock.Call
+}
+
+// FindTickersByIDs is a helper method to define mock.On call
+//   - ids []int
+//   - opts ...QueryOpt
+func (_e *MockTickerStore_Expecter) FindTickersByIDs(ids interface{}, opts ...interface{}) *MockTickerStore_FindTickersByIDs_Call {
+	return &MockTickerStore_FindTickersByIDs_Call{Call: _e.mock.On("FindTickersByIDs",
+		append([]interface{}{ids}, opts...)...)}
+}
+
+func (_c *MockTickerStore_FindTickersByIDs_Call) Run(run func(ids []int, opts ...QueryOpt)) *MockTickerStore_FindTickersByIDs_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 []int
+		if args[0] != nil {
+			arg0 = args[0].([]int)
+		}
+		var arg1 []QueryOpt
+		var variadicArgs []QueryOpt
+		if len(args) > 1 {
+			variadicArgs = args[1].([]QueryOpt)
+		}
+		arg1 = variadicArgs
+		run(
+			arg0,
+			arg1...,
+		)
+	})
+	return _c
+}
+
+func (_c *MockTickerStore_FindTickersByIDs_Call) Return(tickers []Ticker, err error) *MockTickerStore_FindTickersByIDs_Call {
+	_c.Call.Return(tickers, err)
+	return _c
+}
+
+func (_c *MockTickerStore_FindTickersByIDs_Call) RunAndReturn(run func(ids []int, opts ...QueryOpt) ([]Ticker, error)) *MockTickerStore_FindTickersByIDs_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindTickersByUser provides a mock function for the type MockTickerStore
+func (_mock *MockTickerStore) FindTickersByUser(user User, filter TickerFilter, opts ...QueryOpt) ([]Ticker, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(user, filter, opts)
+	} else {
+		tmpRet = _mock.Called(user, filter)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindTickersByUser")
+	}
+
+	var r0 []Ticker
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(User, TickerFilter, ...QueryOpt) ([]Ticker, error)); ok {
+		return returnFunc(user, filter, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(User, TickerFilter, ...QueryOpt) []Ticker); ok {
+		r0 = returnFunc(user, filter, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]Ticker)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(User, TickerFilter, ...QueryOpt) error); ok {
+		r1 = returnFunc(user, filter, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockTickerStore_FindTickersByUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTickersByUser'
+type MockTickerStore_FindTickersByUser_Call struct {
+	*mock.Call
+}
+
+// FindTickersByUser is a helper method to define mock.On call
+//   - user User
+//   - filter TickerFilter
+//   - opts ...QueryOpt
+func (_e *MockTickerStore_Expecter) FindTickersByUser(user interface{}, filter interface{}, opts ...interface{}) *MockTickerStore_FindTickersByUser_Call {
+	return &MockTickerStore_FindTickersByUser_Call{Call: _e.mock.On("FindTickersByUser",
+		append([]interface{}{user, filter}, opts...)...)}
+}
+
+func (_c *MockTickerStore_FindTickersByUser_Call) Run(run func(user User, filter TickerFilter, opts ...QueryOpt)) *MockTickerStore_FindTickersByUser_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 User
+		if args[0] != nil {
+			arg0 = args[0].(User)
+		}
+		var arg1 TickerFilter
+		if args[1] != nil {
+			arg1 = args[1].(TickerFilter)
+		}
+		var arg2 []QueryOpt
+		var variadicArgs []QueryOpt
+		if len(args) > 2 {
+			variadicArgs = args[2].([]QueryOpt)
+		}
+		arg2 = variadicArgs
+		run(
+			arg0,
+			arg1,
+			arg2...,
+		)
+	})
+	return _c
+}
+
+func (_c *MockTickerStore_FindTickersByUser_Call) Return(tickers []Ticker, err error) *MockTickerStore_FindTickersByUser_Call {
+	_c.Call.Return(tickers, err)
+	return _c
+}
+
+func (_c *MockTickerStore_FindTickersByUser_Call) RunAndReturn(run func(user User, filter TickerFilter, opts ...QueryOpt) ([]Ticker, error)) *MockTickerStore_FindTickersByUser_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindUsersByTicker provides a mock function for the type MockTickerStore
+func (_mock *MockTickerStore) FindUsersByTicker(ticker Ticker, opts ...QueryOpt) ([]User, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(ticker, opts)
+	} else {
+		tmpRet = _mock.Called(ticker)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindUsersByTicker")
+	}
+
+	var r0 []User
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(Ticker, ...QueryOpt) ([]User, error)); ok {
+		return returnFunc(ticker, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(Ticker, ...QueryOpt) []User); ok {
+		r0 = returnFunc(ticker, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]User)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(Ticker, ...QueryOpt) error); ok {
+		r1 = returnFunc(ticker, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockTickerStore_FindUsersByTicker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindUsersByTicker'
+type MockTickerStore_FindUsersByTicker_Call struct {
+	*mock.Call
+}
+
+// FindUsersByTicker is a helper method to define mock.On call
+//   - ticker Ticker
+//   - opts ...QueryOpt
+func (_e *MockTickerStore_Expecter) FindUsersByTicker(ticker interface{}, opts ...interface{}) *MockTickerStore_FindUsersByTicker_Call {
+	return &MockTickerStore_FindUsersByTicker_Call{Call: _e.mock.On("FindUsersByTicker",
+		append([]interface{}{ticker}, opts...)...)}
+}
+
+func (_c *MockTickerStore_FindUsersByTicker_Call) Run(run func(ticker Ticker, opts ...QueryOpt)) *MockTickerStore_FindUsersByTicker_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 Ticker
+		if args[0] != nil {
+			arg0 = args[0].(Ticker)
+		}
+		var arg1 []QueryOpt
+		var variadicArgs []QueryOpt
+		if len(args) > 1 {
+			variadicArgs = args[1].([]QueryOpt)
+		}
+		arg1 = variadicArgs
+		run(
+			arg0,
+			arg1...,
+		)
+	})
+	return _c
+}
+
+func (_c *MockTickerStore_FindUsersByTicker_Call) Return(users []User, err error) *MockTickerStore_FindUsersByTicker_Call {
+	_c.Call.Return(users, err)
+	return _c
+}
+
+func (_c *MockTickerStore_FindUsersByTicker_Call) RunAndReturn(run func(ticker Ticker, opts ...QueryOpt) ([]User, error)) *MockTickerStore_FindUsersByTicker_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ResetTicker provides a mock function for the type MockTickerStore
+func (_mock *MockTickerStore) ResetTicker(ticker *Ticker) error {
+	ret := _mock.Called(ticker)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ResetTicker")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*Ticker) error); ok {
+		r0 = returnFunc(ticker)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockTickerStore_ResetTicker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetTicker'
+type MockTickerStore_ResetTicker_Call struct {
+	*mock.Call
+}
+
+// ResetTicker is a helper method to define mock.On call
+//   - ticker *Ticker
+func (_e *MockTickerStore_Expecter) ResetTicker(ticker interface{}) *MockTickerStore_ResetTicker_Call {
+	return &MockTickerStore_ResetTicker_Call{Call: _e.mock.On("ResetTicker", ticker)}
+}
+
+func (_c *MockTickerStore_ResetTicker_Call) Run(run func(ticker *Ticker)) *MockTickerStore_ResetTicker_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *Ticker
+		if args[0] != nil {
+			arg0 = args[0].(*Ticker)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockTickerStore_ResetTicker_Call) Return(err error) *MockTickerStore_ResetTicker_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockTickerStore_ResetTicker_Call) RunAndReturn(run func(ticker *Ticker) error) *MockTickerStore_ResetTicker_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SaveTicker provides a mock function for the type MockTickerStore
+func (_mock *MockTickerStore) SaveTicker(ticker *Ticker) error {
+	ret := _mock.Called(ticker)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveTicker")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*Ticker) error); ok {
+		r0 = returnFunc(ticker)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockTickerStore_SaveTicker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveTicker'
+type MockTickerStore_SaveTicker_Call struct {
+	*mock.Call
+}
+
+// SaveTicker is a helper method to define mock.On call
+//   - ticker *Ticker
+func (_e *MockTickerStore_Expecter) SaveTicker(ticker interface{}) *MockTickerStore_SaveTicker_Call {
+	return &MockTickerStore_SaveTicker_Call{Call: _e.mock.On("SaveTicker", ticker)}
+}
+
+func (_c *MockTickerStore_SaveTicker_Call) Run(run func(ticker *Ticker)) *MockTickerStore_SaveTicker_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *Ticker
+		if args[0] != nil {
+			arg0 = args[0].(*Ticker)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockTickerStore_SaveTicker_Call) Return(err error) *MockTickerStore_SaveTicker_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockTickerStore_SaveTicker_Call) RunAndReturn(run func(ticker *Ticker) error) *MockTickerStore_SaveTicker_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SaveTickerWebsites provides a mock function for the type MockTickerStore
+func (_mock *MockTickerStore) SaveTickerWebsites(ticker *Ticker, websites []TickerWebsite) error {
+	ret := _mock.Called(ticker, websites)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveTickerWebsites")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*Ticker, []TickerWebsite) error); ok {
+		r0 = returnFunc(ticker, websites)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockTickerStore_SaveTickerWebsites_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveTickerWebsites'
+type MockTickerStore_SaveTickerWebsites_Call struct {
+	*mock.Call
+}
+
+// SaveTickerWebsites is a helper method to define mock.On call
+//   - ticker *Ticker
+//   - websites []TickerWebsite
+func (_e *MockTickerStore_Expecter) SaveTickerWebsites(ticker interface{}, websites interface{}) *MockTickerStore_SaveTickerWebsites_Call {
+	return &MockTickerStore_SaveTickerWebsites_Call{Call: _e.mock.On("SaveTickerWebsites", ticker, websites)}
+}
+
+func (_c *MockTickerStore_SaveTickerWebsites_Call) Run(run func(ticker *Ticker, websites []TickerWebsite)) *MockTickerStore_SaveTickerWebsites_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *Ticker
+		if args[0] != nil {
+			arg0 = args[0].(*Ticker)
+		}
+		var arg1 []TickerWebsite
+		if args[1] != nil {
+			arg1 = args[1].([]TickerWebsite)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockTickerStore_SaveTickerWebsites_Call) Return(err error) *MockTickerStore_SaveTickerWebsites_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockTickerStore_SaveTickerWebsites_Call) RunAndReturn(run func(ticker *Ticker, websites []TickerWebsite) error) *MockTickerStore_SaveTickerWebsites_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/internal/storage/mock_UploadStore.go b/internal/storage/mock_UploadStore.go
new file mode 100644
index 00000000..5898154b
--- /dev/null
+++ b/internal/storage/mock_UploadStore.go
@@ -0,0 +1,395 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package storage
+
+import (
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewMockUploadStore creates a new instance of MockUploadStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockUploadStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockUploadStore {
+	mock := &MockUploadStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockUploadStore is an autogenerated mock type for the UploadStore type
+type MockUploadStore struct {
+	mock.Mock
+}
+
+type MockUploadStore_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockUploadStore) EXPECT() *MockUploadStore_Expecter {
+	return &MockUploadStore_Expecter{mock: &_m.Mock}
+}
+
+// DeleteUpload provides a mock function for the type MockUploadStore
+func (_mock *MockUploadStore) DeleteUpload(upload Upload) error {
+	ret := _mock.Called(upload)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteUpload")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(Upload) error); ok {
+		r0 = returnFunc(upload)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockUploadStore_DeleteUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUpload'
+type MockUploadStore_DeleteUpload_Call struct {
+	*mock.Call
+}
+
+// DeleteUpload is a helper method to define mock.On call
+//   - upload Upload
+func (_e *MockUploadStore_Expecter) DeleteUpload(upload interface{}) *MockUploadStore_DeleteUpload_Call {
+	return &MockUploadStore_DeleteUpload_Call{Call: _e.mock.On("DeleteUpload", upload)}
+}
+
+func (_c *MockUploadStore_DeleteUpload_Call) Run(run func(upload Upload)) *MockUploadStore_DeleteUpload_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 Upload
+		if args[0] != nil {
+			arg0 = args[0].(Upload)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockUploadStore_DeleteUpload_Call) Return(err error) *MockUploadStore_DeleteUpload_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockUploadStore_DeleteUpload_Call) RunAndReturn(run func(upload Upload) error) *MockUploadStore_DeleteUpload_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// DeleteUploads provides a mock function for the type MockUploadStore
+func (_mock *MockUploadStore) DeleteUploads(uploads []Upload) {
+	_mock.Called(uploads)
+	return
+}
+
+// MockUploadStore_DeleteUploads_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUploads'
+type MockUploadStore_DeleteUploads_Call struct {
+	*mock.Call
+}
+
+// DeleteUploads is a helper method to define mock.On call
+//   - uploads []Upload
+func (_e *MockUploadStore_Expecter) DeleteUploads(uploads interface{}) *MockUploadStore_DeleteUploads_Call {
+	return &MockUploadStore_DeleteUploads_Call{Call: _e.mock.On("DeleteUploads", uploads)}
+}
+
+func (_c *MockUploadStore_DeleteUploads_Call) Run(run func(uploads []Upload)) *MockUploadStore_DeleteUploads_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 []Upload
+		if args[0] != nil {
+			arg0 = args[0].([]Upload)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockUploadStore_DeleteUploads_Call) Return() *MockUploadStore_DeleteUploads_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockUploadStore_DeleteUploads_Call) RunAndReturn(run func(uploads []Upload)) *MockUploadStore_DeleteUploads_Call {
+	_c.Run(run)
+	return _c
+}
+
+// DeleteUploadsByTicker provides a mock function for the type MockUploadStore
+func (_mock *MockUploadStore) DeleteUploadsByTicker(ticker *Ticker) error {
+	ret := _mock.Called(ticker)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteUploadsByTicker")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*Ticker) error); ok {
+		r0 = returnFunc(ticker)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockUploadStore_DeleteUploadsByTicker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUploadsByTicker'
+type MockUploadStore_DeleteUploadsByTicker_Call struct {
+	*mock.Call
+}
+
+// DeleteUploadsByTicker is a helper method to define mock.On call
+//   - ticker *Ticker
+func (_e *MockUploadStore_Expecter) DeleteUploadsByTicker(ticker interface{}) *MockUploadStore_DeleteUploadsByTicker_Call {
+	return &MockUploadStore_DeleteUploadsByTicker_Call{Call: _e.mock.On("DeleteUploadsByTicker", ticker)}
+}
+
+func (_c *MockUploadStore_DeleteUploadsByTicker_Call) Run(run func(ticker *Ticker)) *MockUploadStore_DeleteUploadsByTicker_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *Ticker
+		if args[0] != nil {
+			arg0 = args[0].(*Ticker)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockUploadStore_DeleteUploadsByTicker_Call) Return(err error) *MockUploadStore_DeleteUploadsByTicker_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockUploadStore_DeleteUploadsByTicker_Call) RunAndReturn(run func(ticker *Ticker) error) *MockUploadStore_DeleteUploadsByTicker_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindUploadByUUID provides a mock function for the type MockUploadStore
+func (_mock *MockUploadStore) FindUploadByUUID(uuid string) (Upload, error) {
+	ret := _mock.Called(uuid)
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindUploadByUUID")
+	}
+
+	var r0 Upload
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(string) (Upload, error)); ok {
+		return returnFunc(uuid)
+	}
+	if returnFunc, ok := ret.Get(0).(func(string) Upload); ok {
+		r0 = returnFunc(uuid)
+	} else {
+		r0 = ret.Get(0).(Upload)
+	}
+	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
+		r1 = returnFunc(uuid)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockUploadStore_FindUploadByUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindUploadByUUID'
+type MockUploadStore_FindUploadByUUID_Call struct {
+	*mock.Call
+}
+
+// FindUploadByUUID is a helper method to define mock.On call
+//   - uuid string
+func (_e *MockUploadStore_Expecter) FindUploadByUUID(uuid interface{}) *MockUploadStore_FindUploadByUUID_Call {
+	return &MockUploadStore_FindUploadByUUID_Call{Call: _e.mock.On("FindUploadByUUID", uuid)}
+}
+
+func (_c *MockUploadStore_FindUploadByUUID_Call) Run(run func(uuid string)) *MockUploadStore_FindUploadByUUID_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockUploadStore_FindUploadByUUID_Call) Return(upload Upload, err error) *MockUploadStore_FindUploadByUUID_Call {
+	_c.Call.Return(upload, err)
+	return _c
+}
+
+func (_c *MockUploadStore_FindUploadByUUID_Call) RunAndReturn(run func(uuid string) (Upload, error)) *MockUploadStore_FindUploadByUUID_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindUploadsByIDs provides a mock function for the type MockUploadStore
+func (_mock *MockUploadStore) FindUploadsByIDs(ids []int) ([]Upload, error) {
+	ret := _mock.Called(ids)
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindUploadsByIDs")
+	}
+
+	var r0 []Upload
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func([]int) ([]Upload, error)); ok {
+		return returnFunc(ids)
+	}
+	if returnFunc, ok := ret.Get(0).(func([]int) []Upload); ok {
+		r0 = returnFunc(ids)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]Upload)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func([]int) error); ok {
+		r1 = returnFunc(ids)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockUploadStore_FindUploadsByIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindUploadsByIDs'
+type MockUploadStore_FindUploadsByIDs_Call struct {
+	*mock.Call
+}
+
+// FindUploadsByIDs is a helper method to define mock.On call
+//   - ids []int
+func (_e *MockUploadStore_Expecter) FindUploadsByIDs(ids interface{}) *MockUploadStore_FindUploadsByIDs_Call {
+	return &MockUploadStore_FindUploadsByIDs_Call{Call: _e.mock.On("FindUploadsByIDs", ids)}
+}
+
+func (_c *MockUploadStore_FindUploadsByIDs_Call) Run(run func(ids []int)) *MockUploadStore_FindUploadsByIDs_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 []int
+		if args[0] != nil {
+			arg0 = args[0].([]int)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockUploadStore_FindUploadsByIDs_Call) Return(uploads []Upload, err error) *MockUploadStore_FindUploadsByIDs_Call {
+	_c.Call.Return(uploads, err)
+	return _c
+}
+
+func (_c *MockUploadStore_FindUploadsByIDs_Call) RunAndReturn(run func(ids []int) ([]Upload, error)) *MockUploadStore_FindUploadsByIDs_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SaveUpload provides a mock function for the type MockUploadStore
+func (_mock *MockUploadStore) SaveUpload(upload *Upload) error {
+	ret := _mock.Called(upload)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveUpload")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*Upload) error); ok {
+		r0 = returnFunc(upload)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockUploadStore_SaveUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveUpload'
+type MockUploadStore_SaveUpload_Call struct {
+	*mock.Call
+}
+
+// SaveUpload is a helper method to define mock.On call
+//   - upload *Upload
+func (_e *MockUploadStore_Expecter) SaveUpload(upload interface{}) *MockUploadStore_SaveUpload_Call {
+	return &MockUploadStore_SaveUpload_Call{Call: _e.mock.On("SaveUpload", upload)}
+}
+
+func (_c *MockUploadStore_SaveUpload_Call) Run(run func(upload *Upload)) *MockUploadStore_SaveUpload_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *Upload
+		if args[0] != nil {
+			arg0 = args[0].(*Upload)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockUploadStore_SaveUpload_Call) Return(err error) *MockUploadStore_SaveUpload_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockUploadStore_SaveUpload_Call) RunAndReturn(run func(upload *Upload) error) *MockUploadStore_SaveUpload_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// UploadPath provides a mock function for the type MockUploadStore
+func (_mock *MockUploadStore) UploadPath() string {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for UploadPath")
+	}
+
+	var r0 string
+	if returnFunc, ok := ret.Get(0).(func() string); ok {
+		r0 = returnFunc()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+	return r0
+}
+
+// MockUploadStore_UploadPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadPath'
+type MockUploadStore_UploadPath_Call struct {
+	*mock.Call
+}
+
+// UploadPath is a helper method to define mock.On call
+func (_e *MockUploadStore_Expecter) UploadPath() *MockUploadStore_UploadPath_Call {
+	return &MockUploadStore_UploadPath_Call{Call: _e.mock.On("UploadPath")}
+}
+
+func (_c *MockUploadStore_UploadPath_Call) Run(run func()) *MockUploadStore_UploadPath_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockUploadStore_UploadPath_Call) Return(s string) *MockUploadStore_UploadPath_Call {
+	_c.Call.Return(s)
+	return _c
+}
+
+func (_c *MockUploadStore_UploadPath_Call) RunAndReturn(run func() string) *MockUploadStore_UploadPath_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/internal/storage/mock_UserStore.go b/internal/storage/mock_UserStore.go
new file mode 100644
index 00000000..70ac1618
--- /dev/null
+++ b/internal/storage/mock_UserStore.go
@@ -0,0 +1,442 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package storage
+
+import (
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewMockUserStore creates a new instance of MockUserStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockUserStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockUserStore {
+	mock := &MockUserStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockUserStore is an autogenerated mock type for the UserStore type
+type MockUserStore struct {
+	mock.Mock
+}
+
+type MockUserStore_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockUserStore) EXPECT() *MockUserStore_Expecter {
+	return &MockUserStore_Expecter{mock: &_m.Mock}
+}
+
+// DeleteUser provides a mock function for the type MockUserStore
+func (_mock *MockUserStore) DeleteUser(user User) error {
+	ret := _mock.Called(user)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteUser")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(User) error); ok {
+		r0 = returnFunc(user)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockUserStore_DeleteUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUser'
+type MockUserStore_DeleteUser_Call struct {
+	*mock.Call
+}
+
+// DeleteUser is a helper method to define mock.On call
+//   - user User
+func (_e *MockUserStore_Expecter) DeleteUser(user interface{}) *MockUserStore_DeleteUser_Call {
+	return &MockUserStore_DeleteUser_Call{Call: _e.mock.On("DeleteUser", user)}
+}
+
+func (_c *MockUserStore_DeleteUser_Call) Run(run func(user User)) *MockUserStore_DeleteUser_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 User
+		if args[0] != nil {
+			arg0 = args[0].(User)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockUserStore_DeleteUser_Call) Return(err error) *MockUserStore_DeleteUser_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockUserStore_DeleteUser_Call) RunAndReturn(run func(user User) error) *MockUserStore_DeleteUser_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindUserByEmail provides a mock function for the type MockUserStore
+func (_mock *MockUserStore) FindUserByEmail(email string, opts ...QueryOpt) (User, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(email, opts)
+	} else {
+		tmpRet = _mock.Called(email)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindUserByEmail")
+	}
+
+	var r0 User
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(string, ...QueryOpt) (User, error)); ok {
+		return returnFunc(email, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(string, ...QueryOpt) User); ok {
+		r0 = returnFunc(email, opts...)
+	} else {
+		r0 = ret.Get(0).(User)
+	}
+	if returnFunc, ok := ret.Get(1).(func(string, ...QueryOpt) error); ok {
+		r1 = returnFunc(email, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockUserStore_FindUserByEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindUserByEmail'
+type MockUserStore_FindUserByEmail_Call struct {
+	*mock.Call
+}
+
+// FindUserByEmail is a helper method to define mock.On call
+//   - email string
+//   - opts ...QueryOpt
+func (_e *MockUserStore_Expecter) FindUserByEmail(email interface{}, opts ...interface{}) *MockUserStore_FindUserByEmail_Call {
+	return &MockUserStore_FindUserByEmail_Call{Call: _e.mock.On("FindUserByEmail",
+		append([]interface{}{email}, opts...)...)}
+}
+
+func (_c *MockUserStore_FindUserByEmail_Call) Run(run func(email string, opts ...QueryOpt)) *MockUserStore_FindUserByEmail_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		var arg1 []QueryOpt
+		var variadicArgs []QueryOpt
+		if len(args) > 1 {
+			variadicArgs = args[1].([]QueryOpt)
+		}
+		arg1 = variadicArgs
+		run(
+			arg0,
+			arg1...,
+		)
+	})
+	return _c
+}
+
+func (_c *MockUserStore_FindUserByEmail_Call) Return(user User, err error) *MockUserStore_FindUserByEmail_Call {
+	_c.Call.Return(user, err)
+	return _c
+}
+
+func (_c *MockUserStore_FindUserByEmail_Call) RunAndReturn(run func(email string, opts ...QueryOpt) (User, error)) *MockUserStore_FindUserByEmail_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindUserByID provides a mock function for the type MockUserStore
+func (_mock *MockUserStore) FindUserByID(id int, opts ...QueryOpt) (User, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(id, opts)
+	} else {
+		tmpRet = _mock.Called(id)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindUserByID")
+	}
+
+	var r0 User
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(int, ...QueryOpt) (User, error)); ok {
+		return returnFunc(id, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(int, ...QueryOpt) User); ok {
+		r0 = returnFunc(id, opts...)
+	} else {
+		r0 = ret.Get(0).(User)
+	}
+	if returnFunc, ok := ret.Get(1).(func(int, ...QueryOpt) error); ok {
+		r1 = returnFunc(id, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockUserStore_FindUserByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindUserByID'
+type MockUserStore_FindUserByID_Call struct {
+	*mock.Call
+}
+
+// FindUserByID is a helper method to define mock.On call
+//   - id int
+//   - opts ...QueryOpt
+func (_e *MockUserStore_Expecter) FindUserByID(id interface{}, opts ...interface{}) *MockUserStore_FindUserByID_Call {
+	return &MockUserStore_FindUserByID_Call{Call: _e.mock.On("FindUserByID",
+		append([]interface{}{id}, opts...)...)}
+}
+
+func (_c *MockUserStore_FindUserByID_Call) Run(run func(id int, opts ...QueryOpt)) *MockUserStore_FindUserByID_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 int
+		if args[0] != nil {
+			arg0 = args[0].(int)
+		}
+		var arg1 []QueryOpt
+		var variadicArgs []QueryOpt
+		if len(args) > 1 {
+			variadicArgs = args[1].([]QueryOpt)
+		}
+		arg1 = variadicArgs
+		run(
+			arg0,
+			arg1...,
+		)
+	})
+	return _c
+}
+
+func (_c *MockUserStore_FindUserByID_Call) Return(user User, err error) *MockUserStore_FindUserByID_Call {
+	_c.Call.Return(user, err)
+	return _c
+}
+
+func (_c *MockUserStore_FindUserByID_Call) RunAndReturn(run func(id int, opts ...QueryOpt) (User, error)) *MockUserStore_FindUserByID_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindUsers provides a mock function for the type MockUserStore
+func (_mock *MockUserStore) FindUsers(filter UserFilter, opts ...QueryOpt) ([]User, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(filter, opts)
+	} else {
+		tmpRet = _mock.Called(filter)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindUsers")
+	}
+
+	var r0 []User
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(UserFilter, ...QueryOpt) ([]User, error)); ok {
+		return returnFunc(filter, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(UserFilter, ...QueryOpt) []User); ok {
+		r0 = returnFunc(filter, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]User)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(UserFilter, ...QueryOpt) error); ok {
+		r1 = returnFunc(filter, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockUserStore_FindUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindUsers'
+type MockUserStore_FindUsers_Call struct {
+	*mock.Call
+}
+
+// FindUsers is a helper method to define mock.On call
+//   - filter UserFilter
+//   - opts ...QueryOpt
+func (_e *MockUserStore_Expecter) FindUsers(filter interface{}, opts ...interface{}) *MockUserStore_FindUsers_Call {
+	return &MockUserStore_FindUsers_Call{Call: _e.mock.On("FindUsers",
+		append([]interface{}{filter}, opts...)...)}
+}
+
+func (_c *MockUserStore_FindUsers_Call) Run(run func(filter UserFilter, opts ...QueryOpt)) *MockUserStore_FindUsers_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 UserFilter
+		if args[0] != nil {
+			arg0 = args[0].(UserFilter)
+		}
+		var arg1 []QueryOpt
+		var variadicArgs []QueryOpt
+		if len(args) > 1 {
+			variadicArgs = args[1].([]QueryOpt)
+		}
+		arg1 = variadicArgs
+		run(
+			arg0,
+			arg1...,
+		)
+	})
+	return _c
+}
+
+func (_c *MockUserStore_FindUsers_Call) Return(users []User, err error) *MockUserStore_FindUsers_Call {
+	_c.Call.Return(users, err)
+	return _c
+}
+
+func (_c *MockUserStore_FindUsers_Call) RunAndReturn(run func(filter UserFilter, opts ...QueryOpt) ([]User, error)) *MockUserStore_FindUsers_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindUsersByIDs provides a mock function for the type MockUserStore
+func (_mock *MockUserStore) FindUsersByIDs(ids []int, opts ...QueryOpt) ([]User, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(ids, opts)
+	} else {
+		tmpRet = _mock.Called(ids)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindUsersByIDs")
+	}
+
+	var r0 []User
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func([]int, ...QueryOpt) ([]User, error)); ok {
+		return returnFunc(ids, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func([]int, ...QueryOpt) []User); ok {
+		r0 = returnFunc(ids, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]User)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func([]int, ...QueryOpt) error); ok {
+		r1 = returnFunc(ids, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockUserStore_FindUsersByIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindUsersByIDs'
+type MockUserStore_FindUsersByIDs_Call struct {
+	*mock.Call
+}
+
+// FindUsersByIDs is a helper method to define mock.On call
+//   - ids []int
+//   - opts ...QueryOpt
+func (_e *MockUserStore_Expecter) FindUsersByIDs(ids interface{}, opts ...interface{}) *MockUserStore_FindUsersByIDs_Call {
+	return &MockUserStore_FindUsersByIDs_Call{Call: _e.mock.On("FindUsersByIDs",
+		append([]interface{}{ids}, opts...)...)}
+}
+
+func (_c *MockUserStore_FindUsersByIDs_Call) Run(run func(ids []int, opts ...QueryOpt)) *MockUserStore_FindUsersByIDs_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 []int
+		if args[0] != nil {
+			arg0 = args[0].([]int)
+		}
+		var arg1 []QueryOpt
+		var variadicArgs []QueryOpt
+		if len(args) > 1 {
+			variadicArgs = args[1].([]QueryOpt)
+		}
+		arg1 = variadicArgs
+		run(
+			arg0,
+			arg1...,
+		)
+	})
+	return _c
+}
+
+func (_c *MockUserStore_FindUsersByIDs_Call) Return(users []User, err error) *MockUserStore_FindUsersByIDs_Call {
+	_c.Call.Return(users, err)
+	return _c
+}
+
+func (_c *MockUserStore_FindUsersByIDs_Call) RunAndReturn(run func(ids []int, opts ...QueryOpt) ([]User, error)) *MockUserStore_FindUsersByIDs_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SaveUser provides a mock function for the type MockUserStore
+func (_mock *MockUserStore) SaveUser(user *User) error {
+	ret := _mock.Called(user)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveUser")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*User) error); ok {
+		r0 = returnFunc(user)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockUserStore_SaveUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveUser'
+type MockUserStore_SaveUser_Call struct {
+	*mock.Call
+}
+
+// SaveUser is a helper method to define mock.On call
+//   - user *User
+func (_e *MockUserStore_Expecter) SaveUser(user interface{}) *MockUserStore_SaveUser_Call {
+	return &MockUserStore_SaveUser_Call{Call: _e.mock.On("SaveUser", user)}
+}
+
+func (_c *MockUserStore_SaveUser_Call) Run(run func(user *User)) *MockUserStore_SaveUser_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *User
+		if args[0] != nil {
+			arg0 = args[0].(*User)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockUserStore_SaveUser_Call) Return(err error) *MockUserStore_SaveUser_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockUserStore_SaveUser_Call) RunAndReturn(run func(user *User) error) *MockUserStore_SaveUser_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/internal/storage/mock_settings_helpers.go b/internal/storage/mock_settings_helpers.go
new file mode 100644
index 00000000..064eab5e
--- /dev/null
+++ b/internal/storage/mock_settings_helpers.go
@@ -0,0 +1,33 @@
+package storage
+
+import (
+	"github.com/stretchr/testify/mock"
+)
+
+// Convenience helpers attached to MockSettingsStore so tests can keep the
+// previous Get<Name>Settings / Save<Name>Settings call shape after the split
+// of the storage interface into per-aggregate stores.
+
+func (m *MockSettingsStore) MockGetInactive(v InactiveSettings) *mock.Call {
+	return MockGetSetting(m, InactiveSetting, v)
+}
+
+func (m *MockSettingsStore) MockGetTelegram(v TelegramSettings) *mock.Call {
+	return MockGetSetting(m, TelegramSetting, v)
+}
+
+func (m *MockSettingsStore) MockGetSignalGroup(v SignalGroupSettings) *mock.Call {
+	return MockGetSetting(m, SignalGroupSetting, v)
+}
+
+func (m *MockSettingsStore) MockSaveInactive(err error) *mock.Call {
+	return MockSaveSetting(m, InactiveSetting, err)
+}
+
+func (m *MockSettingsStore) MockSaveTelegram(err error) *mock.Call {
+	return MockSaveSetting(m, TelegramSetting, err)
+}
+
+func (m *MockSettingsStore) MockSaveSignalGroup(err error) *mock.Call {
+	return MockSaveSetting(m, SignalGroupSetting, err)
+}
diff --git a/internal/storage/mock_storage.go b/internal/storage/mock_storage.go
new file mode 100644
index 00000000..0e7e36eb
--- /dev/null
+++ b/internal/storage/mock_storage.go
@@ -0,0 +1,67 @@
+package storage
+
+import (
+	"encoding/json"
+	"errors"
+
+	"github.com/stretchr/testify/mock"
+)
+
+// MockStorage bundles the five per-aggregate mocks behind a single value for
+// convenience in test setup. Field access is explicit (e.g. `m.Tickers.On(...)`)
+// because each per-store mock has its own `mock.Mock`; embedding would make
+// `.On` ambiguous.
+type MockStorage struct {
+	Users    *MockUserStore
+	Tickers  *MockTickerStore
+	Messages *MockMessageStore
+	Uploads  *MockUploadStore
+	Settings *MockSettingsStore
+}
+
+// NewMockStorage builds a MockStorage with fresh mocks for every aggregate.
+func NewMockStorage() *MockStorage {
+	return &MockStorage{
+		Users:    &MockUserStore{},
+		Tickers:  &MockTickerStore{},
+		Messages: &MockMessageStore{},
+		Uploads:  &MockUploadStore{},
+		Settings: &MockSettingsStore{},
+	}
+}
+
+// Stores returns a storage.Stores aggregate backed by the per-store mocks.
+func (m *MockStorage) Stores() Stores {
+	return Stores{
+		Users:    m.Users,
+		Tickers:  m.Tickers,
+		Messages: m.Messages,
+		Uploads:  m.Uploads,
+		Settings: m.Settings,
+	}
+}
+
+// AssertExpectations verifies all five per-store mocks at once.
+func (m *MockStorage) AssertExpectations(t mock.TestingT) bool {
+	ok := m.Users.AssertExpectations(t)
+	ok = m.Tickers.AssertExpectations(t) && ok
+	ok = m.Messages.AssertExpectations(t) && ok
+	ok = m.Uploads.AssertExpectations(t) && ok
+	ok = m.Settings.AssertExpectations(t) && ok
+	return ok
+}
+
+// MockGetSetting wires the SettingsStore mock to return v for the given
+// descriptor's name. Use this instead of poking GetSetting directly when a
+// test wants the typed Get<Name>Settings() shape.
+func MockGetSetting[T SettingValue](m *MockSettingsStore, desc SettingDescriptor[T], v T) *mock.Call {
+	raw, _ := json.Marshal(v)
+	return m.On("GetSetting", desc.Name).Return(Setting{Name: desc.Name, Value: string(raw)}, nil)
+}
+
+// MockSaveSetting wires GetSetting (missing) + SaveSetting so SaveSettings[T]
+// resolves to a SaveSetting call returning the given err.
+func MockSaveSetting[T SettingValue](m *MockSettingsStore, desc SettingDescriptor[T], err error) *mock.Call {
+	m.On("GetSetting", desc.Name).Return(Setting{}, errors.New("not found")).Maybe()
+	return m.On("SaveSetting", mock.AnythingOfType("*storage.Setting")).Return(err)
+}
diff --git a/internal/storage/query_opt.go b/internal/storage/query_opt.go
new file mode 100644
index 00000000..07fc40bf
--- /dev/null
+++ b/internal/storage/query_opt.go
@@ -0,0 +1,7 @@
+package storage
+
+import "gorm.io/gorm"
+
+// QueryOpt is a GORM query option that can be passed to store reads to apply
+// preloads, ordering, or any other gorm.DB chain.
+type QueryOpt = func(*gorm.DB) *gorm.DB
diff --git a/internal/storage/settings_store.go b/internal/storage/settings_store.go
new file mode 100644
index 00000000..2aeae5ce
--- /dev/null
+++ b/internal/storage/settings_store.go
@@ -0,0 +1,81 @@
+package storage
+
+import (
+	"encoding/json"
+)
+
+// SettingValue is the type constraint for values stored in the settings table.
+// Each is a JSON-encoded blob under a well-known name.
+type SettingValue interface {
+	InactiveSettings | TelegramSettings | SignalGroupSettings
+}
+
+// SettingDescriptor pairs a settings name with the function that produces the
+// default value when the row is missing or unreadable.
+type SettingDescriptor[T SettingValue] struct {
+	Name      string
+	DefaultFn func() T
+}
+
+var (
+	InactiveSetting = SettingDescriptor[InactiveSettings]{
+		Name:      SettingInactiveName,
+		DefaultFn: DefaultInactiveSettings,
+	}
+	TelegramSetting = SettingDescriptor[TelegramSettings]{
+		Name:      SettingTelegramName,
+		DefaultFn: DefaultTelegramSettings,
+	}
+	SignalGroupSetting = SettingDescriptor[SignalGroupSettings]{
+		Name:      SettingSignalGroupName,
+		DefaultFn: DefaultSignalGroupSettings,
+	}
+)
+
+// SettingsStore reads and writes raw setting rows. Use the generic
+// GetSettings / SaveSettings helpers below for typed access.
+type SettingsStore interface {
+	GetSetting(name string) (Setting, error)
+	SaveSetting(setting *Setting) error
+}
+
+// GetSettings reads the row identified by desc and decodes it into T. On any
+// error (missing row, bad JSON) the descriptor's default is returned.
+func GetSettings[T SettingValue](s SettingsStore, desc SettingDescriptor[T]) T {
+	row, err := s.GetSetting(desc.Name)
+	if err != nil {
+		return desc.DefaultFn()
+	}
+	var out T
+	if err := json.Unmarshal([]byte(row.Value), &out); err != nil {
+		return desc.DefaultFn()
+	}
+	return out
+}
+
+// SaveSettings JSON-encodes v and upserts it under desc.Name.
+func SaveSettings[T SettingValue](s SettingsStore, desc SettingDescriptor[T], v T) error {
+	value, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+	row, err := s.GetSetting(desc.Name)
+	if err != nil {
+		row = Setting{Name: desc.Name}
+	}
+	row.Value = string(value)
+	return s.SaveSetting(&row)
+}
+
+// GetSetting fetches a setting row by its well-known name.
+func (s *SqlStorage) GetSetting(name string) (Setting, error) {
+	var setting Setting
+	err := s.DB.First(&setting, EqualName, name).Error
+	return setting, err
+}
+
+// SaveSetting upserts a setting row.
+func (s *SqlStorage) SaveSetting(setting *Setting) error {
+	return s.DB.Save(setting).Error
+}
+
diff --git a/internal/storage/sql_storage.go b/internal/storage/sql_storage.go
index e32599e7..2ca93167 100644
--- a/internal/storage/sql_storage.go
+++ b/internal/storage/sql_storage.go
@@ -1,11 +1,11 @@
 package storage
 
 import (
-	"encoding/json"
 	"fmt"
 	"os"
 
 	"github.com/systemli/ticker/internal/api/pagination"
+	"github.com/systemli/ticker/internal/logger"
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
 )
@@ -15,6 +15,8 @@ const (
 	EqualName     = "name = ?"
 )
 
+var log = logger.GetWithPackage("storage")
+
 type SqlStorage struct {
 	DB         *gorm.DB
 	uploadPath string
@@ -27,7 +29,9 @@ func NewSqlStorage(db *gorm.DB, uploadPath string) *SqlStorage {
 	}
 }
 
-func (s *SqlStorage) FindUsers(filter UserFilter, opts ...func(*gorm.DB) *gorm.DB) ([]User, error) {
+// --- Users ---------------------------------------------------------------
+
+func (s *SqlStorage) FindUsers(filter UserFilter, opts ...QueryOpt) ([]User, error) {
 	users := make([]User, 0)
 	db := s.prepareDb(opts...)
 
@@ -44,7 +48,7 @@ func (s *SqlStorage) FindUsers(filter UserFilter, opts ...func(*gorm.DB) *gorm.D
 	return users, err
 }
 
-func (s *SqlStorage) FindUserByID(id int, opts ...func(*gorm.DB) *gorm.DB) (User, error) {
+func (s *SqlStorage) FindUserByID(id int, opts ...QueryOpt) (User, error) {
 	var user User
 	db := s.prepareDb(opts...)
 	err := db.First(&user, id).Error
@@ -52,7 +56,7 @@ func (s *SqlStorage) FindUserByID(id int, opts ...func(*gorm.DB) *gorm.DB) (User
 	return user, err
 }
 
-func (s *SqlStorage) FindUsersByIDs(ids []int, opts ...func(*gorm.DB) *gorm.DB) ([]User, error) {
+func (s *SqlStorage) FindUsersByIDs(ids []int, opts ...QueryOpt) ([]User, error) {
 	users := make([]User, 0)
 
 	if len(ids) == 0 {
@@ -65,15 +69,7 @@ func (s *SqlStorage) FindUsersByIDs(ids []int, opts ...func(*gorm.DB) *gorm.DB)
 	return users, err
 }
 
-func (s *SqlStorage) FindUsersByTicker(ticker Ticker, opts ...func(*gorm.DB) *gorm.DB) ([]User, error) {
-	users := make([]User, 0)
-	db := s.prepareDb(opts...)
-	err := db.Model(&ticker).Association("Users").Find(&users)
-
-	return users, err
-}
-
-func (s *SqlStorage) FindUserByEmail(email string, opts ...func(*gorm.DB) *gorm.DB) (User, error) {
+func (s *SqlStorage) FindUserByEmail(email string, opts ...QueryOpt) (User, error) {
 	var user User
 	db := s.prepareDb(opts...)
 	err := db.First(&user, "email = ?", email).Error
@@ -99,25 +95,31 @@ func (s *SqlStorage) DeleteUser(user User) error {
 	return s.DB.Delete(&user).Error
 }
 
-func (s *SqlStorage) DeleteTickerUsers(ticker *Ticker) error {
-	err := s.DB.Model(ticker).Association("Users").Clear()
+// --- Ticker <-> User membership -----------------------------------------
 
-	return err
+func (s *SqlStorage) FindUsersByTicker(ticker Ticker, opts ...QueryOpt) ([]User, error) {
+	users := make([]User, 0)
+	db := s.prepareDb(opts...)
+	err := db.Model(&ticker).Association("Users").Find(&users)
+
+	return users, err
 }
 
-func (s *SqlStorage) DeleteTickerUser(ticker *Ticker, user *User) error {
-	err := s.DB.Model(ticker).Association("Users").Delete(user)
+func (s *SqlStorage) DeleteTickerUsers(ticker *Ticker) error {
+	return s.DB.Model(ticker).Association("Users").Clear()
+}
 
-	return err
+func (s *SqlStorage) DeleteTickerUser(ticker *Ticker, user *User) error {
+	return s.DB.Model(ticker).Association("Users").Delete(user)
 }
 
 func (s *SqlStorage) AddTickerUser(ticker *Ticker, user *User) error {
-	err := s.DB.Model(ticker).Association("Users").Append(user)
-
-	return err
+	return s.DB.Model(ticker).Association("Users").Append(user)
 }
 
-func (s *SqlStorage) FindTickersByUser(user User, filter TickerFilter, opts ...func(*gorm.DB) *gorm.DB) ([]Ticker, error) {
+// --- Tickers -------------------------------------------------------------
+
+func (s *SqlStorage) FindTickersByUser(user User, filter TickerFilter, opts ...QueryOpt) ([]Ticker, error) {
 	tickers := make([]Ticker, 0)
 	db := s.prepareDb(opts...)
 
@@ -146,7 +148,7 @@ func (s *SqlStorage) FindTickersByUser(user User, filter TickerFilter, opts ...f
 	return tickers, err
 }
 
-func (s *SqlStorage) FindTickerByUserAndID(user User, id int, opts ...func(*gorm.DB) *gorm.DB) (Ticker, error) {
+func (s *SqlStorage) FindTickerByUserAndID(user User, id int, opts ...QueryOpt) (Ticker, error) {
 	db := s.prepareDb(opts...)
 
 	var ticker Ticker
@@ -160,7 +162,7 @@ func (s *SqlStorage) FindTickerByUserAndID(user User, id int, opts ...func(*gorm
 	return ticker, err
 }
 
-func (s *SqlStorage) FindTickersByIDs(ids []int, opts ...func(*gorm.DB) *gorm.DB) ([]Ticker, error) {
+func (s *SqlStorage) FindTickersByIDs(ids []int, opts ...QueryOpt) ([]Ticker, error) {
 	tickers := make([]Ticker, 0)
 	db := s.prepareDb(opts...)
 	err := db.Find(&tickers, ids).Error
@@ -168,7 +170,7 @@ func (s *SqlStorage) FindTickersByIDs(ids []int, opts ...func(*gorm.DB) *gorm.DB
 	return tickers, err
 }
 
-func (s *SqlStorage) FindTickerByOrigin(origin string, opts ...func(*gorm.DB) *gorm.DB) (Ticker, error) {
+func (s *SqlStorage) FindTickerByOrigin(origin string, opts ...QueryOpt) (Ticker, error) {
 	var ticker Ticker
 	db := s.prepareDb(opts...)
 
@@ -179,7 +181,7 @@ func (s *SqlStorage) FindTickerByOrigin(origin string, opts ...func(*gorm.DB) *g
 	return ticker, err
 }
 
-func (s *SqlStorage) FindTickerByID(id int, opts ...func(*gorm.DB) *gorm.DB) (Ticker, error) {
+func (s *SqlStorage) FindTickerByID(id int, opts ...QueryOpt) (Ticker, error) {
 	var ticker Ticker
 	db := s.prepareDb(opts...)
 
@@ -293,7 +295,7 @@ func (s *SqlStorage) deleteTickerAssociations(ticker *Ticker) error {
 		return err
 	}
 
-	if err := s.DeleteIntegrations(ticker); err != nil {
+	if err := s.ClearIntegrations(ticker); err != nil {
 		log.WithError(err).WithField("ticker_id", ticker.ID).Error("failed to delete ticker integrations")
 		return err
 	}
@@ -301,49 +303,7 @@ func (s *SqlStorage) deleteTickerAssociations(ticker *Ticker) error {
 	return nil
 }
 
-func (s *SqlStorage) DeleteIntegrations(ticker *Ticker) error {
-	if err := s.DeleteMastodon(ticker); err != nil {
-		return err
-	}
-
-	if err := s.DeleteTelegram(ticker); err != nil {
-		return err
-	}
-
-	if err := s.DeleteBluesky(ticker); err != nil {
-		return err
-	}
-
-	if err := s.DeleteSignalGroup(ticker); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (s *SqlStorage) DeleteMastodon(ticker *Ticker) error {
-	ticker.Mastodon = TickerMastodon{}
-
-	return s.DB.Delete(TickerMastodon{}, EqualTickerID, ticker.ID).Error
-}
-
-func (s *SqlStorage) DeleteTelegram(ticker *Ticker) error {
-	ticker.Telegram = TickerTelegram{}
-
-	return s.DB.Delete(TickerTelegram{}, EqualTickerID, ticker.ID).Error
-}
-
-func (s *SqlStorage) DeleteBluesky(ticker *Ticker) error {
-	ticker.Bluesky = TickerBluesky{}
-
-	return s.DB.Delete(TickerBluesky{}, EqualTickerID, ticker.ID).Error
-}
-
-func (s *SqlStorage) DeleteSignalGroup(ticker *Ticker) error {
-	ticker.SignalGroup = TickerSignalGroup{}
-
-	return s.DB.Delete(TickerSignalGroup{}, EqualTickerID, ticker.ID).Error
-}
+// --- Uploads -------------------------------------------------------------
 
 func (s *SqlStorage) FindUploadByUUID(uuid string) (Upload, error) {
 	var upload Upload
@@ -403,7 +363,9 @@ func (s *SqlStorage) DeleteUploadsByTicker(ticker *Ticker) error {
 	return nil
 }
 
-func (s *SqlStorage) FindMessage(tickerID, messageID int, opts ...func(*gorm.DB) *gorm.DB) (Message, error) {
+// --- Messages ------------------------------------------------------------
+
+func (s *SqlStorage) FindMessage(tickerID, messageID int, opts ...QueryOpt) (Message, error) {
 	var message Message
 	db := s.prepareDb(opts...)
 
@@ -412,7 +374,7 @@ func (s *SqlStorage) FindMessage(tickerID, messageID int, opts ...func(*gorm.DB)
 	return message, err
 }
 
-func (s *SqlStorage) FindMessagesByTicker(ticker Ticker, opts ...func(*gorm.DB) *gorm.DB) ([]Message, error) {
+func (s *SqlStorage) FindMessagesByTicker(ticker Ticker, opts ...QueryOpt) ([]Message, error) {
 	messages := make([]Message, 0)
 	db := s.prepareDb(opts...)
 
@@ -421,7 +383,7 @@ func (s *SqlStorage) FindMessagesByTicker(ticker Ticker, opts ...func(*gorm.DB)
 	return messages, err
 }
 
-func (s *SqlStorage) FindMessagesByTickerAndPagination(ticker Ticker, pagination pagination.Pagination, opts ...func(*gorm.DB) *gorm.DB) ([]Message, error) {
+func (s *SqlStorage) FindMessagesByTickerAndPagination(ticker Ticker, pagination pagination.Pagination, opts ...QueryOpt) ([]Message, error) {
 	messages := make([]Message, 0)
 	db := s.prepareDb(opts...)
 	query := db.Where(EqualTickerID, ticker.ID)
@@ -470,103 +432,9 @@ func (s *SqlStorage) DeleteMessages(ticker *Ticker) error {
 	return s.DB.Where(EqualTickerID, ticker.ID).Delete(&Message{}).Error
 }
 
-func (s *SqlStorage) GetInactiveSettings() InactiveSettings {
-	var setting Setting
-	err := s.DB.First(&setting, EqualName, SettingInactiveName).Error
-	if err != nil {
-		return DefaultInactiveSettings()
-	}
-
-	var inactiveSettings InactiveSettings
-	err = json.Unmarshal([]byte(setting.Value), &inactiveSettings)
-	if err != nil {
-		return DefaultInactiveSettings()
-	}
-
-	return inactiveSettings
-}
-
-func (s *SqlStorage) SaveInactiveSettings(inactiveSettings InactiveSettings) error {
-	var setting Setting
-	err := s.DB.First(&setting, EqualName, SettingInactiveName).Error
-	if err != nil {
-		setting = Setting{Name: SettingInactiveName}
-	}
-
-	value, err := json.Marshal(inactiveSettings)
-	if err != nil {
-		return err
-	}
-	setting.Value = string(value)
-
-	return s.DB.Save(&setting).Error
-}
-
-func (s *SqlStorage) GetTelegramSettings() TelegramSettings {
-	var setting Setting
-	err := s.DB.First(&setting, EqualName, SettingTelegramName).Error
-	if err != nil {
-		return DefaultTelegramSettings()
-	}
-
-	var telegramSettings TelegramSettings
-	err = json.Unmarshal([]byte(setting.Value), &telegramSettings)
-	if err != nil {
-		return DefaultTelegramSettings()
-	}
-
-	return telegramSettings
-}
-
-func (s *SqlStorage) SaveTelegramSettings(telegramSettings TelegramSettings) error {
-	var setting Setting
-	err := s.DB.First(&setting, EqualName, SettingTelegramName).Error
-	if err != nil {
-		setting = Setting{Name: SettingTelegramName}
-	}
-
-	value, err := json.Marshal(telegramSettings)
-	if err != nil {
-		return err
-	}
-	setting.Value = string(value)
-
-	return s.DB.Save(&setting).Error
-}
-
-func (s *SqlStorage) GetSignalGroupSettings() SignalGroupSettings {
-	var setting Setting
-	err := s.DB.First(&setting, EqualName, SettingSignalGroupName).Error
-	if err != nil {
-		return DefaultSignalGroupSettings()
-	}
-
-	var signalGroupSettings SignalGroupSettings
-	err = json.Unmarshal([]byte(setting.Value), &signalGroupSettings)
-	if err != nil {
-		return DefaultSignalGroupSettings()
-	}
-
-	return signalGroupSettings
-}
-
-func (s *SqlStorage) SaveSignalGroupSettings(signalGroupSettings SignalGroupSettings) error {
-	var setting Setting
-	err := s.DB.First(&setting, EqualName, SettingSignalGroupName).Error
-	if err != nil {
-		setting = Setting{Name: SettingSignalGroupName}
-	}
-
-	value, err := json.Marshal(signalGroupSettings)
-	if err != nil {
-		return err
-	}
-	setting.Value = string(value)
-
-	return s.DB.Save(&setting).Error
-}
+// --- Internals -----------------------------------------------------------
 
-func (s *SqlStorage) prepareDb(opts ...func(*gorm.DB) *gorm.DB) *gorm.DB {
+func (s *SqlStorage) prepareDb(opts ...QueryOpt) *gorm.DB {
 	db := s.DB
 	for _, opt := range opts {
 		db = opt(db)
@@ -576,21 +444,21 @@ func (s *SqlStorage) prepareDb(opts ...func(*gorm.DB) *gorm.DB) *gorm.DB {
 }
 
 // WithPreload is a helper function to preload all associations.
-func WithPreload() func(*gorm.DB) *gorm.DB {
+func WithPreload() QueryOpt {
 	return func(db *gorm.DB) *gorm.DB {
 		return db.Preload(clause.Associations)
 	}
 }
 
 // WithAttachments is a helper function to preload the attachments association.
-func WithAttachments() func(*gorm.DB) *gorm.DB {
+func WithAttachments() QueryOpt {
 	return func(db *gorm.DB) *gorm.DB {
 		return db.Preload("Attachments")
 	}
 }
 
 // WithTickers is a helper function to preload the tickers association.
-func WithTickers() func(*gorm.DB) *gorm.DB {
+func WithTickers() QueryOpt {
 	return func(db *gorm.DB) *gorm.DB {
 		return db.Preload("Tickers")
 	}
diff --git a/internal/storage/sql_storage_test.go b/internal/storage/sql_storage_test.go
index 5f594117..ac3be66b 100644
--- a/internal/storage/sql_storage_test.go
+++ b/internal/storage/sql_storage_test.go
@@ -705,7 +705,7 @@ func (s *SqlStorageTestSuite) TestSaveTicker() {
 	})
 }
 
-func (s *SqlStorageTestSuite) TestDeleteIntegrations() {
+func (s *SqlStorageTestSuite) TestClearIntegrations() {
 	s.Run("when ticker is resetting integrations", func() {
 		var telegramCount, mastodonCount, blueskyCount, signalGroupCount int64
 
@@ -740,7 +740,7 @@ func (s *SqlStorageTestSuite) TestDeleteIntegrations() {
 		s.Equal("group_id", ticker.SignalGroup.GroupID)
 		s.Equal("group_invite_link", ticker.SignalGroup.GroupInviteLink)
 
-		err = s.store.DeleteIntegrations(&ticker)
+		err = s.store.ClearIntegrations(&ticker)
 		s.NoError(err)
 
 		s.False(ticker.Telegram.Active)
@@ -1397,7 +1397,7 @@ func (s *SqlStorageTestSuite) TestDeleteMessages() {
 
 func (s *SqlStorageTestSuite) TestGetInactiveSettings() {
 	s.Run("when no settings exist", func() {
-		settings := s.store.GetInactiveSettings()
+		settings := GetSettings(s.store, InactiveSetting)
 		s.Equal(DefaultInactiveSettings().Author, settings.Author)
 	})
 
@@ -1406,7 +1406,7 @@ func (s *SqlStorageTestSuite) TestGetInactiveSettings() {
 		err := s.db.Create(&setting).Error
 		s.NoError(err)
 
-		settings := s.store.GetInactiveSettings()
+		settings := GetSettings(s.store, InactiveSetting)
 		s.Equal("test", settings.Author)
 	})
 }
@@ -1415,7 +1415,7 @@ func (s *SqlStorageTestSuite) TestSaveInactiveSettings() {
 	settings := InactiveSettings{Author: "test"}
 
 	s.Run("when settings are new", func() {
-		err := s.store.SaveInactiveSettings(settings)
+		err := SaveSettings(s.store, InactiveSetting, settings)
 		s.NoError(err)
 
 		var count int64
@@ -1426,7 +1426,7 @@ func (s *SqlStorageTestSuite) TestSaveInactiveSettings() {
 
 	s.Run("when settings are existing", func() {
 		settings.Author = "test2"
-		err := s.store.SaveInactiveSettings(settings)
+		err := SaveSettings(s.store, InactiveSetting, settings)
 		s.NoError(err)
 
 		var count int64
@@ -1439,7 +1439,7 @@ func (s *SqlStorageTestSuite) TestSaveInactiveSettings() {
 
 func (s *SqlStorageTestSuite) TestGetTelegramSettings() {
 	s.Run("when no settings exist", func() {
-		settings := s.store.GetTelegramSettings()
+		settings := GetSettings(s.store, TelegramSetting)
 		s.Equal("", settings.Token)
 		s.Equal("", settings.BotUsername)
 	})
@@ -1449,7 +1449,7 @@ func (s *SqlStorageTestSuite) TestGetTelegramSettings() {
 		err := s.db.Create(&setting).Error
 		s.NoError(err)
 
-		settings := s.store.GetTelegramSettings()
+		settings := GetSettings(s.store, TelegramSetting)
 		s.Equal("123456789:ABCdefGHIjklMNOpqrsTUVwxyz", settings.Token)
 		s.Equal("test_bot", settings.BotUsername)
 
@@ -1462,7 +1462,7 @@ func (s *SqlStorageTestSuite) TestGetTelegramSettings() {
 		err := s.db.Create(&setting).Error
 		s.NoError(err)
 
-		settings := s.store.GetTelegramSettings()
+		settings := GetSettings(s.store, TelegramSetting)
 		s.Equal("", settings.Token)
 		s.Equal("", settings.BotUsername)
 
@@ -1475,7 +1475,7 @@ func (s *SqlStorageTestSuite) TestSaveTelegramSettings() {
 	settings := TelegramSettings{Token: "123456789:ABCdefGHIjklMNOpqrsTUVwxyz", BotUsername: "test_bot"}
 
 	s.Run("when settings are new", func() {
-		err := s.store.SaveTelegramSettings(settings)
+		err := SaveSettings(s.store, TelegramSetting, settings)
 		s.NoError(err)
 
 		var count int64
@@ -1494,7 +1494,7 @@ func (s *SqlStorageTestSuite) TestSaveTelegramSettings() {
 	s.Run("when settings are existing", func() {
 		settings.Token = "987654321:ZYXwvuTSRqponMLKjihGFeDcba"
 		settings.BotUsername = "updated_bot"
-		err := s.store.SaveTelegramSettings(settings)
+		err := SaveSettings(s.store, TelegramSetting, settings)
 		s.NoError(err)
 
 		var count int64
@@ -1502,17 +1502,17 @@ func (s *SqlStorageTestSuite) TestSaveTelegramSettings() {
 		s.NoError(err)
 		s.Equal(int64(1), count)
 
-		retrievedSettings := s.store.GetTelegramSettings()
+		retrievedSettings := GetSettings(s.store, TelegramSetting)
 		s.Equal("987654321:ZYXwvuTSRqponMLKjihGFeDcba", retrievedSettings.Token)
 		s.Equal("updated_bot", retrievedSettings.BotUsername)
 	})
 
 	s.Run("when saving empty token", func() {
 		emptySettings := TelegramSettings{Token: "", BotUsername: ""}
-		err := s.store.SaveTelegramSettings(emptySettings)
+		err := SaveSettings(s.store, TelegramSetting, emptySettings)
 		s.NoError(err)
 
-		retrievedSettings := s.store.GetTelegramSettings()
+		retrievedSettings := GetSettings(s.store, TelegramSetting)
 		s.Equal("", retrievedSettings.Token)
 		s.Equal("", retrievedSettings.BotUsername)
 	})
@@ -1520,7 +1520,7 @@ func (s *SqlStorageTestSuite) TestSaveTelegramSettings() {
 
 func (s *SqlStorageTestSuite) TestGetSignalGroupSettings() {
 	s.Run("when no settings exist", func() {
-		settings := s.store.GetSignalGroupSettings()
+		settings := GetSettings(s.store, SignalGroupSetting)
 		s.Equal("", settings.ApiUrl)
 		s.Equal("", settings.Account)
 		s.Equal("", settings.Avatar)
@@ -1531,7 +1531,7 @@ func (s *SqlStorageTestSuite) TestGetSignalGroupSettings() {
 		err := s.db.Create(&setting).Error
 		s.NoError(err)
 
-		settings := s.store.GetSignalGroupSettings()
+		settings := GetSettings(s.store, SignalGroupSetting)
 		s.Equal("https://signal-cli.example.org/api/v1/rpc", settings.ApiUrl)
 		s.Equal("+491234567890", settings.Account)
 		s.Equal("/path/to/avatar.png", settings.Avatar)
@@ -1545,7 +1545,7 @@ func (s *SqlStorageTestSuite) TestGetSignalGroupSettings() {
 		err := s.db.Create(&setting).Error
 		s.NoError(err)
 
-		settings := s.store.GetSignalGroupSettings()
+		settings := GetSettings(s.store, SignalGroupSetting)
 		s.Equal("", settings.ApiUrl)
 		s.Equal("", settings.Account)
 		s.Equal("", settings.Avatar)
@@ -1559,7 +1559,7 @@ func (s *SqlStorageTestSuite) TestSaveSignalGroupSettings() {
 	settings := SignalGroupSettings{ApiUrl: "https://signal-cli.example.org/api/v1/rpc", Account: "+491234567890", Avatar: "/path/to/avatar.png"}
 
 	s.Run("when settings are new", func() {
-		err := s.store.SaveSignalGroupSettings(settings)
+		err := SaveSettings(s.store, SignalGroupSetting, settings)
 		s.NoError(err)
 
 		var count int64
@@ -1580,7 +1580,7 @@ func (s *SqlStorageTestSuite) TestSaveSignalGroupSettings() {
 		settings.ApiUrl = "https://new-signal-cli.example.org/api/v1/rpc"
 		settings.Account = "+490987654321"
 		settings.Avatar = "/new/path/avatar.png"
-		err := s.store.SaveSignalGroupSettings(settings)
+		err := SaveSettings(s.store, SignalGroupSetting, settings)
 		s.NoError(err)
 
 		var count int64
@@ -1588,7 +1588,7 @@ func (s *SqlStorageTestSuite) TestSaveSignalGroupSettings() {
 		s.NoError(err)
 		s.Equal(int64(1), count)
 
-		retrievedSettings := s.store.GetSignalGroupSettings()
+		retrievedSettings := GetSettings(s.store, SignalGroupSetting)
 		s.Equal("https://new-signal-cli.example.org/api/v1/rpc", retrievedSettings.ApiUrl)
 		s.Equal("+490987654321", retrievedSettings.Account)
 		s.Equal("/new/path/avatar.png", retrievedSettings.Avatar)
@@ -1596,10 +1596,10 @@ func (s *SqlStorageTestSuite) TestSaveSignalGroupSettings() {
 
 	s.Run("when saving empty settings", func() {
 		emptySettings := SignalGroupSettings{ApiUrl: "", Account: "", Avatar: ""}
-		err := s.store.SaveSignalGroupSettings(emptySettings)
+		err := SaveSettings(s.store, SignalGroupSetting, emptySettings)
 		s.NoError(err)
 
-		retrievedSettings := s.store.GetSignalGroupSettings()
+		retrievedSettings := GetSettings(s.store, SignalGroupSetting)
 		s.Equal("", retrievedSettings.ApiUrl)
 		s.Equal("", retrievedSettings.Account)
 		s.Equal("", retrievedSettings.Avatar)
diff --git a/internal/storage/storage.go b/internal/storage/storage.go
deleted file mode 100644
index 9918b015..00000000
--- a/internal/storage/storage.go
+++ /dev/null
@@ -1,56 +0,0 @@
-package storage
-
-import (
-	"github.com/systemli/ticker/internal/api/pagination"
-	"github.com/systemli/ticker/internal/logger"
-	"gorm.io/gorm"
-)
-
-var log = logger.GetWithPackage("storage")
-
-type Storage interface {
-	FindUsers(filter UserFilter, opts ...func(*gorm.DB) *gorm.DB) ([]User, error)
-	FindUserByID(id int, opts ...func(*gorm.DB) *gorm.DB) (User, error)
-	FindUsersByIDs(ids []int, opts ...func(*gorm.DB) *gorm.DB) ([]User, error)
-	FindUserByEmail(email string, opts ...func(*gorm.DB) *gorm.DB) (User, error)
-	FindUsersByTicker(ticker Ticker, opts ...func(*gorm.DB) *gorm.DB) ([]User, error)
-	SaveUser(user *User) error
-	DeleteUser(user User) error
-	DeleteTickerUsers(ticker *Ticker) error
-	DeleteTickerUser(ticker *Ticker, user *User) error
-	AddTickerUser(ticker *Ticker, user *User) error
-	FindTickersByUser(user User, filter TickerFilter, opts ...func(*gorm.DB) *gorm.DB) ([]Ticker, error)
-	FindTickerByUserAndID(user User, id int, opts ...func(*gorm.DB) *gorm.DB) (Ticker, error)
-	FindTickersByIDs(ids []int, opts ...func(*gorm.DB) *gorm.DB) ([]Ticker, error)
-	FindTickerByOrigin(origin string, opts ...func(*gorm.DB) *gorm.DB) (Ticker, error)
-	FindTickerByID(id int, opts ...func(*gorm.DB) *gorm.DB) (Ticker, error)
-	SaveTicker(ticker *Ticker) error
-	DeleteTicker(ticker *Ticker) error
-	SaveTickerWebsites(ticker *Ticker, websites []TickerWebsite) error
-	DeleteTickerWebsites(ticker *Ticker) error
-	ResetTicker(ticker *Ticker) error
-	DeleteIntegrations(ticker *Ticker) error
-	DeleteMastodon(ticker *Ticker) error
-	DeleteTelegram(ticker *Ticker) error
-	DeleteBluesky(ticker *Ticker) error
-	DeleteSignalGroup(ticker *Ticker) error
-	SaveUpload(upload *Upload) error
-	FindUploadByUUID(uuid string) (Upload, error)
-	FindUploadsByIDs(ids []int) ([]Upload, error)
-	DeleteUpload(upload Upload) error
-	DeleteUploads(uploads []Upload)
-	DeleteUploadsByTicker(ticker *Ticker) error
-	FindMessage(tickerID, messageID int, opts ...func(*gorm.DB) *gorm.DB) (Message, error)
-	FindMessagesByTicker(ticker Ticker, opts ...func(*gorm.DB) *gorm.DB) ([]Message, error)
-	FindMessagesByTickerAndPagination(ticker Ticker, pagination pagination.Pagination, opts ...func(*gorm.DB) *gorm.DB) ([]Message, error)
-	SaveMessage(message *Message) error
-	DeleteMessage(message Message) error
-	DeleteMessages(ticker *Ticker) error
-	GetInactiveSettings() InactiveSettings
-	SaveInactiveSettings(inactiveSettings InactiveSettings) error
-	GetTelegramSettings() TelegramSettings
-	SaveTelegramSettings(telegramSettings TelegramSettings) error
-	GetSignalGroupSettings() SignalGroupSettings
-	SaveSignalGroupSettings(signalGroupSettings SignalGroupSettings) error
-	UploadPath() string
-}
diff --git a/internal/storage/stores.go b/internal/storage/stores.go
new file mode 100644
index 00000000..3b02bb5e
--- /dev/null
+++ b/internal/storage/stores.go
@@ -0,0 +1,24 @@
+package storage
+
+// Stores is the aggregate of per-aggregate stores carried by handlers, the
+// bridge layer, and command-line entry points. Every field is an interface so
+// individual stores can be swapped in tests.
+type Stores struct {
+	Users    UserStore
+	Tickers  TickerStore
+	Messages MessageStore
+	Uploads  UploadStore
+	Settings SettingsStore
+}
+
+// NewStores wires every store against the same *SqlStorage. Production code
+// uses this; tests build a Stores value with per-store mocks.
+func NewStores(s *SqlStorage) Stores {
+	return Stores{
+		Users:    s,
+		Tickers:  s,
+		Messages: s,
+		Uploads:  s,
+		Settings: s,
+	}
+}
diff --git a/internal/storage/ticker_store.go b/internal/storage/ticker_store.go
new file mode 100644
index 00000000..d7f1a3c8
--- /dev/null
+++ b/internal/storage/ticker_store.go
@@ -0,0 +1,60 @@
+package storage
+
+// TickerStore covers Ticker CRUD, its sub-collections (websites), the integration
+// configs (Telegram/Mastodon/Bluesky/SignalGroup), and User<->Ticker membership.
+type TickerStore interface {
+	// Tickers
+	FindTickersByUser(user User, filter TickerFilter, opts ...QueryOpt) ([]Ticker, error)
+	FindTickerByUserAndID(user User, id int, opts ...QueryOpt) (Ticker, error)
+	FindTickersByIDs(ids []int, opts ...QueryOpt) ([]Ticker, error)
+	FindTickerByOrigin(origin string, opts ...QueryOpt) (Ticker, error)
+	FindTickerByID(id int, opts ...QueryOpt) (Ticker, error)
+	SaveTicker(ticker *Ticker) error
+	DeleteTicker(ticker *Ticker) error
+	ResetTicker(ticker *Ticker) error
+
+	// Websites (sub-collection)
+	SaveTickerWebsites(ticker *Ticker, websites []TickerWebsite) error
+	DeleteTickerWebsites(ticker *Ticker) error
+
+	// Integration configs
+	ClearIntegration(ticker *Ticker, integration Integration) error
+	ClearIntegrations(ticker *Ticker) error
+
+	// Membership (M:N with User)
+	FindUsersByTicker(ticker Ticker, opts ...QueryOpt) ([]User, error)
+	AddTickerUser(ticker *Ticker, user *User) error
+	DeleteTickerUser(ticker *Ticker, user *User) error
+	DeleteTickerUsers(ticker *Ticker) error
+}
+
+// ClearIntegration removes the configuration row for a single integration on
+// the given ticker.
+func (s *SqlStorage) ClearIntegration(ticker *Ticker, integration Integration) error {
+	switch integration {
+	case IntegrationTelegram:
+		ticker.Telegram = TickerTelegram{}
+		return s.DB.Delete(TickerTelegram{}, EqualTickerID, ticker.ID).Error
+	case IntegrationMastodon:
+		ticker.Mastodon = TickerMastodon{}
+		return s.DB.Delete(TickerMastodon{}, EqualTickerID, ticker.ID).Error
+	case IntegrationBluesky:
+		ticker.Bluesky = TickerBluesky{}
+		return s.DB.Delete(TickerBluesky{}, EqualTickerID, ticker.ID).Error
+	case IntegrationSignalGroup:
+		ticker.SignalGroup = TickerSignalGroup{}
+		return s.DB.Delete(TickerSignalGroup{}, EqualTickerID, ticker.ID).Error
+	}
+	return nil
+}
+
+// ClearIntegrations clears every configured integration on the ticker.
+func (s *SqlStorage) ClearIntegrations(ticker *Ticker) error {
+	for _, integration := range AllIntegrations {
+		if err := s.ClearIntegration(ticker, integration); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
diff --git a/internal/storage/upload_store.go b/internal/storage/upload_store.go
new file mode 100644
index 00000000..c6954293
--- /dev/null
+++ b/internal/storage/upload_store.go
@@ -0,0 +1,13 @@
+package storage
+
+// UploadStore covers Upload CRUD and the filesystem path where uploads live.
+type UploadStore interface {
+	SaveUpload(upload *Upload) error
+	FindUploadByUUID(uuid string) (Upload, error)
+	FindUploadsByIDs(ids []int) ([]Upload, error)
+	DeleteUpload(upload Upload) error
+	DeleteUploads(uploads []Upload)
+	DeleteUploadsByTicker(ticker *Ticker) error
+
+	UploadPath() string
+}
diff --git a/internal/storage/user_store.go b/internal/storage/user_store.go
new file mode 100644
index 00000000..e210048a
--- /dev/null
+++ b/internal/storage/user_store.go
@@ -0,0 +1,12 @@
+package storage
+
+// UserStore covers User CRUD and lookups. Membership of users on a Ticker
+// is owned by TickerStore.
+type UserStore interface {
+	FindUsers(filter UserFilter, opts ...QueryOpt) ([]User, error)
+	FindUserByID(id int, opts ...QueryOpt) (User, error)
+	FindUsersByIDs(ids []int, opts ...QueryOpt) ([]User, error)
+	FindUserByEmail(email string, opts ...QueryOpt) (User, error)
+	SaveUser(user *User) error
+	DeleteUser(user User) error
+}
diff --git a/internal/util/file.go b/internal/util/file.go
index 3f1b97b2..ef472055 100644
--- a/internal/util/file.go
+++ b/internal/util/file.go
@@ -5,7 +5,7 @@ import (
 	"net/http"
 )
 
-//DetectContentType detects the ContentType from the first 512 bytes of the given io.Reader.
+// DetectContentType detects the ContentType from the first 512 bytes of the given io.Reader.
 func DetectContentType(r io.Reader) string {
 	// Only the first 512 bytes are used to sniff the content type.
 	buffer := make([]byte, 512)