[performance] cache mute check results (#4202)

This separates our the user mute handling from the typeconverter code, and creates a new "mutes" filter type (in a similar vein to the visibility filter) subpkg with its own result cache. This is a heavy mix of both chore given that mute calculation shouldn't have been handled in the conversion to frontend API types, and a performance bonus since we don't need to load and calculate so many things each time, just the single result each time with all necessary invalidation handled by database cache hooks.

Reviewed-on: https://codeberg.org/superseriousbusiness/gotosocial/pulls/4202
Co-authored-by: kim <grufwub@gmail.com>
Co-committed-by: kim <grufwub@gmail.com>

1 files changed, 302 insertions, 0 deletions

diff --git a/internal/filter/mutes/status.go b/internal/filter/mutes/status.go
new file mode 100644
index 000000000..e2ef1e5a5
--- /dev/null
+++ b/internal/filter/mutes/status.go
@@ -0,0 +1,302 @@
+// GoToSocial
+// Copyright (C) GoToSocial Authors admin@gotosocial.org
+// SPDX-License-Identifier: AGPL-3.0-or-later
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package mutes
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"code.superseriousbusiness.org/gotosocial/internal/cache"
+	"code.superseriousbusiness.org/gotosocial/internal/db"
+	"code.superseriousbusiness.org/gotosocial/internal/gtscontext"
+	"code.superseriousbusiness.org/gotosocial/internal/gtserror"
+	"code.superseriousbusiness.org/gotosocial/internal/gtsmodel"
+)
+
+// StatusMuted returns whether given target status is muted for requester in the context of timeline visibility.
+func (f *Filter) StatusMuted(ctx context.Context, requester *gtsmodel.Account, status *gtsmodel.Status) (muted bool, err error) {
+	details, err := f.StatusMuteDetails(ctx, requester, status)
+	if err != nil {
+		return false, gtserror.Newf("error getting status mute details: %w", err)
+	}
+	return details.Mute && !details.MuteExpired(time.Now()), nil
+}
+
+// StatusNotificationsMuted returns whether notifications are muted for requester when regarding given target status.
+func (f *Filter) StatusNotificationsMuted(ctx context.Context, requester *gtsmodel.Account, status *gtsmodel.Status) (muted bool, err error) {
+	details, err := f.StatusMuteDetails(ctx, requester, status)
+	if err != nil {
+		return false, gtserror.Newf("error getting status mute details: %w", err)
+	}
+	return details.Notifications && !details.NotificationExpired(time.Now()), nil
+}
+
+// StatusMuteDetails returns mute details about the given status for the given requesting account.
+func (f *Filter) StatusMuteDetails(ctx context.Context, requester *gtsmodel.Account, status *gtsmodel.Status) (*cache.CachedMute, error) {
+
+	// For requester ID use a
+	// fallback 'noauth' string
+	// by default for lookups.
+	requesterID := noauth
+	if requester != nil {
+		requesterID = requester.ID
+	}
+
+	// Load mute details for this requesting account about status from cache, using load callback if needed.
+	details, err := f.state.Caches.Mutes.LoadOne("RequesterID,StatusID", func() (*cache.CachedMute, error) {
+
+		// Load the mute details for given status.
+		details, err := f.getStatusMuteDetails(ctx,
+			requester,
+			status,
+		)
+		if err != nil {
+			if err == cache.SentinelError {
+				// Filter-out our temporary
+				// race-condition error.
+				return &cache.CachedMute{}, nil
+			}
+
+			return nil, err
+		}
+
+		// Convert to cache details.
+		return &cache.CachedMute{
+			StatusID:           status.ID,
+			ThreadID:           status.ThreadID,
+			RequesterID:        requester.ID,
+			Mute:               details.mute,
+			MuteExpiry:         details.muteExpiry,
+			Notifications:      details.notif,
+			NotificationExpiry: details.notifExpiry,
+		}, nil
+	}, requesterID, status.ID)
+	if err != nil {
+		return nil, err
+	}
+
+	return details, err
+}
+
+// getStatusMuteDetails loads muteDetails{} for the given
+// status and the thread it is a part of, including any
+// relevant muted parent status authors / mentions.
+func (f *Filter) getStatusMuteDetails(
+	ctx context.Context,
+	requester *gtsmodel.Account,
+	status *gtsmodel.Status,
+) (
+	muteDetails,
+	error,
+) {
+	var details muteDetails
+
+	if requester == nil {
+		// Without auth, there will be no possible
+		// mute to exist. Always return as 'unmuted'.
+		return details, nil
+	}
+
+	// Look for a stored mute from account against thread.
+	threadMute, err := f.state.DB.GetThreadMutedByAccount(ctx,
+		status.ThreadID,
+		requester.ID,
+	)
+	if err != nil && !errors.Is(err, db.ErrNoEntries) {
+		return details, gtserror.Newf("db error checking thread mute: %w", err)
+	}
+
+	// Set notif mute on thread mute.
+	details.notif = (threadMute != nil)
+
+	for next := status; ; {
+		// Load the mute details for 'next' status
+		// in current thread, into our details obj.
+		if err = f.loadOneStatusMuteDetails(ctx,
+			requester,
+			next,
+			&details,
+		); err != nil {
+			return details, err
+		}
+
+		if next.InReplyToURI == "" {
+			// Reached the top
+			// of the thread.
+			break
+		}
+
+		if next.InReplyToID == "" {
+			// Parent is not yet dereferenced.
+			return details, cache.SentinelError
+		}
+
+		// Check if parent is set.
+		inReplyTo := next.InReplyTo
+		if inReplyTo == nil {
+
+			// Fetch next parent in conversation.
+			inReplyTo, err = f.state.DB.GetStatusByID(
+				gtscontext.SetBarebones(ctx),
+				next.InReplyToID,
+			)
+			if err != nil {
+				return details, gtserror.Newf("error getting status parent %s: %w", next.InReplyToURI, err)
+			}
+		}
+
+		// Set next status.
+		next = inReplyTo
+	}
+
+	return details, nil
+}
+
+// loadOneStatusMuteDetails loads the mute details for
+// any relevant accounts to given status to the requesting
+// account into the passed muteDetails object pointer.
+func (f *Filter) loadOneStatusMuteDetails(
+	ctx context.Context,
+	requester *gtsmodel.Account,
+	status *gtsmodel.Status,
+	details *muteDetails,
+) error {
+	// Look for mutes against related status accounts
+	// by requester (e.g. author, mention targets etc).
+	userMutes, err := f.getStatusRelatedUserMutes(ctx,
+		requester,
+		status,
+	)
+	if err != nil {
+		return err
+	}
+
+	for _, mute := range userMutes {
+		// Set as muted!
+		details.mute = true
+
+		// Set notifications as
+		// muted if flag is set.
+		if *mute.Notifications {
+			details.notif = true
+		}
+
+		// Check for expiry data given.
+		if !mute.ExpiresAt.IsZero() {
+
+			// Update mute details expiry time if later.
+			if mute.ExpiresAt.After(details.muteExpiry) {
+				details.muteExpiry = mute.ExpiresAt
+			}
+
+			// Update notif details expiry time if later.
+			if mute.ExpiresAt.After(details.notifExpiry) {
+				details.notifExpiry = mute.ExpiresAt
+			}
+		}
+	}
+
+	return nil
+}
+
+// getStatusRelatedUserMutes fetches user mutes for any
+// of the possible related accounts regarding this status,
+// i.e. the author and any account mentioned.
+func (f *Filter) getStatusRelatedUserMutes(
+	ctx context.Context,
+	requester *gtsmodel.Account,
+	status *gtsmodel.Status,
+) (
+	[]*gtsmodel.UserMute,
+	error,
+) {
+	if status.AccountID == requester.ID {
+		// Status is by requester, we don't take
+		// into account related attached user mutes.
+		return nil, nil
+	}
+
+	if !status.MentionsPopulated() {
+		var err error
+
+		// Populate status mention objects before further mention checks.
+		status.Mentions, err = f.state.DB.GetMentions(ctx, status.MentionIDs)
+		if err != nil {
+			return nil, gtserror.Newf("error populating status %s mentions: %w", status.URI, err)
+		}
+	}
+
+	// Preallocate a slice of worst possible case no. user mutes.
+	mutes := make([]*gtsmodel.UserMute, 0, 2+len(status.Mentions))
+
+	// Look for mute against author.
+	mute, err := f.state.DB.GetMute(
+		gtscontext.SetBarebones(ctx),
+		requester.ID,
+		status.AccountID,
+	)
+	if err != nil && !errors.Is(err, db.ErrNoEntries) {
+		return nil, gtserror.Newf("db error getting status author mute: %w", err)
+	}
+
+	if mute != nil {
+		// Append author mute to total.
+		mutes = append(mutes, mute)
+	}
+
+	if status.BoostOfAccountID != "" {
+		// Look for mute against boost author.
+		mute, err := f.state.DB.GetMute(
+			gtscontext.SetBarebones(ctx),
+			requester.ID,
+			status.AccountID,
+		)
+		if err != nil && !errors.Is(err, db.ErrNoEntries) {
+			return nil, gtserror.Newf("db error getting boost author mute: %w", err)
+		}
+
+		if mute != nil {
+			// Append author mute to total.
+			mutes = append(mutes, mute)
+		}
+	}
+
+	for _, mention := range status.Mentions {
+		// Look for mute against any target mentions.
+		if mention.TargetAccountID != requester.ID {
+
+			// Look for mute against target.
+			mute, err := f.state.DB.GetMute(
+				gtscontext.SetBarebones(ctx),
+				requester.ID,
+				mention.TargetAccountID,
+			)
+			if err != nil && !errors.Is(err, db.ErrNoEntries) {
+				return nil, gtserror.Newf("db error getting mention target mute: %w", err)
+			}
+
+			if mute != nil {
+				// Append target mute to total.
+				mutes = append(mutes, mute)
+			}
+		}
+	}
+
+	return mutes, nil
+}