remove notifs package (#970)

This is part of indexer stuff which isn't actually used anywhere.

cmd/bigsky/main.go

···
 	"github.com/bluesky-social/indigo/did"
 	"github.com/bluesky-social/indigo/events"
 	"github.com/bluesky-social/indigo/indexer"
-	"github.com/bluesky-social/indigo/notifs"
 	"github.com/bluesky-social/indigo/plc"
 	"github.com/bluesky-social/indigo/repomgr"
 	"github.com/bluesky-social/indigo/util"
···
 
 	evtman := events.NewEventManager(persister)
 
-	notifman := &notifs.NullNotifs{}
-
 	rf := indexer.NewRepoFetcher(db, repoman, cctx.Int("max-fetch-concurrency"))
 
-	ix, err := indexer.NewIndexer(db, notifman, evtman, cachedidr, rf, true, false, cctx.Bool("spidering"))
+	ix, err := indexer.NewIndexer(db, evtman, cachedidr, rf, true, false, cctx.Bool("spidering"))
 	if err != nil {
 		return err
 	}

indexer/indexer.go

···
 	"github.com/bluesky-social/indigo/events"
 	lexutil "github.com/bluesky-social/indigo/lex/util"
 	"github.com/bluesky-social/indigo/models"
-	"github.com/bluesky-social/indigo/notifs"
 	"github.com/bluesky-social/indigo/repomgr"
 	"github.com/bluesky-social/indigo/util"
 	"github.com/bluesky-social/indigo/xrpc"
···
 type Indexer struct {
 	db *gorm.DB
 
-	notifman notifs.NotificationManager
-	events   *events.EventManager
-	didr     did.Resolver
+	events *events.EventManager
+	didr   did.Resolver
 
 	Crawler *CrawlDispatcher
 
···
 	log *slog.Logger
 }
 
-func NewIndexer(db *gorm.DB, notifman notifs.NotificationManager, evtman *events.EventManager, didr did.Resolver, fetcher *RepoFetcher, crawl, aggregate, spider bool) (*Indexer, error) {
+func NewIndexer(db *gorm.DB, evtman *events.EventManager, didr did.Resolver, fetcher *RepoFetcher, crawl, aggregate, spider bool) (*Indexer, error) {
 	db.AutoMigrate(&models.FeedPost{})
 	db.AutoMigrate(&models.ActorInfo{})
 	db.AutoMigrate(&models.FollowRecord{})
···
 
 	ix := &Indexer{
 		db:             db,
-		notifman:       notifman,
 		events:         evtman,
 		didr:           didr,
 		doAggregations: aggregate,
···
 		if err := ix.db.Where("reposter = ? AND rkey = ?", evt.User, op.Rkey).Delete(&models.RepostRecord{}).Error; err != nil {
 			return err
 		}
-
-		ix.log.Warn("TODO: remove notifications on delete")
-		/*
-		   if err := ix.notifman.RemoveRepost(ctx, fp.Author, rr.ID, evt.User); err != nil {
-		           return nil, err
-		   }
-		*/
-
 	case "app.bsky.feed.vote":
 		return ix.handleRecordDeleteFeedLike(ctx, evt, op)
 	case "app.bsky.graph.follow":
···
 			return nil, err
 		}
 
-		if err := ix.notifman.AddRepost(ctx, fp.Author, rr.ID, evt.User); err != nil {
-			return nil, err
-		}
-
 	case *bsky.FeedLike:
 		return nil, ix.handleRecordCreateFeedLike(ctx, rec, evt, op)
 	case *bsky.GraphFollow:
···
 		Cid:      op.RecCid.String(),
 	}
 	if err := ix.db.Create(&fr).Error; err != nil {
-		return err
-	}
-
-	if err := ix.notifman.AddFollow(ctx, fr.Follower, fr.Target, fr.ID); err != nil {
 		return err
 	}
 
···
 
 func (ix *Indexer) addNewPostNotification(ctx context.Context, post *bsky.FeedPost, fp *models.FeedPost, mentions []*models.ActorInfo) error {
 	if post.Reply != nil {
-		replyto, err := ix.GetPost(ctx, post.Reply.Parent.Uri)
+		_, err := ix.GetPost(ctx, post.Reply.Parent.Uri)
 		if err != nil {
 			ix.log.Error("probably shouldn't error when processing a reply to a not-found post")
 			return err
 		}
-
-		if err := ix.notifman.AddReplyTo(ctx, fp.Author, fp.ID, replyto); err != nil {
-			return err
-		}
-	}
-
-	for _, mentioned := range mentions {
-		if err := ix.notifman.AddMention(ctx, fp.Author, fp.ID, mentioned.Uid); err != nil {
-			return err
-		}
 	}
 
 	return nil
 }
 
 func (ix *Indexer) addNewVoteNotification(ctx context.Context, postauthor models.Uid, vr *models.VoteRecord) error {
-	return ix.notifman.AddUpVote(ctx, vr.Voter, vr.Post, vr.ID, postauthor)
+	return nil
 }

indexer/posts_test.go

···
 	bsky "github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/carstore"
 	"github.com/bluesky-social/indigo/events"
-	"github.com/bluesky-social/indigo/notifs"
 	"github.com/bluesky-social/indigo/plc"
 	"github.com/bluesky-social/indigo/repomgr"
 	"github.com/bluesky-social/indigo/util"
···
 	}
 
 	repoman := repomgr.NewRepoManager(cs, &util.FakeKeyManager{})
-	notifman := notifs.NewNotificationManager(maindb, repoman.GetRecord)
 	evtman := events.NewEventManager(events.NewMemPersister())
 
 	didr := testPLC(t)
 
 	rf := NewRepoFetcher(maindb, repoman, 10)
 
-	ix, err := NewIndexer(maindb, notifman, evtman, didr, rf, false, true, true)
+	ix, err := NewIndexer(maindb, evtman, didr, rf, false, true, true)
 	if err != nil {
 		t.Fatal(err)
 	}

notifs/notifs.go

···
-package notifs
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	appbskytypes "github.com/bluesky-social/indigo/api/bsky"
-	lexutil "github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/models"
-	"github.com/ipfs/go-cid"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-)
-
-type NotificationManager interface {
-	GetNotifications(ctx context.Context, user models.Uid) ([]*appbskytypes.NotificationListNotifications_Notification, error)
-	GetCount(ctx context.Context, user models.Uid) (int64, error)
-	UpdateSeen(ctx context.Context, usr models.Uid, seen time.Time) error
-	AddReplyTo(ctx context.Context, user models.Uid, replyid uint, replyto *models.FeedPost) error
-	AddMention(ctx context.Context, user models.Uid, postid uint, mentioned models.Uid) error
-	AddUpVote(ctx context.Context, voter models.Uid, postid uint, voteid uint, postauthor models.Uid) error
-	AddFollow(ctx context.Context, follower, followed models.Uid, recid uint) error
-	AddRepost(ctx context.Context, op models.Uid, repost uint, reposter models.Uid) error
-}
-
-var _ NotificationManager = (*DBNotifMan)(nil)
-
-type DBNotifMan struct {
-	db *gorm.DB
-
-	getRecord GetRecord
-}
-type GetRecord func(ctx context.Context, user models.Uid, collection string, rkey string, maybeCid cid.Cid) (cid.Cid, cbg.CBORMarshaler, error)
-
-func NewNotificationManager(db *gorm.DB, getrec GetRecord) *DBNotifMan {
-
-	db.AutoMigrate(&NotifRecord{})
-	db.AutoMigrate(&NotifSeen{})
-
-	return &DBNotifMan{
-		db:        db,
-		getRecord: getrec,
-	}
-}
-
-const (
-	NotifKindReply   = 1
-	NotifKindMention = 2
-	NotifKindUpVote  = 3
-	NotifKindFollow  = 4
-	NotifKindRepost  = 5
-)
-
-type NotifRecord struct {
-	gorm.Model
-	For     models.Uid
-	Kind    int64
-	Record  uint
-	Who     models.Uid
-	ReplyTo uint
-}
-
-type NotifSeen struct {
-	ID       uint       `gorm:"primarykey"`
-	Usr      models.Uid `gorm:"uniqueIndex"`
-	LastSeen time.Time
-}
-
-type HydratedNotification struct {
-	Record        any
-	IsRead        bool
-	IndexedAt     time.Time
-	Uri           string
-	Cid           string
-	Author        *appbskytypes.ActorDefs_ProfileViewBasic
-	Reason        string
-	ReasonSubject *string
-}
-
-func (nm *DBNotifMan) GetNotifications(ctx context.Context, user models.Uid) ([]*appbskytypes.NotificationListNotifications_Notification, error) {
-	var lastSeen time.Time
-	if err := nm.db.Model(NotifSeen{}).Where("usr = ?", user).Select("last_seen").Scan(&lastSeen).Error; err != nil {
-		return nil, err
-	}
-
-	var notifs []NotifRecord
-	if err := nm.db.Order("created_at desc").Find(&notifs, "for = ?", user).Error; err != nil {
-		return nil, err
-	}
-
-	/*
-		Record        any                `json:"record" cborgen:"record"`
-		IsRead        bool               `json:"isRead" cborgen:"isRead"`
-		IndexedAt     string             `json:"indexedAt" cborgen:"indexedAt"`
-		Uri           string             `json:"uri" cborgen:"uri"`
-		Cid           string             `json:"cid" cborgen:"cid"`
-		Author        *ActorRef_WithInfo `json:"author" cborgen:"author"`
-		Reason        string             `json:"reason" cborgen:"reason"`
-		ReasonSubject *string            `json:"reasonSubject" cborgen:"reasonSubject"`
-	*/
-
-	out := []*appbskytypes.NotificationListNotifications_Notification{}
-
-	for _, n := range notifs {
-		hn, err := nm.hydrateNotification(ctx, &n, lastSeen)
-		if err != nil {
-			return nil, err
-		}
-
-		// TODO: muting
-		hn.Author.Viewer = &appbskytypes.ActorDefs_ViewerState{}
-
-		out = append(out, hn)
-	}
-	return out, nil
-}
-
-func (nm *DBNotifMan) hydrateNotification(ctx context.Context, nrec *NotifRecord, lastSeen time.Time) (*appbskytypes.NotificationListNotifications_Notification, error) {
-
-	switch nrec.Kind {
-	case NotifKindReply:
-		return nm.hydrateNotificationReply(ctx, nrec, lastSeen)
-	case NotifKindFollow:
-		return nm.hydrateNotificationFollow(ctx, nrec, lastSeen)
-	case NotifKindUpVote:
-		return nm.hydrateNotificationUpVote(ctx, nrec, lastSeen)
-	case NotifKindRepost:
-		return nm.hydrateNotificationRepost(ctx, nrec, lastSeen)
-		/*
-			case NotifKindMention:
-				return nm.hydrateNotificationMention(ctx, nrec, lastSeen)
-		*/
-	default:
-		return nil, fmt.Errorf("attempted to hydrate unknown notif kind: %d", nrec.Kind)
-	}
-}
-func (nm *DBNotifMan) getActor(ctx context.Context, act models.Uid) (*models.ActorInfo, error) {
-	var ai models.ActorInfo
-	if err := nm.db.First(&ai, "uid = ?", act).Error; err != nil {
-		return nil, err
-	}
-
-	return &ai, nil
-}
-
-func (nm *DBNotifMan) hydrateNotificationUpVote(ctx context.Context, nrec *NotifRecord, lastSeen time.Time) (*appbskytypes.NotificationListNotifications_Notification, error) {
-	var votedOn models.FeedPost
-	if err := nm.db.First(&votedOn, "id = ?", nrec.Record).Error; err != nil {
-		return nil, err
-	}
-
-	voter, err := nm.getActor(ctx, nrec.Who)
-	if err != nil {
-		return nil, err
-	}
-
-	var vote models.VoteRecord
-	if err := nm.db.First(&vote, "id = ?", nrec.Record).Error; err != nil {
-		return nil, err
-	}
-
-	_, rec, err := nm.getRecord(ctx, voter.Uid, "app.bsky.feed.vote", vote.Rkey, cid.Undef)
-	if err != nil {
-		return nil, fmt.Errorf("getting vote: %w", err)
-	}
-
-	postAuthor, err := nm.getActor(ctx, votedOn.Author)
-	if err != nil {
-		return nil, err
-	}
-
-	rsub := "at://" + postAuthor.Did + "/app.bsky.feed.post/" + votedOn.Rkey
-
-	return &appbskytypes.NotificationListNotifications_Notification{
-		Record:        &lexutil.LexiconTypeDecoder{Val: rec},
-		IsRead:        nrec.CreatedAt.Before(lastSeen),
-		IndexedAt:     nrec.CreatedAt.Format(time.RFC3339),
-		Uri:           "at://" + voter.Did + "/app.bsky.feed.vote/" + vote.Rkey,
-		Cid:           vote.Cid,
-		Author:        voter.ActorView(),
-		Reason:        "vote",
-		ReasonSubject: &rsub,
-	}, nil
-}
-
-func (nm *DBNotifMan) hydrateNotificationRepost(ctx context.Context, nrec *NotifRecord, lastSeen time.Time) (*appbskytypes.NotificationListNotifications_Notification, error) {
-	var reposted models.FeedPost
-	if err := nm.db.First(&reposted, "id = ?", nrec.Record).Error; err != nil {
-		return nil, err
-	}
-
-	reposter, err := nm.getActor(ctx, nrec.Who)
-	if err != nil {
-		return nil, err
-	}
-
-	var repost models.RepostRecord
-	if err := nm.db.First(&repost, "id = ?", nrec.Record).Error; err != nil {
-		return nil, err
-	}
-
-	_, rec, err := nm.getRecord(ctx, reposter.Uid, "app.bsky.feed.repost", repost.Rkey, cid.Undef)
-	if err != nil {
-		return nil, fmt.Errorf("getting repost: %w", err)
-	}
-
-	postAuthor, err := nm.getActor(ctx, repost.Author)
-	if err != nil {
-		return nil, err
-	}
-
-	rsub := "at://" + postAuthor.Did + "/app.bsky.feed.post/" + reposted.Rkey
-
-	return &appbskytypes.NotificationListNotifications_Notification{
-		Record:        &lexutil.LexiconTypeDecoder{Val: rec},
-		IsRead:        nrec.CreatedAt.Before(lastSeen),
-		IndexedAt:     nrec.CreatedAt.Format(time.RFC3339),
-		Uri:           "at://" + reposter.Did + "/app.bsky.feed.repost/" + repost.Rkey,
-		Cid:           repost.RecCid,
-		Author:        reposter.ActorView(),
-		Reason:        "repost",
-		ReasonSubject: &rsub,
-	}, nil
-}
-
-func (nm *DBNotifMan) hydrateNotificationReply(ctx context.Context, nrec *NotifRecord, lastSeen time.Time) (*appbskytypes.NotificationListNotifications_Notification, error) {
-	var fp models.FeedPost
-	if err := nm.db.First(&fp, "id = ?", nrec.Record).Error; err != nil {
-		return nil, err
-	}
-
-	var replyTo models.FeedPost
-	if err := nm.db.First(&replyTo, "id = ?", nrec.ReplyTo).Error; err != nil {
-		return nil, err
-	}
-
-	var author models.ActorInfo
-	if err := nm.db.First(&author, "id = ?", fp.Author).Error; err != nil {
-		return nil, err
-	}
-
-	var opAuthor models.ActorInfo
-	if err := nm.db.First(&opAuthor, "id = ?", replyTo.Author).Error; err != nil {
-		return nil, err
-	}
-
-	_, rec, err := nm.getRecord(ctx, author.Uid, "app.bsky.feed.post", fp.Rkey, cid.Undef)
-	if err != nil {
-		return nil, err
-	}
-
-	rsub := "at://" + opAuthor.Did + "/app.bsky.feed.post/" + replyTo.Rkey
-
-	return &appbskytypes.NotificationListNotifications_Notification{
-		Record:        &lexutil.LexiconTypeDecoder{Val: rec},
-		IsRead:        nrec.CreatedAt.Before(lastSeen),
-		IndexedAt:     nrec.CreatedAt.Format(time.RFC3339),
-		Uri:           "at://" + author.Did + "/app.bsky.feed.post/" + fp.Rkey,
-		Cid:           fp.Cid,
-		Author:        author.ActorView(),
-		Reason:        "reply",
-		ReasonSubject: &rsub,
-	}, nil
-}
-
-func (nm *DBNotifMan) hydrateNotificationFollow(ctx context.Context, nrec *NotifRecord, lastSeen time.Time) (*appbskytypes.NotificationListNotifications_Notification, error) {
-	var frec models.FollowRecord
-	if err := nm.db.First(&frec, "id = ?", nrec.Record).Error; err != nil {
-		return nil, err
-	}
-
-	var follower models.ActorInfo
-	if err := nm.db.First(&follower, "id = ?", nrec.Who).Error; err != nil {
-		return nil, err
-	}
-
-	_, rec, err := nm.getRecord(ctx, follower.Uid, "app.bsky.graph.follow", frec.Rkey, cid.Undef)
-	if err != nil {
-		return nil, err
-	}
-
-	return &appbskytypes.NotificationListNotifications_Notification{
-		Record:    &lexutil.LexiconTypeDecoder{Val: rec},
-		IsRead:    nrec.CreatedAt.Before(lastSeen),
-		IndexedAt: nrec.CreatedAt.Format(time.RFC3339),
-		Uri:       "at://" + follower.Did + "/app.bsky.graph.follow/" + frec.Rkey,
-		Cid:       frec.Cid,
-		Author:    follower.ActorView(),
-		Reason:    "follow",
-	}, nil
-
-}
-
-func (nm *DBNotifMan) GetCount(ctx context.Context, user models.Uid) (int64, error) {
-	// TODO: sql count is inefficient
-	var lseen time.Time
-	if err := nm.db.Model(NotifSeen{}).Where("usr = ?", user).Select("last_seen").Scan(&lseen).Error; err != nil {
-		return 0, err
-	}
-
-	var c int64
-	//seen := nm.db.Model(NotifSeen{}).Where("usr = ?", user).Select("last_seen")
-	if err := nm.db.Model(NotifRecord{}).Where("for = ? AND created_at > ?", user, lseen).Count(&c).Error; err != nil {
-		return 0, err
-	}
-
-	return c, nil
-}
-
-func (nm *DBNotifMan) UpdateSeen(ctx context.Context, usr models.Uid, seen time.Time) error {
-	if err := nm.db.Clauses(clause.OnConflict{
-		Columns:   []clause.Column{{Name: "usr"}},
-		DoUpdates: clause.AssignmentColumns([]string{"last_seen"}),
-	}).Create(NotifSeen{
-		Usr:      usr,
-		LastSeen: seen,
-	}).Error; err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (nm *DBNotifMan) AddReplyTo(ctx context.Context, user models.Uid, replyid uint, replyto *models.FeedPost) error {
-	return nm.db.Create(&NotifRecord{
-		Kind:    NotifKindReply,
-		For:     replyto.Author,
-		Who:     user,
-		ReplyTo: replyto.ID,
-		Record:  replyid,
-	}).Error
-}
-
-func (nm *DBNotifMan) AddMention(ctx context.Context, user models.Uid, postid uint, mentioned models.Uid) error {
-	return nm.db.Create(&NotifRecord{
-		For:    mentioned,
-		Kind:   NotifKindMention,
-		Record: postid,
-		Who:    user,
-	}).Error
-}
-
-func (nm *DBNotifMan) AddUpVote(ctx context.Context, voter models.Uid, postid uint, voteid uint, postauthor models.Uid) error {
-	return nm.db.Create(&NotifRecord{
-		For:     postauthor,
-		Kind:    NotifKindUpVote,
-		ReplyTo: postid,
-		Record:  voteid,
-		Who:     voter,
-	}).Error
-}
-
-func (nm *DBNotifMan) AddFollow(ctx context.Context, follower, followed models.Uid, recid uint) error {
-	return nm.db.Create(&NotifRecord{
-		Kind:   NotifKindFollow,
-		For:    followed,
-		Who:    follower,
-		Record: recid,
-	}).Error
-}
-
-func (nm *DBNotifMan) AddRepost(ctx context.Context, op models.Uid, repost uint, reposter models.Uid) error {
-	return nm.db.Create(&NotifRecord{
-		Kind:   NotifKindRepost,
-		For:    op,
-		Record: repost,
-		Who:    reposter,
-	}).Error
-}

notifs/null.go

···
-package notifs
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	appbskytypes "github.com/bluesky-social/indigo/api/bsky"
-	"github.com/bluesky-social/indigo/models"
-)
-
-type NullNotifs struct {
-}
-
-var _ NotificationManager = (*NullNotifs)(nil)
-
-func (nn *NullNotifs) GetNotifications(ctx context.Context, user models.Uid) ([]*appbskytypes.NotificationListNotifications_Notification, error) {
-	return nil, fmt.Errorf("no notifications engine loaded")
-}
-
-func (nn *NullNotifs) GetCount(ctx context.Context, user models.Uid) (int64, error) {
-	return 0, fmt.Errorf("no notifications engine loaded")
-}
-
-func (nn *NullNotifs) UpdateSeen(ctx context.Context, usr models.Uid, seen time.Time) error {
-	return nil
-}
-
-func (nn *NullNotifs) AddReplyTo(ctx context.Context, user models.Uid, replyid uint, replyto *models.FeedPost) error {
-	return nil
-}
-
-func (nn *NullNotifs) AddMention(ctx context.Context, user models.Uid, postid uint, mentioned models.Uid) error {
-	return nil
-}
-
-func (nn *NullNotifs) AddUpVote(ctx context.Context, voter models.Uid, postid uint, voteid uint, postauthor models.Uid) error {
-	return nil
-}
-
-func (nn *NullNotifs) AddFollow(ctx context.Context, follower, followed models.Uid, recid uint) error {
-	return nil
-}
-
-func (nn *NullNotifs) AddRepost(ctx context.Context, op models.Uid, repost uint, reposter models.Uid) error {
-	return nil
-}

pds/server.go

···
 	"github.com/bluesky-social/indigo/indexer"
 	lexutil "github.com/bluesky-social/indigo/lex/util"
 	"github.com/bluesky-social/indigo/models"
-	"github.com/bluesky-social/indigo/notifs"
 	pdsdata "github.com/bluesky-social/indigo/pds/data"
 	"github.com/bluesky-social/indigo/plc"
 	"github.com/bluesky-social/indigo/repomgr"
···
 	cs             carstore.CarStore
 	repoman        *repomgr.RepoManager
 	feedgen        *FeedGenerator
-	notifman       notifs.NotificationManager
 	indexer        *indexer.Indexer
 	events         *events.EventManager
 	signingKey     *did.PrivKey
···
 	kmgr := indexer.NewKeyManager(didr, serkey)
 
 	repoman := repomgr.NewRepoManager(cs, kmgr)
-	notifman := notifs.NewNotificationManager(db, repoman.GetRecord)
 
 	rf := indexer.NewRepoFetcher(db, repoman, 10)
 
-	ix, err := indexer.NewIndexer(db, notifman, evtman, didr, rf, false, true, true)
+	ix, err := indexer.NewIndexer(db, evtman, didr, rf, false, true, true)
 	if err != nil {
 		return nil, err
 	}
···
 		signingKey:     serkey,
 		db:             db,
 		cs:             cs,
-		notifman:       notifman,
 		indexer:        ix,
 		plc:            didr,
 		events:         evtman,

testing/utils.go

···
 	"github.com/bluesky-social/indigo/indexer"
 	lexutil "github.com/bluesky-social/indigo/lex/util"
 	"github.com/bluesky-social/indigo/models"
-	"github.com/bluesky-social/indigo/notifs"
 	"github.com/bluesky-social/indigo/pds"
 	"github.com/bluesky-social/indigo/plc"
 	"github.com/bluesky-social/indigo/repo"
···
 	return resp.Feed
 }
 
-func (u *TestUser) GetNotifs(t *testing.T) []*bsky.NotificationListNotifications_Notification {
-	t.Helper()
-
-	ctx := context.TODO()
-	resp, err := bsky.NotificationListNotifications(ctx, u.client, "", 100, false, nil, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	return resp.Notifications
-}
-
 func (u *TestUser) ChangeHandle(t *testing.T, nhandle string) {
 	t.Helper()
 
···
 
 	repoman := repomgr.NewRepoManager(cs, kmgr)
 
-	notifman := notifs.NewNotificationManager(maindb, repoman.GetRecord)
-
 	opts := events.DefaultDiskPersistOptions()
 	opts.EventsPerFile = 10
 	diskpersist, err := events.NewDiskPersistence(filepath.Join(dir, "dp-primary"), filepath.Join(dir, "dp-archive"), maindb, opts)
···
 	evtman := events.NewEventManager(diskpersist)
 	rf := indexer.NewRepoFetcher(maindb, repoman, 10)
 
-	ix, err := indexer.NewIndexer(maindb, notifman, evtman, didr, rf, true, true, true)
+	ix, err := indexer.NewIndexer(maindb, evtman, didr, rf, true, true, true)
 	if err != nil {
 		return nil, err
 	}