go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/projects/chirp/pkg/model/manager.go

/*

Copyright (c) 2023 - Present. Will Charczuk. All rights reserved.
Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.

*/

package model

import (
	"context"
	"fmt"
	"time"

	"go.charczuk.com/sdk/apputil"
	"go.charczuk.com/sdk/db/dbutil"
	"go.charczuk.com/sdk/uuid"
	"go.charczuk.com/sdk/web"
)

var qf = new(dbutil.QueryFormatter).
	WithModels(
		Audit{},
		Chirp{},
		ChirpStats{},
		ChirpStatus{},
		ChirpLike{},
		apputil.User{},
		UserInfo{},
		Feed{},
		Graph{},
		Notification{},
	).WithTemplates(
	templateUserColumns,
	templateUserJoins,
	templateChirpColumns,
	templateChirpAuxJoins,
	templateChirpBlockChecks,
)

var f = qf.MustFormat

// queries live here in all their glory.
var (
	templateUserColumns = `{{ define "user_columns" }}
	{{ columns_prefix_alias "User" "user_" "u" }}
	, {{ columns_prefix_alias "UserInfo" "userinfo_" "ui" }}
	, u.id as userstatus_user_id
	, case when following.user_id is not null then 1 else 0 end as userstatus_is_following
	, case when u.id = $1 then 1 else 0 end as userstatus_is_self
{{ end }}`
	templateUserJoins = `{{ define "user_joins" }}
	{{ table "User" }} u
	JOIN {{ table "UserInfo" }} ui on ui.user_id = u.id
	LEFT JOIN {{ table "Graph" }} following ON following.user_id = $1 AND following.target_id = u.id AND type = 'follow'
{{ end }}`

	templateChirpColumns = `{{ define "chirp_columns" }}
	{{ columns_prefix_alias "Chirp" "chirp_" "c" }}
	, {{ columns_prefix_alias "ChirpStats" "chirp_stats_" "cs" }}
	, {{ columns_prefix_alias "User" "chirp_user_" "u" }}
	, {{ columns_prefix_alias "UserInfo" "chirp_userinfo_" "ui" }}

	, case when cl.chirp_id is not null then 1 else 0 end as chirp_status_is_liked
	, case when cr.id is not null then 1 else 0 end as chirp_status_is_quoted
	
	, {{ columns_prefix_alias "Chirp" "quoted_" "qc" }}
	, {{ columns_prefix_alias "ChirpStats" "quoted_stats_" "qcs" }}
	, {{ columns_prefix_alias "User" "quoted_user_" "qu" }}
	, {{ columns_prefix_alias "UserInfo" "quoted_userinfo_" "qui" }}

	, {{ columns_prefix_alias "Chirp" "reply_" "rc" }}
	, {{ columns_prefix_alias "ChirpStats" "reply_stats_" "rcs" }}
	, {{ columns_prefix_alias "User" "reply_user_" "ru" }}
	, {{ columns_prefix_alias "UserInfo" "reply_userinfo_" "rui" }}
{{ end }}`

	templateChirpAuxJoins = `{{ define "chirp_aux_joins" }}
	JOIN {{ table "ChirpStats" }} cs on cs.chirp_id = c.id
	JOIN {{ table "User" }} u on c.user_id = u.id
	JOIN {{ table "UserInfo" }} ui on c.user_id = ui.user_id

	LEFT JOIN {{ table "ChirpLike" }} cl on cl.chirp_id = c.id AND cl.user_id = $1
	LEFT JOIN {{ table "Chirp" }} cr on cr.id = c.quoted_id AND cl.user_id = $1

	LEFT JOIN {{ table "Chirp" }} qc on qc.id = c.quoted_id
	LEFT JOIN {{ table "ChirpStats" }} qcs on qcs.chirp_id = c.quoted_id
	LEFT JOIN {{ table "User" }} qu on qu.id = qc.user_id
	LEFT JOIN {{ table "UserInfo" }} qui on qui.user_id = qc.user_id
	
	LEFT JOIN {{ table "Chirp" }} rc on rc.id = c.reply_id
	LEFT JOIN {{ table "ChirpStats" }} rcs on rcs.chirp_id = c.reply_id
	LEFT JOIN {{ table "User" }} ru on ru.id = rc.user_id
	LEFT JOIN {{ table "UserInfo" }} rui on rui.user_id = rc.user_id
{{ end }}`

	templateChirpBlockChecks = `{{ define "chirp_block_checks" }}
	AND NOT EXISTS (SELECT 1 FROM {{ table "Graph" }} g WHERE g.user_id = $1 AND g.target_id = c.user_id AND type IN ('block', 'mute'))
	AND NOT EXISTS (SELECT 1 FROM {{ table "Graph" }} g WHERE g.target_id = $1 AND g.user_id= c.user_id AND type = 'block')
	AND (
		c.quoted_id IS NULL 
		OR (
			c.quoted_id IS NOT NULL
			AND NOT EXISTS (SELECT 1 FROM {{ table "Graph" }} g WHERE g.user_id = $1 AND g.target_id = qc.user_id AND type IN ('block', 'mute'))
			AND NOT EXISTS (SELECT 1 FROM {{ table "Graph" }} g WHERE g.target_id = $1 AND g.user_id= qc.user_id AND type = 'block')
		)
	)
	AND (
		c.reply_id IS NULL 
		OR (
			c.reply_id IS NOT NULL
			AND NOT EXISTS (SELECT 1 FROM {{ table "Graph" }} g WHERE g.user_id = $1 AND g.target_id = rc.user_id AND type IN ('block', 'mute'))
			AND NOT EXISTS (SELECT 1 FROM {{ table "Graph" }} g WHERE g.target_id = $1 AND g.user_id= rc.user_id AND type = 'block')
		)
	)
{{ end }}`

	queryUser = f(`
SELECT	
	{{ template "user_columns" . }}
FROM
	{{ template "user_joins" . }}	
WHERE
	u.id = $2`, nil)

	queryUserByUsername = f(`
SELECT	
	{{ template "user_columns" . }}
FROM
	{{ template "user_joins" . }}	
WHERE
	u.email = $2`, nil)

	querySearchUsers = f(`
SELECT	
	{{ template "user_columns" . }}
FROM
	{{ template "user_joins" . }}	
WHERE
	u.email ilike $2
	OR u.given_name ilike $2
	OR u.family_name ilike $2
	AND u.id <> $1
	AND NOT EXISTS (SELECT 1 FROM {{ table "Graph" }} blocked WHERE blocked.target_id = $1 and blocked.user_id = u.id AND type = 'block')
		`, nil)

	queryChirp = f(`
SELECT	
	{{ template "chirp_columns" . }}
FROM
	{{ table "Chirp" }} c
	{{ template "chirp_aux_joins" }}
WHERE
	c.id = $2
	{{ template "chirp_block_checks" }}
	`, nil)

	queryChirpReplies = f(`
SELECT	
	{{ template "chirp_columns" . }}
FROM
	{{ table "Chirp" }} c
	{{ template "chirp_aux_joins" }}
WHERE
	c.reply_id = $2
	{{ template "chirp_block_checks" }}
	`, nil)

	queryFeedForUserID = f(`
; WITH feed_data as (
	SELECT
		{{ template "chirp_columns" . }}
		, ROW_NUMBER() OVER (ORDER BY f.timestamp_utc desc) as feed_rank
	FROM 
		{{ table "Feed" }} f
		JOIN {{ table "Chirp" }} c on c.id = f.chirp_id
		{{ template "chirp_aux_joins" }}
	WHERE 
		f.user_id = $1
		{{ template "chirp_block_checks" }}
)
SELECT
	*
FROM 
	feed_data
WHERE
	$3::uuid IS NULL 
	OR (
		feed_rank > (SELECT feed_rank from feed_data WHERE chirp_id = $3 LIMIT 1)
	)
ORDER BY feed_rank ASC
LIMIT $2
`, nil)

	queryProfilePosts = f(`
; WITH profile_data as (
	SELECT 
		{{ template "chirp_columns" . }}
		, ROW_NUMBER() OVER (ORDER BY c.published_utc desc) as profile_rank
	FROM 
		{{ table "Chirp" }} c
		{{ template "chirp_aux_joins" }}
	WHERE
		c.user_id = $2
		AND c.published_utc is not null
		AND c.reply_id is null
		{{ template "chirp_block_checks" }}
)
SELECT
	*
FROM 
	profile_data
WHERE
	$4::uuid IS NULL 
	OR (
		profile_rank > (SELECT profile_rank from profile_data WHERE chirp_id = $4 LIMIT 1)
	)

	ORDER BY profile_rank ASC
LIMIT $3
	`, nil)

	queryProfileReplies = f(`
; WITH profile_data as (
	SELECT 
		{{ template "chirp_columns" . }}
		, ROW_NUMBER() OVER (ORDER BY c.published_utc desc) as profile_rank
	FROM 
		{{ table "Chirp" }} c
		{{ template "chirp_aux_joins" }}
	WHERE
		c.user_id = $2
		AND c.published_utc is not null
		AND c.reply_id is not null
		{{ template "chirp_block_checks" }}
)
SELECT
	*
FROM 
	profile_data
WHERE
	$4::uuid IS NULL 
	OR (
		profile_rank > (SELECT profile_rank from profile_data WHERE chirp_id = $4 LIMIT 1)
	)
ORDER BY profile_rank ASC
LIMIT $3
		`, nil)

	queryProfileLikes = f(`
; WITH profile_data as (
	SELECT 
		{{ template "chirp_columns" . }}
		, ROW_NUMBER() OVER (ORDER BY c.published_utc desc) as profile_rank
	FROM 
		{{ table "ChirpLike" }} clike
		JOIN {{ table "Chirp" }} c ON clike.chirp_id = c.id
		{{ template "chirp_aux_joins" }}
	WHERE
		clike.user_id = $2
		{{ template "chirp_block_checks" }}
)
SELECT
	*
FROM 
	profile_data
WHERE
	$4::uuid IS NULL 
	OR (
		profile_rank > (SELECT profile_rank from profile_data WHERE chirp_id = $4 LIMIT 1)
	)
ORDER BY profile_rank ASC
LIMIT $3
			`, nil)

	queryNotifications = f(`
; WITH feed_data as (
SELECT 
	{{ columns_prefix_alias "Notification" "notification_" "n" }}
	, {{ columns_prefix_alias "User" "user_" "u" }}
	, {{ columns_prefix_alias "UserInfo" "userinfo_" "ui" }}
	, {{ columns_prefix_alias "Chirp" "chirp_" "c" }}
	, u.id as userstatus_user_id
	, case when following.user_id is not null then 1 else 0 end as userstatus_is_following
	, case when u.id = $1 then 1 else 0 end as userstatus_is_self
	, ROW_NUMBER() OVER (ORDER BY n.created_utc desc) as feed_rank
FROM 
	{{ table "Notification" }} n
	JOIN {{ table "User" }} u ON u.id = n.acting_user_id
	JOIN {{ table "UserInfo" }} ui ON ui.user_id = n.acting_user_id
	LEFT JOIN {{ table "Chirp" }} c ON c.id = n.chirp_id
	LEFT JOIN {{ table "Graph" }} following ON following.user_id = $1 AND following.target_id = u.id AND following.type = 'follow'
WHERE
	n.user_id = $1
)
SELECT
	*
FROM
	feed_data
WHERE
	$3::uuid IS NULL 
	OR (
		feed_rank > (SELECT feed_rank from feed_data WHERE notification_id = $3 LIMIT 1)
	)
ORDER BY
	feed_rank ASC
LIMIT $2`, nil)
	queryNotificationsUnread = f(`SELECT count(id) FROM {{ table "Notification" }} WHERE read_utc is null AND user_id = $1`, nil)

	execIncrementChirpReplies        = f(`UPDATE {{ table "ChirpStats" }} SET replies = replies + 1 WHERE chirp_id = $1`, nil)
	execIncrementChirpRechirps       = f(`UPDATE {{ table "ChirpStats" }}  SET rechirps = rechirps + 1 WHERE chirp_id = $1`, nil)
	execDeleteChirpFromFeeds         = f(`DELETE FROM {{ table "Feed" }} WHERE chirp_id = $1`, nil)
	execDeleteChirpFromLikes         = f(`DELETE FROM {{ table "ChirpLike" }} WHERE chirp_id = $1`, nil)
	execDeleteChirpFromNotifications = f(`DELETE FROM {{ table "Notification" }} WHERE chirp_id = $1`, nil)
	execDecementChirpReplies         = f(`UPDATE {{ table "ChirpStats" }} SET replies = replies - 1 WHERE chirp_id = $1`, nil)
	execDecementChirpRechirps        = f(`UPDATE {{ table "ChirpStats" }} SET rechirps = rechirps - 1 WHERE chirp_id = $1`, nil)
	execIncrementChirpLikes          = f(`UPDATE {{ table "ChirpStats" }} SET likes = chirp_stats.likes + 1 WHERE chirp_id = $1`, nil)
	execDecrementChirpLikes          = f(`UPDATE {{ table "ChirpStats" }} SET likes = chirp_stats.likes - 1 WHERE chirp_id = $1`, nil)
	execAddUserChirpsToFeed          = f(`INSERT INTO {{ table "Feed" }} (user_id, timestamp_utc, chirp_id) 
SELECT 
	$1
	, published_utc
	, id 
FROM 
	{{ table "Chirp" }} c 
WHERE 
	c.user_id = $2
	AND NOT EXISTS (SELECT 1 FROM {{ table "Feed" }} f WHERE f.user_id = $1 and f.chirp_id = c.id)
`, nil)
	execRemoveUserChirpsFromFeed = f(`DELETE FROM {{ table "Feed" }} WHERE user_id = $1 AND EXISTS (select 1 from chirp c where c.id = {{ table "Feed" }}.chirp_id AND c.user_id = $2)`, nil)
	execMarkNotificationsRead    = f(`UPDATE {{ table "Notification" }} SET read_utc = $3 WHERE user_id = $1 and id = any ($2)`, nil)
)

// Manager is the datumsbase manager.
type Manager struct {
	dbutil.BaseManager
}

// EnsureUserInfoOnCreate creates the rest of the user components on login.
func (m Manager) EnsureUserInfoOnCreate(ctx context.Context, user *apputil.User) error {
	return m.Invoke(ctx).Create(&UserInfo{
		UserID: user.ID,
	})
}

// SessionState is an application specific session state.
type SessionState struct {
	apputil.SessionState
	UnreadNotifications int
	UserInfo            UserInfo
}

// EnsureUserInfoOnFetch fetches the rest of the user components.
func (m Manager) EnsureUserInfoOnFetch(ctx context.Context, session *web.Session) error {
	existingState, ok := session.State.(apputil.SessionState)
	if !ok {
		return fmt.Errorf("invalid session state; expected apputil.SessionState")
	}
	user := existingState.User
	var userInfo UserInfo
	if _, err := m.Invoke(ctx).Get(&userInfo, user.ID); err != nil {
		return err
	}
	unreadNotifications, err := m.NotificationsUnread(ctx, user.ID)
	if err != nil {
		return err
	}
	session.State = SessionState{
		SessionState:        existingState,
		UnreadNotifications: unreadNotifications,
		UserInfo:            userInfo,
	}
	return nil
}

// Audit creates a new audit log record.
func (m Manager) Audit(ctx context.Context, userID uuid.UUID, verb, noun, subject string) error {
	return m.Invoke(ctx).Create(&Audit{
		TimestampUTC: time.Now().UTC(),
		UserID:       userID,
		Verb:         verb,
		Noun:         noun,
		Subject:      subject,
	})
}

// FollowsForUserID gets the users that follow a given user.
func (m Manager) FollowsForUserID(ctx context.Context, userID uuid.UUID) (output []uuid.UUID, err error) {
	err = m.Invoke(ctx).Query(`select user_id from graph where target_id = $1 and type = $2`, userID, EdgeTypeFollow).OutMany(&output)
	return
}

// FollowingForUserID gets the users that a given user follows.
func (m Manager) FollowingForUserID(ctx context.Context, userID uuid.UUID) (output []uuid.UUID, err error) {
	err = m.Invoke(ctx).Query(`select target_id from graph where user_id = $1 and type = $2`, userID, EdgeTypeFollow).OutMany(&output)
	return
}

// BlocksForUserID gets the users a given user blocks.
func (m Manager) BlocksForUserID(ctx context.Context, userID uuid.UUID) (output []uuid.UUID, err error) {
	err = m.Invoke(ctx).Query(`select target_id from graph where user_id = $1 and type = $2`, userID, EdgeTypeBlock).OutMany(&output)
	return
}

// BlocksForUserID gets the users a given user has muted.
func (m Manager) MutesForUserID(ctx context.Context, userID uuid.UUID) (output []uuid.UUID, err error) {
	err = m.Invoke(ctx).Query(`select target_id from graph where user_id = $1 and type = $2`, userID, EdgeTypeMute).OutMany(&output)
	return
}

// User returns a user by ID.
func (m Manager) User(ctx context.Context, selfUserID, userID uuid.UUID) (output UserFull, found bool, err error) {
	found, err = m.Invoke(ctx).Query(queryUser, selfUserID, userID).Out(&output)
	return
}

// UserByUsername returns a user by username.
func (m Manager) UserByUsername(ctx context.Context, selfUserID uuid.UUID, username string) (output UserFull, found bool, err error) {
	found, err = m.Invoke(ctx).Query(queryUserByUsername, selfUserID, username).Out(&output)
	return
}

// SearchUsers returns a list of users that match a search query.
func (m Manager) SearchUsers(ctx context.Context, userID uuid.UUID, query string) (output []UserFull, err error) {
	err = m.Invoke(ctx).Query(querySearchUsers, userID, "%"+query+"%").OutMany(&output)
	return
}

// Chirp gets a chirp by ID (and infers status based on the provided userID).
func (m Manager) Chirp(ctx context.Context, userID, id uuid.UUID) (c ChirpFull, found bool, err error) {
	found, err = m.Invoke(ctx).Query(queryChirp, userID, id).Out(&c)
	return
}

// FeedForUserID returns the feed for a given user, optionally after a given chirpID.
func (m Manager) FeedForUserID(ctx context.Context, userID uuid.UUID, take int, afterChirpID *uuid.UUID) (output []ChirpFull, err error) {
	err = m.Invoke(ctx).Query(queryFeedForUserID, userID, take, afterChirpID).OutMany(&output)
	return
}

// ProfilePosts returns the posts (non-reply, non-likes) for a given user, optionally after a given chirpID.
func (m Manager) ProfilePosts(ctx context.Context, selfUserID, userID uuid.UUID, take int, afterChirpID *uuid.UUID) (output []ChirpFull, err error) {
	err = m.Invoke(ctx).Query(queryProfilePosts, selfUserID, userID, take, afterChirpID).OutMany(&output)
	return
}

// ProfileReplies returns the posts (non-reply, non-likes) for a given user, optionally after a given chirpID.
func (m Manager) ProfileReplies(ctx context.Context, selfUserID, userID uuid.UUID, take int, afterChirpID *uuid.UUID) (output []ChirpFull, err error) {
	err = m.Invoke(ctx).Query(queryProfileReplies, selfUserID, userID, take, afterChirpID).OutMany(&output)
	return
}

// ProfileLikes returns the liked chirps for a given user.
func (m Manager) ProfileLikes(ctx context.Context, selfUserID, targetUserID uuid.UUID, take int, afterChirpID *uuid.UUID) (output []ChirpFull, err error) {
	err = m.Invoke(ctx).Query(queryProfileLikes, selfUserID, targetUserID, take, afterChirpID).OutMany(&output)
	return
}

// Notifications yields the last N notifications for a user
func (m Manager) Notifications(ctx context.Context, userID uuid.UUID, take int, afterNotificationID *uuid.UUID) (output []NotificationFull, err error) {
	err = m.Invoke(ctx).Query(queryNotifications, userID, take, afterNotificationID).OutMany(&output)
	return
}

// NotificationsUnread returns the unread notification count.
func (m Manager) NotificationsUnread(ctx context.Context, userID uuid.UUID) (output int, err error) {
	_, err = m.Invoke(ctx).Query(queryNotificationsUnread, userID).Scan(&output)
	return
}

// MarkNotificationsRead marks a list of notifications as read.
func (m Manager) MarkNotificationsRead(ctx context.Context, userID uuid.UUID, notificationIDs []uuid.UUID) error {
	_, err := m.Invoke(ctx).Exec(execMarkNotificationsRead, userID, notificationIDs, time.Now().UTC())
	return err
}

// ChirpReplies returns the replies for a given chirp id.
func (m Manager) ChirpReplies(ctx context.Context, selfUserID, chirpID uuid.UUID) (output []ChirpFull, err error) {
	err = m.Invoke(ctx).Query(queryChirpReplies, selfUserID, chirpID).OutMany(&output)
	return
}

// CreateChirp creates the chirp staging it for publishing.
func (m Manager) CreateChirp(ctx context.Context, c *Chirp) (err error) {
	c.CreatedUTC = time.Now().UTC()
	c.PublishedUTC = nil
	if err = m.Invoke(ctx).Create(c); err != nil {
		return
	}
	if err = m.Invoke(ctx).Create(&ChirpStats{
		UserID:  c.UserID,
		ChirpID: c.ID,
	}); err != nil {
		return
	}
	return
}

// PublishChirp publishes the chirp, adding attachments and forwarding to the feed table.
func (m Manager) PublishChirp(ctx context.Context, c *Chirp) (err error) {
	t := time.Now().UTC()
	c.PublishedUTC = &t
	if _, err = m.Invoke(ctx).Update(c); err != nil {
		return
	}
	if c.ReplyID != nil && !c.ReplyID.IsZero() {
		if _, err = m.Invoke(ctx).Exec(execIncrementChirpReplies, c.ReplyID); err != nil {
			return
		}
	}
	if c.QuotedID != nil && !c.QuotedID.IsZero() {
		if _, err = m.Invoke(ctx).Exec(execIncrementChirpRechirps, c.QuotedID); err != nil {
			return
		}
	}

	// Publish for self
	if err = m.Invoke(ctx).Create(Feed{
		UserID:       c.UserID,
		ChirpID:      c.ID,
		TimestampUTC: t,
	}); err != nil {
		return
	}

	// Publish for those that are following
	var follows []uuid.UUID
	follows, err = m.FollowsForUserID(ctx, c.UserID)
	if err != nil {
		return
	}
	for _, f := range follows {
		if err = m.Invoke(ctx).Create(Feed{
			UserID:       f,
			ChirpID:      c.ID,
			TimestampUTC: t,
		}); err != nil {
			return
		}
	}
	return
}

// DeleteChirp deletes a chirp and removes it from any referenced table(s).
func (m Manager) DeleteChirp(ctx context.Context, c Chirp) (deleted bool, err error) {
	_, err = m.Invoke(ctx).Exec(execDeleteChirpFromFeeds, c.ID)
	if err != nil {
		return
	}
	_, err = m.Invoke(ctx).Exec(execDeleteChirpFromLikes, c.ID)
	if err != nil {
		return
	}
	_, err = m.Invoke(ctx).Exec(execDeleteChirpFromNotifications, c.ID)
	if err != nil {
		return
	}
	_, err = m.Invoke(ctx).Delete(ChirpStats{ChirpID: c.ID})
	if err != nil {
		return
	}
	deleted, err = m.Invoke(ctx).Delete(c)
	if err != nil {
		return
	}
	if deleted {
		if c.ReplyID != nil && !c.ReplyID.IsZero() {
			if _, err = m.Invoke(ctx).Exec(execDecementChirpReplies, c.ReplyID); err != nil {
				return
			}
		}
		if c.QuotedID != nil && !c.QuotedID.IsZero() {
			if _, err = m.Invoke(ctx).Exec(execDecementChirpRechirps, c.QuotedID); err != nil {
				return
			}
		}
	}
	return
}

// LikeChirp applies a like to a chirp.
func (m Manager) LikeChirp(ctx context.Context, userID uuid.UUID, chirp Chirp) error {
	if _, err := m.Invoke(ctx).Exec(execIncrementChirpLikes, chirp.ID); err != nil {
		return err
	}
	if err := m.Invoke(ctx).Create(&ChirpLike{
		ChirpID:      chirp.ID,
		UserID:       userID,
		TimestampUTC: time.Now().UTC(),
	}); err != nil {
		return err
	}
	if !chirp.UserID.Equal(userID) {
		if err := m.Invoke(ctx).Create(&Notification{
			CreatedUTC:   time.Now().UTC(),
			ActingUserID: userID,
			UserID:       chirp.UserID,
			ChirpID:      &chirp.ID,
			Type:         NotificationTypeLike,
		}); err != nil {
			return err
		}
	}
	return nil
}

// UnlikeChirp undoes a like to a chirp.
func (m Manager) UnlikeChirp(ctx context.Context, userID, chirpID uuid.UUID) error {
	deleted, err := m.Invoke(ctx).Delete(&ChirpLike{
		UserID:  userID,
		ChirpID: chirpID,
	})
	if err != nil {
		return err
	}
	if deleted {
		if _, err := m.Invoke(ctx).Exec(execDecrementChirpLikes, chirpID); err != nil {
			return err
		}
	}
	return nil
}

// Follow adds a graph record that a given user follows a target user as well
// as adds that target user's chirps to the given user's feed.
func (m Manager) Follow(ctx context.Context, userID, targetUserID uuid.UUID) error {
	if err := m.Invoke(ctx).Create(&Graph{
		TimestampUTC: time.Now().UTC(),
		UserID:       userID,
		TargetID:     targetUserID,
		Type:         EdgeTypeFollow,
	}); err != nil {
		return err
	}
	if _, err := m.Invoke(ctx).Exec(execAddUserChirpsToFeed, userID /* who's feed we're adding to */, targetUserID /* add this users chirps to my feed */); err != nil {
		return err
	}
	if err := m.Invoke(ctx).Create(&Notification{
		CreatedUTC:   time.Now().UTC(),
		UserID:       targetUserID,
		ActingUserID: userID,
		Type:         NotificationTypeFollow,
	}); err != nil {
		return err
	}
	return nil
}

// Unfollow is the reverse of follow and removes a target user's chirps from a given
// user's feed and removes the graph record that the given user follows the target user.
func (m Manager) Unfollow(ctx context.Context, userID, targetUserID uuid.UUID) error {
	if _, err := m.Invoke(ctx).Delete(&Graph{
		UserID:   userID,
		TargetID: targetUserID,
		Type:     EdgeTypeFollow,
	}); err != nil {
		return err
	}
	if _, err := m.Invoke(ctx).Exec(execRemoveUserChirpsFromFeed, userID /* who's feed we're removing from*/, targetUserID /*remove this users chirps from my feed */); err != nil {
		return err
	}
	return nil
}

// Mute adds a graph record to indicate we should not show a target user's chirps
// in a given user's feed but we should not block the target user from following the
// given user or seeing their chirps.
func (m Manager) Mute(ctx context.Context, userID, targetUserID uuid.UUID) error {
	if err := m.Invoke(ctx).Create(&Graph{
		TimestampUTC: time.Now().UTC(),
		UserID:       userID,
		TargetID:     targetUserID,
		Type:         EdgeTypeMute,
	}); err != nil {
		return err
	}
	return nil
}

// Unmute is the reverse of mute and allows a target user's chirps to appear
// in a given user's feed.
func (m Manager) Unmute(ctx context.Context, userID, targetUserID uuid.UUID) error {
	if _, err := m.Invoke(ctx).Delete(&Graph{
		UserID:   userID,
		TargetID: targetUserID,
		Type:     EdgeTypeMute,
	}); err != nil {
		return err
	}
	return nil
}

// Block blocks a user.
func (m Manager) Block(ctx context.Context, userID, targetUserID uuid.UUID) error {
	if err := m.Invoke(ctx).Create(&Graph{
		TimestampUTC: time.Now().UTC(),
		UserID:       userID,
		TargetID:     targetUserID,
		Type:         EdgeTypeBlock,
	}); err != nil {
		return err
	}
	return nil
}

// Unblock unblocks a user.
func (m Manager) Unblock(ctx context.Context, userID, targetUserID uuid.UUID) error {
	if _, err := m.Invoke(ctx).Delete(&Graph{
		UserID:   userID,
		TargetID: targetUserID,
		Type:     EdgeTypeBlock,
	}); err != nil {
		return err
	}
	return nil
}