patch of draft: render backlinks · round #2 · pull #765 · tangled.org/core

+212

appview/db/reference.go

···

       249
       249
        
       

     

       250
       250
        
       	return result, nil

     

       251
       251
        
       }

     

       252
       252
       +
       

     

       253
       253
       +
       func GetBacklinks(e Execer, target syntax.ATURI) ([]models.RichReferenceLink, error) {

     

       254
       254
       +
       	rows, err := e.Query(

     

       255
       255
       +
       		`select from_at from reference_links

     

       256
       256
       +
       		where to_at = ?`,

     

       257
       257
       +
       		target,

     

       258
       258
       +
       	)

     

       259
       259
       +
       	if err != nil {

     

       260
       260
       +
       		return nil, fmt.Errorf("query backlinks: %w", err)

     

       261
       261
       +
       	}

     

       262
       262
       +
       	defer rows.Close()

     

       263
       263
       +
       

     

       264
       264
       +
       	var (

     

       265
       265
       +
       		backlinks    []models.RichReferenceLink

     

       266
       266
       +
       		backlinksMap = make(map[string][]syntax.ATURI)

     

       267
       267
       +
       	)

     

       268
       268
       +
       	for rows.Next() {

     

       269
       269
       +
       		var from syntax.ATURI

     

       270
       270
       +
       		if err := rows.Scan(&from); err != nil {

     

       271
       271
       +
       			return nil, fmt.Errorf("scan row: %w", err)

     

       272
       272
       +
       		}

     

       273
       273
       +
       		nsid := from.Collection().String()

     

       274
       274
       +
       		backlinksMap[nsid] = append(backlinksMap[nsid], from)

     

       275
       275
       +
       	}

     

       276
       276
       +
       	if err := rows.Err(); err != nil {

     

       277
       277
       +
       		return nil, fmt.Errorf("iterate rows: %w", err)

     

       278
       278
       +
       	}

     

       279
       279
       +
       

     

       280
       280
       +
       	var ls []models.RichReferenceLink

     

       281
       281
       +
       	ls, err = getIssueBacklinks(e, backlinksMap[tangled.RepoIssueNSID])

     

       282
       282
       +
       	if err != nil {

     

       283
       283
       +
       		return nil, fmt.Errorf("get issue backlinks: %w", err)

     

       284
       284
       +
       	}

     

       285
       285
       +
       	backlinks = append(backlinks, ls...)

     

       286
       286
       +
       	ls, err = getIssueCommentBacklinks(e, backlinksMap[tangled.RepoIssueCommentNSID])

     

       287
       287
       +
       	if err != nil {

     

       288
       288
       +
       		return nil, fmt.Errorf("get issue_comment backlinks: %w", err)

     

       289
       289
       +
       	}

     

       290
       290
       +
       	backlinks = append(backlinks, ls...)

     

       291
       291
       +
       	ls, err = getPullBacklinks(e, backlinksMap[tangled.RepoPullNSID])

     

       292
       292
       +
       	if err != nil {

     

       293
       293
       +
       		return nil, fmt.Errorf("get pull backlinks: %w", err)

     

       294
       294
       +
       	}

     

       295
       295
       +
       	backlinks = append(backlinks, ls...)

     

       296
       296
       +
       	ls, err = getPullCommentBacklinks(e, backlinksMap[tangled.RepoPullCommentNSID])

     

       297
       297
       +
       	if err != nil {

     

       298
       298
       +
       		return nil, fmt.Errorf("get pull_comment backlinks: %w", err)

     

       299
       299
       +
       	}

     

       300
       300
       +
       	backlinks = append(backlinks, ls...)

     

       301
       301
       +
       

     

       302
       302
       +
       	return backlinks, nil

     

       303
       303
       +
       }

     

       304
       304
       +
       

     

       305
       305
       +
       func getIssueBacklinks(e Execer, aturis []syntax.ATURI) ([]models.RichReferenceLink, error) {

     

       306
       306
       +
       	if len(aturis) == 0 {

     

       307
       307
       +
       		return nil, nil

     

       308
       308
       +
       	}

     

       309
       309
       +
       	vals := make([]string, len(aturis))

     

       310
       310
       +
       	args := make([]any, 0, len(aturis)*2)

     

       311
       311
       +
       	for i, aturi := range aturis {

     

       312
       312
       +
       		vals[i] = "(?, ?, ?, ?)"

     

       313
       313
       +
       		did := aturi.Authority().String()

     

       314
       314
       +
       		rkey := aturi.RecordKey().String()

     

       315
       315
       +
       		args = append(args, did, rkey)

     

       316
       316
       +
       	}

     

       317
       317
       +
       	rows, err := e.Query(

     

       318
       318
       +
       		fmt.Sprintf(

     

       319
       319
       +
       			`select r.did, r.name, i.issue_id, i.title, i.open

     

       320
       320
       +
       			from issues i

     

       321
       321
       +
       			join repos r

     

       322
       322
       +
       				on r.at_uri = i.repo_at

     

       323
       323
       +
       			where (i.did, i.rkey) in (%s)`,

     

       324
       324
       +
       			strings.Join(vals, ","),

     

       325
       325
       +
       		),

     

       326
       326
       +
       		args...,

     

       327
       327
       +
       	)

     

       328
       328
       +
       	if err != nil {

     

       329
       329
       +
       		return nil, err

     

       330
       330
       +
       	}

     

       331
       331
       +
       	defer rows.Close()

     

       332
       332
       +
       	var refLinks []models.RichReferenceLink

     

       333
       333
       +
       	for rows.Next() {

     

       334
       334
       +
       		var l models.RichReferenceLink

     

       335
       335
       +
       		l.Kind = models.RefKindIssue

     

       336
       336
       +
       		if err := rows.Scan(&l.Handle, &l.Repo, &l.SubjectId, &l.Title, &l.State); err != nil {

     

       337
       337
       +
       			return nil, err

     

       338
       338
       +
       		}

     

       339
       339
       +
       		refLinks = append(refLinks, l)

     

       340
       340
       +
       	}

     

       341
       341
       +
       	if err := rows.Err(); err != nil {

     

       342
       342
       +
       		return nil, fmt.Errorf("iterate rows: %w", err)

     

       343
       343
       +
       	}

     

       344
       344
       +
       	return refLinks, nil

     

       345
       345
       +
       }

     

       346
       346
       +
       

     

       347
       347
       +
       func getIssueCommentBacklinks(e Execer, aturis []syntax.ATURI) ([]models.RichReferenceLink, error) {

     

       348
       348
       +
       	if len(aturis) == 0 {

     

       349
       349
       +
       		return nil, nil

     

       350
       350
       +
       	}

     

       351
       351
       +
       	filter := FilterIn("c.at_uri", aturis)

     

       352
       352
       +
       	rows, err := e.Query(

     

       353
       353
       +
       		fmt.Sprintf(

     

       354
       354
       +
       			`select r.did, r.name, i.issue_id, c.id, i.title, i.open

     

       355
       355
       +
       			from issue_comments c

     

       356
       356
       +
       			join issues i

     

       357
       357
       +
       				on i.at_uri = c.issue_at

     

       358
       358
       +
       			join repos r

     

       359
       359
       +
       				on r.at_uri = i.repo_at

     

       360
       360
       +
       			where %s`,

     

       361
       361
       +
       			filter.Condition(),

     

       362
       362
       +
       		),

     

       363
       363
       +
       		filter.Arg()...,

     

       364
       364
       +
       	)

     

       365
       365
       +
       	if err != nil {

     

       366
       366
       +
       		return nil, err

     

       367
       367
       +
       	}

     

       368
       368
       +
       	defer rows.Close()

     

       369
       369
       +
       	var refLinks []models.RichReferenceLink

     

       370
       370
       +
       	for rows.Next() {

     

       371
       371
       +
       		var l models.RichReferenceLink

     

       372
       372
       +
       		l.Kind = models.RefKindIssue

     

       373
       373
       +
       		l.CommentId = new(int)

     

       374
       374
       +
       		if err := rows.Scan(&l.Handle, &l.Repo, &l.SubjectId, l.CommentId, &l.Title, &l.State); err != nil {

     

       375
       375
       +
       			return nil, err

     

       376
       376
       +
       		}

     

       377
       377
       +
       		refLinks = append(refLinks, l)

     

       378
       378
       +
       	}

     

       379
       379
       +
       	if err := rows.Err(); err != nil {

     

       380
       380
       +
       		return nil, fmt.Errorf("iterate rows: %w", err)

     

       381
       381
       +
       	}

     

       382
       382
       +
       	return refLinks, nil

     

       383
       383
       +
       }

     

       384
       384
       +
       

     

       385
       385
       +
       func getPullBacklinks(e Execer, aturis []syntax.ATURI) ([]models.RichReferenceLink, error) {

     

       386
       386
       +
       	if len(aturis) == 0 {

     

       387
       387
       +
       		return nil, nil

     

       388
       388
       +
       	}

     

       389
       389
       +
       	vals := make([]string, len(aturis))

     

       390
       390
       +
       	args := make([]any, 0, len(aturis)*2)

     

       391
       391
       +
       	for i, aturi := range aturis {

     

       392
       392
       +
       		vals[i] = "(?, ?, ?, ?)"

     

       393
       393
       +
       		did := aturi.Authority().String()

     

       394
       394
       +
       		rkey := aturi.RecordKey().String()

     

       395
       395
       +
       		args = append(args, did, rkey)

     

       396
       396
       +
       	}

     

       397
       397
       +
       	rows, err := e.Query(

     

       398
       398
       +
       		fmt.Sprintf(

     

       399
       399
       +
       			`select r.did, r.name, p.pull_id, p.title, p.state

     

       400
       400
       +
       			join repos r

     

       401
       401
       +
       			join pulls p

     

       402
       402
       +
       				on r.at_uri = i.repo_at

     

       403
       403
       +
       			where (p.owner_did, p.rkey) in (%s)`,

     

       404
       404
       +
       			strings.Join(vals, ","),

     

       405
       405
       +
       		),

     

       406
       406
       +
       		args...,

     

       407
       407
       +
       	)

     

       408
       408
       +
       	if err != nil {

     

       409
       409
       +
       		return nil, err

     

       410
       410
       +
       	}

     

       411
       411
       +
       	defer rows.Close()

     

       412
       412
       +
       	var refLinks []models.RichReferenceLink

     

       413
       413
       +
       	for rows.Next() {

     

       414
       414
       +
       		var l models.RichReferenceLink

     

       415
       415
       +
       		l.Kind = models.RefKindIssue

     

       416
       416
       +
       		if err := rows.Scan(&l.Handle, &l.Repo, &l.SubjectId, &l.Title, &l.State); err != nil {

     

       417
       417
       +
       			return nil, err

     

       418
       418
       +
       		}

     

       419
       419
       +
       		refLinks = append(refLinks, l)

     

       420
       420
       +
       	}

     

       421
       421
       +
       	if err := rows.Err(); err != nil {

     

       422
       422
       +
       		return nil, fmt.Errorf("iterate rows: %w", err)

     

       423
       423
       +
       	}

     

       424
       424
       +
       	return refLinks, nil

     

       425
       425
       +
       }

     

       426
       426
       +
       

     

       427
       427
       +
       func getPullCommentBacklinks(e Execer, aturis []syntax.ATURI) ([]models.RichReferenceLink, error) {

     

       428
       428
       +
       	if len(aturis) == 0 {

     

       429
       429
       +
       		return nil, nil

     

       430
       430
       +
       	}

     

       431
       431
       +
       	filter := FilterIn("c.comment_at", aturis)

     

       432
       432
       +
       	rows, err := e.Query(

     

       433
       433
       +
       		fmt.Sprintf(

     

       434
       434
       +
       			`select r.did, r.name, p.pull_id, c.id, p.title, p.state

     

       435
       435
       +
       			from repos r

     

       436
       436
       +
       			join pulls p

     

       437
       437
       +
       				on r.at_uri = p.repo_at

     

       438
       438
       +
       			join pull_comments c

     

       439
       439
       +
       				on r.at_uri = c.repo_at and p.pull_id = c.pull_id

     

       440
       440
       +
       			where %s`,

     

       441
       441
       +
       			filter.Condition(),

     

       442
       442
       +
       		),

     

       443
       443
       +
       		filter.Arg()...,

     

       444
       444
       +
       	)

     

       445
       445
       +
       	if err != nil {

     

       446
       446
       +
       		return nil, err

     

       447
       447
       +
       	}

     

       448
       448
       +
       	defer rows.Close()

     

       449
       449
       +
       	var refLinks []models.RichReferenceLink

     

       450
       450
       +
       	for rows.Next() {

     

       451
       451
       +
       		var l models.RichReferenceLink

     

       452
       452
       +
       		l.Kind = models.RefKindPull

     

       453
       453
       +
       		l.CommentId = new(int)

     

       454
       454
       +
       		if err := rows.Scan(&l.Handle, &l.Repo, &l.SubjectId, l.CommentId, &l.Title, &l.State); err != nil {

     

       455
       455
       +
       			return nil, err

     

       456
       456
       +
       		}

     

       457
       457
       +
       		refLinks = append(refLinks, l)

     

       458
       458
       +
       	}

     

       459
       459
       +
       	if err := rows.Err(); err != nil {

     

       460
       460
       +
       		return nil, fmt.Errorf("iterate rows: %w", err)

     

       461
       461
       +
       	}

     

       462
       462
       +
       	return refLinks, nil

     

       463
       463
       +
       }

appview/issues/issues.go

···

       100
       100
        
       		userReactions = db.GetReactionStatusMap(rp.db, user.Did, issue.AtUri())

     

       101
       101
        
       	}

     

       102
       102
        
       

     

       103
       103
       +
       	backlinks, err := db.GetBacklinks(rp.db, issue.AtUri())

     

       104
       104
       +
       	if err != nil {

     

       105
       105
       +
       		l.Error("failed to fetch backlinks", "err", err)

     

       106
       106
       +
       		rp.pages.Error503(w)

     

       107
       107
       +
       		return

     

       108
       108
       +
       	}

     

       109
       109
       +
       

     

       103
       110
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       104
       111
        
       		rp.db,

     

       105
       112
        
       		db.FilterIn("at_uri", f.Repo.Labels),

     
···

       121
       128
        
       		RepoInfo:             f.RepoInfo(user),

     

       122
       129
        
       		Issue:                issue,

     

       123
       130
        
       		CommentList:          issue.CommentList(),

     

       131
       131
       +
       		Backlinks:            backlinks,

     

       124
       132
        
       		OrderedReactionKinds: models.OrderedReactionKinds,

     

       125
       133
        
       		Reactions:            reactionMap,

     

       126
       134
        
       		UserReacted:          userReactions,

+31

appview/models/reference.go

···

       1
       1
        
       package models

     

       2
       2
        
       

     

       3
       3
       +
       import "fmt"

     

       4
       4
       +
       

     

       3
       5
        
       type RefKind int

     

       4
       6
        
       

     

       5
       7
        
       const (

     
···

       7
       9
        
       	RefKindPull

     

       8
       10
        
       )

     

       9
       11
        
       

     

       12
       12
       +
       func (k RefKind) String() string {

     

       13
       13
       +
       	if k == RefKindIssue {

     

       14
       14
       +
       		return "issues"

     

       15
       15
       +
       	} else {

     

       16
       16
       +
       		return "pulls"

     

       17
       17
       +
       	}

     

       18
       18
       +
       }

     

       19
       19
       +
       

     

       10
       20
        
       // /@alice.com/cool-proj/issues/123

     

       11
       21
        
       // /@alice.com/cool-proj/issues/123#comment-321

     

       12
       22
        
       type ReferenceLink struct {

     
···

       16
       26
        
       	SubjectId int

     

       17
       27
        
       	CommentId *int

     

       18
       28
        
       }

     

       29
       29
       +
       

     

       30
       30
       +
       func (l ReferenceLink) String() string {

     

       31
       31
       +
       	comment := ""

     

       32
       32
       +
       	if l.CommentId != nil {

     

       33
       33
       +
       		comment = fmt.Sprintf("#comment-%d", *l.CommentId)

     

       34
       34
       +
       	}

     

       35
       35
       +
       	return fmt.Sprintf("/%s/%s/%s/%d%s",

     

       36
       36
       +
       		l.Handle,

     

       37
       37
       +
       		l.Repo,

     

       38
       38
       +
       		l.Kind.String(),

     

       39
       39
       +
       		l.SubjectId,

     

       40
       40
       +
       		comment,

     

       41
       41
       +
       	)

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       type RichReferenceLink struct {

     

       45
       45
       +
       	ReferenceLink

     

       46
       46
       +
       	Title string

     

       47
       47
       +
       	// reusing PullState for both issue & PR

     

       48
       48
       +
       	State PullState

     

       49
       49
       +
       }

appview/pages/pages.go

···

       975
       975
        
       	Active       string

     

       976
       976
        
       	Issue        *models.Issue

     

       977
       977
        
       	CommentList  []models.CommentListItem

     

       978
       978
       +
       	Backlinks    []models.RichReferenceLink

     

       978
       979
        
       	LabelDefs    map[string]*models.LabelDefinition

     

       979
       980
        
       

     

       980
       981
        
       	OrderedReactionKinds []models.ReactionKind

     
···

       1128
       1129
        
       	Pull               *models.Pull

     

       1129
       1130
        
       	Stack              models.Stack

     

       1130
       1131
        
       	AbandonedPulls     []*models.Pull

     

       1132
       1132
       +
       	Backlinks          []models.RichReferenceLink

     

       1131
       1133
        
       	BranchDeleteStatus *models.BranchDeleteStatus

     

       1132
       1134
        
       	MergeCheck         types.MergeCheckResponse

     

       1133
       1135
        
       	ResubmitCheck      ResubmitResult

+49

appview/pages/templates/repo/fragments/backlinks.html

···

       1
       1
       +
       {{ define "repo/fragments/backlinks" }}

     

       2
       2
       +
         {{ if .Backlinks }}

     

       3
       3
       +
         <div id="at-uri-panel" class="px-2 md:px-0">

     

       4
       4
       +
           <div>

     

       5
       5
       +
             <span class="text-sm py-1 font-bold text-gray-500 dark:text-gray-400">Referenced by</span>

     

       6
       6
       +
           </div>

     

       7
       7
       +
           <ul>

     

       8
       8
       +
             {{ range .Backlinks }}

     

       9
       9
       +
             <li>

     

       10
       10
       +
               {{ $repoOwner := resolve .Handle }}

     

       11
       11
       +
               {{ $repoName := .Repo }}

     

       12
       12
       +
               {{ $repoUrl := printf "%s/%s" $repoOwner $repoName }}

     

       13
       13
       +
               <div class="flex flex-col">

     

       14
       14
       +
                 <div class="flex gap-2 items-center">

     

       15
       15
       +
                   {{ if .State.IsClosed }}

     

       16
       16
       +
                     <span class="text-gray-500 dark:text-gray-400">

     

       17
       17
       +
                       {{ i "ban" "w-4 h-4" }}

     

       18
       18
       +
                     </span>

     

       19
       19
       +
                   {{ else if eq .Kind.String "issues" }}

     

       20
       20
       +
                     <span class="text-green-600 dark:text-green-500">

     

       21
       21
       +
                       {{ i "circle-dot" "w-4 h-4" }}

     

       22
       22
       +
                     </span>

     

       23
       23
       +
                   {{ else if .State.IsOpen }}

     

       24
       24
       +
                     <span class="text-green-600 dark:text-green-500">

     

       25
       25
       +
                       {{ i "git-pull-request" "w-4 h-4" }}

     

       26
       26
       +
                     </span>

     

       27
       27
       +
                   {{ else if .State.IsMerged }}

     

       28
       28
       +
                     <span class="text-purple-600 dark:text-purple-500">

     

       29
       29
       +
                       {{ i "git-merge" "w-4 h-4" }}

     

       30
       30
       +
                     </span>

     

       31
       31
       +
                   {{ else }}

     

       32
       32
       +
                     <span class="text-gray-600 dark:text-gray-300">

     

       33
       33
       +
                       {{ i "git-pull-request-closed" "w-4 h-4" }}

     

       34
       34
       +
                     </span>

     

       35
       35
       +
                   {{ end }}

     

       36
       36
       +
                   <a href="{{ . }}"><span class="text-gray-500 dark:text-gray-400">#{{ .SubjectId }}</span> {{ .Title }}</a>

     

       37
       37
       +
                 </div>

     

       38
       38
       +
                 {{ if not (eq $.RepoInfo.FullName $repoUrl) }}

     

       39
       39
       +
                 <div>

     

       40
       40
       +
                   <span>on <a href="/{{ $repoUrl }}">{{ $repoUrl }}</a></span>

     

       41
       41
       +
                 </div>

     

       42
       42
       +
                 {{ end }}

     

       43
       43
       +
               </div>

     

       44
       44
       +
             </li>

     

       45
       45
       +
             {{ end }}

     

       46
       46
       +
           </ul>

     

       47
       47
       +
         </div>

     

       48
       48
       +
         {{ end }}

     

       49
       49
       +
       {{ end }}

appview/pages/templates/repo/issues/issue.html

···

       20
       20
        
                     "Subject" $.Issue.AtUri

     

       21
       21
        
                     "State" $.Issue.Labels) }}

     

       22
       22
        
             {{ template "repo/fragments/participants" $.Issue.Participants }}

     

       23
       23
       +
             {{ template "repo/fragments/backlinks"

     

       24
       24
       +
               (dict "RepoInfo" $.RepoInfo

     

       25
       25
       +
                     "Backlinks" $.Backlinks) }}

     

       23
       26
        
             {{ template "repo/fragments/externalLinkPanel" $.Issue.AtUri }}

     

       24
       27
        
           </div>

     

       25
       28
        
         </div>

appview/pages/templates/repo/pulls/pull.html

···

       21
       21
        
                     "Subject" $.Pull.AtUri

     

       22
       22
        
                     "State" $.Pull.Labels) }}

     

       23
       23
        
             {{ template "repo/fragments/participants" $.Pull.Participants }}

     

       24
       24
       +
             {{ template "repo/fragments/backlinks"

     

       25
       25
       +
               (dict "RepoInfo" $.RepoInfo

     

       26
       26
       +
                     "Backlinks" $.Backlinks) }}

     

       24
       27
        
             {{ template "repo/fragments/externalLinkPanel" $.Pull.AtUri }}

     

       25
       28
        
           </div>

     

       26
       29
        
         </div>

appview/pulls/pulls.go

···

       154
       154
        
       		return

     

       155
       155
        
       	}

     

       156
       156
        
       

     

       157
       157
       +
       	backlinks, err := db.GetBacklinks(s.db, pull.AtUri())

     

       158
       158
       +
       	if err != nil {

     

       159
       159
       +
       		log.Println("failed to get pull backlinks", err)

     

       160
       160
       +
       		s.pages.Notice(w, "pull-error", "Failed to get pull. Try again later.")

     

       161
       161
       +
       		return

     

       162
       162
       +
       	}

     

       163
       163
       +
       

     

       157
       164
        
       	// can be nil  if this pull is not stacked

     

       158
       165
        
       	stack, _ := r.Context().Value("stack").(models.Stack)

     

       159
       166
        
       	abandonedPulls, _ := r.Context().Value("abandonedPulls").([]*models.Pull)

     
···

       229
       236
        
       		Pull:               pull,

     

       230
       237
        
       		Stack:              stack,

     

       231
       238
        
       		AbandonedPulls:     abandonedPulls,

     

       239
       239
       +
       		Backlinks:          backlinks,

     

       232
       240
        
       		BranchDeleteStatus: branchDeleteStatus,

     

       233
       241
        
       		MergeCheck:         mergeCheckResponse,

     

       234
       242
        
       		ResubmitCheck:      resubmitResult,