commit dc802605c77d33070b7eed808026332c157bd1e1 · nel.pet/core

+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,