+1 -1

appview/db/collaborators.go

··· 34 34 return err 35 35 } 36 36 37 37 - func CollaboratingIn(e Execer, collaborator string) ([]Repo, error) { 37 37 + func CollaboratingIn(e Execer, collaborator string) ([]models.Repo, error) { 38 38 rows, err := e.Query(`select repo_at from collaborators where subject_did = ?`, collaborator) 39 39 if err != nil { 40 40 return nil, err

+5 -10

appview/db/issues.go

··· 32 32 // like comment counts, parent repo etc. 33 33 Comments []IssueComment 34 34 Labels models.LabelState 35 35 - Repo *Repo 35 35 + Repo *models.Repo 36 36 } 37 37 38 38 func (i *Issue) AtUri() syntax.ATURI { ··· 376 376 return nil, fmt.Errorf("failed to build repo mappings: %w", err) 377 377 } 378 378 379 379 - repoMap := make(map[string]*Repo) 379 379 + repoMap := make(map[string]*models.Repo) 380 380 for i := range repos { 381 381 repoMap[string(repos[i].RepoAt())] = &repos[i] 382 382 } ··· 658 658 return err 659 659 } 660 660 661 661 - type IssueCount struct { 662 662 - Open int 663 663 - Closed int 664 664 - } 665 665 - 666 666 - func GetIssueCount(e Execer, repoAt syntax.ATURI) (IssueCount, error) { 661 661 + func GetIssueCount(e Execer, repoAt syntax.ATURI) (models.IssueCount, error) { 667 662 row := e.QueryRow(` 668 663 select 669 664 count(case when open = 1 then 1 end) as open_count, ··· 673 668 repoAt, 674 669 ) 675 670 676 676 - var count IssueCount 671 671 + var count models.IssueCount 677 672 if err := row.Scan(&count.Open, &count.Closed); err != nil { 678 678 - return IssueCount{0, 0}, err 673 673 + return models.IssueCount{0, 0}, err 679 674 } 680 675 681 676 return count, nil

+4 -3

appview/db/profile.go

··· 11 11 12 12 "github.com/bluesky-social/indigo/atproto/syntax" 13 13 "tangled.org/core/api/tangled" 14 14 + "tangled.org/core/appview/models" 14 15 ) 15 16 16 17 type RepoEvent struct { 17 17 - Repo *Repo 18 18 - Source *Repo 18 18 + Repo *models.Repo 19 19 + Source *models.Repo 19 20 } 20 21 21 22 type ProfileTimeline struct { ··· 162 163 163 164 for _, repo := range repos { 164 165 // TODO: get this in the original query; requires COALESCE because nullable 165 165 - var sourceRepo *Repo 166 166 + var sourceRepo *models.Repo 166 167 if repo.Source != "" { 167 168 sourceRepo, err = GetRepoByAtUri(e, repo.Source) 168 169 if err != nil {

+8 -14

appview/db/pulls.go

··· 11 11 12 12 "github.com/bluesky-social/indigo/atproto/syntax" 13 13 "tangled.org/core/api/tangled" 14 14 + "tangled.org/core/appview/models" 14 15 "tangled.org/core/patchutil" 15 16 "tangled.org/core/types" 16 17 ) ··· 79 80 PullSource *PullSource 80 81 81 82 // optionally, populate this when querying for reverse mappings 82 82 - Repo *Repo 83 83 + Repo *models.Repo 83 84 } 84 85 85 86 func (p Pull) AsRecord() tangled.RepoPull { ··· 109 110 RepoAt *syntax.ATURI 110 111 111 112 // optionally populate this for reverse mappings 112 112 - Repo *Repo 113 113 + Repo *models.Repo 113 114 } 114 115 115 116 func (p PullSource) AsRecord() tangled.RepoPull_Source { ··· 723 724 return nil, err 724 725 } 725 726 726 726 - var pullSourceRepo *Repo 727 727 + var pullSourceRepo *models.Repo 727 728 if pull.PullSource != nil { 728 729 if pull.PullSource.RepoAt != nil { 729 730 pullSourceRepo, err = GetRepoByAtUri(e, pull.PullSource.RepoAt.String()) ··· 776 777 777 778 for rows.Next() { 778 779 var pull Pull 779 779 - var repo Repo 780 780 + var repo models.Repo 780 781 var pullCreatedAt, repoCreatedAt string 781 782 err := rows.Scan( 782 783 &pull.OwnerDid, ··· 931 932 return err 932 933 } 933 934 934 934 - type PullCount struct { 935 935 - Open int 936 936 - Merged int 937 937 - Closed int 938 938 - Deleted int 939 939 - } 940 940 - 941 941 - func GetPullCount(e Execer, repoAt syntax.ATURI) (PullCount, error) { 935 935 + func GetPullCount(e Execer, repoAt syntax.ATURI) (models.PullCount, error) { 942 936 row := e.QueryRow(` 943 937 select 944 938 count(case when state = ? then 1 end) as open_count, ··· 954 948 repoAt, 955 949 ) 956 950 957 957 - var count PullCount 951 951 + var count models.PullCount 958 952 if err := row.Scan(&count.Open, &count.Merged, &count.Closed, &count.Deleted); err != nil { 959 959 - return PullCount{0, 0, 0, 0}, err 953 953 + return models.PullCount{Open: 0, Merged: 0, Closed: 0, Deleted: 0}, err 960 954 } 961 955 962 956 return count, nil

+20 -86

appview/db/repos.go

··· 10 10 "time" 11 11 12 12 "github.com/bluesky-social/indigo/atproto/syntax" 13 13 - securejoin "github.com/cyphar/filepath-securejoin" 14 14 - "tangled.org/core/api/tangled" 13 13 + "tangled.org/core/appview/models" 15 14 ) 16 15 17 17 - type Repo struct { 18 18 - Did string 19 19 - Name string 20 20 - Knot string 21 21 - Rkey string 22 22 - Created time.Time 23 23 - Description string 24 24 - Spindle string 25 25 - Labels []string 26 26 - 27 27 - // optionally, populate this when querying for reverse mappings 28 28 - RepoStats *RepoStats 29 29 - 30 30 - // optional 31 31 - Source string 32 32 - } 33 33 - 34 34 - func (r *Repo) AsRecord() tangled.Repo { 35 35 - var source, spindle, description *string 36 36 - 37 37 - if r.Source != "" { 38 38 - source = &r.Source 39 39 - } 40 40 - 41 41 - if r.Spindle != "" { 42 42 - spindle = &r.Spindle 43 43 - } 44 44 - 45 45 - if r.Description != "" { 46 46 - description = &r.Description 47 47 - } 48 48 - 49 49 - return tangled.Repo{ 50 50 - Knot: r.Knot, 51 51 - Name: r.Name, 52 52 - Description: description, 53 53 - CreatedAt: r.Created.Format(time.RFC3339), 54 54 - Source: source, 55 55 - Spindle: spindle, 56 56 - Labels: r.Labels, 57 57 - } 58 58 - } 59 59 - 60 60 - func (r Repo) RepoAt() syntax.ATURI { 61 61 - return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", r.Did, tangled.RepoNSID, r.Rkey)) 62 62 - } 63 63 - 64 64 - func (r Repo) DidSlashRepo() string { 65 65 - p, _ := securejoin.SecureJoin(r.Did, r.Name) 66 66 - return p 67 67 - } 68 68 - 69 69 - func GetRepos(e Execer, limit int, filters ...filter) ([]Repo, error) { 70 70 - repoMap := make(map[syntax.ATURI]*Repo) 16 16 + func GetRepos(e Execer, limit int, filters ...filter) ([]models.Repo, error) { 17 17 + repoMap := make(map[syntax.ATURI]*models.Repo) 71 18 72 19 var conditions []string 73 20 var args []any ··· 111 58 } 112 59 113 60 for rows.Next() { 114 114 - var repo Repo 61 61 + var repo models.Repo 115 62 var createdAt string 116 63 var description, source, spindle sql.NullString 117 64 ··· 142 89 repo.Spindle = spindle.String 143 90 } 144 91 145 145 - repo.RepoStats = &RepoStats{} 92 92 + repo.RepoStats = &models.RepoStats{} 146 93 repoMap[repo.RepoAt()] = &repo 147 94 } 148 95 ··· 320 267 return nil, fmt.Errorf("failed to execute pulls-count query: %w ", err) 321 268 } 322 269 323 323 - var repos []Repo 270 270 + var repos []models.Repo 324 271 for _, r := range repoMap { 325 272 repos = append(repos, *r) 326 273 } 327 274 328 328 - slices.SortFunc(repos, func(a, b Repo) int { 275 275 + slices.SortFunc(repos, func(a, b models.Repo) int { 329 276 if a.Created.After(b.Created) { 330 277 return -1 331 278 } ··· 336 283 } 337 284 338 285 // helper to get exactly one repo 339 339 - func GetRepo(e Execer, filters ...filter) (*Repo, error) { 286 286 + func GetRepo(e Execer, filters ...filter) (*models.Repo, error) { 340 287 repos, err := GetRepos(e, 0, filters...) 341 288 if err != nil { 342 289 return nil, err ··· 377 324 return count, nil 378 325 } 379 326 380 380 - func GetRepoByAtUri(e Execer, atUri string) (*Repo, error) { 381 381 - var repo Repo 327 327 + func GetRepoByAtUri(e Execer, atUri string) (*models.Repo, error) { 328 328 + var repo models.Repo 382 329 var nullableDescription sql.NullString 383 330 384 331 row := e.QueryRow(`select did, name, knot, created, rkey, description from repos where at_uri = ?`, atUri) ··· 399 346 return &repo, nil 400 347 } 401 348 402 402 - func AddRepo(e Execer, repo *Repo) error { 349 349 + func AddRepo(e Execer, repo *models.Repo) error { 403 350 _, err := e.Exec( 404 351 `insert into repos 405 352 (did, name, knot, rkey, at_uri, description, source) ··· 423 370 return nullableSource.String, nil 424 371 } 425 372 426 426 - func GetForksByDid(e Execer, did string) ([]Repo, error) { 427 427 - var repos []Repo 373 373 + func GetForksByDid(e Execer, did string) ([]models.Repo, error) { 374 374 + var repos []models.Repo 428 375 429 376 rows, err := e.Query( 430 377 `select distinct r.did, r.name, r.knot, r.rkey, r.description, r.created, r.source ··· 442 389 defer rows.Close() 443 390 444 391 for rows.Next() { 445 445 - var repo Repo 392 392 + var repo models.Repo 446 393 var createdAt string 447 394 var nullableDescription sql.NullString 448 395 var nullableSource sql.NullString ··· 477 424 return repos, nil 478 425 } 479 426 480 480 - func GetForkByDid(e Execer, did string, name string) (*Repo, error) { 481 481 - var repo Repo 427 427 + func GetForkByDid(e Execer, did string, name string) (*models.Repo, error) { 428 428 + var repo models.Repo 482 429 var createdAt string 483 430 var nullableDescription sql.NullString 484 431 var nullableSource sql.NullString ··· 525 472 return err 526 473 } 527 474 528 528 - type RepoStats struct { 529 529 - Language string 530 530 - StarCount int 531 531 - IssueCount IssueCount 532 532 - PullCount PullCount 533 533 - } 534 534 - 535 535 - type RepoLabel struct { 536 536 - Id int64 537 537 - RepoAt syntax.ATURI 538 538 - LabelAt syntax.ATURI 539 539 - } 540 540 - 541 541 - func SubscribeLabel(e Execer, rl *RepoLabel) error { 475 475 + func SubscribeLabel(e Execer, rl *models.RepoLabel) error { 542 476 query := `insert or ignore into repo_labels (repo_at, label_at) values (?, ?)` 543 477 544 478 _, err := e.Exec(query, rl.RepoAt.String(), rl.LabelAt.String()) ··· 563 497 return err 564 498 } 565 499 566 566 - func GetRepoLabels(e Execer, filters ...filter) ([]RepoLabel, error) { 500 500 + func GetRepoLabels(e Execer, filters ...filter) ([]models.RepoLabel, error) { 567 501 var conditions []string 568 502 var args []any 569 503 for _, filter := range filters { ··· 584 518 } 585 519 defer rows.Close() 586 520 587 587 - var labels []RepoLabel 521 521 + var labels []models.RepoLabel 588 522 for rows.Next() { 589 589 - var label RepoLabel 523 523 + var label models.RepoLabel 590 524 591 525 err := rows.Scan(&label.Id, &label.RepoAt, &label.LabelAt) 592 526 if err != nil {

+7 -6

appview/db/star.go

··· 9 9 "time" 10 10 11 11 "github.com/bluesky-social/indigo/atproto/syntax" 12 12 + "tangled.org/core/appview/models" 12 13 ) 13 14 14 15 type Star struct { ··· 18 19 Rkey string 19 20 20 21 // optionally, populate this when querying for reverse mappings 21 21 - Repo *Repo 22 22 + Repo *models.Repo 22 23 } 23 24 24 25 func (star *Star) ResolveRepo(e Execer) error { ··· 284 285 285 286 for rows.Next() { 286 287 var star Star 287 287 - var repo Repo 288 288 + var repo models.Repo 288 289 var starCreatedAt, repoCreatedAt string 289 290 290 291 if err := rows.Scan( ··· 322 323 } 323 324 324 325 // GetTopStarredReposLastWeek returns the top 8 most starred repositories from the last week 325 325 - func GetTopStarredReposLastWeek(e Execer) ([]Repo, error) { 326 326 + func GetTopStarredReposLastWeek(e Execer) ([]models.Repo, error) { 326 327 // first, get the top repo URIs by star count from the last week 327 328 query := ` 328 329 with recent_starred_repos as ( ··· 366 367 } 367 368 368 369 if len(repoUris) == 0 { 369 369 - return []Repo{}, nil 370 370 + return []models.Repo{}, nil 370 371 } 371 372 372 373 // get full repo data ··· 376 377 } 377 378 378 379 // sort repos by the original trending order 379 379 - repoMap := make(map[string]Repo) 380 380 + repoMap := make(map[string]models.Repo) 380 381 for _, repo := range repos { 381 382 repoMap[repo.RepoAt().String()] = repo 382 383 } 383 384 384 384 - orderedRepos := make([]Repo, 0, len(repoUris)) 385 385 + orderedRepos := make([]models.Repo, 0, len(repoUris)) 385 386 for _, uri := range repoUris { 386 387 if repo, exists := repoMap[uri]; exists { 387 388 orderedRepos = append(orderedRepos, repo)

+8 -8

appview/db/timeline.go

··· 9 9 ) 10 10 11 11 type TimelineEvent struct { 12 12 - *Repo 12 12 + *models.Repo 13 13 *models.Follow 14 14 *Star 15 15 16 16 EventAt time.Time 17 17 18 18 // optional: populate only if Repo is a fork 19 19 - Source *Repo 19 19 + Source *models.Repo 20 20 21 21 // optional: populate only if event is Follow 22 22 *Profile ··· 64 64 return events, nil 65 65 } 66 66 67 67 - func fetchStarStatuses(e Execer, loggedInUserDid string, repos []Repo) (map[string]bool, error) { 67 67 + func fetchStarStatuses(e Execer, loggedInUserDid string, repos []models.Repo) (map[string]bool, error) { 68 68 if loggedInUserDid == "" { 69 69 return nil, nil 70 70 } ··· 77 77 return GetStarStatuses(e, loggedInUserDid, repoAts) 78 78 } 79 79 80 80 - func getRepoStarInfo(repo *Repo, starStatuses map[string]bool) (bool, int64) { 80 80 + func getRepoStarInfo(repo *models.Repo, starStatuses map[string]bool) (bool, int64) { 81 81 var isStarred bool 82 82 if starStatuses != nil { 83 83 isStarred = starStatuses[repo.RepoAt().String()] ··· 105 105 } 106 106 } 107 107 108 108 - var origRepos []Repo 108 108 + var origRepos []models.Repo 109 109 if args != nil { 110 110 origRepos, err = GetRepos(e, 0, FilterIn("at_uri", args)) 111 111 } ··· 113 113 return nil, err 114 114 } 115 115 116 116 - uriToRepo := make(map[string]Repo) 116 116 + uriToRepo := make(map[string]models.Repo) 117 117 for _, r := range origRepos { 118 118 uriToRepo[r.RepoAt().String()] = r 119 119 } ··· 125 125 126 126 var events []TimelineEvent 127 127 for _, r := range repos { 128 128 - var source *Repo 128 128 + var source *models.Repo 129 129 if r.Source != "" { 130 130 if origRepo, ok := uriToRepo[r.Source]; ok { 131 131 source = &origRepo ··· 162 162 } 163 163 stars = stars[:n] 164 164 165 165 - var repos []Repo 165 165 + var repos []models.Repo 166 166 for _, s := range stars { 167 167 repos = append(repos, *s.Repo) 168 168 }

+2 -1

appview/knots/knots.go

··· 13 13 "tangled.org/core/appview/config" 14 14 "tangled.org/core/appview/db" 15 15 "tangled.org/core/appview/middleware" 16 16 + "tangled.org/core/appview/models" 16 17 "tangled.org/core/appview/oauth" 17 18 "tangled.org/core/appview/pages" 18 19 "tangled.org/core/appview/serververify" ··· 119 120 } 120 121 121 122 // organize repos by did 122 122 - repoMap := make(map[string][]db.Repo) 123 123 + repoMap := make(map[string][]models.Repo) 123 124 for _, r := range repos { 124 125 repoMap[r.Did] = append(repoMap[r.Did], r) 125 126 }

+87

appview/models/repo.go

··· 1 1 + package models 2 2 + 3 3 + import ( 4 4 + "fmt" 5 5 + "time" 6 6 + 7 7 + "github.com/bluesky-social/indigo/atproto/syntax" 8 8 + securejoin "github.com/cyphar/filepath-securejoin" 9 9 + "tangled.org/core/api/tangled" 10 10 + ) 11 11 + 12 12 + type Repo struct { 13 13 + Did string 14 14 + Name string 15 15 + Knot string 16 16 + Rkey string 17 17 + Created time.Time 18 18 + Description string 19 19 + Spindle string 20 20 + Labels []string 21 21 + 22 22 + // optionally, populate this when querying for reverse mappings 23 23 + RepoStats *RepoStats 24 24 + 25 25 + // optional 26 26 + Source string 27 27 + } 28 28 + 29 29 + func (r *Repo) AsRecord() tangled.Repo { 30 30 + var source, spindle, description *string 31 31 + 32 32 + if r.Source != "" { 33 33 + source = &r.Source 34 34 + } 35 35 + 36 36 + if r.Spindle != "" { 37 37 + spindle = &r.Spindle 38 38 + } 39 39 + 40 40 + if r.Description != "" { 41 41 + description = &r.Description 42 42 + } 43 43 + 44 44 + return tangled.Repo{ 45 45 + Knot: r.Knot, 46 46 + Name: r.Name, 47 47 + Description: description, 48 48 + CreatedAt: r.Created.Format(time.RFC3339), 49 49 + Source: source, 50 50 + Spindle: spindle, 51 51 + Labels: r.Labels, 52 52 + } 53 53 + } 54 54 + 55 55 + func (r Repo) RepoAt() syntax.ATURI { 56 56 + return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", r.Did, tangled.RepoNSID, r.Rkey)) 57 57 + } 58 58 + 59 59 + func (r Repo) DidSlashRepo() string { 60 60 + p, _ := securejoin.SecureJoin(r.Did, r.Name) 61 61 + return p 62 62 + } 63 63 + 64 64 + type RepoStats struct { 65 65 + Language string 66 66 + StarCount int 67 67 + IssueCount IssueCount 68 68 + PullCount PullCount 69 69 + } 70 70 + 71 71 + type IssueCount struct { 72 72 + Open int 73 73 + Closed int 74 74 + } 75 75 + 76 76 + type PullCount struct { 77 77 + Open int 78 78 + Merged int 79 79 + Closed int 80 80 + Deleted int 81 81 + } 82 82 + 83 83 + type RepoLabel struct { 84 84 + Id int64 85 85 + RepoAt syntax.ATURI 86 86 + LabelAt syntax.ATURI 87 87 + }

+1 -1

appview/notify/merged_notifier.go

··· 17 17 18 18 var _ Notifier = &mergedNotifier{} 19 19 20 20 - func (m *mergedNotifier) NewRepo(ctx context.Context, repo *db.Repo) { 20 20 + func (m *mergedNotifier) NewRepo(ctx context.Context, repo *models.Repo) { 21 21 for _, notifier := range m.notifiers { 22 22 notifier.NewRepo(ctx, repo) 23 23 }

+2 -2

appview/notify/notifier.go

··· 8 8 ) 9 9 10 10 type Notifier interface { 11 11 - NewRepo(ctx context.Context, repo *db.Repo) 11 11 + NewRepo(ctx context.Context, repo *models.Repo) 12 12 13 13 NewStar(ctx context.Context, star *db.Star) 14 14 DeleteStar(ctx context.Context, star *db.Star) ··· 33 33 34 34 var _ Notifier = &BaseNotifier{} 35 35 36 36 - func (m *BaseNotifier) NewRepo(ctx context.Context, repo *db.Repo) {} 36 36 + func (m *BaseNotifier) NewRepo(ctx context.Context, repo *models.Repo) {} 37 37 38 38 func (m *BaseNotifier) NewStar(ctx context.Context, star *db.Star) {} 39 39 func (m *BaseNotifier) DeleteStar(ctx context.Context, star *db.Star) {}

+12 -12

appview/pages/pages.go

··· 284 284 type TimelineParams struct { 285 285 LoggedInUser *oauth.User 286 286 Timeline []db.TimelineEvent 287 287 - Repos []db.Repo 287 287 + Repos []models.Repo 288 288 } 289 289 290 290 func (p *Pages) Timeline(w io.Writer, params TimelineParams) error { ··· 345 345 LoggedInUser *oauth.User 346 346 Registration *db.Registration 347 347 Members []string 348 348 - Repos map[string][]db.Repo 348 348 + Repos map[string][]models.Repo 349 349 IsOwner bool 350 350 } 351 351 ··· 382 382 LoggedInUser *oauth.User 383 383 Spindle db.Spindle 384 384 Members []string 385 385 - Repos map[string][]db.Repo 385 385 + Repos map[string][]models.Repo 386 386 } 387 387 388 388 func (p *Pages) SpindleDashboard(w io.Writer, params SpindleDashboardParams) error { ··· 439 439 440 440 type ProfileOverviewParams struct { 441 441 LoggedInUser *oauth.User 442 442 - Repos []db.Repo 443 443 - CollaboratingRepos []db.Repo 442 442 + Repos []models.Repo 443 443 + CollaboratingRepos []models.Repo 444 444 ProfileTimeline *db.ProfileTimeline 445 445 Card *ProfileCard 446 446 Active string ··· 453 453 454 454 type ProfileReposParams struct { 455 455 LoggedInUser *oauth.User 456 456 - Repos []db.Repo 456 456 + Repos []models.Repo 457 457 Card *ProfileCard 458 458 Active string 459 459 } ··· 465 465 466 466 type ProfileStarredParams struct { 467 467 LoggedInUser *oauth.User 468 468 - Repos []db.Repo 468 468 + Repos []models.Repo 469 469 Card *ProfileCard 470 470 Active string 471 471 } ··· 545 545 546 546 type PinnedRepo struct { 547 547 IsPinned bool 548 548 - db.Repo 548 548 + models.Repo 549 549 } 550 550 551 551 func (p *Pages) EditPinsFragment(w io.Writer, params EditPinsParams) error { ··· 555 555 type RepoStarFragmentParams struct { 556 556 IsStarred bool 557 557 RepoAt syntax.ATURI 558 558 - Stats db.RepoStats 558 558 + Stats models.RepoStats 559 559 } 560 560 561 561 func (p *Pages) RepoStarFragment(w io.Writer, params RepoStarFragmentParams) error { ··· 1122 1122 1123 1123 type PullCompareForkParams struct { 1124 1124 RepoInfo repoinfo.RepoInfo 1125 1125 - Forks []db.Repo 1125 1125 + Forks []models.Repo 1126 1126 Selected string 1127 1127 } 1128 1128 ··· 1179 1179 type RepoCompareParams struct { 1180 1180 LoggedInUser *oauth.User 1181 1181 RepoInfo repoinfo.RepoInfo 1182 1182 - Forks []db.Repo 1182 1182 + Forks []models.Repo 1183 1183 Branches []types.Branch 1184 1184 Tags []*types.TagReference 1185 1185 Base string ··· 1198 1198 type RepoCompareNewParams struct { 1199 1199 LoggedInUser *oauth.User 1200 1200 RepoInfo repoinfo.RepoInfo 1201 1201 - Forks []db.Repo 1201 1201 + Forks []models.Repo 1202 1202 Branches []types.Branch 1203 1203 Tags []*types.TagReference 1204 1204 Base string

+3 -3

appview/pages/repoinfo/repoinfo.go

··· 7 7 "strings" 8 8 9 9 "github.com/bluesky-social/indigo/atproto/syntax" 10 10 - "tangled.org/core/appview/db" 10 10 + "tangled.org/core/appview/models" 11 11 "tangled.org/core/appview/state/userutil" 12 12 ) 13 13 ··· 60 60 Spindle string 61 61 RepoAt syntax.ATURI 62 62 IsStarred bool 63 63 - Stats db.RepoStats 63 63 + Stats models.RepoStats 64 64 Roles RolesInRepo 65 65 - Source *db.Repo 65 65 + Source *models.Repo 66 66 SourceHandle string 67 67 Ref string 68 68 DisableFork bool

+1 -1

appview/posthog/notifier.go

··· 24 24 25 25 var _ notify.Notifier = &posthogNotifier{} 26 26 27 27 - func (n *posthogNotifier) NewRepo(ctx context.Context, repo *db.Repo) { 27 27 + func (n *posthogNotifier) NewRepo(ctx context.Context, repo *models.Repo) { 28 28 err := n.client.Enqueue(posthog.Capture{ 29 29 DistinctId: repo.Did, 30 30 Event: "new_repo",

+2 -1

appview/pulls/pulls.go

··· 15 15 "tangled.org/core/api/tangled" 16 16 "tangled.org/core/appview/config" 17 17 "tangled.org/core/appview/db" 18 18 + "tangled.org/core/appview/models" 18 19 "tangled.org/core/appview/notify" 19 20 "tangled.org/core/appview/oauth" 20 21 "tangled.org/core/appview/pages" ··· 500 501 } 501 502 502 503 for _, p := range pulls { 503 503 - var pullSourceRepo *db.Repo 504 504 + var pullSourceRepo *models.Repo 504 505 if p.PullSource != nil { 505 506 if p.PullSource.RepoAt != nil { 506 507 pullSourceRepo, err = db.GetRepoByAtUri(s.db, p.PullSource.RepoAt.String())

+3 -3

appview/repo/repo.go

··· 1110 1110 return 1111 1111 } 1112 1112 1113 1113 - err = db.SubscribeLabel(tx, &db.RepoLabel{ 1113 1113 + err = db.SubscribeLabel(tx, &models.RepoLabel{ 1114 1114 RepoAt: f.RepoAt(), 1115 1115 LabelAt: label.AtUri(), 1116 1116 }) ··· 1286 1286 }, 1287 1287 }) 1288 1288 1289 1289 - err = db.SubscribeLabel(rp.db, &db.RepoLabel{ 1289 1289 + err = db.SubscribeLabel(rp.db, &models.RepoLabel{ 1290 1290 RepoAt: f.RepoAt(), 1291 1291 LabelAt: syntax.ATURI(labelAt), 1292 1292 }) ··· 2142 2142 2143 2143 // create an atproto record for this fork 2144 2144 rkey := tid.TID() 2145 2145 - repo := &db.Repo{ 2145 2145 + repo := &models.Repo{ 2146 2146 Did: user.Did, 2147 2147 Name: forkName, 2148 2148 Knot: targetKnot,

+5 -4

appview/reporesolver/resolver.go

··· 16 16 "github.com/go-chi/chi/v5" 17 17 "tangled.org/core/appview/config" 18 18 "tangled.org/core/appview/db" 19 19 + "tangled.org/core/appview/models" 19 20 "tangled.org/core/appview/oauth" 20 21 "tangled.org/core/appview/pages" 21 22 "tangled.org/core/appview/pages/repoinfo" ··· 24 25 ) 25 26 26 27 type ResolvedRepo struct { 27 27 - db.Repo 28 28 + models.Repo 28 29 OwnerId identity.Identity 29 30 CurrentDir string 30 31 Ref string ··· 44 45 } 45 46 46 47 func (rr *RepoResolver) Resolve(r *http.Request) (*ResolvedRepo, error) { 47 47 - repo, ok := r.Context().Value("repo").(*db.Repo) 48 48 + repo, ok := r.Context().Value("repo").(*models.Repo) 48 49 if !ok { 49 50 log.Println("malformed middleware: `repo` not exist in context") 50 51 return nil, fmt.Errorf("malformed middleware") ··· 162 163 log.Println("failed to get repo source for ", repoAt, err) 163 164 } 164 165 165 165 - var sourceRepo *db.Repo 166 166 + var sourceRepo *models.Repo 166 167 if source != "" { 167 168 sourceRepo, err = db.GetRepoByAtUri(f.rr.execer, source) 168 169 if err != nil { ··· 191 192 Knot: knot, 192 193 Spindle: f.Spindle, 193 194 Roles: f.RolesInRepo(user), 194 194 - Stats: db.RepoStats{ 195 195 + Stats: models.RepoStats{ 195 196 StarCount: starCount, 196 197 IssueCount: issueCount, 197 198 PullCount: pullCount,

+2 -1

appview/spindles/spindles.go

··· 13 13 "tangled.org/core/appview/config" 14 14 "tangled.org/core/appview/db" 15 15 "tangled.org/core/appview/middleware" 16 16 + "tangled.org/core/appview/models" 16 17 "tangled.org/core/appview/oauth" 17 18 "tangled.org/core/appview/pages" 18 19 "tangled.org/core/appview/serververify" ··· 115 116 } 116 117 117 118 // organize repos by did 118 118 - repoMap := make(map[string][]db.Repo) 119 119 + repoMap := make(map[string][]models.Repo) 119 120 for _, r := range repos { 120 121 repoMap[r.Did] = append(repoMap[r.Did], r) 121 122 }

+4 -4

appview/state/git_http.go

··· 8 8 9 9 "github.com/bluesky-social/indigo/atproto/identity" 10 10 "github.com/go-chi/chi/v5" 11 11 - "tangled.org/core/appview/db" 11 11 + "tangled.org/core/appview/models" 12 12 ) 13 13 14 14 func (s *State) InfoRefs(w http.ResponseWriter, r *http.Request) { 15 15 user := r.Context().Value("resolvedId").(identity.Identity) 16 16 - repo := r.Context().Value("repo").(*db.Repo) 16 16 + repo := r.Context().Value("repo").(*models.Repo) 17 17 18 18 scheme := "https" 19 19 if s.config.Core.Dev { ··· 31 31 http.Error(w, "failed to resolve user", http.StatusInternalServerError) 32 32 return 33 33 } 34 34 - repo := r.Context().Value("repo").(*db.Repo) 34 34 + repo := r.Context().Value("repo").(*models.Repo) 35 35 36 36 scheme := "https" 37 37 if s.config.Core.Dev { ··· 48 48 http.Error(w, "failed to resolve user", http.StatusInternalServerError) 49 49 return 50 50 } 51 51 - repo := r.Context().Value("repo").(*db.Repo) 51 51 + repo := r.Context().Value("repo").(*models.Repo) 52 52 53 53 scheme := "https" 54 54 if s.config.Core.Dev {

+2 -2

appview/state/profile.go

··· 131 131 } 132 132 133 133 // filter out ones that are pinned 134 134 - pinnedRepos := []db.Repo{} 134 134 + pinnedRepos := []models.Repo{} 135 135 for i, r := range repos { 136 136 // if this is a pinned repo, add it 137 137 if slices.Contains(profile.Profile.PinnedRepos[:], r.RepoAt()) { ··· 149 149 l.Error("failed to fetch collaborating repos", "err", err) 150 150 } 151 151 152 152 - pinnedCollaboratingRepos := []db.Repo{} 152 152 + pinnedCollaboratingRepos := []models.Repo{} 153 153 for _, r := range collaboratingRepos { 154 154 // if this is a pinned repo, add it 155 155 if slices.Contains(profile.Profile.PinnedRepos[:], r.RepoAt()) {

+3 -2

appview/state/star.go

··· 10 10 lexutil "github.com/bluesky-social/indigo/lex/util" 11 11 "tangled.org/core/api/tangled" 12 12 "tangled.org/core/appview/db" 13 13 + "tangled.org/core/appview/models" 13 14 "tangled.org/core/appview/pages" 14 15 "tangled.org/core/tid" 15 16 ) ··· 77 78 s.pages.RepoStarFragment(w, pages.RepoStarFragmentParams{ 78 79 IsStarred: true, 79 80 RepoAt: subjectUri, 80 80 - Stats: db.RepoStats{ 81 81 + Stats: models.RepoStats{ 81 82 StarCount: starCount, 82 83 }, 83 84 }) ··· 119 120 s.pages.RepoStarFragment(w, pages.RepoStarFragmentParams{ 120 121 IsStarred: false, 121 122 RepoAt: subjectUri, 122 122 - Stats: db.RepoStats{ 123 123 + Stats: models.RepoStats{ 123 124 StarCount: starCount, 124 125 }, 125 126 })

+2 -2

appview/state/state.go

··· 23 23 "tangled.org/core/appview/cache/session" 24 24 "tangled.org/core/appview/config" 25 25 "tangled.org/core/appview/db" 26 26 + "tangled.org/core/appview/models" 26 27 "tangled.org/core/appview/notify" 27 28 "tangled.org/core/appview/oauth" 28 29 "tangled.org/core/appview/pages" ··· 36 37 tlog "tangled.org/core/log" 37 38 "tangled.org/core/rbac" 38 39 "tangled.org/core/tid" 39 39 - // xrpcerr "tangled.org/core/xrpc/errors" 40 40 ) 41 41 42 42 type State struct { ··· 433 433 434 434 // create atproto record for this repo 435 435 rkey := tid.TID() 436 436 - repo := &db.Repo{ 436 436 + repo := &models.Repo{ 437 437 Did: user.Did, 438 438 Name: repoName, 439 439 Knot: domain,