Add resolver for Twitch users (#680)

Author: M4tthewDE

CHANGELOG.md

@@ -5,6 +5,7 @@
 - Breaking: Go version 1.22.1 is now the minimum required version to build this project. (#667, #671)
 - Minor: Add playlist support to YouTube resolver. (#597, #601)
 - Minor: Add YouTube livestream support. (#678)
+- Minor: Add Twitch user resolver (e.g. `https://twitch.tv/forsen`). (#680)
 - Fix: Do not resolve /results using YouTube channel resolver (#616)
 
 ## 2.0.3

config.yaml

@@ -98,6 +98,9 @@
 # Cache duration for Wikipedia article links
 #wikipedia-article-cache-duration: 1h
 
+# Cache duration for Twitch username links
+#twitch-username-cache-duration: 1h
+
 # Minimum level of log message importance required for the log message to not be filtered out.
 # Available levels: debug, info, warn, error
 # See https://pkg.go.dev/go.uber.org/zap for more information about the logging library we use

internal/mocks/mock_TwitchAPIClient.go

@@ -93,8 +93,6 @@ func TestClipResolver(t *testing.T) {
 				},
 			}
 
-			const q = `SELECT value FROM cache WHERE key=$1`
-
 			for _, test := range tests {
 				c.Run(test.label, func(c *qt.C) {
 					outputBytes, outputError := resolver.Run(ctx, test.inputURL, test.inputReq)
@@ -170,8 +168,6 @@ func TestClipResolver(t *testing.T) {
 				// },
 			}
 
-			const q = `SELECT value FROM cache WHERE key=$1`
-
 			for _, test := range tests {
 				c.Run(test.label, func(c *qt.C) {
 					helixClient.EXPECT().GetClips(&helix.ClipsParams{IDs: []string{test.inputSlug}}).Times(1).Return(test.expectedClipResponse, test.expectedClipError)

internal/resolvers/twitch/clip_resolver_test.go

@@ -38,3 +38,19 @@ var invalidClipSlugs = []string{
 	"https://twitch.tv/zneix/clip/ImpossibleOilyAlpacaTF2John-jIlgtnSAQ52BThHhifyouseethisvivon",
 	"https://m.twitch.tv/username/notclip/slug",
 }
+
+var validUsers = []string{
+	"https://twitch.tv/pajlada",
+	"https://twitch.tv/matthewde",
+}
+
+var invalidUsers = []string{
+	"https://twitch.tv/inventory",
+	"https://twitch.tv/popout",
+	"https://twitch.tv/subscriptions",
+	"https://twitch.tv/videos",
+	"https://twitch.tv/following",
+	"https://twitch.tv/directory",
+	"https://twitch.tv/DIRECTORY",
+	"https://twitch.tv/moderator",
+}

internal/resolvers/twitch/data_test.go

@@ -17,6 +17,7 @@ import (
 
 type TwitchAPIClient interface {
 	GetClips(params *helix.ClipsParams) (clip *helix.ClipsResponse, err error)
+	GetUsers(params *helix.UsersParams) (clip *helix.UsersResponse, err error)
 }
 
 const (
@@ -28,12 +29,20 @@ const (
 		`<b>Created:</b> {{.CreationDate}}<br>` +
 		`<b>Views:</b> {{.Views}}` +
 		`</div>`
+
+	twitchUserTooltipString = `<div style="text-align: left;">` +
+		`<b>{{.Name}} - Twitch</b><br>` +
+		`{{.Description}}<br>` +
+		`<b>Created:</b> {{.CreatedAt}}<br>` +
+		`<b>URL:</b> {{.URL}}` +
+		`</div>`
 )
 
 var (
 	errInvalidTwitchClip = errors.New("invalid Twitch clip link")
 
 	twitchClipsTooltip = template.Must(template.New("twitchclipsTooltip").Parse(twitchClipsTooltipString))
+	twitchUserTooltip  = template.Must(template.New("twitchUserTooltip").Parse(twitchUserTooltipString))
 
 	domains = map[string]struct{}{
 		"twitch.tv":       {},
@@ -51,5 +60,6 @@ func Initialize(ctx context.Context, cfg config.APIConfig, pool db.Pool, helixCl
 		return
 	}
 
+	*resolvers = append(*resolvers, NewUserResolver(ctx, cfg, pool, helixClient))
 	*resolvers = append(*resolvers, NewClipResolver(ctx, cfg, pool, helixClient))
 }

internal/resolvers/twitch/initialize.go

@@ -49,6 +49,6 @@ func TestInitialize(t *testing.T) {
 		customResolvers := []resolver.Resolver{}
 		c.Assert(customResolvers, qt.HasLen, 0)
 		Initialize(ctx, cfg, pool, helixClient, &customResolvers)
-		c.Assert(customResolvers, qt.HasLen, 1)
+		c.Assert(customResolvers, qt.HasLen, 2)
 	})
 }

internal/resolvers/twitch/initialize_test.go

@@ -0,0 +1,77 @@
+package twitch
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/Chatterino/api/internal/logger"
+	"github.com/Chatterino/api/pkg/cache"
+	"github.com/Chatterino/api/pkg/humanize"
+	"github.com/Chatterino/api/pkg/resolver"
+	"github.com/nicklaw5/helix"
+)
+
+type twitchUserTooltipData struct {
+	Name        string
+	CreatedAt   string
+	Description string
+	URL         string
+}
+
+type UserLoader struct {
+	helixAPI TwitchAPIClient
+}
+
+func (l *UserLoader) Load(ctx context.Context, login string, r *http.Request) (*resolver.Response, time.Duration, error) {
+	log := logger.FromContext(ctx)
+
+	log.Debugw("[Twitch] Get user",
+		"login", login,
+	)
+
+	response, err := l.helixAPI.GetUsers(&helix.UsersParams{Logins: []string{login}})
+	if err != nil {
+		log.Errorw("[Twitch] Error getting user",
+			"login", login,
+			"error", err,
+		)
+
+		return resolver.Errorf("Twitch user load error: %s", err)
+	}
+
+	if len(response.Data.Users) != 1 {
+		return nil, cache.NoSpecialDur, resolver.ErrDontHandle
+	}
+
+	var user = response.Data.Users[0]
+
+	var name string
+	if strings.ToLower(user.DisplayName) == login {
+		name = user.DisplayName
+	} else {
+		name = fmt.Sprintf("%s (%s)", user.DisplayName, user.Login)
+	}
+
+	data := twitchUserTooltipData{
+		Name:        name,
+		CreatedAt:   humanize.CreationDate(user.CreatedAt.Time),
+		Description: user.Description,
+		URL:         fmt.Sprintf("https://twitch.tv/%s", user.Login),
+	}
+
+	var tooltip bytes.Buffer
+	if err := twitchUserTooltip.Execute(&tooltip, data); err != nil {
+		return resolver.Errorf("Twitch user template error: %s", err)
+	}
+
+	return &resolver.Response{
+		Status:    200,
+		Tooltip:   url.PathEscape(tooltip.String()),
+		Thumbnail: user.ProfileImageURL,
+	}, cache.NoSpecialDur, nil
+}

internal/resolvers/twitch/user_loader.go

@@ -0,0 +1,68 @@
+package twitch
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strings"
+
+	"github.com/Chatterino/api/internal/db"
+	"github.com/Chatterino/api/pkg/cache"
+	"github.com/Chatterino/api/pkg/config"
+	"github.com/Chatterino/api/pkg/resolver"
+	"github.com/Chatterino/api/pkg/utils"
+)
+
+var userRegex = regexp.MustCompile(`^\/([a-zA-Z0-9_]+)$`)
+var ignoredUsers = []string{
+	"inventory",
+	"popout",
+	"subscriptions",
+	"videos",
+	"following",
+	"directory",
+	"moderator",
+}
+
+type UserResolver struct {
+	userCache cache.Cache
+}
+
+func (r *UserResolver) Check(ctx context.Context, url *url.URL) (context.Context, bool) {
+	if !utils.IsDomain(url, "twitch.tv") {
+		return ctx, false
+	}
+
+	userMatch := userRegex.FindStringSubmatch(url.Path)
+	if len(userMatch) != 2 {
+		return ctx, false
+	}
+
+	for _, ignoredUser := range ignoredUsers {
+		if ignoredUser == strings.ToLower(userMatch[1]) {
+			return ctx, false
+		}
+	}
+
+	return ctx, true
+}
+
+func (r *UserResolver) Run(ctx context.Context, url *url.URL, req *http.Request) (*cache.Response, error) {
+	return r.userCache.Get(ctx, strings.ToLower(strings.TrimLeft(url.Path, "/")), req)
+}
+
+func (r *UserResolver) Name() string {
+	return "twitch:user"
+}
+
+func NewUserResolver(ctx context.Context, cfg config.APIConfig, pool db.Pool, helixAPI TwitchAPIClient) *UserResolver {
+	userLoader := &UserLoader{helixAPI: helixAPI}
+
+	r := &UserResolver{
+		userCache: cache.NewPostgreSQLCache(ctx, cfg, pool, cache.NewPrefixKeyProvider("twitch:user"),
+			resolver.NewResponseMarshaller(userLoader), cfg.TwitchUsernameCacheDuration),
+	}
+
+	return r
+}