appview: parse reference links from markdown body #760

+172

appview/db/reference.go

··· 1 1 + package db 2 2 + 3 3 + import ( 4 4 + "database/sql" 5 5 + "fmt" 6 6 + "strings" 7 7 + 8 8 + "github.com/bluesky-social/indigo/atproto/syntax" 9 9 + "tangled.org/core/api/tangled" 10 10 + "tangled.org/core/appview/models" 11 11 + ) 12 12 + 13 13 + // FindReferences resolves refLinks to Issue/PR/IssueComment/PullComment ATURIs. 14 14 + // It will ignore missing refLinks. 15 15 + func FindReferences(e Execer, refLinks []models.ReferenceLink) ([]syntax.ATURI, error) { 16 16 + var ( 17 17 + issueRefs []models.ReferenceLink 18 18 + pullRefs []models.ReferenceLink 19 19 + ) 20 20 + for _, ref := range refLinks { 21 21 + switch ref.Kind { 22 22 + case models.RefKindIssue: 23 23 + issueRefs = append(issueRefs, ref) 24 24 + case models.RefKindPull: 25 25 + pullRefs = append(pullRefs, ref) 26 26 + } 27 27 + } 28 28 + issueUris, err := findIssueReferences(e, issueRefs) 29 29 + if err != nil { 30 30 + return nil, err 31 31 + } 32 32 + pullUris, err := findPullReferences(e, pullRefs) 33 33 + if err != nil { 34 34 + return nil, err 35 35 + } 36 36 + 37 37 + return append(issueUris, pullUris...), nil 38 38 + } 39 39 + 40 40 + func findIssueReferences(e Execer, refLinks []models.ReferenceLink) ([]syntax.ATURI, error) { 41 41 + if len(refLinks) == 0 { 42 42 + return nil, nil 43 43 + } 44 44 + vals := make([]string, len(refLinks)) 45 45 + args := make([]any, 0, len(refLinks)*4) 46 46 + for i, ref := range refLinks { 47 47 + vals[i] = "(?, ?, ?, ?)" 48 48 + args = append(args, ref.Handle, ref.Repo, ref.SubjectId, ref.CommentId) 49 49 + } 50 50 + query := fmt.Sprintf( 51 51 + `with input(owner_did, name, issue_id, comment_id) as ( 52 52 + values %s 53 53 + ) 54 54 + select 55 55 + i.did, i.rkey, 56 56 + c.did, c.rkey 57 57 + from input inp 58 58 + join repos r 59 59 + on r.did = inp.owner_did 60 60 + and r.name = inp.name 61 61 + join issues i 62 62 + on i.repo_at = r.at_uri 63 63 + and i.issue_id = inp.issue_id 64 64 + left join issue_comments c 65 65 + on inp.comment_id is not null 66 66 + and c.issue_at = i.at_uri 67 67 + and c.id = inp.comment_id 68 68 + `, 69 69 + strings.Join(vals, ","), 70 70 + ) 71 71 + rows, err := e.Query(query, args...) 72 72 + if err != nil { 73 73 + return nil, err 74 74 + } 75 75 + defer rows.Close() 76 76 + 77 77 + var uris []syntax.ATURI 78 78 + 79 79 + for rows.Next() { 80 80 + // Scan rows 81 81 + var issueOwner, issueRkey string 82 82 + var commentOwner, commentRkey sql.NullString 83 83 + var uri syntax.ATURI 84 84 + if err := rows.Scan(&issueOwner, &issueRkey, &commentOwner, &commentRkey); err != nil { 85 85 + return nil, err 86 86 + } 87 87 + if commentOwner.Valid && commentRkey.Valid { 88 88 + uri = syntax.ATURI(fmt.Sprintf( 89 89 + "at://%s/%s/%s", 90 90 + commentOwner.String, 91 91 + tangled.RepoIssueCommentNSID, 92 92 + commentRkey.String, 93 93 + )) 94 94 + } else { 95 95 + uri = syntax.ATURI(fmt.Sprintf( 96 96 + "at://%s/%s/%s", 97 97 + issueOwner, 98 98 + tangled.RepoIssueNSID, 99 99 + issueRkey, 100 100 + )) 101 101 + } 102 102 + uris = append(uris, uri) 103 103 + } 104 104 + return uris, nil 105 105 + } 106 106 + 107 107 + func findPullReferences(e Execer, refLinks []models.ReferenceLink) ([]syntax.ATURI, error) { 108 108 + if len(refLinks) == 0 { 109 109 + return nil, nil 110 110 + } 111 111 + vals := make([]string, len(refLinks)) 112 112 + args := make([]any, 0, len(refLinks)*4) 113 113 + for i, ref := range refLinks { 114 114 + vals[i] = "(?, ?, ?, ?)" 115 115 + args = append(args, ref.Handle, ref.Repo, ref.SubjectId, ref.CommentId) 116 116 + } 117 117 + query := fmt.Sprintf( 118 118 + `with input(owner_did, name, pull_id, comment_id) as ( 119 119 + values %s 120 120 + ) 121 121 + select 122 122 + p.owner_did, p.rkey, 123 123 + c.owner_did, c.rkey 124 124 + from input inp 125 125 + join repos r 126 126 + on r.did = inp.owner_did 127 127 + and r.name = inp.name 128 128 + join pulls p 129 129 + on p.repo_at = r.at_uri 130 130 + and p.pull_id = inp.pull_id 131 131 + left join pull_comments c 132 132 + on inp.comment_id is not null 133 133 + and c.repo_at = r.at_uri and c.pull_id = p.pull_id 134 134 + and c.id = inp.comment_id 135 135 + `, 136 136 + strings.Join(vals, ","), 137 137 + ) 138 138 + rows, err := e.Query(query, args...) 139 139 + if err != nil { 140 140 + return nil, err 141 141 + } 142 142 + defer rows.Close() 143 143 + 144 144 + var uris []syntax.ATURI 145 145 + 146 146 + for rows.Next() { 147 147 + // Scan rows 148 148 + var pullOwner, pullRkey string 149 149 + var commentOwner, commentRkey sql.NullString 150 150 + var uri syntax.ATURI 151 151 + if err := rows.Scan(&pullOwner, &pullRkey, &commentOwner, &commentRkey); err != nil { 152 152 + return nil, err 153 153 + } 154 154 + if commentOwner.Valid && commentRkey.Valid { 155 155 + uri = syntax.ATURI(fmt.Sprintf( 156 156 + "at://%s/%s/%s", 157 157 + commentOwner.String, 158 158 + tangled.RepoPullCommentNSID, 159 159 + commentRkey.String, 160 160 + )) 161 161 + } else { 162 162 + uri = syntax.ATURI(fmt.Sprintf( 163 163 + "at://%s/%s/%s", 164 164 + pullOwner, 165 165 + tangled.RepoPullNSID, 166 166 + pullRkey, 167 167 + )) 168 168 + } 169 169 + uris = append(uris, uri) 170 170 + } 171 171 + return uris, nil 172 172 + }

+10 -20

appview/issues/issues.go

··· 24 24 "tangled.org/core/appview/notify" 25 25 "tangled.org/core/appview/oauth" 26 26 "tangled.org/core/appview/pages" 27 27 - "tangled.org/core/appview/pages/markup" 28 27 "tangled.org/core/appview/pagination" 28 28 + "tangled.org/core/appview/refresolver" 29 29 "tangled.org/core/appview/reporesolver" 30 30 "tangled.org/core/appview/validator" 31 31 "tangled.org/core/idresolver" ··· 37 37 repoResolver *reporesolver.RepoResolver 38 38 pages *pages.Pages 39 39 idResolver *idresolver.Resolver 40 40 + refResolver *refresolver.Resolver 40 41 db *db.DB 41 42 config *config.Config 42 43 notifier notify.Notifier ··· 50 51 repoResolver *reporesolver.RepoResolver, 51 52 pages *pages.Pages, 52 53 idResolver *idresolver.Resolver, 54 54 + refResolver *refresolver.Resolver, 53 55 db *db.DB, 54 56 config *config.Config, 55 57 notifier notify.Notifier, ··· 62 64 repoResolver: repoResolver, 63 65 pages: pages, 64 66 idResolver: idResolver, 67 67 + refResolver: refResolver, 65 68 db: db, 66 69 config: config, 67 70 notifier: notifier, ··· 399 402 replyTo = &replyToUri 400 403 } 401 404 405 405 + mentions, _ := rp.refResolver.Resolve(r.Context(), body) 406 406 + 402 407 comment := models.IssueComment{ 403 408 Did: user.Did, 404 409 Rkey: tid.TID(), ··· 455 460 // notify about the new comment 456 461 comment.Id = commentId 457 462 458 458 - rawMentions := markup.FindUserMentions(comment.Body) 459 459 - idents := rp.idResolver.ResolveIdents(r.Context(), rawMentions) 460 460 - l.Debug("parsed mentions", "raw", rawMentions, "idents", idents) 461 461 - var mentions []syntax.DID 462 462 - for _, ident := range idents { 463 463 - if ident != nil && !ident.Handle.IsInvalidHandle() { 464 464 - mentions = append(mentions, ident.DID) 465 465 - } 466 466 - } 467 463 rp.notifier.NewIssueComment(r.Context(), &comment, mentions) 468 464 469 465 rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d#comment-%d", f.OwnerSlashRepo(), issue.IssueId, commentId)) ··· 884 880 RepoInfo: f.RepoInfo(user), 885 881 }) 886 882 case http.MethodPost: 883 883 + body := r.FormValue("body") 884 884 + mentions, _ := rp.refResolver.Resolve(r.Context(), body) 885 885 + 887 886 issue := &models.Issue{ 888 887 RepoAt: f.RepoAt(), 889 888 Rkey: tid.TID(), 890 889 Title: r.FormValue("title"), 891 891 - Body: r.FormValue("body"), 890 890 + Body: body, 892 891 Open: true, 893 892 Did: user.Did, 894 893 Created: time.Now(), ··· 960 959 // everything is successful, do not rollback the atproto record 961 960 atUri = "" 962 961 963 963 - rawMentions := markup.FindUserMentions(issue.Body) 964 964 - idents := rp.idResolver.ResolveIdents(r.Context(), rawMentions) 965 965 - l.Debug("parsed mentions", "raw", rawMentions, "idents", idents) 966 966 - var mentions []syntax.DID 967 967 - for _, ident := range idents { 968 968 - if ident != nil && !ident.Handle.IsInvalidHandle() { 969 969 - mentions = append(mentions, ident.DID) 970 970 - } 971 971 - } 972 962 rp.notifier.NewIssue(r.Context(), issue, mentions) 973 963 rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId)) 974 964 return

+18

appview/models/reference.go

··· 1 1 + package models 2 2 + 3 3 + type RefKind int 4 4 + 5 5 + const ( 6 6 + RefKindIssue RefKind = iota 7 7 + RefKindPull 8 8 + ) 9 9 + 10 10 + // /@alice.com/cool-proj/issues/123 11 11 + // /@alice.com/cool-proj/issues/123#comment-321 12 12 + type ReferenceLink struct { 13 13 + Handle string 14 14 + Repo string 15 15 + Kind RefKind 16 16 + SubjectId int 17 17 + CommentId *int 18 18 + }

+3 -3

appview/pages/markup/extension/atlink.go

··· 16 16 17 17 // An AtNode struct represents an AtNode 18 18 type AtNode struct { 19 19 - handle string 19 19 + Handle string 20 20 ast.BaseInline 21 21 } 22 22 ··· 59 59 block.Advance(m[1]) 60 60 node := &AtNode{} 61 61 node.AppendChild(node, ast.NewTextSegment(atSegment)) 62 62 - node.handle = string(atSegment.Value(block.Source())[1:]) 62 62 + node.Handle = string(atSegment.Value(block.Source())[1:]) 63 63 return node 64 64 } 65 65 ··· 88 88 func (r *atHtmlRenderer) renderAt(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) { 89 89 if entering { 90 90 w.WriteString(`<a href="/@`) 91 91 - w.WriteString(n.(*AtNode).handle) 91 91 + w.WriteString(n.(*AtNode).Handle) 92 92 w.WriteString(`" class="mention">`) 93 93 } else { 94 94 w.WriteString("</a>")

+24

appview/pages/markup/markdown.go

··· 77 77 return md 78 78 } 79 79 80 80 + // FindUserMentions returns Set of user handles from given markup soruce. 81 81 + // It doesn't guarntee unique DIDs 82 82 + func FindUserMentions(source string) []string { 83 83 + var ( 84 84 + mentions []string 85 85 + mentionsSet = make(map[string]struct{}) 86 86 + md = NewMarkdown() 87 87 + sourceBytes = []byte(source) 88 88 + root = md.Parser().Parse(text.NewReader(sourceBytes)) 89 89 + ) 90 90 + ast.Walk(root, func(n ast.Node, entering bool) (ast.WalkStatus, error) { 91 91 + if entering && n.Kind() == textension.KindAt { 92 92 + handle := n.(*textension.AtNode).Handle 93 93 + mentionsSet[handle] = struct{}{} 94 94 + return ast.WalkSkipChildren, nil 95 95 + } 96 96 + return ast.WalkContinue, nil 97 97 + }) 98 98 + for handle := range mentionsSet { 99 99 + mentions = append(mentions, handle) 100 100 + } 101 101 + return mentions 102 102 + } 103 103 + 80 104 func (rctx *RenderContext) RenderMarkdown(source string) string { 81 105 md := NewMarkdown() 82 106

+123

appview/pages/markup/reference_link.go

··· 1 1 + package markup 2 2 + 3 3 + import ( 4 4 + "maps" 5 5 + "net/url" 6 6 + "path" 7 7 + "slices" 8 8 + "strconv" 9 9 + "strings" 10 10 + 11 11 + "github.com/yuin/goldmark/ast" 12 12 + "github.com/yuin/goldmark/text" 13 13 + "tangled.org/core/appview/models" 14 14 + ) 15 15 + 16 16 + // FindReferences collects all links referencing tangled-related objects 17 17 + // like issues, PRs, comments or even @-mentions 18 18 + // This funciton doesn't actually check for the existence of records in the DB 19 19 + // or the PDS; it merely returns a list of what are presumed to be references. 20 20 + func FindReferences(baseUrl string, source string) ([]string, []models.ReferenceLink) { 21 21 + var ( 22 22 + refLinkSet = make(map[models.ReferenceLink]struct{}) 23 23 + mentionsSet = make(map[string]struct{}) 24 24 + md = NewMarkdown() 25 25 + sourceBytes = []byte(source) 26 26 + root = md.Parser().Parse(text.NewReader(sourceBytes)) 27 27 + ) 28 28 + // trim url scheme. the SSL shouldn't matter 29 29 + baseUrl = strings.TrimPrefix(baseUrl, "https://") 30 30 + baseUrl = strings.TrimPrefix(baseUrl, "http://") 31 31 + 32 32 + ast.Walk(root, func(n ast.Node, entering bool) (ast.WalkStatus, error) { 33 33 + if !entering { 34 34 + return ast.WalkContinue, nil 35 35 + } 36 36 + switch n.Kind() { 37 37 + case KindAt: 38 38 + handle := n.(*AtNode).handle 39 39 + mentionsSet[handle] = struct{}{} 40 40 + return ast.WalkSkipChildren, nil 41 41 + case ast.KindLink: 42 42 + dest := string(n.(*ast.Link).Destination) 43 43 + ref := parseTangledLink(baseUrl, dest) 44 44 + if ref != nil { 45 45 + refLinkSet[*ref] = struct{}{} 46 46 + } 47 47 + return ast.WalkSkipChildren, nil 48 48 + case ast.KindAutoLink: 49 49 + an := n.(*ast.AutoLink) 50 50 + if an.AutoLinkType == ast.AutoLinkURL { 51 51 + dest := string(an.URL(sourceBytes)) 52 52 + ref := parseTangledLink(baseUrl, dest) 53 53 + if ref != nil { 54 54 + refLinkSet[*ref] = struct{}{} 55 55 + } 56 56 + } 57 57 + return ast.WalkSkipChildren, nil 58 58 + } 59 59 + return ast.WalkContinue, nil 60 60 + }) 61 61 + mentions := slices.Collect(maps.Keys(mentionsSet)) 62 62 + references := slices.Collect(maps.Keys(refLinkSet)) 63 63 + return mentions, references 64 64 + } 65 65 + 66 66 + func parseTangledLink(baseHost string, urlStr string) *models.ReferenceLink { 67 67 + u, err := url.Parse(urlStr) 68 68 + if err != nil { 69 69 + return nil 70 70 + } 71 71 + 72 72 + if u.Host != "" && !strings.EqualFold(u.Host, baseHost) { 73 73 + return nil 74 74 + } 75 75 + 76 76 + p := path.Clean(u.Path) 77 77 + parts := strings.FieldsFunc(p, func(r rune) bool { return r == '/' }) 78 78 + if len(parts) < 4 { 79 79 + // need at least: handle / repo / kind / id 80 80 + return nil 81 81 + } 82 82 + 83 83 + var ( 84 84 + handle = parts[0] 85 85 + repo = parts[1] 86 86 + kindSeg = parts[2] 87 87 + subjectSeg = parts[3] 88 88 + ) 89 89 + 90 90 + handle = strings.TrimPrefix(handle, "@") 91 91 + 92 92 + var kind models.RefKind 93 93 + switch kindSeg { 94 94 + case "issues": 95 95 + kind = models.RefKindIssue 96 96 + case "pulls": 97 97 + kind = models.RefKindPull 98 98 + default: 99 99 + return nil 100 100 + } 101 101 + 102 102 + subjectId, err := strconv.Atoi(subjectSeg) 103 103 + if err != nil { 104 104 + return nil 105 105 + } 106 106 + var commentId *int 107 107 + if u.Fragment != "" { 108 108 + if strings.HasPrefix(u.Fragment, "comment-") { 109 109 + commentIdStr := u.Fragment[len("comment-"):] 110 110 + if id, err := strconv.Atoi(commentIdStr); err == nil { 111 111 + commentId = &id 112 112 + } 113 113 + } 114 114 + } 115 115 + 116 116 + return &models.ReferenceLink{ 117 117 + Handle: handle, 118 118 + Repo: repo, 119 119 + Kind: kind, 120 120 + SubjectId: subjectId, 121 121 + CommentId: commentId, 122 122 + } 123 123 + }

+42

appview/pages/markup/reference_link_test.go

··· 1 1 + package markup_test 2 2 + 3 3 + import ( 4 4 + "testing" 5 5 + 6 6 + "github.com/stretchr/testify/assert" 7 7 + "tangled.org/core/appview/models" 8 8 + "tangled.org/core/appview/pages/markup" 9 9 + ) 10 10 + 11 11 + func TestMarkupParsing(t *testing.T) { 12 12 + tests := []struct { 13 13 + name string 14 14 + source string 15 15 + wantHandles []string 16 16 + wantRefLinks []models.ReferenceLink 17 17 + }{ 18 18 + { 19 19 + name: "normal link", 20 20 + source: `[link](http://127.0.0.1:3000/alice.pds.tngl.boltless.dev/coolproj/issues/1)`, 21 21 + wantHandles: make([]string, 0), 22 22 + wantRefLinks: []models.ReferenceLink{ 23 23 + {Handle: "alice.pds.tngl.boltless.dev", Repo: "coolproj", Kind: models.RefKindIssue, SubjectId: 1, CommentId: nil}, 24 24 + }, 25 25 + }, 26 26 + { 27 27 + name: "commonmark style autolink", 28 28 + source: `<http://127.0.0.1:3000/alice.pds.tngl.boltless.dev/coolproj/issues/1>`, 29 29 + wantHandles: make([]string, 0), 30 30 + wantRefLinks: []models.ReferenceLink{ 31 31 + {Handle: "alice.pds.tngl.boltless.dev", Repo: "coolproj", Kind: models.RefKindIssue, SubjectId: 1, CommentId: nil}, 32 32 + }, 33 33 + }, 34 34 + } 35 35 + for _, tt := range tests { 36 36 + t.Run(tt.name, func(t *testing.T) { 37 37 + handles, refLinks := markup.FindReferences("http://127.0.0.1:3000", tt.source) 38 38 + assert.ElementsMatch(t, tt.wantHandles, handles) 39 39 + assert.ElementsMatch(t, tt.wantRefLinks, refLinks) 40 40 + }) 41 41 + } 42 42 + }

+6 -10

appview/pulls/pulls.go

··· 23 23 "tangled.org/core/appview/oauth" 24 24 "tangled.org/core/appview/pages" 25 25 "tangled.org/core/appview/pages/markup" 26 26 + "tangled.org/core/appview/refresolver" 26 27 "tangled.org/core/appview/reporesolver" 27 28 "tangled.org/core/appview/validator" 28 29 "tangled.org/core/appview/xrpcclient" ··· 45 46 repoResolver *reporesolver.RepoResolver 46 47 pages *pages.Pages 47 48 idResolver *idresolver.Resolver 49 49 + refResolver *refresolver.Resolver 48 50 db *db.DB 49 51 config *config.Config 50 52 notifier notify.Notifier ··· 59 61 repoResolver *reporesolver.RepoResolver, 60 62 pages *pages.Pages, 61 63 resolver *idresolver.Resolver, 64 64 + refResolver *refresolver.Resolver, 62 65 db *db.DB, 63 66 config *config.Config, 64 67 notifier notify.Notifier, ··· 72 75 repoResolver: repoResolver, 73 76 pages: pages, 74 77 idResolver: resolver, 78 78 + refResolver: refResolver, 75 79 db: db, 76 80 config: config, 77 81 notifier: notifier, ··· 691 695 } 692 696 693 697 func (s *Pulls) PullComment(w http.ResponseWriter, r *http.Request) { 694 694 - l := s.logger.With("handler", "PullComment") 695 698 user := s.oauth.GetUser(r) 696 699 f, err := s.repoResolver.Resolve(r) 697 700 if err != nil { ··· 730 733 return 731 734 } 732 735 736 736 + mentions, _ := s.refResolver.Resolve(r.Context(), body) 737 737 + 733 738 // Start a transaction 734 739 tx, err := s.db.BeginTx(r.Context(), nil) 735 740 if err != nil { ··· 789 794 return 790 795 } 791 796 792 792 - rawMentions := markup.FindUserMentions(comment.Body) 793 793 - idents := s.idResolver.ResolveIdents(r.Context(), rawMentions) 794 794 - l.Debug("parsed mentions", "raw", rawMentions, "idents", idents) 795 795 - var mentions []syntax.DID 796 796 - for _, ident := range idents { 797 797 - if ident != nil && !ident.Handle.IsInvalidHandle() { 798 798 - mentions = append(mentions, ident.DID) 799 799 - } 800 800 - } 801 797 s.notifier.NewPullComment(r.Context(), comment, mentions) 802 798 803 799 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", f.OwnerSlashRepo(), pull.PullId, commentId))

+65

appview/refresolver/resolver.go

··· 1 1 + package refresolver 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "log/slog" 6 6 + 7 7 + "github.com/bluesky-social/indigo/atproto/syntax" 8 8 + "tangled.org/core/appview/config" 9 9 + "tangled.org/core/appview/db" 10 10 + "tangled.org/core/appview/models" 11 11 + "tangled.org/core/appview/pages/markup" 12 12 + "tangled.org/core/idresolver" 13 13 + ) 14 14 + 15 15 + type Resolver struct { 16 16 + config *config.Config 17 17 + idResolver *idresolver.Resolver 18 18 + execer db.Execer 19 19 + logger *slog.Logger 20 20 + } 21 21 + 22 22 + func New( 23 23 + config *config.Config, 24 24 + idResolver *idresolver.Resolver, 25 25 + execer db.Execer, 26 26 + logger *slog.Logger, 27 27 + ) *Resolver { 28 28 + return &Resolver{ 29 29 + config, 30 30 + idResolver, 31 31 + execer, 32 32 + logger, 33 33 + } 34 34 + } 35 35 + 36 36 + func (r *Resolver) Resolve(ctx context.Context, source string) ([]syntax.DID, []syntax.ATURI) { 37 37 + l := r.logger.With("method", "find_references") 38 38 + rawMentions, rawRefs := markup.FindReferences(r.config.Core.AppviewHost, source) 39 39 + l.Debug("found possible references", "mentions", rawMentions, "refs", rawRefs) 40 40 + idents := r.idResolver.ResolveIdents(ctx, rawMentions) 41 41 + var mentions []syntax.DID 42 42 + for _, ident := range idents { 43 43 + if ident != nil && !ident.Handle.IsInvalidHandle() { 44 44 + mentions = append(mentions, ident.DID) 45 45 + } 46 46 + } 47 47 + l.Debug("found mentions", "mentions", mentions) 48 48 + 49 49 + var resolvedRefs []models.ReferenceLink 50 50 + for _, rawRef := range rawRefs { 51 51 + ident, err := r.idResolver.ResolveIdent(ctx, rawRef.Handle) 52 52 + if err != nil || ident == nil || ident.Handle.IsInvalidHandle() { 53 53 + continue 54 54 + } 55 55 + rawRef.Handle = string(ident.DID) 56 56 + resolvedRefs = append(resolvedRefs, rawRef) 57 57 + } 58 58 + aturiRefs, err := db.FindReferences(r.execer, resolvedRefs) 59 59 + if err != nil { 60 60 + l.Error("failed running query", "err", err) 61 61 + } 62 62 + l.Debug("found references", "refs", aturiRefs) 63 63 + 64 64 + return mentions, aturiRefs 65 65 + }

+2

appview/state/router.go

··· 260 260 s.repoResolver, 261 261 s.pages, 262 262 s.idResolver, 263 263 + s.refResolver, 263 264 s.db, 264 265 s.config, 265 266 s.notifier, ··· 276 277 s.repoResolver, 277 278 s.pages, 278 279 s.idResolver, 280 280 + s.refResolver, 279 281 s.db, 280 282 s.config, 281 283 s.notifier,

+5

appview/state/state.go

··· 21 21 phnotify "tangled.org/core/appview/notify/posthog" 22 22 "tangled.org/core/appview/oauth" 23 23 "tangled.org/core/appview/pages" 24 24 + "tangled.org/core/appview/refresolver" 24 25 "tangled.org/core/appview/reporesolver" 25 26 "tangled.org/core/appview/validator" 26 27 xrpcclient "tangled.org/core/appview/xrpcclient" ··· 49 50 enforcer *rbac.Enforcer 50 51 pages *pages.Pages 51 52 idResolver *idresolver.Resolver 53 53 + refResolver *refresolver.Resolver 52 54 posthog posthog.Client 53 55 jc *jetstream.JetstreamClient 54 56 config *config.Config ··· 98 100 99 101 repoResolver := reporesolver.New(config, enforcer, res, d) 100 102 103 103 + refResolver := refresolver.New(config, res, d, log.SubLogger(logger, "refResolver")) 104 104 + 101 105 wrapper := db.DbWrapper{Execer: d} 102 106 jc, err := jetstream.NewJetstreamClient( 103 107 config.Jetstream.Endpoint, ··· 178 182 enforcer, 179 183 pages, 180 184 res, 185 185 + refResolver, 181 186 posthog, 182 187 jc, 183 188 config,