comparing feat/mentions and master on julien.rbrt.fr/tangled-core

+8 -6

.air/appview.toml

···

       1
       1
       -
       [build]

     

       2
       2
       -
       cmd = "tailwindcss -i input.css -o ./appview/pages/static/tw.css && go build -o .bin/app ./cmd/appview/main.go"

     

       3
       3
       -
       bin = ";set -o allexport && source .env && set +o allexport; .bin/app"

     

       4
       1
        
       root = "."

     

       2
       2
       +
       tmp_dir = "out"

     

       5
       3
        
       

     

       6
       6
       -
       exclude_regex = [".*_templ.go"]

     

       7
       7
       -
       include_ext = ["go", "templ", "html", "css"]

     

       8
       8
       -
       exclude_dir = ["target", "atrium", "nix"]

     

       4
       4
       +
       [build]

     

       5
       5
       +
       cmd = "go build -o out/appview.out cmd/appview/main.go"

     

       6
       6
       +
       bin = "out/appview.out"

     

       7
       7
       +
       

     

       8
       8
       +
       include_ext = ["go"]

     

       9
       9
       +
       exclude_dir = ["avatar", "camo", "indexes", "nix", "tmp"]

     

       10
       10
       +
       stop_on_error = true

+11

.air/knot.toml

···

       1
       1
       +
       root = "."

     

       2
       2
       +
       tmp_dir = "out"

     

       3
       3
       +
       

     

       4
       4
       +
       [build]

     

       5
       5
       +
       cmd = 'go build -ldflags "-X tangled.org/core/knotserver.version=$(git describe --tags --long)" -o out/knot.out cmd/knot/main.go'

     

       6
       6
       +
       bin = "out/knot.out"

     

       7
       7
       +
       args_bin = ["server"]

     

       8
       8
       +
       

     

       9
       9
       +
       include_ext = ["go"]

     

       10
       10
       +
       exclude_dir = ["avatar", "camo", "indexes", "nix", "tmp"]

     

       11
       11
       +
       stop_on_error = true

-7

.air/knotserver.toml

···

       1
       1
       -
       [build]

     

       2
       2
       -
       cmd = 'go build -ldflags "-X tangled.org/core/knotserver.version=$(git describe --tags --long)" -o .bin/knot ./cmd/knot/'

     

       3
       3
       -
       bin = ".bin/knot server"

     

       4
       4
       -
       root = "."

     

       5
       5
       -
       

     

       6
       6
       -
       exclude_regex = [""]

     

       7
       7
       -
       include_ext = ["go", "templ"]

+10

.air/spindle.toml

···

       1
       1
       +
       root = "."

     

       2
       2
       +
       tmp_dir = "out"

     

       3
       3
       +
       

     

       4
       4
       +
       [build]

     

       5
       5
       +
       cmd = "go build -o out/spindle.out cmd/spindle/main.go"

     

       6
       6
       +
       bin = "out/spindle.out"

     

       7
       7
       +
       

     

       8
       8
       +
       include_ext = ["go"]

     

       9
       9
       +
       exclude_dir = ["avatar", "camo", "indexes", "nix", "tmp"]

     

       10
       10
       +
       stop_on_error = true

+13

.editorconfig

···

       1
       1
       +
       root = true

     

       2
       2
       +
       

     

       3
       3
       +
       [*.html]

     

       4
       4
       +
       indent_size = 2

     

       5
       5
       +
       

     

       6
       6
       +
       [*.json]

     

       7
       7
       +
       indent_size = 2

     

       8
       8
       +
       

     

       9
       9
       +
       [*.nix]

     

       10
       10
       +
       indent_size = 2

     

       11
       11
       +
       

     

       12
       12
       +
       [*.yml]

     

       13
       13
       +
       indent_size = 2

+13 -1

api/tangled/repoblob.go

···

       30
       30
        
       // RepoBlob_Output is the output of a sh.tangled.repo.blob call.

     

       31
       31
        
       type RepoBlob_Output struct {

     

       32
       32
        
       	// content: File content (base64 encoded for binary files)

     

       33
       33
       -
       	Content string `json:"content" cborgen:"content"`

     

       33
       33
       +
       	Content *string `json:"content,omitempty" cborgen:"content,omitempty"`

     

       34
       34
        
       	// encoding: Content encoding

     

       35
       35
        
       	Encoding *string `json:"encoding,omitempty" cborgen:"encoding,omitempty"`

     

       36
       36
        
       	// isBinary: Whether the file is binary

     
···

       44
       44
        
       	Ref string `json:"ref" cborgen:"ref"`

     

       45
       45
        
       	// size: File size in bytes

     

       46
       46
        
       	Size *int64 `json:"size,omitempty" cborgen:"size,omitempty"`

     

       47
       47
       +
       	// submodule: Submodule information if path is a submodule

     

       48
       48
       +
       	Submodule *RepoBlob_Submodule `json:"submodule,omitempty" cborgen:"submodule,omitempty"`

     

       47
       49
        
       }

     

       48
       50
        
       

     

       49
       51
        
       // RepoBlob_Signature is a "signature" in the sh.tangled.repo.blob schema.

     
···

       54
       56
        
       	Name string `json:"name" cborgen:"name"`

     

       55
       57
        
       	// when: Author timestamp

     

       56
       58
        
       	When string `json:"when" cborgen:"when"`

     

       59
       59
       +
       }

     

       60
       60
       +
       

     

       61
       61
       +
       // RepoBlob_Submodule is a "submodule" in the sh.tangled.repo.blob schema.

     

       62
       62
       +
       type RepoBlob_Submodule struct {

     

       63
       63
       +
       	// branch: Branch to track in the submodule

     

       64
       64
       +
       	Branch *string `json:"branch,omitempty" cborgen:"branch,omitempty"`

     

       65
       65
       +
       	// name: Submodule name

     

       66
       66
       +
       	Name string `json:"name" cborgen:"name"`

     

       67
       67
       +
       	// url: Submodule repository URL

     

       68
       68
       +
       	Url string `json:"url" cborgen:"url"`

     

       57
       69
        
       }

     

       58
       70
        
       

     

       59
       71
        
       // RepoBlob calls the XRPC method "sh.tangled.repo.blob".

-4

api/tangled/repotree.go

···

       47
       47
        
       

     

       48
       48
        
       // RepoTree_TreeEntry is a "treeEntry" in the sh.tangled.repo.tree schema.

     

       49
       49
        
       type RepoTree_TreeEntry struct {

     

       50
       50
       -
       	// is_file: Whether this entry is a file

     

       51
       51
       -
       	Is_file bool `json:"is_file" cborgen:"is_file"`

     

       52
       52
       -
       	// is_subtree: Whether this entry is a directory/subtree

     

       53
       53
       -
       	Is_subtree  bool                 `json:"is_subtree" cborgen:"is_subtree"`

     

       54
       50
        
       	Last_commit *RepoTree_LastCommit `json:"last_commit,omitempty" cborgen:"last_commit,omitempty"`

     

       55
       51
        
       	// mode: File mode

     

       56
       52
        
       	Mode string `json:"mode" cborgen:"mode"`

+6 -45

appview/commitverify/verify.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"log"

     

       5
       5
        
       

     

       6
       6
       -
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       7
       6
        
       	"tangled.org/core/appview/db"

     

       8
       7
        
       	"tangled.org/core/appview/models"

     

       9
       8
        
       	"tangled.org/core/crypto"

     
···

       35
       34
        
       	return ""

     

       36
       35
        
       }

     

       37
       36
        
       

     

       38
       38
       -
       func GetVerifiedObjectCommits(e db.Execer, emailToDid map[string]string, commits []*object.Commit) (VerifiedCommits, error) {

     

       39
       39
       -
       	ndCommits := []types.NiceDiff{}

     

       40
       40
       -
       	for _, commit := range commits {

     

       41
       41
       -
       		ndCommits = append(ndCommits, ObjectCommitToNiceDiff(commit))

     

       42
       42
       -
       	}

     

       43
       43
       -
       	return GetVerifiedCommits(e, emailToDid, ndCommits)

     

       44
       44
       -
       }

     

       45
       45
       -
       

     

       46
       46
       -
       func GetVerifiedCommits(e db.Execer, emailToDid map[string]string, ndCommits []types.NiceDiff) (VerifiedCommits, error) {

     

       37
       37
       +
       func GetVerifiedCommits(e db.Execer, emailToDid map[string]string, ndCommits []types.Commit) (VerifiedCommits, error) {

     

       47
       38
        
       	vcs := VerifiedCommits{}

     

       48
       39
        
       

     

       49
       40
        
       	didPubkeyCache := make(map[string][]models.PublicKey)

     

       50
       41
        
       

     

       51
       42
        
       	for _, commit := range ndCommits {

     

       52
       52
       -
       		c := commit.Commit

     

       53
       53
       -
       

     

       54
       54
       -
       		committerEmail := c.Committer.Email

     

       43
       43
       +
       		committerEmail := commit.Committer.Email

     

       55
       44
        
       		if did, exists := emailToDid[committerEmail]; exists {

     

       56
       45
        
       			// check if we've already fetched public keys for this did

     

       57
       46
        
       			pubKeys, ok := didPubkeyCache[did]

     
···

       67
       56
        
       			}

     

       68
       57
        
       

     

       69
       58
        
       			// try to verify with any associated pubkeys

     

       59
       59
       +
       			payload := commit.Payload()

     

       60
       60
       +
       			signature := commit.PGPSignature

     

       70
       61
        
       			for _, pk := range pubKeys {

     

       71
       71
       -
       				if _, ok := crypto.VerifyCommitSignature(pk.Key, commit); ok {

     

       62
       62
       +
       				if _, ok := crypto.VerifySignature([]byte(pk.Key), []byte(signature), []byte(payload)); ok {

     

       72
       63
        
       

     

       73
       64
        
       					fp, err := crypto.SSHFingerprint(pk.Key)

     

       74
       65
        
       					if err != nil {

     

       75
       66
        
       						log.Println("error computing ssh fingerprint:", err)

     

       76
       67
        
       					}

     

       77
       68
        
       

     

       78
       78
       -
       					vc := verifiedCommit{fingerprint: fp, hash: c.This}

     

       69
       69
       +
       					vc := verifiedCommit{fingerprint: fp, hash: commit.This}

     

       79
       70
        
       					vcs[vc] = struct{}{}

     

       80
       71
        
       					break

     

       81
       72
        
       				}

     
···

       86
       77
        
       

     

       87
       78
        
       	return vcs, nil

     

       88
       79
        
       }

     

       89
       89
       -
       

     

       90
       90
       -
       // ObjectCommitToNiceDiff is a compatibility function to convert a

     

       91
       91
       -
       // commit object into a NiceDiff structure.

     

       92
       92
       -
       func ObjectCommitToNiceDiff(c *object.Commit) types.NiceDiff {

     

       93
       93
       -
       	var niceDiff types.NiceDiff

     

       94
       94
       -
       

     

       95
       95
       -
       	// set commit information

     

       96
       96
       -
       	niceDiff.Commit.Message = c.Message

     

       97
       97
       -
       	niceDiff.Commit.Author = c.Author

     

       98
       98
       -
       	niceDiff.Commit.This = c.Hash.String()

     

       99
       99
       -
       	niceDiff.Commit.Committer = c.Committer

     

       100
       100
       -
       	niceDiff.Commit.Tree = c.TreeHash.String()

     

       101
       101
       -
       	niceDiff.Commit.PGPSignature = c.PGPSignature

     

       102
       102
       -
       

     

       103
       103
       -
       	changeId, ok := c.ExtraHeaders["change-id"]

     

       104
       104
       -
       	if ok {

     

       105
       105
       -
       		niceDiff.Commit.ChangedId = string(changeId)

     

       106
       106
       -
       	}

     

       107
       107
       -
       

     

       108
       108
       -
       	// set parent hash if available

     

       109
       109
       -
       	if len(c.ParentHashes) > 0 {

     

       110
       110
       -
       		niceDiff.Commit.Parent = c.ParentHashes[0].String()

     

       111
       111
       -
       	}

     

       112
       112
       -
       

     

       113
       113
       -
       	// XXX: Stats and Diff fields are typically populated

     

       114
       114
       -
       	// after fetching the actual diff information, which isn't

     

       115
       115
       -
       	// directly available in the commit object itself.

     

       116
       116
       -
       

     

       117
       117
       -
       	return niceDiff

     

       118
       118
       -
       }

+3 -2

appview/db/artifact.go

···

       8
       8
        
       	"github.com/go-git/go-git/v5/plumbing"

     

       9
       9
        
       	"github.com/ipfs/go-cid"

     

       10
       10
        
       	"tangled.org/core/appview/models"

     

       11
       11
       +
       	"tangled.org/core/orm"

     

       11
       12
        
       )

     

       12
       13
        
       

     

       13
       14
        
       func AddArtifact(e Execer, artifact models.Artifact) error {

     
···

       37
       38
        
       	return err

     

       38
       39
        
       }

     

       39
       40
        
       

     

       40
       40
       -
       func GetArtifact(e Execer, filters ...filter) ([]models.Artifact, error) {

     

       41
       41
       +
       func GetArtifact(e Execer, filters ...orm.Filter) ([]models.Artifact, error) {

     

       41
       42
        
       	var artifacts []models.Artifact

     

       42
       43
        
       

     

       43
       44
        
       	var conditions []string

     
···

       109
       110
        
       	return artifacts, nil

     

       110
       111
        
       }

     

       111
       112
        
       

     

       112
       112
       -
       func DeleteArtifact(e Execer, filters ...filter) error {

     

       113
       113
       +
       func DeleteArtifact(e Execer, filters ...orm.Filter) error {

     

       113
       114
        
       	var conditions []string

     

       114
       115
        
       	var args []any

     

       115
       116
        
       	for _, filter := range filters {

+4 -3

appview/db/collaborators.go

···

       6
       6
        
       	"time"

     

       7
       7
        
       

     

       8
       8
        
       	"tangled.org/core/appview/models"

     

       9
       9
       +
       	"tangled.org/core/orm"

     

       9
       10
        
       )

     

       10
       11
        
       

     

       11
       12
        
       func AddCollaborator(e Execer, c models.Collaborator) error {

     
···

       16
       17
        
       	return err

     

       17
       18
        
       }

     

       18
       19
        
       

     

       19
       19
       -
       func DeleteCollaborator(e Execer, filters ...filter) error {

     

       20
       20
       +
       func DeleteCollaborator(e Execer, filters ...orm.Filter) error {

     

       20
       21
        
       	var conditions []string

     

       21
       22
        
       	var args []any

     

       22
       23
        
       	for _, filter := range filters {

     
···

       58
       59
        
       		return nil, nil

     

       59
       60
        
       	}

     

       60
       61
        
       

     

       61
       61
       -
       	return GetRepos(e, 0, FilterIn("at_uri", repoAts))

     

       62
       62
       +
       	return GetRepos(e, 0, orm.FilterIn("at_uri", repoAts))

     

       62
       63
        
       }

     

       63
       64
        
       

     

       64
       64
       -
       func GetCollaborators(e Execer, filters ...filter) ([]models.Collaborator, error) {

     

       65
       65
       +
       func GetCollaborators(e Execer, filters ...orm.Filter) ([]models.Collaborator, error) {

     

       65
       66
        
       	var collaborators []models.Collaborator

     

       66
       67
        
       	var conditions []string

     

       67
       68
        
       	var args []any

+60 -136

appview/db/db.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"context"

     

       5
       5
        
       	"database/sql"

     

       6
       6
       -
       	"fmt"

     

       7
       6
        
       	"log/slog"

     

       8
       8
       -
       	"reflect"

     

       9
       7
        
       	"strings"

     

       10
       8
        
       

     

       11
       9
        
       	_ "github.com/mattn/go-sqlite3"

     

       12
       10
        
       	"tangled.org/core/log"

     

       11
       11
       +
       	"tangled.org/core/orm"

     

       13
       12
        
       )

     

       14
       13
        
       

     

       15
       14
        
       type DB struct {

     
···

       576
       575
        
       		-- indexes for better performance

     

       577
       576
        
       		create index if not exists idx_notifications_recipient_created on notifications(recipient_did, created desc);

     

       578
       577
        
       		create index if not exists idx_notifications_recipient_read on notifications(recipient_did, read);

     

       579
       579
       -
       		create index if not exists idx_stars_created on stars(created);

     

       580
       580
       -
       		create index if not exists idx_stars_repo_at_created on stars(repo_at, created);

     

       581
       578
        
       		create index if not exists idx_references_from_at on reference_links(from_at);

     

       582
       579
        
       		create index if not exists idx_references_to_at on reference_links(to_at);

     

       583
       580
        
       	`)

     
···

       586
       583
        
       	}

     

       587
       584
        
       

     

       588
       585
        
       	// run migrations

     

       589
       589
       -
       	runMigration(conn, logger, "add-description-to-repos", func(tx *sql.Tx) error {

     

       586
       586
       +
       	orm.RunMigration(conn, logger, "add-description-to-repos", func(tx *sql.Tx) error {

     

       590
       587
        
       		tx.Exec(`

     

       591
       588
        
       			alter table repos add column description text check (length(description) <= 200);

     

       592
       589
        
       		`)

     

       593
       590
        
       		return nil

     

       594
       591
        
       	})

     

       595
       592
        
       

     

       596
       596
       -
       	runMigration(conn, logger, "add-rkey-to-pubkeys", func(tx *sql.Tx) error {

     

       593
       593
       +
       	orm.RunMigration(conn, logger, "add-rkey-to-pubkeys", func(tx *sql.Tx) error {

     

       597
       594
        
       		// add unconstrained column

     

       598
       595
        
       		_, err := tx.Exec(`

     

       599
       596
        
       			alter table public_keys

     
···

       616
       613
        
       		return nil

     

       617
       614
        
       	})

     

       618
       615
        
       

     

       619
       619
       -
       	runMigration(conn, logger, "add-rkey-to-comments", func(tx *sql.Tx) error {

     

       616
       616
       +
       	orm.RunMigration(conn, logger, "add-rkey-to-comments", func(tx *sql.Tx) error {

     

       620
       617
        
       		_, err := tx.Exec(`

     

       621
       618
        
       			alter table comments drop column comment_at;

     

       622
       619
        
       			alter table comments add column rkey text;

     
···

       624
       621
        
       		return err

     

       625
       622
        
       	})

     

       626
       623
        
       

     

       627
       627
       -
       	runMigration(conn, logger, "add-deleted-and-edited-to-issue-comments", func(tx *sql.Tx) error {

     

       624
       624
       +
       	orm.RunMigration(conn, logger, "add-deleted-and-edited-to-issue-comments", func(tx *sql.Tx) error {

     

       628
       625
        
       		_, err := tx.Exec(`

     

       629
       626
        
       			alter table comments add column deleted text; -- timestamp

     

       630
       627
        
       			alter table comments add column edited text; -- timestamp

     
···

       632
       629
        
       		return err

     

       633
       630
        
       	})

     

       634
       631
        
       

     

       635
       635
       -
       	runMigration(conn, logger, "add-source-info-to-pulls-and-submissions", func(tx *sql.Tx) error {

     

       632
       632
       +
       	orm.RunMigration(conn, logger, "add-source-info-to-pulls-and-submissions", func(tx *sql.Tx) error {

     

       636
       633
        
       		_, err := tx.Exec(`

     

       637
       634
        
       			alter table pulls add column source_branch text;

     

       638
       635
        
       			alter table pulls add column source_repo_at text;

     
···

       641
       638
        
       		return err

     

       642
       639
        
       	})

     

       643
       640
        
       

     

       644
       644
       -
       	runMigration(conn, logger, "add-source-to-repos", func(tx *sql.Tx) error {

     

       641
       641
       +
       	orm.RunMigration(conn, logger, "add-source-to-repos", func(tx *sql.Tx) error {

     

       645
       642
        
       		_, err := tx.Exec(`

     

       646
       643
        
       			alter table repos add column source text;

     

       647
       644
        
       		`)

     
···

       653
       650
        
       	//

     

       654
       651
        
       	// [0]: https://sqlite.org/pragma.html#pragma_foreign_keys

     

       655
       652
        
       	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       656
       656
       -
       	runMigration(conn, logger, "recreate-pulls-column-for-stacking-support", func(tx *sql.Tx) error {

     

       653
       653
       +
       	orm.RunMigration(conn, logger, "recreate-pulls-column-for-stacking-support", func(tx *sql.Tx) error {

     

       657
       654
        
       		_, err := tx.Exec(`

     

       658
       655
        
       			create table pulls_new (

     

       659
       656
        
       				-- identifiers

     
···

       710
       707
        
       	})

     

       711
       708
        
       	conn.ExecContext(ctx, "pragma foreign_keys = on;")

     

       712
       709
        
       

     

       713
       713
       -
       	runMigration(conn, logger, "add-spindle-to-repos", func(tx *sql.Tx) error {

     

       710
       710
       +
       	orm.RunMigration(conn, logger, "add-spindle-to-repos", func(tx *sql.Tx) error {

     

       714
       711
        
       		tx.Exec(`

     

       715
       712
        
       			alter table repos add column spindle text;

     

       716
       713
        
       		`)

     
···

       720
       717
        
       	// drop all knot secrets, add unique constraint to knots

     

       721
       718
        
       	//

     

       722
       719
        
       	// knots will henceforth use service auth for signed requests

     

       723
       723
       -
       	runMigration(conn, logger, "no-more-secrets", func(tx *sql.Tx) error {

     

       720
       720
       +
       	orm.RunMigration(conn, logger, "no-more-secrets", func(tx *sql.Tx) error {

     

       724
       721
        
       		_, err := tx.Exec(`

     

       725
       722
        
       			create table registrations_new (

     

       726
       723
        
       				id integer primary key autoincrement,

     
···

       743
       740
        
       	})

     

       744
       741
        
       

     

       745
       742
        
       	// recreate and add rkey + created columns with default constraint

     

       746
       746
       -
       	runMigration(conn, logger, "rework-collaborators-table", func(tx *sql.Tx) error {

     

       743
       743
       +
       	orm.RunMigration(conn, logger, "rework-collaborators-table", func(tx *sql.Tx) error {

     

       747
       744
        
       		// create new table

     

       748
       745
        
       		// - repo_at instead of repo integer

     

       749
       746
        
       		// - rkey field

     
···

       797
       794
        
       		return err

     

       798
       795
        
       	})

     

       799
       796
        
       

     

       800
       800
       -
       	runMigration(conn, logger, "add-rkey-to-issues", func(tx *sql.Tx) error {

     

       797
       797
       +
       	orm.RunMigration(conn, logger, "add-rkey-to-issues", func(tx *sql.Tx) error {

     

       801
       798
        
       		_, err := tx.Exec(`

     

       802
       799
        
       			alter table issues add column rkey text not null default '';

     

       803
       800
        
       

     
···

       809
       806
        
       	})

     

       810
       807
        
       

     

       811
       808
        
       	// repurpose the read-only column to "needs-upgrade"

     

       812
       812
       -
       	runMigration(conn, logger, "rename-registrations-read-only-to-needs-upgrade", func(tx *sql.Tx) error {

     

       809
       809
       +
       	orm.RunMigration(conn, logger, "rename-registrations-read-only-to-needs-upgrade", func(tx *sql.Tx) error {

     

       813
       810
        
       		_, err := tx.Exec(`

     

       814
       811
        
       			alter table registrations rename column read_only to needs_upgrade;

     

       815
       812
        
       		`)

     
···

       817
       814
        
       	})

     

       818
       815
        
       

     

       819
       816
        
       	// require all knots to upgrade after the release of total xrpc

     

       820
       820
       -
       	runMigration(conn, logger, "migrate-knots-to-total-xrpc", func(tx *sql.Tx) error {

     

       817
       817
       +
       	orm.RunMigration(conn, logger, "migrate-knots-to-total-xrpc", func(tx *sql.Tx) error {

     

       821
       818
        
       		_, err := tx.Exec(`

     

       822
       819
        
       			update registrations set needs_upgrade = 1;

     

       823
       820
        
       		`)

     
···

       825
       822
        
       	})

     

       826
       823
        
       

     

       827
       824
        
       	// require all knots to upgrade after the release of total xrpc

     

       828
       828
       -
       	runMigration(conn, logger, "migrate-spindles-to-xrpc-owner", func(tx *sql.Tx) error {

     

       825
       825
       +
       	orm.RunMigration(conn, logger, "migrate-spindles-to-xrpc-owner", func(tx *sql.Tx) error {

     

       829
       826
        
       		_, err := tx.Exec(`

     

       830
       827
        
       			alter table spindles add column needs_upgrade integer not null default 0;

     

       831
       828
        
       		`)

     
···

       843
       840
        
       	//

     

       844
       841
        
       	// disable foreign-keys for the next migration

     

       845
       842
        
       	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       846
       846
       -
       	runMigration(conn, logger, "remove-issue-at-from-issues", func(tx *sql.Tx) error {

     

       843
       843
       +
       	orm.RunMigration(conn, logger, "remove-issue-at-from-issues", func(tx *sql.Tx) error {

     

       847
       844
        
       		_, err := tx.Exec(`

     

       848
       845
        
       			create table if not exists issues_new (

     

       849
       846
        
       				-- identifiers

     
···

       913
       910
        
       	// - new columns

     

       914
       911
        
       	//   * column "reply_to" which can be any other comment

     

       915
       912
        
       	//   * column "at-uri" which is a generated column

     

       916
       916
       -
       	runMigration(conn, logger, "rework-issue-comments", func(tx *sql.Tx) error {

     

       913
       913
       +
       	orm.RunMigration(conn, logger, "rework-issue-comments", func(tx *sql.Tx) error {

     

       917
       914
        
       		_, err := tx.Exec(`

     

       918
       915
        
       			create table if not exists issue_comments (

     

       919
       916
        
       				-- identifiers

     
···

       973
       970
        
       	//

     

       974
       971
        
       	// disable foreign-keys for the next migration

     

       975
       972
        
       	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       976
       976
       -
       	runMigration(conn, logger, "add-at-uri-to-pulls", func(tx *sql.Tx) error {

     

       973
       973
       +
       	orm.RunMigration(conn, logger, "add-at-uri-to-pulls", func(tx *sql.Tx) error {

     

       977
       974
        
       		_, err := tx.Exec(`

     

       978
       975
        
       		create table if not exists pulls_new (

     

       979
       976
        
       			-- identifiers

     
···

       1054
       1051
        
       	//

     

       1055
       1052
        
       	// disable foreign-keys for the next migration

     

       1056
       1053
        
       	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       1057
       1057
       -
       	runMigration(conn, logger, "remove-repo-at-pull-id-from-pull-submissions", func(tx *sql.Tx) error {

     

       1054
       1054
       +
       	orm.RunMigration(conn, logger, "remove-repo-at-pull-id-from-pull-submissions", func(tx *sql.Tx) error {

     

       1058
       1055
        
       		_, err := tx.Exec(`

     

       1059
       1056
        
       		create table if not exists pull_submissions_new (

     

       1060
       1057
        
       			-- identifiers

     
···

       1108
       1105
        
       

     

       1109
       1106
        
       	// knots may report the combined patch for a comparison, we can store that on the appview side

     

       1110
       1107
        
       	// (but not on the pds record), because calculating the combined patch requires a git index

     

       1111
       1111
       -
       	runMigration(conn, logger, "add-combined-column-submissions", func(tx *sql.Tx) error {

     

       1108
       1108
       +
       	orm.RunMigration(conn, logger, "add-combined-column-submissions", func(tx *sql.Tx) error {

     

       1112
       1109
        
       		_, err := tx.Exec(`

     

       1113
       1110
        
       			alter table pull_submissions add column combined text;

     

       1114
       1111
        
       		`)

     

       1115
       1112
        
       		return err

     

       1116
       1113
        
       	})

     

       1117
       1114
        
       

     

       1118
       1118
       -
       	runMigration(conn, logger, "add-pronouns-profile", func(tx *sql.Tx) error {

     

       1115
       1115
       +
       	orm.RunMigration(conn, logger, "add-pronouns-profile", func(tx *sql.Tx) error {

     

       1119
       1116
        
       		_, err := tx.Exec(`

     

       1120
       1117
        
       			alter table profile add column pronouns text;

     

       1121
       1118
        
       		`)

     

       1122
       1119
        
       		return err

     

       1123
       1120
        
       	})

     

       1124
       1121
        
       

     

       1125
       1125
       -
       	runMigration(conn, logger, "add-meta-column-repos", func(tx *sql.Tx) error {

     

       1122
       1122
       +
       	orm.RunMigration(conn, logger, "add-meta-column-repos", func(tx *sql.Tx) error {

     

       1126
       1123
        
       		_, err := tx.Exec(`

     

       1127
       1124
        
       			alter table repos add column website text;

     

       1128
       1125
        
       			alter table repos add column topics text;

     
···

       1130
       1127
        
       		return err

     

       1131
       1128
        
       	})

     

       1132
       1129
        
       

     

       1133
       1133
       -
       	runMigration(conn, logger, "add-usermentioned-preference", func(tx *sql.Tx) error {

     

       1130
       1130
       +
       	orm.RunMigration(conn, logger, "add-usermentioned-preference", func(tx *sql.Tx) error {

     

       1134
       1131
        
       		_, err := tx.Exec(`

     

       1135
       1132
        
       			alter table notification_preferences add column user_mentioned integer not null default 1;

     

       1136
       1133
        
       		`)

     

       1137
       1134
        
       		return err

     

       1138
       1135
        
       	})

     

       1139
       1136
        
       

     

       1140
       1140
       -
       	return &DB{

     

       1141
       1141
       -
       		db,

     

       1142
       1142
       -
       		logger,

     

       1143
       1143
       -
       	}, nil

     

       1144
       1144
       -
       }

     

       1137
       1137
       +
       	// remove the foreign key constraints from stars.

     

       1138
       1138
       +
       	orm.RunMigration(conn, logger, "generalize-stars-subject", func(tx *sql.Tx) error {

     

       1139
       1139
       +
       		_, err := tx.Exec(`

     

       1140
       1140
       +
       			create table stars_new (

     

       1141
       1141
       +
       				id integer primary key autoincrement,

     

       1142
       1142
       +
       				did text not null,

     

       1143
       1143
       +
       				rkey text not null,

     

       1145
       1144
        
       

     

       1146
       1146
       -
       type migrationFn = func(*sql.Tx) error

     

       1145
       1145
       +
       				subject_at text not null,

     

       1147
       1146
        
       

     

       1148
       1148
       -
       func runMigration(c *sql.Conn, logger *slog.Logger, name string, migrationFn migrationFn) error {

     

       1149
       1149
       -
       	logger = logger.With("migration", name)

     

       1147
       1147
       +
       				created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),

     

       1148
       1148
       +
       				unique(did, rkey),

     

       1149
       1149
       +
       				unique(did, subject_at)

     

       1150
       1150
       +
       			);

     

       1150
       1151
        
       

     

       1151
       1151
       -
       	tx, err := c.BeginTx(context.Background(), nil)

     

       1152
       1152
       -
       	if err != nil {

     

       1153
       1153
       -
       		return err

     

       1154
       1154
       -
       	}

     

       1155
       1155
       -
       	defer tx.Rollback()

     

       1156
       1156
       -
       

     

       1157
       1157
       -
       	var exists bool

     

       1158
       1158
       -
       	err = tx.QueryRow("select exists (select 1 from migrations where name = ?)", name).Scan(&exists)

     

       1159
       1159
       -
       	if err != nil {

     

       1160
       1160
       -
       		return err

     

       1161
       1161
       -
       	}

     

       1162
       1162
       -
       

     

       1163
       1163
       -
       	if !exists {

     

       1164
       1164
       -
       		// run migration

     

       1165
       1165
       -
       		err = migrationFn(tx)

     

       1166
       1166
       -
       		if err != nil {

     

       1167
       1167
       -
       			logger.Error("failed to run migration", "err", err)

     

       1168
       1168
       -
       			return err

     

       1169
       1169
       -
       		}

     

       1170
       1170
       -
       

     

       1171
       1171
       -
       		// mark migration as complete

     

       1172
       1172
       -
       		_, err = tx.Exec("insert into migrations (name) values (?)", name)

     

       1173
       1173
       -
       		if err != nil {

     

       1174
       1174
       -
       			logger.Error("failed to mark migration as complete", "err", err)

     

       1175
       1175
       -
       			return err

     

       1176
       1176
       -
       		}

     

       1152
       1152
       +
       			insert into stars_new (

     

       1153
       1153
       +
       				id,

     

       1154
       1154
       +
       				did,

     

       1155
       1155
       +
       				rkey,

     

       1156
       1156
       +
       				subject_at,

     

       1157
       1157
       +
       				created

     

       1158
       1158
       +
       			)

     

       1159
       1159
       +
       			select

     

       1160
       1160
       +
       				id,

     

       1161
       1161
       +
       				starred_by_did,

     

       1162
       1162
       +
       				rkey,

     

       1163
       1163
       +
       				repo_at,

     

       1164
       1164
       +
       				created

     

       1165
       1165
       +
       			from stars;

     

       1177
       1166
        
       

     

       1178
       1178
       -
       		// commit the transaction

     

       1179
       1179
       -
       		if err := tx.Commit(); err != nil {

     

       1180
       1180
       -
       			return err

     

       1181
       1181
       -
       		}

     

       1167
       1167
       +
       			drop table stars;

     

       1168
       1168
       +
       			alter table stars_new rename to stars;

     

       1182
       1169
        
       

     

       1183
       1183
       -
       		logger.Info("migration applied successfully")

     

       1184
       1184
       -
       	} else {

     

       1185
       1185
       -
       		logger.Warn("skipped migration, already applied")

     

       1186
       1186
       -
       	}

     

       1170
       1170
       +
       			create index if not exists idx_stars_created on stars(created);

     

       1171
       1171
       +
       			create index if not exists idx_stars_subject_at_created on stars(subject_at, created);

     

       1172
       1172
       +
       		`)

     

       1173
       1173
       +
       		return err

     

       1174
       1174
       +
       	})

     

       1187
       1175
        
       

     

       1188
       1188
       -
       	return nil

     

       1176
       1176
       +
       	return &DB{

     

       1177
       1177
       +
       		db,

     

       1178
       1178
       +
       		logger,

     

       1179
       1179
       +
       	}, nil

     

       1189
       1180
        
       }

     

       1190
       1181
        
       

     

       1191
       1182
        
       func (d *DB) Close() error {

     

       1192
       1183
        
       	return d.DB.Close()

     

       1193
       1184
        
       }

     

       1194
       1194
       -
       

     

       1195
       1195
       -
       type filter struct {

     

       1196
       1196
       -
       	key string

     

       1197
       1197
       -
       	arg any

     

       1198
       1198
       -
       	cmp string

     

       1199
       1199
       -
       }

     

       1200
       1200
       -
       

     

       1201
       1201
       -
       func newFilter(key, cmp string, arg any) filter {

     

       1202
       1202
       -
       	return filter{

     

       1203
       1203
       -
       		key: key,

     

       1204
       1204
       -
       		arg: arg,

     

       1205
       1205
       -
       		cmp: cmp,

     

       1206
       1206
       -
       	}

     

       1207
       1207
       -
       }

     

       1208
       1208
       -
       

     

       1209
       1209
       -
       func FilterEq(key string, arg any) filter      { return newFilter(key, "=", arg) }

     

       1210
       1210
       -
       func FilterNotEq(key string, arg any) filter   { return newFilter(key, "<>", arg) }

     

       1211
       1211
       -
       func FilterGte(key string, arg any) filter     { return newFilter(key, ">=", arg) }

     

       1212
       1212
       -
       func FilterLte(key string, arg any) filter     { return newFilter(key, "<=", arg) }

     

       1213
       1213
       -
       func FilterIs(key string, arg any) filter      { return newFilter(key, "is", arg) }

     

       1214
       1214
       -
       func FilterIsNot(key string, arg any) filter   { return newFilter(key, "is not", arg) }

     

       1215
       1215
       -
       func FilterIn(key string, arg any) filter      { return newFilter(key, "in", arg) }

     

       1216
       1216
       -
       func FilterLike(key string, arg any) filter    { return newFilter(key, "like", arg) }

     

       1217
       1217
       -
       func FilterNotLike(key string, arg any) filter { return newFilter(key, "not like", arg) }

     

       1218
       1218
       -
       func FilterContains(key string, arg any) filter {

     

       1219
       1219
       -
       	return newFilter(key, "like", fmt.Sprintf("%%%v%%", arg))

     

       1220
       1220
       -
       }

     

       1221
       1221
       -
       

     

       1222
       1222
       -
       func (f filter) Condition() string {

     

       1223
       1223
       -
       	rv := reflect.ValueOf(f.arg)

     

       1224
       1224
       -
       	kind := rv.Kind()

     

       1225
       1225
       -
       

     

       1226
       1226
       -
       	// if we have `FilterIn(k, [1, 2, 3])`, compile it down to `k in (?, ?, ?)`

     

       1227
       1227
       -
       	if (kind == reflect.Slice && rv.Type().Elem().Kind() != reflect.Uint8) || kind == reflect.Array {

     

       1228
       1228
       -
       		if rv.Len() == 0 {

     

       1229
       1229
       -
       			// always false

     

       1230
       1230
       -
       			return "1 = 0"

     

       1231
       1231
       -
       		}

     

       1232
       1232
       -
       

     

       1233
       1233
       -
       		placeholders := make([]string, rv.Len())

     

       1234
       1234
       -
       		for i := range placeholders {

     

       1235
       1235
       -
       			placeholders[i] = "?"

     

       1236
       1236
       -
       		}

     

       1237
       1237
       -
       

     

       1238
       1238
       -
       		return fmt.Sprintf("%s %s (%s)", f.key, f.cmp, strings.Join(placeholders, ", "))

     

       1239
       1239
       -
       	}

     

       1240
       1240
       -
       

     

       1241
       1241
       -
       	return fmt.Sprintf("%s %s ?", f.key, f.cmp)

     

       1242
       1242
       -
       }

     

       1243
       1243
       -
       

     

       1244
       1244
       -
       func (f filter) Arg() []any {

     

       1245
       1245
       -
       	rv := reflect.ValueOf(f.arg)

     

       1246
       1246
       -
       	kind := rv.Kind()

     

       1247
       1247
       -
       	if (kind == reflect.Slice && rv.Type().Elem().Kind() != reflect.Uint8) || kind == reflect.Array {

     

       1248
       1248
       -
       		if rv.Len() == 0 {

     

       1249
       1249
       -
       			return nil

     

       1250
       1250
       -
       		}

     

       1251
       1251
       -
       

     

       1252
       1252
       -
       		out := make([]any, rv.Len())

     

       1253
       1253
       -
       		for i := range rv.Len() {

     

       1254
       1254
       -
       			out[i] = rv.Index(i).Interface()

     

       1255
       1255
       -
       		}

     

       1256
       1256
       -
       		return out

     

       1257
       1257
       -
       	}

     

       1258
       1258
       -
       

     

       1259
       1259
       -
       	return []any{f.arg}

     

       1260
       1260
       -
       }

+4 -3

appview/db/follow.go

···

       7
       7
        
       	"time"

     

       8
       8
        
       

     

       9
       9
        
       	"tangled.org/core/appview/models"

     

       10
       10
       +
       	"tangled.org/core/orm"

     

       10
       11
        
       )

     

       11
       12
        
       

     

       12
       13
        
       func AddFollow(e Execer, follow *models.Follow) error {

     
···

       134
       135
        
       	return result, nil

     

       135
       136
        
       }

     

       136
       137
        
       

     

       137
       137
       -
       func GetFollows(e Execer, limit int, filters ...filter) ([]models.Follow, error) {

     

       138
       138
       +
       func GetFollows(e Execer, limit int, filters ...orm.Filter) ([]models.Follow, error) {

     

       138
       139
        
       	var follows []models.Follow

     

       139
       140
        
       

     

       140
       141
        
       	var conditions []string

     
···

       191
       192
        
       }

     

       192
       193
        
       

     

       193
       194
        
       func GetFollowers(e Execer, did string) ([]models.Follow, error) {

     

       194
       194
       -
       	return GetFollows(e, 0, FilterEq("subject_did", did))

     

       195
       195
       +
       	return GetFollows(e, 0, orm.FilterEq("subject_did", did))

     

       195
       196
        
       }

     

       196
       197
        
       

     

       197
       198
        
       func GetFollowing(e Execer, did string) ([]models.Follow, error) {

     

       198
       198
       -
       	return GetFollows(e, 0, FilterEq("user_did", did))

     

       199
       199
       +
       	return GetFollows(e, 0, orm.FilterEq("user_did", did))

     

       199
       200
        
       }

     

       200
       201
        
       

     

       201
       202
        
       func getFollowStatuses(e Execer, userDid string, subjectDids []string) (map[string]models.FollowStatus, error) {

+21 -20

appview/db/issues.go

···

       13
       13
        
       	"tangled.org/core/api/tangled"

     

       14
       14
        
       	"tangled.org/core/appview/models"

     

       15
       15
        
       	"tangled.org/core/appview/pagination"

     

       16
       16
       +
       	"tangled.org/core/orm"

     

       16
       17
        
       )

     

       17
       18
        
       

     

       18
       19
        
       func PutIssue(tx *sql.Tx, issue *models.Issue) error {

     
···

       27
       28
        
       

     

       28
       29
        
       	issues, err := GetIssues(

     

       29
       30
        
       		tx,

     

       30
       30
       -
       		FilterEq("did", issue.Did),

     

       31
       31
       -
       		FilterEq("rkey", issue.Rkey),

     

       31
       31
       +
       		orm.FilterEq("did", issue.Did),

     

       32
       32
       +
       		orm.FilterEq("rkey", issue.Rkey),

     

       32
       33
        
       	)

     

       33
       34
        
       	switch {

     

       34
       35
        
       	case err != nil:

     
···

       98
       99
        
       	return nil

     

       99
       100
        
       }

     

       100
       101
        
       

     

       101
       101
       -
       func GetIssuesPaginated(e Execer, page pagination.Page, filters ...filter) ([]models.Issue, error) {

     

       102
       102
       +
       func GetIssuesPaginated(e Execer, page pagination.Page, filters ...orm.Filter) ([]models.Issue, error) {

     

       102
       103
        
       	issueMap := make(map[string]*models.Issue) // at-uri -> issue

     

       103
       104
        
       

     

       104
       105
        
       	var conditions []string

     
···

       114
       115
        
       		whereClause = " where " + strings.Join(conditions, " and ")

     

       115
       116
        
       	}

     

       116
       117
        
       

     

       117
       117
       -
       	pLower := FilterGte("row_num", page.Offset+1)

     

       118
       118
       -
       	pUpper := FilterLte("row_num", page.Offset+page.Limit)

     

       118
       118
       +
       	pLower := orm.FilterGte("row_num", page.Offset+1)

     

       119
       119
       +
       	pUpper := orm.FilterLte("row_num", page.Offset+page.Limit)

     

       119
       120
        
       

     

       120
       121
        
       	pageClause := ""

     

       121
       122
        
       	if page.Limit > 0 {

     
···

       205
       206
        
       		repoAts = append(repoAts, string(issue.RepoAt))

     

       206
       207
        
       	}

     

       207
       208
        
       

     

       208
       208
       -
       	repos, err := GetRepos(e, 0, FilterIn("at_uri", repoAts))

     

       209
       209
       +
       	repos, err := GetRepos(e, 0, orm.FilterIn("at_uri", repoAts))

     

       209
       210
        
       	if err != nil {

     

       210
       211
        
       		return nil, fmt.Errorf("failed to build repo mappings: %w", err)

     

       211
       212
        
       	}

     
···

       228
       229
        
       	// collect comments

     

       229
       230
        
       	issueAts := slices.Collect(maps.Keys(issueMap))

     

       230
       231
        
       

     

       231
       231
       -
       	comments, err := GetIssueComments(e, FilterIn("issue_at", issueAts))

     

       232
       232
       +
       	comments, err := GetIssueComments(e, orm.FilterIn("issue_at", issueAts))

     

       232
       233
        
       	if err != nil {

     

       233
       234
        
       		return nil, fmt.Errorf("failed to query comments: %w", err)

     

       234
       235
        
       	}

     
···

       240
       241
        
       	}

     

       241
       242
        
       

     

       242
       243
        
       	// collect allLabels for each issue

     

       243
       243
       -
       	allLabels, err := GetLabels(e, FilterIn("subject", issueAts))

     

       244
       244
       +
       	allLabels, err := GetLabels(e, orm.FilterIn("subject", issueAts))

     

       244
       245
        
       	if err != nil {

     

       245
       246
        
       		return nil, fmt.Errorf("failed to query labels: %w", err)

     

       246
       247
        
       	}

     
···

       251
       252
        
       	}

     

       252
       253
        
       

     

       253
       254
        
       	// collect references for each issue

     

       254
       254
       -
       	allReferencs, err := GetReferencesAll(e, FilterIn("from_at", issueAts))

     

       255
       255
       +
       	allReferencs, err := GetReferencesAll(e, orm.FilterIn("from_at", issueAts))

     

       255
       256
        
       	if err != nil {

     

       256
       257
        
       		return nil, fmt.Errorf("failed to query reference_links: %w", err)

     

       257
       258
        
       	}

     
···

       277
       278
        
       	issues, err := GetIssuesPaginated(

     

       278
       279
        
       		e,

     

       279
       280
        
       		pagination.Page{},

     

       280
       280
       -
       		FilterEq("repo_at", repoAt),

     

       281
       281
       -
       		FilterEq("issue_id", issueId),

     

       281
       281
       +
       		orm.FilterEq("repo_at", repoAt),

     

       282
       282
       +
       		orm.FilterEq("issue_id", issueId),

     

       282
       283
        
       	)

     

       283
       284
        
       	if err != nil {

     

       284
       285
        
       		return nil, err

     
···

       290
       291
        
       	return &issues[0], nil

     

       291
       292
        
       }

     

       292
       293
        
       

     

       293
       293
       -
       func GetIssues(e Execer, filters ...filter) ([]models.Issue, error) {

     

       294
       294
       +
       func GetIssues(e Execer, filters ...orm.Filter) ([]models.Issue, error) {

     

       294
       295
        
       	return GetIssuesPaginated(e, pagination.Page{}, filters...)

     

       295
       296
        
       }

     

       296
       297
        
       

     
···

       298
       299
        
       func GetIssueIDs(e Execer, opts models.IssueSearchOptions) ([]int64, error) {

     

       299
       300
        
       	var ids []int64

     

       300
       301
        
       

     

       301
       301
       -
       	var filters []filter

     

       302
       302
       +
       	var filters []orm.Filter

     

       302
       303
        
       	openValue := 0

     

       303
       304
        
       	if opts.IsOpen {

     

       304
       305
        
       		openValue = 1

     

       305
       306
        
       	}

     

       306
       306
       -
       	filters = append(filters, FilterEq("open", openValue))

     

       307
       307
       +
       	filters = append(filters, orm.FilterEq("open", openValue))

     

       307
       308
        
       	if opts.RepoAt != "" {

     

       308
       308
       -
       		filters = append(filters, FilterEq("repo_at", opts.RepoAt))

     

       309
       309
       +
       		filters = append(filters, orm.FilterEq("repo_at", opts.RepoAt))

     

       309
       310
        
       	}

     

       310
       311
        
       

     

       311
       312
        
       	var conditions []string

     
···

       397
       398
        
       	return id, nil

     

       398
       399
        
       }

     

       399
       400
        
       

     

       400
       400
       -
       func DeleteIssueComments(e Execer, filters ...filter) error {

     

       401
       401
       +
       func DeleteIssueComments(e Execer, filters ...orm.Filter) error {

     

       401
       402
        
       	var conditions []string

     

       402
       403
        
       	var args []any

     

       403
       404
        
       	for _, filter := range filters {

     
···

       416
       417
        
       	return err

     

       417
       418
        
       }

     

       418
       419
        
       

     

       419
       419
       -
       func GetIssueComments(e Execer, filters ...filter) ([]models.IssueComment, error) {

     

       420
       420
       +
       func GetIssueComments(e Execer, filters ...orm.Filter) ([]models.IssueComment, error) {

     

       420
       421
        
       	commentMap := make(map[string]*models.IssueComment)

     

       421
       422
        
       

     

       422
       423
        
       	var conditions []string

     
···

       506
       507
        
       

     

       507
       508
        
       	// collect references for each comments

     

       508
       509
        
       	commentAts := slices.Collect(maps.Keys(commentMap))

     

       509
       509
       -
       	allReferencs, err := GetReferencesAll(e, FilterIn("from_at", commentAts))

     

       510
       510
       +
       	allReferencs, err := GetReferencesAll(e, orm.FilterIn("from_at", commentAts))

     

       510
       511
        
       	if err != nil {

     

       511
       512
        
       		return nil, fmt.Errorf("failed to query reference_links: %w", err)

     

       512
       513
        
       	}

     
···

       548
       549
        
       	return nil

     

       549
       550
        
       }

     

       550
       551
        
       

     

       551
       551
       -
       func CloseIssues(e Execer, filters ...filter) error {

     

       552
       552
       +
       func CloseIssues(e Execer, filters ...orm.Filter) error {

     

       552
       553
        
       	var conditions []string

     

       553
       554
        
       	var args []any

     

       554
       555
        
       	for _, filter := range filters {

     
···

       566
       567
        
       	return err

     

       567
       568
        
       }

     

       568
       569
        
       

     

       569
       569
       -
       func ReopenIssues(e Execer, filters ...filter) error {

     

       570
       570
       +
       func ReopenIssues(e Execer, filters ...orm.Filter) error {

     

       570
       571
        
       	var conditions []string

     

       571
       572
        
       	var args []any

     

       572
       573
        
       	for _, filter := range filters {

+8 -7

appview/db/label.go

···

       10
       10
        
       

     

       11
       11
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       12
       12
        
       	"tangled.org/core/appview/models"

     

       13
       13
       +
       	"tangled.org/core/orm"

     

       13
       14
        
       )

     

       14
       15
        
       

     

       15
       16
        
       // no updating type for now

     
···

       59
       60
        
       	return id, nil

     

       60
       61
        
       }

     

       61
       62
        
       

     

       62
       62
       -
       func DeleteLabelDefinition(e Execer, filters ...filter) error {

     

       63
       63
       +
       func DeleteLabelDefinition(e Execer, filters ...orm.Filter) error {

     

       63
       64
        
       	var conditions []string

     

       64
       65
        
       	var args []any

     

       65
       66
        
       	for _, filter := range filters {

     
···

       75
       76
        
       	return err

     

       76
       77
        
       }

     

       77
       78
        
       

     

       78
       78
       -
       func GetLabelDefinitions(e Execer, filters ...filter) ([]models.LabelDefinition, error) {

     

       79
       79
       +
       func GetLabelDefinitions(e Execer, filters ...orm.Filter) ([]models.LabelDefinition, error) {

     

       79
       80
        
       	var labelDefinitions []models.LabelDefinition

     

       80
       81
        
       	var conditions []string

     

       81
       82
        
       	var args []any

     
···

       167
       168
        
       }

     

       168
       169
        
       

     

       169
       170
        
       // helper to get exactly one label def

     

       170
       170
       -
       func GetLabelDefinition(e Execer, filters ...filter) (*models.LabelDefinition, error) {

     

       171
       171
       +
       func GetLabelDefinition(e Execer, filters ...orm.Filter) (*models.LabelDefinition, error) {

     

       171
       172
        
       	labels, err := GetLabelDefinitions(e, filters...)

     

       172
       173
        
       	if err != nil {

     

       173
       174
        
       		return nil, err

     
···

       227
       228
        
       	return id, nil

     

       228
       229
        
       }

     

       229
       230
        
       

     

       230
       230
       -
       func GetLabelOps(e Execer, filters ...filter) ([]models.LabelOp, error) {

     

       231
       231
       +
       func GetLabelOps(e Execer, filters ...orm.Filter) ([]models.LabelOp, error) {

     

       231
       232
        
       	var labelOps []models.LabelOp

     

       232
       233
        
       	var conditions []string

     

       233
       234
        
       	var args []any

     
···

       302
       303
        
       }

     

       303
       304
        
       

     

       304
       305
        
       // get labels for a given list of subject URIs

     

       305
       305
       -
       func GetLabels(e Execer, filters ...filter) (map[syntax.ATURI]models.LabelState, error) {

     

       306
       306
       +
       func GetLabels(e Execer, filters ...orm.Filter) (map[syntax.ATURI]models.LabelState, error) {

     

       306
       307
        
       	ops, err := GetLabelOps(e, filters...)

     

       307
       308
        
       	if err != nil {

     

       308
       309
        
       		return nil, err

     
···

       322
       323
        
       	}

     

       323
       324
        
       	labelAts := slices.Collect(maps.Keys(labelAtSet))

     

       324
       325
        
       

     

       325
       325
       -
       	actx, err := NewLabelApplicationCtx(e, FilterIn("at_uri", labelAts))

     

       326
       326
       +
       	actx, err := NewLabelApplicationCtx(e, orm.FilterIn("at_uri", labelAts))

     

       326
       327
        
       	if err != nil {

     

       327
       328
        
       		return nil, err

     

       328
       329
        
       	}

     
···

       338
       339
        
       	return results, nil

     

       339
       340
        
       }

     

       340
       341
        
       

     

       341
       341
       -
       func NewLabelApplicationCtx(e Execer, filters ...filter) (*models.LabelApplicationCtx, error) {

     

       342
       342
       +
       func NewLabelApplicationCtx(e Execer, filters ...orm.Filter) (*models.LabelApplicationCtx, error) {

     

       342
       343
        
       	labels, err := GetLabelDefinitions(e, filters...)

     

       343
       344
        
       	if err != nil {

     

       344
       345
        
       		return nil, err

+5 -4

appview/db/language.go

···

       7
       7
        
       

     

       8
       8
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       9
       9
        
       	"tangled.org/core/appview/models"

     

       10
       10
       +
       	"tangled.org/core/orm"

     

       10
       11
        
       )

     

       11
       12
        
       

     

       12
       12
       -
       func GetRepoLanguages(e Execer, filters ...filter) ([]models.RepoLanguage, error) {

     

       13
       13
       +
       func GetRepoLanguages(e Execer, filters ...orm.Filter) ([]models.RepoLanguage, error) {

     

       13
       14
        
       	var conditions []string

     

       14
       15
        
       	var args []any

     

       15
       16
        
       	for _, filter := range filters {

     
···

       85
       86
        
       	return nil

     

       86
       87
        
       }

     

       87
       88
        
       

     

       88
       88
       -
       func DeleteRepoLanguages(e Execer, filters ...filter) error {

     

       89
       89
       +
       func DeleteRepoLanguages(e Execer, filters ...orm.Filter) error {

     

       89
       90
        
       	var conditions []string

     

       90
       91
        
       	var args []any

     

       91
       92
        
       	for _, filter := range filters {

     
···

       107
       108
        
       func UpdateRepoLanguages(tx *sql.Tx, repoAt syntax.ATURI, ref string, langs []models.RepoLanguage) error {

     

       108
       109
        
       	err := DeleteRepoLanguages(

     

       109
       110
        
       		tx,

     

       110
       110
       -
       		FilterEq("repo_at", repoAt),

     

       111
       111
       -
       		FilterEq("ref", ref),

     

       111
       111
       +
       		orm.FilterEq("repo_at", repoAt),

     

       112
       112
       +
       		orm.FilterEq("ref", ref),

     

       112
       113
        
       	)

     

       113
       114
        
       	if err != nil {

     

       114
       115
        
       		return fmt.Errorf("failed to delete existing languages: %w", err)

+14 -13

appview/db/notifications.go

···

       11
       11
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       12
       12
        
       	"tangled.org/core/appview/models"

     

       13
       13
        
       	"tangled.org/core/appview/pagination"

     

       14
       14
       +
       	"tangled.org/core/orm"

     

       14
       15
        
       )

     

       15
       16
        
       

     

       16
       17
        
       func CreateNotification(e Execer, notification *models.Notification) error {

     
···

       44
       45
        
       }

     

       45
       46
        
       

     

       46
       47
        
       // GetNotificationsPaginated retrieves notifications with filters and pagination

     

       47
       47
       -
       func GetNotificationsPaginated(e Execer, page pagination.Page, filters ...filter) ([]*models.Notification, error) {

     

       48
       48
       +
       func GetNotificationsPaginated(e Execer, page pagination.Page, filters ...orm.Filter) ([]*models.Notification, error) {

     

       48
       49
        
       	var conditions []string

     

       49
       50
        
       	var args []any

     

       50
       51
        
       

     
···

       113
       114
        
       }

     

       114
       115
        
       

     

       115
       116
        
       // GetNotificationsWithEntities retrieves notifications with their related entities

     

       116
       116
       -
       func GetNotificationsWithEntities(e Execer, page pagination.Page, filters ...filter) ([]*models.NotificationWithEntity, error) {

     

       117
       117
       +
       func GetNotificationsWithEntities(e Execer, page pagination.Page, filters ...orm.Filter) ([]*models.NotificationWithEntity, error) {

     

       117
       118
        
       	var conditions []string

     

       118
       119
        
       	var args []any

     

       119
       120
        
       

     
···

       256
       257
        
       }

     

       257
       258
        
       

     

       258
       259
        
       // GetNotifications retrieves notifications with filters

     

       259
       259
       -
       func GetNotifications(e Execer, filters ...filter) ([]*models.Notification, error) {

     

       260
       260
       +
       func GetNotifications(e Execer, filters ...orm.Filter) ([]*models.Notification, error) {

     

       260
       261
        
       	return GetNotificationsPaginated(e, pagination.FirstPage(), filters...)

     

       261
       262
        
       }

     

       262
       263
        
       

     

       263
       263
       -
       func CountNotifications(e Execer, filters ...filter) (int64, error) {

     

       264
       264
       +
       func CountNotifications(e Execer, filters ...orm.Filter) (int64, error) {

     

       264
       265
        
       	var conditions []string

     

       265
       266
        
       	var args []any

     

       266
       267
        
       	for _, filter := range filters {

     
···

       285
       286
        
       }

     

       286
       287
        
       

     

       287
       288
        
       func MarkNotificationRead(e Execer, notificationID int64, userDID string) error {

     

       288
       288
       -
       	idFilter := FilterEq("id", notificationID)

     

       289
       289
       -
       	recipientFilter := FilterEq("recipient_did", userDID)

     

       289
       289
       +
       	idFilter := orm.FilterEq("id", notificationID)

     

       290
       290
       +
       	recipientFilter := orm.FilterEq("recipient_did", userDID)

     

       290
       291
        
       

     

       291
       292
        
       	query := fmt.Sprintf(`

     

       292
       293
        
       		UPDATE notifications

     
···

       314
       315
        
       }

     

       315
       316
        
       

     

       316
       317
        
       func MarkAllNotificationsRead(e Execer, userDID string) error {

     

       317
       317
       -
       	recipientFilter := FilterEq("recipient_did", userDID)

     

       318
       318
       -
       	readFilter := FilterEq("read", 0)

     

       318
       318
       +
       	recipientFilter := orm.FilterEq("recipient_did", userDID)

     

       319
       319
       +
       	readFilter := orm.FilterEq("read", 0)

     

       319
       320
        
       

     

       320
       321
        
       	query := fmt.Sprintf(`

     

       321
       322
        
       		UPDATE notifications

     
···

       334
       335
        
       }

     

       335
       336
        
       

     

       336
       337
        
       func DeleteNotification(e Execer, notificationID int64, userDID string) error {

     

       337
       337
       -
       	idFilter := FilterEq("id", notificationID)

     

       338
       338
       -
       	recipientFilter := FilterEq("recipient_did", userDID)

     

       338
       338
       +
       	idFilter := orm.FilterEq("id", notificationID)

     

       339
       339
       +
       	recipientFilter := orm.FilterEq("recipient_did", userDID)

     

       339
       340
        
       

     

       340
       341
        
       	query := fmt.Sprintf(`

     

       341
       342
        
       		DELETE FROM notifications

     
···

       362
       363
        
       }

     

       363
       364
        
       

     

       364
       365
        
       func GetNotificationPreference(e Execer, userDid string) (*models.NotificationPreferences, error) {

     

       365
       365
       -
       	prefs, err := GetNotificationPreferences(e, FilterEq("user_did", userDid))

     

       366
       366
       +
       	prefs, err := GetNotificationPreferences(e, orm.FilterEq("user_did", userDid))

     

       366
       367
        
       	if err != nil {

     

       367
       368
        
       		return nil, err

     

       368
       369
        
       	}

     
···

       375
       376
        
       	return p, nil

     

       376
       377
        
       }

     

       377
       378
        
       

     

       378
       378
       -
       func GetNotificationPreferences(e Execer, filters ...filter) (map[syntax.DID]*models.NotificationPreferences, error) {

     

       379
       379
       +
       func GetNotificationPreferences(e Execer, filters ...orm.Filter) (map[syntax.DID]*models.NotificationPreferences, error) {

     

       379
       380
        
       	prefsMap := make(map[syntax.DID]*models.NotificationPreferences)

     

       380
       381
        
       

     

       381
       382
        
       	var conditions []string

     
···

       483
       484
        
       

     

       484
       485
        
       func (d *DB) ClearOldNotifications(ctx context.Context, olderThan time.Duration) error {

     

       485
       486
        
       	cutoff := time.Now().Add(-olderThan)

     

       486
       486
       -
       	createdFilter := FilterLte("created", cutoff)

     

       487
       487
       +
       	createdFilter := orm.FilterLte("created", cutoff)

     

       487
       488
        
       

     

       488
       489
        
       	query := fmt.Sprintf(`

     

       489
       490
        
       		DELETE FROM notifications

+9 -6

appview/db/pipeline.go

···

       7
       7
        
       	"time"

     

       8
       8
        
       

     

       9
       9
        
       	"tangled.org/core/appview/models"

     

       10
       10
       +
       	"tangled.org/core/orm"

     

       10
       11
        
       )

     

       11
       12
        
       

     

       12
       12
       -
       func GetPipelines(e Execer, filters ...filter) ([]models.Pipeline, error) {

     

       13
       13
       +
       func GetPipelines(e Execer, filters ...orm.Filter) ([]models.Pipeline, error) {

     

       13
       14
        
       	var pipelines []models.Pipeline

     

       14
       15
        
       

     

       15
       16
        
       	var conditions []string

     
···

       168
       169
        
       

     

       169
       170
        
       // this is a mega query, but the most useful one:

     

       170
       171
        
       // get N pipelines, for each one get the latest status of its N workflows

     

       171
       171
       -
       func GetPipelineStatuses(e Execer, filters ...filter) ([]models.Pipeline, error) {

     

       172
       172
       +
       func GetPipelineStatuses(e Execer, limit int, filters ...orm.Filter) ([]models.Pipeline, error) {

     

       172
       173
        
       	var conditions []string

     

       173
       174
        
       	var args []any

     

       174
       175
        
       	for _, filter := range filters {

     

       175
       175
       -
       		filter.key = "p." + filter.key // the table is aliased in the query to `p`

     

       176
       176
       +
       		filter.Key = "p." + filter.Key // the table is aliased in the query to `p`

     

       176
       177
        
       		conditions = append(conditions, filter.Condition())

     

       177
       178
        
       		args = append(args, filter.Arg()...)

     

       178
       179
        
       	}

     
···

       205
       206
        
       		join

     

       206
       207
        
       			triggers t ON p.trigger_id = t.id

     

       207
       208
        
       		%s

     

       208
       208
       -
       	`, whereClause)

     

       209
       209
       +
       		order by p.created desc

     

       210
       210
       +
       		limit %d

     

       211
       211
       +
       	`, whereClause, limit)

     

       209
       212
        
       

     

       210
       213
        
       	rows, err := e.Query(query, args...)

     

       211
       214
        
       	if err != nil {

     
···

       262
       265
        
       	conditions = nil

     

       263
       266
        
       	args = nil

     

       264
       267
        
       	for _, p := range pipelines {

     

       265
       265
       -
       		knotFilter := FilterEq("pipeline_knot", p.Knot)

     

       266
       266
       -
       		rkeyFilter := FilterEq("pipeline_rkey", p.Rkey)

     

       268
       268
       +
       		knotFilter := orm.FilterEq("pipeline_knot", p.Knot)

     

       269
       269
       +
       		rkeyFilter := orm.FilterEq("pipeline_rkey", p.Rkey)

     

       267
       270
        
       		conditions = append(conditions, fmt.Sprintf("(%s and %s)", knotFilter.Condition(), rkeyFilter.Condition()))

     

       268
       271
        
       		args = append(args, p.Knot)

     

       269
       272
        
       		args = append(args, p.Rkey)

+6 -5

appview/db/profile.go

···

       11
       11
        
       

     

       12
       12
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       13
       13
        
       	"tangled.org/core/appview/models"

     

       14
       14
       +
       	"tangled.org/core/orm"

     

       14
       15
        
       )

     

       15
       16
        
       

     

       16
       17
        
       const TimeframeMonths = 7

     
···

       44
       45
        
       

     

       45
       46
        
       	issues, err := GetIssues(

     

       46
       47
        
       		e,

     

       47
       47
       -
       		FilterEq("did", forDid),

     

       48
       48
       -
       		FilterGte("created", time.Now().AddDate(0, -TimeframeMonths, 0)),

     

       48
       48
       +
       		orm.FilterEq("did", forDid),

     

       49
       49
       +
       		orm.FilterGte("created", time.Now().AddDate(0, -TimeframeMonths, 0)),

     

       49
       50
        
       	)

     

       50
       51
        
       	if err != nil {

     

       51
       52
        
       		return nil, fmt.Errorf("error getting issues by owner did: %w", err)

     
···

       65
       66
        
       		*items = append(*items, &issue)

     

       66
       67
        
       	}

     

       67
       68
        
       

     

       68
       68
       -
       	repos, err := GetRepos(e, 0, FilterEq("did", forDid))

     

       69
       69
       +
       	repos, err := GetRepos(e, 0, orm.FilterEq("did", forDid))

     

       69
       70
        
       	if err != nil {

     

       70
       71
        
       		return nil, fmt.Errorf("error getting all repos by did: %w", err)

     

       71
       72
        
       	}

     
···

       199
       200
        
       	return tx.Commit()

     

       200
       201
        
       }

     

       201
       202
        
       

     

       202
       202
       -
       func GetProfiles(e Execer, filters ...filter) (map[string]*models.Profile, error) {

     

       203
       203
       +
       func GetProfiles(e Execer, filters ...orm.Filter) (map[string]*models.Profile, error) {

     

       203
       204
        
       	var conditions []string

     

       204
       205
        
       	var args []any

     

       205
       206
        
       	for _, filter := range filters {

     
···

       441
       442
        
       	}

     

       442
       443
        
       

     

       443
       444
        
       	// ensure all pinned repos are either own repos or collaborating repos

     

       444
       444
       -
       	repos, err := GetRepos(e, 0, FilterEq("did", profile.Did))

     

       445
       445
       +
       	repos, err := GetRepos(e, 0, orm.FilterEq("did", profile.Did))

     

       445
       446
        
       	if err != nil {

     

       446
       447
        
       		log.Printf("getting repos for %s: %s", profile.Did, err)

     

       447
       448
        
       	}

+21 -20

appview/db/pulls.go

···

       13
       13
        
       

     

       14
       14
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       15
       15
        
       	"tangled.org/core/appview/models"

     

       16
       16
       +
       	"tangled.org/core/orm"

     

       16
       17
        
       )

     

       17
       18
        
       

     

       18
       19
        
       func NewPull(tx *sql.Tx, pull *models.Pull) error {

     
···

       118
       119
        
       	return pullId - 1, err

     

       119
       120
        
       }

     

       120
       121
        
       

     

       121
       121
       -
       func GetPullsWithLimit(e Execer, limit int, filters ...filter) ([]*models.Pull, error) {

     

       122
       122
       +
       func GetPullsWithLimit(e Execer, limit int, filters ...orm.Filter) ([]*models.Pull, error) {

     

       122
       123
        
       	pulls := make(map[syntax.ATURI]*models.Pull)

     

       123
       124
        
       

     

       124
       125
        
       	var conditions []string

     
···

       229
       230
        
       	for _, p := range pulls {

     

       230
       231
        
       		pullAts = append(pullAts, p.AtUri())

     

       231
       232
        
       	}

     

       232
       232
       -
       	submissionsMap, err := GetPullSubmissions(e, FilterIn("pull_at", pullAts))

     

       233
       233
       +
       	submissionsMap, err := GetPullSubmissions(e, orm.FilterIn("pull_at", pullAts))

     

       233
       234
        
       	if err != nil {

     

       234
       235
        
       		return nil, fmt.Errorf("failed to get submissions: %w", err)

     

       235
       236
        
       	}

     
···

       241
       242
        
       	}

     

       242
       243
        
       

     

       243
       244
        
       	// collect allLabels for each issue

     

       244
       244
       -
       	allLabels, err := GetLabels(e, FilterIn("subject", pullAts))

     

       245
       245
       +
       	allLabels, err := GetLabels(e, orm.FilterIn("subject", pullAts))

     

       245
       246
        
       	if err != nil {

     

       246
       247
        
       		return nil, fmt.Errorf("failed to query labels: %w", err)

     

       247
       248
        
       	}

     
···

       258
       259
        
       			sourceAts = append(sourceAts, *p.PullSource.RepoAt)

     

       259
       260
        
       		}

     

       260
       261
        
       	}

     

       261
       261
       -
       	sourceRepos, err := GetRepos(e, 0, FilterIn("at_uri", sourceAts))

     

       262
       262
       +
       	sourceRepos, err := GetRepos(e, 0, orm.FilterIn("at_uri", sourceAts))

     

       262
       263
        
       	if err != nil && !errors.Is(err, sql.ErrNoRows) {

     

       263
       264
        
       		return nil, fmt.Errorf("failed to get source repos: %w", err)

     

       264
       265
        
       	}

     
···

       274
       275
        
       		}

     

       275
       276
        
       	}

     

       276
       277
        
       

     

       277
       277
       -
       	allReferences, err := GetReferencesAll(e, FilterIn("from_at", pullAts))

     

       278
       278
       +
       	allReferences, err := GetReferencesAll(e, orm.FilterIn("from_at", pullAts))

     

       278
       279
        
       	if err != nil {

     

       279
       280
        
       		return nil, fmt.Errorf("failed to query reference_links: %w", err)

     

       280
       281
        
       	}

     
···

       295
       296
        
       	return orderedByPullId, nil

     

       296
       297
        
       }

     

       297
       298
        
       

     

       298
       298
       -
       func GetPulls(e Execer, filters ...filter) ([]*models.Pull, error) {

     

       299
       299
       +
       func GetPulls(e Execer, filters ...orm.Filter) ([]*models.Pull, error) {

     

       299
       300
        
       	return GetPullsWithLimit(e, 0, filters...)

     

       300
       301
        
       }

     

       301
       302
        
       

     

       302
       303
        
       func GetPullIDs(e Execer, opts models.PullSearchOptions) ([]int64, error) {

     

       303
       304
        
       	var ids []int64

     

       304
       305
        
       

     

       305
       305
       -
       	var filters []filter

     

       306
       306
       -
       	filters = append(filters, FilterEq("state", opts.State))

     

       306
       306
       +
       	var filters []orm.Filter

     

       307
       307
       +
       	filters = append(filters, orm.FilterEq("state", opts.State))

     

       307
       308
        
       	if opts.RepoAt != "" {

     

       308
       308
       -
       		filters = append(filters, FilterEq("repo_at", opts.RepoAt))

     

       309
       309
       +
       		filters = append(filters, orm.FilterEq("repo_at", opts.RepoAt))

     

       309
       310
        
       	}

     

       310
       311
        
       

     

       311
       312
        
       	var conditions []string

     
···

       361
       362
        
       }

     

       362
       363
        
       

     

       363
       364
        
       func GetPull(e Execer, repoAt syntax.ATURI, pullId int) (*models.Pull, error) {

     

       364
       364
       -
       	pulls, err := GetPullsWithLimit(e, 1, FilterEq("repo_at", repoAt), FilterEq("pull_id", pullId))

     

       365
       365
       +
       	pulls, err := GetPullsWithLimit(e, 1, orm.FilterEq("repo_at", repoAt), orm.FilterEq("pull_id", pullId))

     

       365
       366
        
       	if err != nil {

     

       366
       367
        
       		return nil, err

     

       367
       368
        
       	}

     
···

       373
       374
        
       }

     

       374
       375
        
       

     

       375
       376
        
       // mapping from pull -> pull submissions

     

       376
       376
       -
       func GetPullSubmissions(e Execer, filters ...filter) (map[syntax.ATURI][]*models.PullSubmission, error) {

     

       377
       377
       +
       func GetPullSubmissions(e Execer, filters ...orm.Filter) (map[syntax.ATURI][]*models.PullSubmission, error) {

     

       377
       378
        
       	var conditions []string

     

       378
       379
        
       	var args []any

     

       379
       380
        
       	for _, filter := range filters {

     
···

       448
       449
        
       

     

       449
       450
        
       	// Get comments for all submissions using GetPullComments

     

       450
       451
        
       	submissionIds := slices.Collect(maps.Keys(submissionMap))

     

       451
       451
       -
       	comments, err := GetPullComments(e, FilterIn("submission_id", submissionIds))

     

       452
       452
       +
       	comments, err := GetPullComments(e, orm.FilterIn("submission_id", submissionIds))

     

       452
       453
        
       	if err != nil {

     

       453
       454
        
       		return nil, fmt.Errorf("failed to get pull comments: %w", err)

     

       454
       455
        
       	}

     
···

       474
       475
        
       	return m, nil

     

       475
       476
        
       }

     

       476
       477
        
       

     

       477
       477
       -
       func GetPullComments(e Execer, filters ...filter) ([]models.PullComment, error) {

     

       478
       478
       +
       func GetPullComments(e Execer, filters ...orm.Filter) ([]models.PullComment, error) {

     

       478
       479
        
       	var conditions []string

     

       479
       480
        
       	var args []any

     

       480
       481
        
       	for _, filter := range filters {

     
···

       542
       543
        
       

     

       543
       544
        
       	// collect references for each comments

     

       544
       545
        
       	commentAts := slices.Collect(maps.Keys(commentMap))

     

       545
       545
       -
       	allReferencs, err := GetReferencesAll(e, FilterIn("from_at", commentAts))

     

       546
       546
       +
       	allReferencs, err := GetReferencesAll(e, orm.FilterIn("from_at", commentAts))

     

       546
       547
        
       	if err != nil {

     

       547
       548
        
       		return nil, fmt.Errorf("failed to query reference_links: %w", err)

     

       548
       549
        
       	}

     
···

       708
       709
        
       	return err

     

       709
       710
        
       }

     

       710
       711
        
       

     

       711
       711
       -
       func SetPullParentChangeId(e Execer, parentChangeId string, filters ...filter) error {

     

       712
       712
       +
       func SetPullParentChangeId(e Execer, parentChangeId string, filters ...orm.Filter) error {

     

       712
       713
        
       	var conditions []string

     

       713
       714
        
       	var args []any

     

       714
       715
        
       

     
···

       732
       733
        
       

     

       733
       734
        
       // Only used when stacking to update contents in the event of a rebase (the interdiff should be empty).

     

       734
       735
        
       // otherwise submissions are immutable

     

       735
       735
       -
       func UpdatePull(e Execer, newPatch, sourceRev string, filters ...filter) error {

     

       736
       736
       +
       func UpdatePull(e Execer, newPatch, sourceRev string, filters ...orm.Filter) error {

     

       736
       737
        
       	var conditions []string

     

       737
       738
        
       	var args []any

     

       738
       739
        
       

     
···

       790
       791
        
       func GetStack(e Execer, stackId string) (models.Stack, error) {

     

       791
       792
        
       	unorderedPulls, err := GetPulls(

     

       792
       793
        
       		e,

     

       793
       793
       -
       		FilterEq("stack_id", stackId),

     

       794
       794
       -
       		FilterNotEq("state", models.PullDeleted),

     

       794
       794
       +
       		orm.FilterEq("stack_id", stackId),

     

       795
       795
       +
       		orm.FilterNotEq("state", models.PullDeleted),

     

       795
       796
        
       	)

     

       796
       797
        
       	if err != nil {

     

       797
       798
        
       		return nil, err

     
···

       835
       836
        
       func GetAbandonedPulls(e Execer, stackId string) ([]*models.Pull, error) {

     

       836
       837
        
       	pulls, err := GetPulls(

     

       837
       838
        
       		e,

     

       838
       838
       -
       		FilterEq("stack_id", stackId),

     

       839
       839
       -
       		FilterEq("state", models.PullDeleted),

     

       839
       839
       +
       		orm.FilterEq("stack_id", stackId),

     

       840
       840
       +
       		orm.FilterEq("state", models.PullDeleted),

     

       840
       841
        
       	)

     

       841
       842
        
       	if err != nil {

     

       842
       843
        
       		return nil, err

+2 -1

appview/db/punchcard.go

···

       7
       7
        
       	"time"

     

       8
       8
        
       

     

       9
       9
        
       	"tangled.org/core/appview/models"

     

       10
       10
       +
       	"tangled.org/core/orm"

     

       10
       11
        
       )

     

       11
       12
        
       

     

       12
       13
        
       // this adds to the existing count

     
···

       20
       21
        
       	return err

     

       21
       22
        
       }

     

       22
       23
        
       

     

       23
       23
       -
       func MakePunchcard(e Execer, filters ...filter) (*models.Punchcard, error) {

     

       24
       24
       +
       func MakePunchcard(e Execer, filters ...orm.Filter) (*models.Punchcard, error) {

     

       24
       25
        
       	punchcard := &models.Punchcard{}

     

       25
       26
        
       	now := time.Now()

     

       26
       27
        
       	startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC)

+4 -3

appview/db/reference.go

···

       8
       8
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       9
       9
        
       	"tangled.org/core/api/tangled"

     

       10
       10
        
       	"tangled.org/core/appview/models"

     

       11
       11
       +
       	"tangled.org/core/orm"

     

       11
       12
        
       )

     

       12
       13
        
       

     

       13
       14
        
       // ValidateReferenceLinks resolves refLinks to Issue/PR/IssueComment/PullComment ATURIs.

     
···

       205
       206
        
       	return err

     

       206
       207
        
       }

     

       207
       208
        
       

     

       208
       208
       -
       func GetReferencesAll(e Execer, filters ...filter) (map[syntax.ATURI][]syntax.ATURI, error) {

     

       209
       209
       +
       func GetReferencesAll(e Execer, filters ...orm.Filter) (map[syntax.ATURI][]syntax.ATURI, error) {

     

       209
       210
        
       	var (

     

       210
       211
        
       		conditions []string

     

       211
       212
        
       		args       []any

     
···

       347
       348
        
       	if len(aturis) == 0 {

     

       348
       349
        
       		return nil, nil

     

       349
       350
        
       	}

     

       350
       350
       -
       	filter := FilterIn("c.at_uri", aturis)

     

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

     

       351
       352
        
       	rows, err := e.Query(

     

       352
       353
        
       		fmt.Sprintf(

     

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

     
···

       427
       428
        
       	if len(aturis) == 0 {

     

       428
       429
        
       		return nil, nil

     

       429
       430
        
       	}

     

       430
       430
       -
       	filter := FilterIn("c.comment_at", aturis)

     

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

     

       431
       432
        
       	rows, err := e.Query(

     

       432
       433
        
       		fmt.Sprintf(

     

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

+4 -3

appview/db/registration.go

···

       7
       7
        
       	"time"

     

       8
       8
        
       

     

       9
       9
        
       	"tangled.org/core/appview/models"

     

       10
       10
       +
       	"tangled.org/core/orm"

     

       10
       11
        
       )

     

       11
       12
        
       

     

       12
       12
       -
       func GetRegistrations(e Execer, filters ...filter) ([]models.Registration, error) {

     

       13
       13
       +
       func GetRegistrations(e Execer, filters ...orm.Filter) ([]models.Registration, error) {

     

       13
       14
        
       	var registrations []models.Registration

     

       14
       15
        
       

     

       15
       16
        
       	var conditions []string

     
···

       69
       70
        
       	return registrations, nil

     

       70
       71
        
       }

     

       71
       72
        
       

     

       72
       72
       -
       func MarkRegistered(e Execer, filters ...filter) error {

     

       73
       73
       +
       func MarkRegistered(e Execer, filters ...orm.Filter) error {

     

       73
       74
        
       	var conditions []string

     

       74
       75
        
       	var args []any

     

       75
       76
        
       	for _, filter := range filters {

     
···

       94
       95
        
       	return err

     

       95
       96
        
       }

     

       96
       97
        
       

     

       97
       97
       -
       func DeleteKnot(e Execer, filters ...filter) error {

     

       98
       98
       +
       func DeleteKnot(e Execer, filters ...orm.Filter) error {

     

       98
       99
        
       	var conditions []string

     

       99
       100
        
       	var args []any

     

       100
       101
        
       	for _, filter := range filters {

+20 -36

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"

     

       15
       13
        
       	"tangled.org/core/appview/models"

     

       14
       14
       +
       	"tangled.org/core/orm"

     

       16
       15
        
       )

     

       17
       16
        
       

     

       18
       18
       -
       type Repo struct {

     

       19
       19
       -
       	Id          int64

     

       20
       20
       -
       	Did         string

     

       21
       21
       -
       	Name        string

     

       22
       22
       -
       	Knot        string

     

       23
       23
       -
       	Rkey        string

     

       24
       24
       -
       	Created     time.Time

     

       25
       25
       -
       	Description string

     

       26
       26
       -
       	Spindle     string

     

       27
       27
       -
       

     

       28
       28
       -
       	// optionally, populate this when querying for reverse mappings

     

       29
       29
       -
       	RepoStats *models.RepoStats

     

       30
       30
       -
       

     

       31
       31
       -
       	// optional

     

       32
       32
       -
       	Source string

     

       33
       33
       -
       }

     

       34
       34
       -
       

     

       35
       35
       -
       func (r Repo) RepoAt() syntax.ATURI {

     

       36
       36
       -
       	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", r.Did, tangled.RepoNSID, r.Rkey))

     

       37
       37
       -
       }

     

       38
       38
       -
       

     

       39
       39
       -
       func (r Repo) DidSlashRepo() string {

     

       40
       40
       -
       	p, _ := securejoin.SecureJoin(r.Did, r.Name)

     

       41
       41
       -
       	return p

     

       42
       42
       -
       }

     

       43
       43
       -
       

     

       44
       44
       -
       func GetRepos(e Execer, limit int, filters ...filter) ([]models.Repo, error) {

     

       17
       17
       +
       func GetRepos(e Execer, limit int, filters ...orm.Filter) ([]models.Repo, error) {

     

       45
       18
        
       	repoMap := make(map[syntax.ATURI]*models.Repo)

     

       46
       19
        
       

     

       47
       20
        
       	var conditions []string

     
···

       208
       181
        
       

     

       209
       182
        
       	starCountQuery := fmt.Sprintf(

     

       210
       183
        
       		`select

     

       211
       211
       -
       			repo_at, count(1)

     

       184
       184
       +
       			subject_at, count(1)

     

       212
       185
        
       		from stars

     

       213
       213
       -
       		where repo_at in (%s)

     

       214
       214
       -
       		group by repo_at`,

     

       186
       186
       +
       		where subject_at in (%s)

     

       187
       187
       +
       		group by subject_at`,

     

       215
       188
        
       		inClause,

     

       216
       189
        
       	)

     

       217
       190
        
       	rows, err = e.Query(starCountQuery, args...)

     
···

       322
       295
        
       }

     

       323
       296
        
       

     

       324
       297
        
       // helper to get exactly one repo

     

       325
       325
       -
       func GetRepo(e Execer, filters ...filter) (*models.Repo, error) {

     

       298
       298
       +
       func GetRepo(e Execer, filters ...orm.Filter) (*models.Repo, error) {

     

       326
       299
        
       	repos, err := GetRepos(e, 0, filters...)

     

       327
       300
        
       	if err != nil {

     

       328
       301
        
       		return nil, err

     
···

       339
       312
        
       	return &repos[0], nil

     

       340
       313
        
       }

     

       341
       314
        
       

     

       342
       342
       -
       func CountRepos(e Execer, filters ...filter) (int64, error) {

     

       315
       315
       +
       func CountRepos(e Execer, filters ...orm.Filter) (int64, error) {

     

       343
       316
        
       	var conditions []string

     

       344
       317
        
       	var args []any

     

       345
       318
        
       	for _, filter := range filters {

     
···

       439
       412
        
       	return nullableSource.String, nil

     

       440
       413
        
       }

     

       441
       414
        
       

     

       415
       415
       +
       func GetRepoSourceRepo(e Execer, repoAt syntax.ATURI) (*models.Repo, error) {

     

       416
       416
       +
       	source, err := GetRepoSource(e, repoAt)

     

       417
       417
       +
       	if source == "" || errors.Is(err, sql.ErrNoRows) {

     

       418
       418
       +
       		return nil, nil

     

       419
       419
       +
       	}

     

       420
       420
       +
       	if err != nil {

     

       421
       421
       +
       		return nil, err

     

       422
       422
       +
       	}

     

       423
       423
       +
       	return GetRepoByAtUri(e, source)

     

       424
       424
       +
       }

     

       425
       425
       +
       

     

       442
       426
        
       func GetForksByDid(e Execer, did string) ([]models.Repo, error) {

     

       443
       427
        
       	var repos []models.Repo

     

       444
       428
        
       

     
···

       559
       543
        
       	return err

     

       560
       544
        
       }

     

       561
       545
        
       

     

       562
       562
       -
       func UnsubscribeLabel(e Execer, filters ...filter) error {

     

       546
       546
       +
       func UnsubscribeLabel(e Execer, filters ...orm.Filter) error {

     

       563
       547
        
       	var conditions []string

     

       564
       548
        
       	var args []any

     

       565
       549
        
       	for _, filter := range filters {

     
···

       577
       561
        
       	return err

     

       578
       562
        
       }

     

       579
       563
        
       

     

       580
       580
       -
       func GetRepoLabels(e Execer, filters ...filter) ([]models.RepoLabel, error) {

     

       564
       564
       +
       func GetRepoLabels(e Execer, filters ...orm.Filter) ([]models.RepoLabel, error) {

     

       581
       565
        
       	var conditions []string

     

       582
       566
        
       	var args []any

     

       583
       567
        
       	for _, filter := range filters {

+6 -5

appview/db/spindle.go

···

       7
       7
        
       	"time"

     

       8
       8
        
       

     

       9
       9
        
       	"tangled.org/core/appview/models"

     

       10
       10
       +
       	"tangled.org/core/orm"

     

       10
       11
        
       )

     

       11
       12
        
       

     

       12
       12
       -
       func GetSpindles(e Execer, filters ...filter) ([]models.Spindle, error) {

     

       13
       13
       +
       func GetSpindles(e Execer, filters ...orm.Filter) ([]models.Spindle, error) {

     

       13
       14
        
       	var spindles []models.Spindle

     

       14
       15
        
       

     

       15
       16
        
       	var conditions []string

     
···

       91
       92
        
       	return err

     

       92
       93
        
       }

     

       93
       94
        
       

     

       94
       94
       -
       func VerifySpindle(e Execer, filters ...filter) (int64, error) {

     

       95
       95
       +
       func VerifySpindle(e Execer, filters ...orm.Filter) (int64, error) {

     

       95
       96
        
       	var conditions []string

     

       96
       97
        
       	var args []any

     

       97
       98
        
       	for _, filter := range filters {

     
···

       114
       115
        
       	return res.RowsAffected()

     

       115
       116
        
       }

     

       116
       117
        
       

     

       117
       117
       -
       func DeleteSpindle(e Execer, filters ...filter) error {

     

       118
       118
       +
       func DeleteSpindle(e Execer, filters ...orm.Filter) error {

     

       118
       119
        
       	var conditions []string

     

       119
       120
        
       	var args []any

     

       120
       121
        
       	for _, filter := range filters {

     
···

       144
       145
        
       	return err

     

       145
       146
        
       }

     

       146
       147
        
       

     

       147
       147
       -
       func RemoveSpindleMember(e Execer, filters ...filter) error {

     

       148
       148
       +
       func RemoveSpindleMember(e Execer, filters ...orm.Filter) error {

     

       148
       149
        
       	var conditions []string

     

       149
       150
        
       	var args []any

     

       150
       151
        
       	for _, filter := range filters {

     
···

       163
       164
        
       	return err

     

       164
       165
        
       }

     

       165
       166
        
       

     

       166
       166
       -
       func GetSpindleMembers(e Execer, filters ...filter) ([]models.SpindleMember, error) {

     

       167
       167
       +
       func GetSpindleMembers(e Execer, filters ...orm.Filter) ([]models.SpindleMember, error) {

     

       167
       168
        
       	var members []models.SpindleMember

     

       168
       169
        
       

     

       169
       170
        
       	var conditions []string

+43 -102

appview/db/star.go

···

       11
       11
        
       

     

       12
       12
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       13
       13
        
       	"tangled.org/core/appview/models"

     

       14
       14
       +
       	"tangled.org/core/orm"

     

       14
       15
        
       )

     

       15
       16
        
       

     

       16
       17
        
       func AddStar(e Execer, star *models.Star) error {

     

       17
       17
       -
       	query := `insert or ignore into stars (starred_by_did, repo_at, rkey) values (?, ?, ?)`

     

       18
       18
       +
       	query := `insert or ignore into stars (did, subject_at, rkey) values (?, ?, ?)`

     

       18
       19
        
       	_, err := e.Exec(

     

       19
       20
        
       		query,

     

       20
       20
       -
       		star.StarredByDid,

     

       21
       21
       +
       		star.Did,

     

       21
       22
        
       		star.RepoAt.String(),

     

       22
       23
        
       		star.Rkey,

     

       23
       24
        
       	)

     
···

       25
       26
        
       }

     

       26
       27
        
       

     

       27
       28
        
       // Get a star record

     

       28
       28
       -
       func GetStar(e Execer, starredByDid string, repoAt syntax.ATURI) (*models.Star, error) {

     

       29
       29
       +
       func GetStar(e Execer, did string, subjectAt syntax.ATURI) (*models.Star, error) {

     

       29
       30
        
       	query := `

     

       30
       30
       -
       	select starred_by_did, repo_at, created, rkey

     

       31
       31
       +
       	select did, subject_at, created, rkey

     

       31
       32
        
       	from stars

     

       32
       32
       -
       	where starred_by_did = ? and repo_at = ?`

     

       33
       33
       -
       	row := e.QueryRow(query, starredByDid, repoAt)

     

       33
       33
       +
       	where did = ? and subject_at = ?`

     

       34
       34
       +
       	row := e.QueryRow(query, did, subjectAt)

     

       34
       35
        
       

     

       35
       36
        
       	var star models.Star

     

       36
       37
        
       	var created string

     

       37
       37
       -
       	err := row.Scan(&star.StarredByDid, &star.RepoAt, &created, &star.Rkey)

     

       38
       38
       +
       	err := row.Scan(&star.Did, &star.RepoAt, &created, &star.Rkey)

     

       38
       39
        
       	if err != nil {

     

       39
       40
        
       		return nil, err

     

       40
       41
        
       	}

     
···

       51
       52
        
       }

     

       52
       53
        
       

     

       53
       54
        
       // Remove a star

     

       54
       54
       -
       func DeleteStar(e Execer, starredByDid string, repoAt syntax.ATURI) error {

     

       55
       55
       -
       	_, err := e.Exec(`delete from stars where starred_by_did = ? and repo_at = ?`, starredByDid, repoAt)

     

       55
       55
       +
       func DeleteStar(e Execer, did string, subjectAt syntax.ATURI) error {

     

       56
       56
       +
       	_, err := e.Exec(`delete from stars where did = ? and subject_at = ?`, did, subjectAt)

     

       56
       57
        
       	return err

     

       57
       58
        
       }

     

       58
       59
        
       

     

       59
       60
        
       // Remove a star

     

       60
       60
       -
       func DeleteStarByRkey(e Execer, starredByDid string, rkey string) error {

     

       61
       61
       -
       	_, err := e.Exec(`delete from stars where starred_by_did = ? and rkey = ?`, starredByDid, rkey)

     

       61
       61
       +
       func DeleteStarByRkey(e Execer, did string, rkey string) error {

     

       62
       62
       +
       	_, err := e.Exec(`delete from stars where did = ? and rkey = ?`, did, rkey)

     

       62
       63
        
       	return err

     

       63
       64
        
       }

     

       64
       65
        
       

     

       65
       65
       -
       func GetStarCount(e Execer, repoAt syntax.ATURI) (int, error) {

     

       66
       66
       +
       func GetStarCount(e Execer, subjectAt syntax.ATURI) (int, error) {

     

       66
       67
        
       	stars := 0

     

       67
       68
        
       	err := e.QueryRow(

     

       68
       68
       -
       		`select count(starred_by_did) from stars where repo_at = ?`, repoAt).Scan(&stars)

     

       69
       69
       +
       		`select count(did) from stars where subject_at = ?`, subjectAt).Scan(&stars)

     

       69
       70
        
       	if err != nil {

     

       70
       71
        
       		return 0, err

     

       71
       72
        
       	}

     
···

       89
       90
        
       	}

     

       90
       91
        
       

     

       91
       92
        
       	query := fmt.Sprintf(`

     

       92
       92
       -
       		SELECT repo_at

     

       93
       93
       +
       		SELECT subject_at

     

       93
       94
        
       		FROM stars

     

       94
       94
       -
       		WHERE starred_by_did = ? AND repo_at IN (%s)

     

       95
       95
       +
       		WHERE did = ? AND subject_at IN (%s)

     

       95
       96
        
       	`, strings.Join(placeholders, ","))

     

       96
       97
        
       

     

       97
       98
        
       	rows, err := e.Query(query, args...)

     
···

       118
       119
        
       	return result, nil

     

       119
       120
        
       }

     

       120
       121
        
       

     

       121
       121
       -
       func GetStarStatus(e Execer, userDid string, repoAt syntax.ATURI) bool {

     

       122
       122
       -
       	statuses, err := getStarStatuses(e, userDid, []syntax.ATURI{repoAt})

     

       122
       122
       +
       func GetStarStatus(e Execer, userDid string, subjectAt syntax.ATURI) bool {

     

       123
       123
       +
       	statuses, err := getStarStatuses(e, userDid, []syntax.ATURI{subjectAt})

     

       123
       124
        
       	if err != nil {

     

       124
       125
        
       		return false

     

       125
       126
        
       	}

     

       126
       126
       -
       	return statuses[repoAt.String()]

     

       127
       127
       +
       	return statuses[subjectAt.String()]

     

       127
       128
        
       }

     

       128
       129
        
       

     

       129
       130
        
       // GetStarStatuses returns a map of repo URIs to star status for a given user

     

       130
       130
       -
       func GetStarStatuses(e Execer, userDid string, repoAts []syntax.ATURI) (map[string]bool, error) {

     

       131
       131
       -
       	return getStarStatuses(e, userDid, repoAts)

     

       131
       131
       +
       func GetStarStatuses(e Execer, userDid string, subjectAts []syntax.ATURI) (map[string]bool, error) {

     

       132
       132
       +
       	return getStarStatuses(e, userDid, subjectAts)

     

       132
       133
        
       }

     

       133
       133
       -
       func GetStars(e Execer, limit int, filters ...filter) ([]models.Star, error) {

     

       134
       134
       +
       

     

       135
       135
       +
       // GetRepoStars return a list of stars each holding target repository.

     

       136
       136
       +
       // If there isn't known repo with starred at-uri, those stars will be ignored.

     

       137
       137
       +
       func GetRepoStars(e Execer, limit int, filters ...orm.Filter) ([]models.RepoStar, error) {

     

       134
       138
        
       	var conditions []string

     

       135
       139
        
       	var args []any

     

       136
       140
        
       	for _, filter := range filters {

     
···

       149
       153
        
       	}

     

       150
       154
        
       

     

       151
       155
        
       	repoQuery := fmt.Sprintf(

     

       152
       152
       -
       		`select starred_by_did, repo_at, created, rkey

     

       156
       156
       +
       		`select did, subject_at, created, rkey

     

       153
       157
        
       		from stars

     

       154
       158
        
       		%s

     

       155
       159
        
       		order by created desc

     
···

       166
       170
        
       	for rows.Next() {

     

       167
       171
        
       		var star models.Star

     

       168
       172
        
       		var created string

     

       169
       169
       -
       		err := rows.Scan(&star.StarredByDid, &star.RepoAt, &created, &star.Rkey)

     

       173
       173
       +
       		err := rows.Scan(&star.Did, &star.RepoAt, &created, &star.Rkey)

     

       170
       174
        
       		if err != nil {

     

       171
       175
        
       			return nil, err

     

       172
       176
        
       		}

     
···

       192
       196
        
       		return nil, nil

     

       193
       197
        
       	}

     

       194
       198
        
       

     

       195
       195
       -
       	repos, err := GetRepos(e, 0, FilterIn("at_uri", args))

     

       199
       199
       +
       	repos, err := GetRepos(e, 0, orm.FilterIn("at_uri", args))

     

       196
       200
        
       	if err != nil {

     

       197
       201
        
       		return nil, err

     

       198
       202
        
       	}

     

       199
       203
        
       

     

       204
       204
       +
       	var repoStars []models.RepoStar

     

       200
       205
        
       	for _, r := range repos {

     

       201
       206
        
       		if stars, ok := starMap[string(r.RepoAt())]; ok {

     

       202
       202
       -
       			for i := range stars {

     

       203
       203
       -
       				stars[i].Repo = &r

     

       207
       207
       +
       			for _, star := range stars {

     

       208
       208
       +
       				repoStars = append(repoStars, models.RepoStar{

     

       209
       209
       +
       					Star: star,

     

       210
       210
       +
       					Repo: &r,

     

       211
       211
       +
       				})

     

       204
       212
        
       			}

     

       205
       213
        
       		}

     

       206
       214
        
       	}

     

       207
       215
        
       

     

       208
       208
       -
       	var stars []models.Star

     

       209
       209
       -
       	for _, s := range starMap {

     

       210
       210
       -
       		stars = append(stars, s...)

     

       211
       211
       -
       	}

     

       212
       212
       -
       

     

       213
       213
       -
       	slices.SortFunc(stars, func(a, b models.Star) int {

     

       216
       216
       +
       	slices.SortFunc(repoStars, func(a, b models.RepoStar) int {

     

       214
       217
        
       		if a.Created.After(b.Created) {

     

       215
       218
        
       			return -1

     

       216
       219
        
       		}

     
···

       220
       223
        
       		return 0

     

       221
       224
        
       	})

     

       222
       225
        
       

     

       223
       223
       -
       	return stars, nil

     

       226
       226
       +
       	return repoStars, nil

     

       224
       227
        
       }

     

       225
       228
        
       

     

       226
       226
       -
       func CountStars(e Execer, filters ...filter) (int64, error) {

     

       229
       229
       +
       func CountStars(e Execer, filters ...orm.Filter) (int64, error) {

     

       227
       230
        
       	var conditions []string

     

       228
       231
        
       	var args []any

     

       229
       232
        
       	for _, filter := range filters {

     
···

       247
       250
        
       	return count, nil

     

       248
       251
        
       }

     

       249
       252
        
       

     

       250
       250
       -
       func GetAllStars(e Execer, limit int) ([]models.Star, error) {

     

       251
       251
       -
       	var stars []models.Star

     

       252
       252
       -
       

     

       253
       253
       -
       	rows, err := e.Query(`

     

       254
       254
       -
       		select

     

       255
       255
       -
       			s.starred_by_did,

     

       256
       256
       -
       			s.repo_at,

     

       257
       257
       -
       			s.rkey,

     

       258
       258
       -
       			s.created,

     

       259
       259
       -
       			r.did,

     

       260
       260
       -
       			r.name,

     

       261
       261
       -
       			r.knot,

     

       262
       262
       -
       			r.rkey,

     

       263
       263
       -
       			r.created

     

       264
       264
       -
       		from stars s

     

       265
       265
       -
       		join repos r on s.repo_at = r.at_uri

     

       266
       266
       -
       	`)

     

       267
       267
       -
       

     

       268
       268
       -
       	if err != nil {

     

       269
       269
       -
       		return nil, err

     

       270
       270
       -
       	}

     

       271
       271
       -
       	defer rows.Close()

     

       272
       272
       -
       

     

       273
       273
       -
       	for rows.Next() {

     

       274
       274
       -
       		var star models.Star

     

       275
       275
       -
       		var repo models.Repo

     

       276
       276
       -
       		var starCreatedAt, repoCreatedAt string

     

       277
       277
       -
       

     

       278
       278
       -
       		if err := rows.Scan(

     

       279
       279
       -
       			&star.StarredByDid,

     

       280
       280
       -
       			&star.RepoAt,

     

       281
       281
       -
       			&star.Rkey,

     

       282
       282
       -
       			&starCreatedAt,

     

       283
       283
       -
       			&repo.Did,

     

       284
       284
       -
       			&repo.Name,

     

       285
       285
       -
       			&repo.Knot,

     

       286
       286
       -
       			&repo.Rkey,

     

       287
       287
       -
       			&repoCreatedAt,

     

       288
       288
       -
       		); err != nil {

     

       289
       289
       -
       			return nil, err

     

       290
       290
       -
       		}

     

       291
       291
       -
       

     

       292
       292
       -
       		star.Created, err = time.Parse(time.RFC3339, starCreatedAt)

     

       293
       293
       -
       		if err != nil {

     

       294
       294
       -
       			star.Created = time.Now()

     

       295
       295
       -
       		}

     

       296
       296
       -
       		repo.Created, err = time.Parse(time.RFC3339, repoCreatedAt)

     

       297
       297
       -
       		if err != nil {

     

       298
       298
       -
       			repo.Created = time.Now()

     

       299
       299
       -
       		}

     

       300
       300
       -
       		star.Repo = &repo

     

       301
       301
       -
       

     

       302
       302
       -
       		stars = append(stars, star)

     

       303
       303
       -
       	}

     

       304
       304
       -
       

     

       305
       305
       -
       	if err := rows.Err(); err != nil {

     

       306
       306
       -
       		return nil, err

     

       307
       307
       -
       	}

     

       308
       308
       -
       

     

       309
       309
       -
       	return stars, nil

     

       310
       310
       -
       }

     

       311
       311
       -
       

     

       312
       253
        
       // GetTopStarredReposLastWeek returns the top 8 most starred repositories from the last week

     

       313
       254
        
       func GetTopStarredReposLastWeek(e Execer) ([]models.Repo, error) {

     

       314
       255
        
       	// first, get the top repo URIs by star count from the last week

     

       315
       256
        
       	query := `

     

       316
       257
        
       		with recent_starred_repos as (

     

       317
       317
       -
       			select distinct repo_at

     

       258
       258
       +
       			select distinct subject_at

     

       318
       259
        
       			from stars

     

       319
       260
        
       			where created >= datetime('now', '-7 days')

     

       320
       261
        
       		),

     

       321
       262
        
       		repo_star_counts as (

     

       322
       263
        
       			select

     

       323
       323
       -
       				s.repo_at,

     

       264
       264
       +
       				s.subject_at,

     

       324
       265
        
       				count(*) as stars_gained_last_week

     

       325
       266
        
       			from stars s

     

       326
       326
       -
       			join recent_starred_repos rsr on s.repo_at = rsr.repo_at

     

       267
       267
       +
       			join recent_starred_repos rsr on s.subject_at = rsr.subject_at

     

       327
       268
        
       			where s.created >= datetime('now', '-7 days')

     

       328
       328
       -
       			group by s.repo_at

     

       269
       269
       +
       			group by s.subject_at

     

       329
       270
        
       		)

     

       330
       330
       -
       		select rsc.repo_at

     

       271
       271
       +
       		select rsc.subject_at

     

       331
       272
        
       		from repo_star_counts rsc

     

       332
       273
        
       		order by rsc.stars_gained_last_week desc

     

       333
       274
        
       		limit 8

     
···

       358
       299
        
       	}

     

       359
       300
        
       

     

       360
       301
        
       	// get full repo data

     

       361
       361
       -
       	repos, err := GetRepos(e, 0, FilterIn("at_uri", repoUris))

     

       302
       302
       +
       	repos, err := GetRepos(e, 0, orm.FilterIn("at_uri", repoUris))

     

       362
       303
        
       	if err != nil {

     

       363
       304
        
       		return nil, err

     

       364
       305
        
       	}

+4 -3

appview/db/strings.go

···

       8
       8
        
       	"time"

     

       9
       9
        
       

     

       10
       10
        
       	"tangled.org/core/appview/models"

     

       11
       11
       +
       	"tangled.org/core/orm"

     

       11
       12
        
       )

     

       12
       13
        
       

     

       13
       14
        
       func AddString(e Execer, s models.String) error {

     
···

       44
       45
        
       	return err

     

       45
       46
        
       }

     

       46
       47
        
       

     

       47
       47
       -
       func GetStrings(e Execer, limit int, filters ...filter) ([]models.String, error) {

     

       48
       48
       +
       func GetStrings(e Execer, limit int, filters ...orm.Filter) ([]models.String, error) {

     

       48
       49
        
       	var all []models.String

     

       49
       50
        
       

     

       50
       51
        
       	var conditions []string

     
···

       127
       128
        
       	return all, nil

     

       128
       129
        
       }

     

       129
       130
        
       

     

       130
       130
       -
       func CountStrings(e Execer, filters ...filter) (int64, error) {

     

       131
       131
       +
       func CountStrings(e Execer, filters ...orm.Filter) (int64, error) {

     

       131
       132
        
       	var conditions []string

     

       132
       133
        
       	var args []any

     

       133
       134
        
       	for _, filter := range filters {

     
···

       151
       152
        
       	return count, nil

     

       152
       153
        
       }

     

       153
       154
        
       

     

       154
       154
       -
       func DeleteString(e Execer, filters ...filter) error {

     

       155
       155
       +
       func DeleteString(e Execer, filters ...orm.Filter) error {

     

       155
       156
        
       	var conditions []string

     

       156
       157
        
       	var args []any

     

       157
       158
        
       	for _, filter := range filters {

+11 -20

appview/db/timeline.go

···

       5
       5
        
       

     

       6
       6
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       7
       7
        
       	"tangled.org/core/appview/models"

     

       8
       8
       +
       	"tangled.org/core/orm"

     

       8
       9
        
       )

     

       9
       10
        
       

     

       10
       11
        
       // TODO: this gathers heterogenous events from different sources and aggregates

     
···

       84
       85
        
       }

     

       85
       86
        
       

     

       86
       87
        
       func getTimelineRepos(e Execer, limit int, loggedInUserDid string, userIsFollowing []string) ([]models.TimelineEvent, error) {

     

       87
       87
       -
       	filters := make([]filter, 0)

     

       88
       88
       +
       	filters := make([]orm.Filter, 0)

     

       88
       89
        
       	if userIsFollowing != nil {

     

       89
       89
       -
       		filters = append(filters, FilterIn("did", userIsFollowing))

     

       90
       90
       +
       		filters = append(filters, orm.FilterIn("did", userIsFollowing))

     

       90
       91
        
       	}

     

       91
       92
        
       

     

       92
       93
        
       	repos, err := GetRepos(e, limit, filters...)

     
···

       104
       105
        
       

     

       105
       106
        
       	var origRepos []models.Repo

     

       106
       107
        
       	if args != nil {

     

       107
       107
       -
       		origRepos, err = GetRepos(e, 0, FilterIn("at_uri", args))

     

       108
       108
       +
       		origRepos, err = GetRepos(e, 0, orm.FilterIn("at_uri", args))

     

       108
       109
        
       	}

     

       109
       110
        
       	if err != nil {

     

       110
       111
        
       		return nil, err

     
···

       144
       145
        
       }

     

       145
       146
        
       

     

       146
       147
        
       func getTimelineStars(e Execer, limit int, loggedInUserDid string, userIsFollowing []string) ([]models.TimelineEvent, error) {

     

       147
       147
       -
       	filters := make([]filter, 0)

     

       148
       148
       +
       	filters := make([]orm.Filter, 0)

     

       148
       149
        
       	if userIsFollowing != nil {

     

       149
       149
       -
       		filters = append(filters, FilterIn("starred_by_did", userIsFollowing))

     

       150
       150
       +
       		filters = append(filters, orm.FilterIn("did", userIsFollowing))

     

       150
       151
        
       	}

     

       151
       152
        
       

     

       152
       152
       -
       	stars, err := GetStars(e, limit, filters...)

     

       153
       153
       +
       	stars, err := GetRepoStars(e, limit, filters...)

     

       153
       154
        
       	if err != nil {

     

       154
       155
        
       		return nil, err

     

       155
       156
        
       	}

     

       156
       157
        
       

     

       157
       157
       -
       	// filter star records without a repo

     

       158
       158
       -
       	n := 0

     

       159
       159
       -
       	for _, s := range stars {

     

       160
       160
       -
       		if s.Repo != nil {

     

       161
       161
       -
       			stars[n] = s

     

       162
       162
       -
       			n++

     

       163
       163
       -
       		}

     

       164
       164
       -
       	}

     

       165
       165
       -
       	stars = stars[:n]

     

       166
       166
       -
       

     

       167
       158
        
       	var repos []models.Repo

     

       168
       159
        
       	for _, s := range stars {

     

       169
       160
        
       		repos = append(repos, *s.Repo)

     
···

       179
       170
        
       		isStarred, starCount := getRepoStarInfo(s.Repo, starStatuses)

     

       180
       171
        
       

     

       181
       172
        
       		events = append(events, models.TimelineEvent{

     

       182
       182
       -
       			Star:      &s,

     

       173
       173
       +
       			RepoStar:  &s,

     

       183
       174
        
       			EventAt:   s.Created,

     

       184
       175
        
       			IsStarred: isStarred,

     

       185
       176
        
       			StarCount: starCount,

     
···

       190
       181
        
       }

     

       191
       182
        
       

     

       192
       183
        
       func getTimelineFollows(e Execer, limit int, loggedInUserDid string, userIsFollowing []string) ([]models.TimelineEvent, error) {

     

       193
       193
       -
       	filters := make([]filter, 0)

     

       184
       184
       +
       	filters := make([]orm.Filter, 0)

     

       194
       185
        
       	if userIsFollowing != nil {

     

       195
       195
       -
       		filters = append(filters, FilterIn("user_did", userIsFollowing))

     

       186
       186
       +
       		filters = append(filters, orm.FilterIn("user_did", userIsFollowing))

     

       196
       187
        
       	}

     

       197
       188
        
       

     

       198
       189
        
       	follows, err := GetFollows(e, limit, filters...)

     
···

       209
       200
        
       		return nil, nil

     

       210
       201
        
       	}

     

       211
       202
        
       

     

       212
       212
       -
       	profiles, err := GetProfiles(e, FilterIn("did", subjects))

     

       203
       203
       +
       	profiles, err := GetProfiles(e, orm.FilterIn("did", subjects))

     

       213
       204
        
       	if err != nil {

     

       214
       205
        
       		return nil, err

     

       215
       206
        
       	}

+7 -12

appview/email/email.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"fmt"

     

       5
       5
        
       	"net"

     

       6
       6
       -
       	"regexp"

     

       6
       6
       +
       	"net/mail"

     

       7
       7
        
       	"strings"

     

       8
       8
        
       

     

       9
       9
        
       	"github.com/resend/resend-go/v2"

     
···

       34
       34
        
       }

     

       35
       35
        
       

     

       36
       36
        
       func IsValidEmail(email string) bool {

     

       37
       37
       -
       	// Basic length check

     

       38
       38
       -
       	if len(email) < 3 || len(email) > 254 {

     

       37
       37
       +
       	// Reject whitespace (ParseAddress normalizes it away)

     

       38
       38
       +
       	if strings.ContainsAny(email, " \t\n\r") {

     

       39
       39
        
       		return false

     

       40
       40
        
       	}

     

       41
       41
        
       

     

       42
       42
       -
       	// Regular expression for email validation (RFC 5322 compliant)

     

       43
       43
       -
       	pattern := `^[a-zA-Z0-9.!#$%&'*+/=?^_\x60{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$`

     

       44
       44
       -
       

     

       45
       45
       -
       	// Compile regex

     

       46
       46
       -
       	regex := regexp.MustCompile(pattern)

     

       47
       47
       -
       

     

       48
       48
       -
       	// Check if email matches regex pattern

     

       49
       49
       -
       	if !regex.MatchString(email) {

     

       42
       42
       +
       	// Use stdlib RFC 5322 parser

     

       43
       43
       +
       	addr, err := mail.ParseAddress(email)

     

       44
       44
       +
       	if err != nil {

     

       50
       45
        
       		return false

     

       51
       46
        
       	}

     

       52
       47
        
       

     

       53
       48
        
       	// Split email into local and domain parts

     

       54
       54
       -
       	parts := strings.Split(email, "@")

     

       49
       49
       +
       	parts := strings.Split(addr.Address, "@")

     

       55
       50
        
       	domain := parts[1]

     

       56
       51
        
       

     

       57
       52
        
       	mx, err := net.LookupMX(domain)

+53

appview/email/email_test.go

···

       1
       1
       +
       package email

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"testing"

     

       5
       5
       +
       )

     

       6
       6
       +
       

     

       7
       7
       +
       func TestIsValidEmail(t *testing.T) {

     

       8
       8
       +
       	tests := []struct {

     

       9
       9
       +
       		name  string

     

       10
       10
       +
       		email string

     

       11
       11
       +
       		want  bool

     

       12
       12
       +
       	}{

     

       13
       13
       +
       		// Valid emails using RFC 2606 reserved domains

     

       14
       14
       +
       		{"standard email", "user@example.com", true},

     

       15
       15
       +
       		{"single char local", "a@example.com", true},

     

       16
       16
       +
       		{"dot in middle", "first.last@example.com", true},

     

       17
       17
       +
       		{"multiple dots", "a.b.c@example.com", true},

     

       18
       18
       +
       		{"plus tag", "user+tag@example.com", true},

     

       19
       19
       +
       		{"numbers", "user123@example.com", true},

     

       20
       20
       +
       		{"example.org", "user@example.org", true},

     

       21
       21
       +
       		{"example.net", "user@example.net", true},

     

       22
       22
       +
       

     

       23
       23
       +
       		// Invalid format - rejected by mail.ParseAddress

     

       24
       24
       +
       		{"empty string", "", false},

     

       25
       25
       +
       		{"no at sign", "userexample.com", false},

     

       26
       26
       +
       		{"no domain", "user@", false},

     

       27
       27
       +
       		{"no local part", "@example.com", false},

     

       28
       28
       +
       		{"double at", "user@@example.com", false},

     

       29
       29
       +
       		{"just at sign", "@", false},

     

       30
       30
       +
       		{"leading dot", ".user@example.com", false},

     

       31
       31
       +
       		{"trailing dot", "user.@example.com", false},

     

       32
       32
       +
       		{"consecutive dots", "user..name@example.com", false},

     

       33
       33
       +
       

     

       34
       34
       +
       		// Whitespace - rejected before parsing

     

       35
       35
       +
       		{"space in local", "user @example.com", false},

     

       36
       36
       +
       		{"space in domain", "user@ example.com", false},

     

       37
       37
       +
       		{"tab", "user\t@example.com", false},

     

       38
       38
       +
       		{"newline", "user\n@example.com", false},

     

       39
       39
       +
       

     

       40
       40
       +
       		// MX lookup - using RFC 2606 reserved TLDs (guaranteed no MX)

     

       41
       41
       +
       		{"invalid TLD", "user@example.invalid", false},

     

       42
       42
       +
       		{"test TLD", "user@mail.test", false},

     

       43
       43
       +
       	}

     

       44
       44
       +
       

     

       45
       45
       +
       	for _, tt := range tests {

     

       46
       46
       +
       		t.Run(tt.name, func(t *testing.T) {

     

       47
       47
       +
       			got := IsValidEmail(tt.email)

     

       48
       48
       +
       			if got != tt.want {

     

       49
       49
       +
       				t.Errorf("IsValidEmail(%q) = %v, want %v", tt.email, got, tt.want)

     

       50
       50
       +
       			}

     

       51
       51
       +
       		})

     

       52
       52
       +
       	}

     

       53
       53
       +
       }

+3 -1

appview/indexer/issues/indexer.go

···

       56
       56
        
       			log.Fatalln("failed to populate issue indexer", err)

     

       57
       57
        
       		}

     

       58
       58
        
       	}

     

       59
       59
       -
       	l.Info("Initialized the issue indexer")

     

       59
       59
       +
       

     

       60
       60
       +
       	count, _ := ix.indexer.DocCount()

     

       61
       61
       +
       	l.Info("Initialized the issue indexer", "docCount", count)

     

       60
       62
        
       }

     

       61
       63
        
       

     

       62
       64
        
       func generateIssueIndexMapping() (mapping.IndexMapping, error) {

+3 -1

appview/indexer/pulls/indexer.go

···

       55
       55
        
       			log.Fatalln("failed to populate pull indexer", err)

     

       56
       56
        
       		}

     

       57
       57
        
       	}

     

       58
       58
       -
       	l.Info("Initialized the pull indexer")

     

       58
       58
       +
       

     

       59
       59
       +
       	count, _ := ix.indexer.DocCount()

     

       60
       60
       +
       	l.Info("Initialized the pull indexer", "docCount", count)

     

       59
       61
        
       }

     

       60
       62
        
       

     

       61
       63
        
       func generatePullIndexMapping() (mapping.IndexMapping, error) {

+28 -27

appview/ingester.go

···

       21
       21
        
       	"tangled.org/core/appview/serververify"

     

       22
       22
        
       	"tangled.org/core/appview/validator"

     

       23
       23
        
       	"tangled.org/core/idresolver"

     

       24
       24
       +
       	"tangled.org/core/orm"

     

       24
       25
        
       	"tangled.org/core/rbac"

     

       25
       26
        
       )

     

       26
       27
        
       

     
···

       121
       122
        
       			return err

     

       122
       123
        
       		}

     

       123
       124
        
       		err = db.AddStar(i.Db, &models.Star{

     

       124
       124
       -
       			StarredByDid: did,

     

       125
       125
       -
       			RepoAt:       subjectUri,

     

       126
       126
       -
       			Rkey:         e.Commit.RKey,

     

       125
       125
       +
       			Did:    did,

     

       126
       126
       +
       			RepoAt: subjectUri,

     

       127
       127
       +
       			Rkey:   e.Commit.RKey,

     

       127
       128
        
       		})

     

       128
       129
        
       	case jmodels.CommitOperationDelete:

     

       129
       130
        
       		err = db.DeleteStarByRkey(i.Db, did, e.Commit.RKey)

     
···

       253
       254
        
       

     

       254
       255
        
       		err = db.AddArtifact(i.Db, artifact)

     

       255
       256
        
       	case jmodels.CommitOperationDelete:

     

       256
       256
       -
       		err = db.DeleteArtifact(i.Db, db.FilterEq("did", did), db.FilterEq("rkey", e.Commit.RKey))

     

       257
       257
       +
       		err = db.DeleteArtifact(i.Db, orm.FilterEq("did", did), orm.FilterEq("rkey", e.Commit.RKey))

     

       257
       258
        
       	}

     

       258
       259
        
       

     

       259
       260
        
       	if err != nil {

     
···

       350
       351
        
       

     

       351
       352
        
       		err = db.UpsertProfile(tx, &profile)

     

       352
       353
        
       	case jmodels.CommitOperationDelete:

     

       353
       353
       -
       		err = db.DeleteArtifact(i.Db, db.FilterEq("did", did), db.FilterEq("rkey", e.Commit.RKey))

     

       354
       354
       +
       		err = db.DeleteArtifact(i.Db, orm.FilterEq("did", did), orm.FilterEq("rkey", e.Commit.RKey))

     

       354
       355
        
       	}

     

       355
       356
        
       

     

       356
       357
        
       	if err != nil {

     
···

       424
       425
        
       		// get record from db first

     

       425
       426
        
       		members, err := db.GetSpindleMembers(

     

       426
       427
        
       			ddb,

     

       427
       427
       -
       			db.FilterEq("did", did),

     

       428
       428
       -
       			db.FilterEq("rkey", rkey),

     

       428
       428
       +
       			orm.FilterEq("did", did),

     

       429
       429
       +
       			orm.FilterEq("rkey", rkey),

     

       429
       430
        
       		)

     

       430
       431
        
       		if err != nil || len(members) != 1 {

     

       431
       432
        
       			return fmt.Errorf("failed to get member: %w, len(members) = %d", err, len(members))

     
···

       440
       441
        
       		// remove record by rkey && update enforcer

     

       441
       442
        
       		if err = db.RemoveSpindleMember(

     

       442
       443
        
       			tx,

     

       443
       443
       -
       			db.FilterEq("did", did),

     

       444
       444
       -
       			db.FilterEq("rkey", rkey),

     

       444
       444
       +
       			orm.FilterEq("did", did),

     

       445
       445
       +
       			orm.FilterEq("rkey", rkey),

     

       445
       446
        
       		); err != nil {

     

       446
       447
        
       			return fmt.Errorf("failed to remove from db: %w", err)

     

       447
       448
        
       		}

     
···

       523
       524
        
       		// get record from db first

     

       524
       525
        
       		spindles, err := db.GetSpindles(

     

       525
       526
        
       			ddb,

     

       526
       526
       -
       			db.FilterEq("owner", did),

     

       527
       527
       -
       			db.FilterEq("instance", instance),

     

       527
       527
       +
       			orm.FilterEq("owner", did),

     

       528
       528
       +
       			orm.FilterEq("instance", instance),

     

       528
       529
        
       		)

     

       529
       530
        
       		if err != nil || len(spindles) != 1 {

     

       530
       531
        
       			return fmt.Errorf("failed to get spindles: %w, len(spindles) = %d", err, len(spindles))

     
···

       543
       544
        
       		// remove spindle members first

     

       544
       545
        
       		err = db.RemoveSpindleMember(

     

       545
       546
        
       			tx,

     

       546
       546
       -
       			db.FilterEq("owner", did),

     

       547
       547
       -
       			db.FilterEq("instance", instance),

     

       547
       547
       +
       			orm.FilterEq("owner", did),

     

       548
       548
       +
       			orm.FilterEq("instance", instance),

     

       548
       549
        
       		)

     

       549
       550
        
       		if err != nil {

     

       550
       551
        
       			return err

     
···

       552
       553
        
       

     

       553
       554
        
       		err = db.DeleteSpindle(

     

       554
       555
        
       			tx,

     

       555
       555
       -
       			db.FilterEq("owner", did),

     

       556
       556
       -
       			db.FilterEq("instance", instance),

     

       556
       556
       +
       			orm.FilterEq("owner", did),

     

       557
       557
       +
       			orm.FilterEq("instance", instance),

     

       557
       558
        
       		)

     

       558
       559
        
       		if err != nil {

     

       559
       560
        
       			return err

     
···

       621
       622
        
       	case jmodels.CommitOperationDelete:

     

       622
       623
        
       		if err := db.DeleteString(

     

       623
       624
        
       			ddb,

     

       624
       624
       -
       			db.FilterEq("did", did),

     

       625
       625
       -
       			db.FilterEq("rkey", rkey),

     

       625
       625
       +
       			orm.FilterEq("did", did),

     

       626
       626
       +
       			orm.FilterEq("rkey", rkey),

     

       626
       627
        
       		); err != nil {

     

       627
       628
        
       			l.Error("failed to delete", "err", err)

     

       628
       629
        
       			return fmt.Errorf("failed to delete string record: %w", err)

     
···

       740
       741
        
       		// get record from db first

     

       741
       742
        
       		registrations, err := db.GetRegistrations(

     

       742
       743
        
       			ddb,

     

       743
       743
       -
       			db.FilterEq("domain", domain),

     

       744
       744
       -
       			db.FilterEq("did", did),

     

       744
       744
       +
       			orm.FilterEq("domain", domain),

     

       745
       745
       +
       			orm.FilterEq("did", did),

     

       745
       746
        
       		)

     

       746
       747
        
       		if err != nil {

     

       747
       748
        
       			return fmt.Errorf("failed to get registration: %w", err)

     
···

       762
       763
        
       

     

       763
       764
        
       		err = db.DeleteKnot(

     

       764
       765
        
       			tx,

     

       765
       765
       -
       			db.FilterEq("did", did),

     

       766
       766
       -
       			db.FilterEq("domain", domain),

     

       766
       766
       +
       			orm.FilterEq("did", did),

     

       767
       767
       +
       			orm.FilterEq("domain", domain),

     

       767
       768
        
       		)

     

       768
       769
        
       		if err != nil {

     

       769
       770
        
       			return err

     
···

       915
       916
        
       	case jmodels.CommitOperationDelete:

     

       916
       917
        
       		if err := db.DeleteIssueComments(

     

       917
       918
        
       			ddb,

     

       918
       918
       -
       			db.FilterEq("did", did),

     

       919
       919
       -
       			db.FilterEq("rkey", rkey),

     

       919
       919
       +
       			orm.FilterEq("did", did),

     

       920
       920
       +
       			orm.FilterEq("rkey", rkey),

     

       920
       921
        
       		); err != nil {

     

       921
       922
        
       			return fmt.Errorf("failed to delete issue comment record: %w", err)

     

       922
       923
        
       		}

     
···

       969
       970
        
       	case jmodels.CommitOperationDelete:

     

       970
       971
        
       		if err := db.DeleteLabelDefinition(

     

       971
       972
        
       			ddb,

     

       972
       972
       -
       			db.FilterEq("did", did),

     

       973
       973
       -
       			db.FilterEq("rkey", rkey),

     

       973
       973
       +
       			orm.FilterEq("did", did),

     

       974
       974
       +
       			orm.FilterEq("rkey", rkey),

     

       974
       975
        
       		); err != nil {

     

       975
       976
        
       			return fmt.Errorf("failed to delete labeldef record: %w", err)

     

       976
       977
        
       		}

     
···

       1010
       1011
        
       		var repo *models.Repo

     

       1011
       1012
        
       		switch collection {

     

       1012
       1013
        
       		case tangled.RepoIssueNSID:

     

       1013
       1013
       -
       			i, err := db.GetIssues(ddb, db.FilterEq("at_uri", subject))

     

       1014
       1014
       +
       			i, err := db.GetIssues(ddb, orm.FilterEq("at_uri", subject))

     

       1014
       1015
        
       			if err != nil || len(i) != 1 {

     

       1015
       1016
        
       				return fmt.Errorf("failed to find subject: %w || subject count %d", err, len(i))

     

       1016
       1017
        
       			}

     
···

       1019
       1020
        
       			return fmt.Errorf("unsupport label subject: %s", collection)

     

       1020
       1021
        
       		}

     

       1021
       1022
        
       

     

       1022
       1022
       -
       		actx, err := db.NewLabelApplicationCtx(ddb, db.FilterIn("at_uri", repo.Labels))

     

       1023
       1023
       +
       		actx, err := db.NewLabelApplicationCtx(ddb, orm.FilterIn("at_uri", repo.Labels))

     

       1023
       1024
        
       		if err != nil {

     

       1024
       1025
        
       			return fmt.Errorf("failed to build label application ctx: %w", err)

     

       1025
       1026
        
       		}

+110 -121

appview/issues/issues.go

···

       7
       7
        
       	"fmt"

     

       8
       8
        
       	"log/slog"

     

       9
       9
        
       	"net/http"

     

       10
       10
       -
       	"slices"

     

       11
       10
        
       	"time"

     

       12
       11
        
       

     

       13
       12
        
       	comatproto "github.com/bluesky-social/indigo/api/atproto"

     
···

       20
       19
        
       	"tangled.org/core/appview/config"

     

       21
       20
        
       	"tangled.org/core/appview/db"

     

       22
       21
        
       	issues_indexer "tangled.org/core/appview/indexer/issues"

     

       22
       22
       +
       	"tangled.org/core/appview/mentions"

     

       23
       23
        
       	"tangled.org/core/appview/models"

     

       24
       24
        
       	"tangled.org/core/appview/notify"

     

       25
       25
        
       	"tangled.org/core/appview/oauth"

     

       26
       26
        
       	"tangled.org/core/appview/pages"

     

       27
       27
       +
       	"tangled.org/core/appview/pages/repoinfo"

     

       27
       28
        
       	"tangled.org/core/appview/pagination"

     

       28
       28
       -
       	"tangled.org/core/appview/refresolver"

     

       29
       29
        
       	"tangled.org/core/appview/reporesolver"

     

       30
       30
        
       	"tangled.org/core/appview/validator"

     

       31
       31
        
       	"tangled.org/core/idresolver"

     

       32
       32
       +
       	"tangled.org/core/orm"

     

       33
       33
       +
       	"tangled.org/core/rbac"

     

       32
       34
        
       	"tangled.org/core/tid"

     

       33
       35
        
       )

     

       34
       36
        
       

     

       35
       37
        
       type Issues struct {

     

       36
       36
       -
       	oauth        *oauth.OAuth

     

       37
       37
       -
       	repoResolver *reporesolver.RepoResolver

     

       38
       38
       -
       	pages        *pages.Pages

     

       39
       39
       -
       	idResolver   *idresolver.Resolver

     

       40
       40
       -
       	refResolver  *refresolver.Resolver

     

       41
       41
       -
       	db           *db.DB

     

       42
       42
       -
       	config       *config.Config

     

       43
       43
       -
       	notifier     notify.Notifier

     

       44
       44
       -
       	logger       *slog.Logger

     

       45
       45
       -
       	validator    *validator.Validator

     

       46
       46
       -
       	indexer      *issues_indexer.Indexer

     

       38
       38
       +
       	oauth            *oauth.OAuth

     

       39
       39
       +
       	repoResolver     *reporesolver.RepoResolver

     

       40
       40
       +
       	enforcer         *rbac.Enforcer

     

       41
       41
       +
       	pages            *pages.Pages

     

       42
       42
       +
       	idResolver       *idresolver.Resolver

     

       43
       43
       +
       	mentionsResolver *mentions.Resolver

     

       44
       44
       +
       	db               *db.DB

     

       45
       45
       +
       	config           *config.Config

     

       46
       46
       +
       	notifier         notify.Notifier

     

       47
       47
       +
       	logger           *slog.Logger

     

       48
       48
       +
       	validator        *validator.Validator

     

       49
       49
       +
       	indexer          *issues_indexer.Indexer

     

       47
       50
        
       }

     

       48
       51
        
       

     

       49
       52
        
       func New(

     

       50
       53
        
       	oauth *oauth.OAuth,

     

       51
       54
        
       	repoResolver *reporesolver.RepoResolver,

     

       55
       55
       +
       	enforcer *rbac.Enforcer,

     

       52
       56
        
       	pages *pages.Pages,

     

       53
       57
        
       	idResolver *idresolver.Resolver,

     

       54
       54
       -
       	refResolver *refresolver.Resolver,

     

       58
       58
       +
       	mentionsResolver *mentions.Resolver,

     

       55
       59
        
       	db *db.DB,

     

       56
       60
        
       	config *config.Config,

     

       57
       61
        
       	notifier notify.Notifier,

     
···

       60
       64
        
       	logger *slog.Logger,

     

       61
       65
        
       ) *Issues {

     

       62
       66
        
       	return &Issues{

     

       63
       63
       -
       		oauth:        oauth,

     

       64
       64
       -
       		repoResolver: repoResolver,

     

       65
       65
       -
       		pages:        pages,

     

       66
       66
       -
       		idResolver:   idResolver,

     

       67
       67
       -
       		refResolver:  refResolver,

     

       68
       68
       -
       		db:           db,

     

       69
       69
       -
       		config:       config,

     

       70
       70
       -
       		notifier:     notifier,

     

       71
       71
       -
       		logger:       logger,

     

       72
       72
       -
       		validator:    validator,

     

       73
       73
       -
       		indexer:      indexer,

     

       67
       67
       +
       		oauth:            oauth,

     

       68
       68
       +
       		repoResolver:     repoResolver,

     

       69
       69
       +
       		enforcer:         enforcer,

     

       70
       70
       +
       		pages:            pages,

     

       71
       71
       +
       		idResolver:       idResolver,

     

       72
       72
       +
       		mentionsResolver: mentionsResolver,

     

       73
       73
       +
       		db:               db,

     

       74
       74
       +
       		config:           config,

     

       75
       75
       +
       		notifier:         notifier,

     

       76
       76
       +
       		logger:           logger,

     

       77
       77
       +
       		validator:        validator,

     

       78
       78
       +
       		indexer:          indexer,

     

       74
       79
        
       	}

     

       75
       80
        
       }

     

       76
       81
        
       

     
···

       109
       114
        
       

     

       110
       115
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       111
       116
        
       		rp.db,

     

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

     

       113
       113
       -
       		db.FilterContains("scope", tangled.RepoIssueNSID),

     

       117
       117
       +
       		orm.FilterIn("at_uri", f.Labels),

     

       118
       118
       +
       		orm.FilterContains("scope", tangled.RepoIssueNSID),

     

       114
       119
        
       	)

     

       115
       120
        
       	if err != nil {

     

       116
       121
        
       		l.Error("failed to fetch labels", "err", err)

     
···

       125
       130
        
       

     

       126
       131
        
       	rp.pages.RepoSingleIssue(w, pages.RepoSingleIssueParams{

     

       127
       132
        
       		LoggedInUser:         user,

     

       128
       128
       -
       		RepoInfo:             f.RepoInfo(user),

     

       133
       133
       +
       		RepoInfo:             rp.repoResolver.GetRepoInfo(r, user),

     

       129
       134
        
       		Issue:                issue,

     

       130
       135
        
       		CommentList:          issue.CommentList(),

     

       131
       136
        
       		Backlinks:            backlinks,

     
···

       139
       144
        
       func (rp *Issues) EditIssue(w http.ResponseWriter, r *http.Request) {

     

       140
       145
        
       	l := rp.logger.With("handler", "EditIssue")

     

       141
       146
        
       	user := rp.oauth.GetUser(r)

     

       142
       142
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       143
       143
       -
       	if err != nil {

     

       144
       144
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       145
       145
       -
       		return

     

       146
       146
       -
       	}

     

       147
       147
        
       

     

       148
       148
        
       	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       149
       149
        
       	if !ok {

     
···

       156
       156
        
       	case http.MethodGet:

     

       157
       157
        
       		rp.pages.EditIssueFragment(w, pages.EditIssueParams{

     

       158
       158
        
       			LoggedInUser: user,

     

       159
       159
       -
       			RepoInfo:     f.RepoInfo(user),

     

       159
       159
       +
       			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       160
       160
        
       			Issue:        issue,

     

       161
       161
        
       		})

     

       162
       162
        
       	case http.MethodPost:

     
···

       164
       164
        
       		newIssue := issue

     

       165
       165
        
       		newIssue.Title = r.FormValue("title")

     

       166
       166
        
       		newIssue.Body = r.FormValue("body")

     

       167
       167
       -
       		newIssue.Mentions, newIssue.References = rp.refResolver.Resolve(r.Context(), newIssue.Body)

     

       167
       167
       +
       		newIssue.Mentions, newIssue.References = rp.mentionsResolver.Resolve(r.Context(), newIssue.Body)

     

       168
       168
        
       

     

       169
       169
        
       		if err := rp.validator.ValidateIssue(newIssue); err != nil {

     

       170
       170
        
       			l.Error("validation error", "err", err)

     
···

       234
       234
        
       	l := rp.logger.With("handler", "DeleteIssue")

     

       235
       235
        
       	noticeId := "issue-actions-error"

     

       236
       236
        
       

     

       237
       237
       -
       	user := rp.oauth.GetUser(r)

     

       238
       238
       -
       

     

       239
       237
        
       	f, err := rp.repoResolver.Resolve(r)

     

       240
       238
        
       	if err != nil {

     

       241
       239
        
       		l.Error("failed to get repo and knot", "err", err)

     
···

       288
       286
        
       	rp.notifier.DeleteIssue(r.Context(), issue)

     

       289
       287
        
       

     

       290
       288
        
       	// return to all issues page

     

       291
       291
       -
       	rp.pages.HxRedirect(w, "/"+f.RepoInfo(user).FullName()+"/issues")

     

       289
       289
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       290
       290
       +
       	rp.pages.HxRedirect(w, "/"+ownerSlashRepo+"/issues")

     

       292
       291
        
       }

     

       293
       292
        
       

     

       294
       293
        
       func (rp *Issues) CloseIssue(w http.ResponseWriter, r *http.Request) {

     
···

       307
       306
        
       		return

     

       308
       307
        
       	}

     

       309
       308
        
       

     

       310
       310
       -
       	collaborators, err := f.Collaborators(r.Context())

     

       311
       311
       -
       	if err != nil {

     

       312
       312
       -
       		l.Error("failed to fetch repo collaborators", "err", err)

     

       313
       313
       -
       	}

     

       314
       314
       -
       	isCollaborator := slices.ContainsFunc(collaborators, func(collab pages.Collaborator) bool {

     

       315
       315
       -
       		return user.Did == collab.Did

     

       316
       316
       -
       	})

     

       309
       309
       +
       	roles := repoinfo.RolesInRepo{Roles: rp.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}

     

       310
       310
       +
       	isRepoOwner := roles.IsOwner()

     

       311
       311
       +
       	isCollaborator := roles.IsCollaborator()

     

       317
       312
        
       	isIssueOwner := user.Did == issue.Did

     

       318
       313
        
       

     

       319
       314
        
       	// TODO: make this more granular

     

       320
       320
       -
       	if isIssueOwner || isCollaborator {

     

       315
       315
       +
       	if isIssueOwner || isRepoOwner || isCollaborator {

     

       321
       316
        
       		err = db.CloseIssues(

     

       322
       317
        
       			rp.db,

     

       323
       323
       -
       			db.FilterEq("id", issue.Id),

     

       318
       318
       +
       			orm.FilterEq("id", issue.Id),

     

       324
       319
        
       		)

     

       325
       320
        
       		if err != nil {

     

       326
       321
        
       			l.Error("failed to close issue", "err", err)

     
···

       333
       328
        
       		// notify about the issue closure

     

       334
       329
        
       		rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Did), issue)

     

       335
       330
        
       

     

       336
       336
       -
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId))

     

       331
       331
       +
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       332
       332
       +
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))

     

       337
       333
        
       		return

     

       338
       334
        
       	} else {

     

       339
       335
        
       		l.Error("user is not permitted to close issue")

     
···

       358
       354
        
       		return

     

       359
       355
        
       	}

     

       360
       356
        
       

     

       361
       361
       -
       	collaborators, err := f.Collaborators(r.Context())

     

       362
       362
       -
       	if err != nil {

     

       363
       363
       -
       		l.Error("failed to fetch repo collaborators", "err", err)

     

       364
       364
       -
       	}

     

       365
       365
       -
       	isCollaborator := slices.ContainsFunc(collaborators, func(collab pages.Collaborator) bool {

     

       366
       366
       -
       		return user.Did == collab.Did

     

       367
       367
       -
       	})

     

       357
       357
       +
       	roles := repoinfo.RolesInRepo{Roles: rp.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}

     

       358
       358
       +
       	isRepoOwner := roles.IsOwner()

     

       359
       359
       +
       	isCollaborator := roles.IsCollaborator()

     

       368
       360
        
       	isIssueOwner := user.Did == issue.Did

     

       369
       361
        
       

     

       370
       370
       -
       	if isCollaborator || isIssueOwner {

     

       362
       362
       +
       	if isCollaborator || isRepoOwner || isIssueOwner {

     

       371
       363
        
       		err := db.ReopenIssues(

     

       372
       364
        
       			rp.db,

     

       373
       373
       -
       			db.FilterEq("id", issue.Id),

     

       365
       365
       +
       			orm.FilterEq("id", issue.Id),

     

       374
       366
        
       		)

     

       375
       367
        
       		if err != nil {

     

       376
       368
        
       			l.Error("failed to reopen issue", "err", err)

     
···

       383
       375
        
       		// notify about the issue reopen

     

       384
       376
        
       		rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Did), issue)

     

       385
       377
        
       

     

       386
       386
       -
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId))

     

       378
       378
       +
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       379
       379
       +
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))

     

       387
       380
        
       		return

     

       388
       381
        
       	} else {

     

       389
       382
        
       		l.Error("user is not the owner of the repo")

     
···

       420
       413
        
       		replyTo = &replyToUri

     

       421
       414
        
       	}

     

       422
       415
        
       

     

       423
       423
       -
       	mentions, references := rp.refResolver.Resolve(r.Context(), body)

     

       416
       416
       +
       	mentions, references := rp.mentionsResolver.Resolve(r.Context(), body)

     

       424
       417
        
       

     

       425
       418
        
       	comment := models.IssueComment{

     

       426
       419
        
       		Did:        user.Did,

     
···

       496
       489
        
       

     

       497
       490
        
       	rp.notifier.NewIssueComment(r.Context(), &comment, mentions)

     

       498
       491
        
       

     

       499
       499
       -
       	rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d#comment-%d", f.OwnerSlashRepo(), issue.IssueId, commentId))

     

       492
       492
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       493
       493
       +
       	rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d#comment-%d", ownerSlashRepo, issue.IssueId, commentId))

     

       500
       494
        
       }

     

       501
       495
        
       

     

       502
       496
        
       func (rp *Issues) IssueComment(w http.ResponseWriter, r *http.Request) {

     

       503
       497
        
       	l := rp.logger.With("handler", "IssueComment")

     

       504
       498
        
       	user := rp.oauth.GetUser(r)

     

       505
       505
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       506
       506
       -
       	if err != nil {

     

       507
       507
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       508
       508
       -
       		return

     

       509
       509
       -
       	}

     

       510
       499
        
       

     

       511
       500
        
       	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       512
       501
        
       	if !ok {

     
···

       518
       507
        
       	commentId := chi.URLParam(r, "commentId")

     

       519
       508
        
       	comments, err := db.GetIssueComments(

     

       520
       509
        
       		rp.db,

     

       521
       521
       -
       		db.FilterEq("id", commentId),

     

       510
       510
       +
       		orm.FilterEq("id", commentId),

     

       522
       511
        
       	)

     

       523
       512
        
       	if err != nil {

     

       524
       513
        
       		l.Error("failed to fetch comment", "id", commentId)

     
···

       534
       523
        
       

     

       535
       524
        
       	rp.pages.IssueCommentBodyFragment(w, pages.IssueCommentBodyParams{

     

       536
       525
        
       		LoggedInUser: user,

     

       537
       537
       -
       		RepoInfo:     f.RepoInfo(user),

     

       526
       526
       +
       		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       538
       527
        
       		Issue:        issue,

     

       539
       528
        
       		Comment:      &comment,

     

       540
       529
        
       	})

     
···

       543
       532
        
       func (rp *Issues) EditIssueComment(w http.ResponseWriter, r *http.Request) {

     

       544
       533
        
       	l := rp.logger.With("handler", "EditIssueComment")

     

       545
       534
        
       	user := rp.oauth.GetUser(r)

     

       546
       546
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       547
       547
       -
       	if err != nil {

     

       548
       548
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       549
       549
       -
       		return

     

       550
       550
       -
       	}

     

       551
       535
        
       

     

       552
       536
        
       	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       553
       537
        
       	if !ok {

     
···

       559
       543
        
       	commentId := chi.URLParam(r, "commentId")

     

       560
       544
        
       	comments, err := db.GetIssueComments(

     

       561
       545
        
       		rp.db,

     

       562
       562
       -
       		db.FilterEq("id", commentId),

     

       546
       546
       +
       		orm.FilterEq("id", commentId),

     

       563
       547
        
       	)

     

       564
       548
        
       	if err != nil {

     

       565
       549
        
       		l.Error("failed to fetch comment", "id", commentId)

     
···

       583
       567
        
       	case http.MethodGet:

     

       584
       568
        
       		rp.pages.EditIssueCommentFragment(w, pages.EditIssueCommentParams{

     

       585
       569
        
       			LoggedInUser: user,

     

       586
       586
       -
       			RepoInfo:     f.RepoInfo(user),

     

       570
       570
       +
       			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       587
       571
        
       			Issue:        issue,

     

       588
       572
        
       			Comment:      &comment,

     

       589
       573
        
       		})

     
···

       601
       585
        
       		newComment := comment

     

       602
       586
        
       		newComment.Body = newBody

     

       603
       587
        
       		newComment.Edited = &now

     

       604
       604
       -
       		newComment.Mentions, newComment.References = rp.refResolver.Resolve(r.Context(), newBody)

     

       588
       588
       +
       		newComment.Mentions, newComment.References = rp.mentionsResolver.Resolve(r.Context(), newBody)

     

       605
       589
        
       

     

       606
       590
        
       		record := newComment.AsRecord()

     

       607
       591
        
       

     
···

       648
       632
        
       		// return new comment body with htmx

     

       649
       633
        
       		rp.pages.IssueCommentBodyFragment(w, pages.IssueCommentBodyParams{

     

       650
       634
        
       			LoggedInUser: user,

     

       651
       651
       -
       			RepoInfo:     f.RepoInfo(user),

     

       635
       635
       +
       			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       652
       636
        
       			Issue:        issue,

     

       653
       637
        
       			Comment:      &newComment,

     

       654
       638
        
       		})

     
···

       658
       642
        
       func (rp *Issues) ReplyIssueCommentPlaceholder(w http.ResponseWriter, r *http.Request) {

     

       659
       643
        
       	l := rp.logger.With("handler", "ReplyIssueCommentPlaceholder")

     

       660
       644
        
       	user := rp.oauth.GetUser(r)

     

       661
       661
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       662
       662
       -
       	if err != nil {

     

       663
       663
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       664
       664
       -
       		return

     

       665
       665
       -
       	}

     

       666
       645
        
       

     

       667
       646
        
       	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       668
       647
        
       	if !ok {

     
···

       674
       653
        
       	commentId := chi.URLParam(r, "commentId")

     

       675
       654
        
       	comments, err := db.GetIssueComments(

     

       676
       655
        
       		rp.db,

     

       677
       677
       -
       		db.FilterEq("id", commentId),

     

       656
       656
       +
       		orm.FilterEq("id", commentId),

     

       678
       657
        
       	)

     

       679
       658
        
       	if err != nil {

     

       680
       659
        
       		l.Error("failed to fetch comment", "id", commentId)

     
···

       690
       669
        
       

     

       691
       670
        
       	rp.pages.ReplyIssueCommentPlaceholderFragment(w, pages.ReplyIssueCommentPlaceholderParams{

     

       692
       671
        
       		LoggedInUser: user,

     

       693
       693
       -
       		RepoInfo:     f.RepoInfo(user),

     

       672
       672
       +
       		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       694
       673
        
       		Issue:        issue,

     

       695
       674
        
       		Comment:      &comment,

     

       696
       675
        
       	})

     
···

       699
       678
        
       func (rp *Issues) ReplyIssueComment(w http.ResponseWriter, r *http.Request) {

     

       700
       679
        
       	l := rp.logger.With("handler", "ReplyIssueComment")

     

       701
       680
        
       	user := rp.oauth.GetUser(r)

     

       702
       702
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       703
       703
       -
       	if err != nil {

     

       704
       704
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       705
       705
       -
       		return

     

       706
       706
       -
       	}

     

       707
       681
        
       

     

       708
       682
        
       	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       709
       683
        
       	if !ok {

     
···

       715
       689
        
       	commentId := chi.URLParam(r, "commentId")

     

       716
       690
        
       	comments, err := db.GetIssueComments(

     

       717
       691
        
       		rp.db,

     

       718
       718
       -
       		db.FilterEq("id", commentId),

     

       692
       692
       +
       		orm.FilterEq("id", commentId),

     

       719
       693
        
       	)

     

       720
       694
        
       	if err != nil {

     

       721
       695
        
       		l.Error("failed to fetch comment", "id", commentId)

     
···

       731
       705
        
       

     

       732
       706
        
       	rp.pages.ReplyIssueCommentFragment(w, pages.ReplyIssueCommentParams{

     

       733
       707
        
       		LoggedInUser: user,

     

       734
       734
       -
       		RepoInfo:     f.RepoInfo(user),

     

       708
       708
       +
       		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       735
       709
        
       		Issue:        issue,

     

       736
       710
        
       		Comment:      &comment,

     

       737
       711
        
       	})

     
···

       740
       714
        
       func (rp *Issues) DeleteIssueComment(w http.ResponseWriter, r *http.Request) {

     

       741
       715
        
       	l := rp.logger.With("handler", "DeleteIssueComment")

     

       742
       716
        
       	user := rp.oauth.GetUser(r)

     

       743
       743
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       744
       744
       -
       	if err != nil {

     

       745
       745
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       746
       746
       -
       		return

     

       747
       747
       -
       	}

     

       748
       717
        
       

     

       749
       718
        
       	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       750
       719
        
       	if !ok {

     
···

       756
       725
        
       	commentId := chi.URLParam(r, "commentId")

     

       757
       726
        
       	comments, err := db.GetIssueComments(

     

       758
       727
        
       		rp.db,

     

       759
       759
       -
       		db.FilterEq("id", commentId),

     

       728
       728
       +
       		orm.FilterEq("id", commentId),

     

       760
       729
        
       	)

     

       761
       730
        
       	if err != nil {

     

       762
       731
        
       		l.Error("failed to fetch comment", "id", commentId)

     
···

       783
       752
        
       

     

       784
       753
        
       	// optimistic deletion

     

       785
       754
        
       	deleted := time.Now()

     

       786
       786
       -
       	err = db.DeleteIssueComments(rp.db, db.FilterEq("id", comment.Id))

     

       755
       755
       +
       	err = db.DeleteIssueComments(rp.db, orm.FilterEq("id", comment.Id))

     

       787
       756
        
       	if err != nil {

     

       788
       757
        
       		l.Error("failed to delete comment", "err", err)

     

       789
       758
        
       		rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "failed to delete comment")

     
···

       815
       784
        
       	// htmx fragment of comment after deletion

     

       816
       785
        
       	rp.pages.IssueCommentBodyFragment(w, pages.IssueCommentBodyParams{

     

       817
       786
        
       		LoggedInUser: user,

     

       818
       818
       -
       		RepoInfo:     f.RepoInfo(user),

     

       787
       787
       +
       		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       819
       788
        
       		Issue:        issue,

     

       820
       789
        
       		Comment:      &comment,

     

       821
       790
        
       	})

     
···

       845
       814
        
       		return

     

       846
       815
        
       	}

     

       847
       816
        
       

     

       817
       817
       +
       	totalIssues := 0

     

       818
       818
       +
       	if isOpen {

     

       819
       819
       +
       		totalIssues = f.RepoStats.IssueCount.Open

     

       820
       820
       +
       	} else {

     

       821
       821
       +
       		totalIssues = f.RepoStats.IssueCount.Closed

     

       822
       822
       +
       	}

     

       823
       823
       +
       

     

       848
       824
        
       	keyword := params.Get("q")

     

       849
       825
        
       

     

       850
       850
       -
       	var ids []int64

     

       826
       826
       +
       	var issues []models.Issue

     

       851
       827
        
       	searchOpts := models.IssueSearchOptions{

     

       852
       828
        
       		Keyword: keyword,

     

       853
       829
        
       		RepoAt:  f.RepoAt().String(),

     
···

       860
       836
        
       			l.Error("failed to search for issues", "err", err)

     

       861
       837
        
       			return

     

       862
       838
        
       		}

     

       863
       863
       -
       		ids = res.Hits

     

       864
       864
       -
       		l.Debug("searched issues with indexer", "count", len(ids))

     

       839
       839
       +
       		l.Debug("searched issues with indexer", "count", len(res.Hits))

     

       840
       840
       +
       		totalIssues = int(res.Total)

     

       841
       841
       +
       

     

       842
       842
       +
       		issues, err = db.GetIssues(

     

       843
       843
       +
       			rp.db,

     

       844
       844
       +
       			orm.FilterIn("id", res.Hits),

     

       845
       845
       +
       		)

     

       846
       846
       +
       		if err != nil {

     

       847
       847
       +
       			l.Error("failed to get issues", "err", err)

     

       848
       848
       +
       			rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.")

     

       849
       849
       +
       			return

     

       850
       850
       +
       		}

     

       851
       851
       +
       

     

       865
       852
        
       	} else {

     

       866
       866
       -
       		ids, err = db.GetIssueIDs(rp.db, searchOpts)

     

       853
       853
       +
       		openInt := 0

     

       854
       854
       +
       		if isOpen {

     

       855
       855
       +
       			openInt = 1

     

       856
       856
       +
       		}

     

       857
       857
       +
       		issues, err = db.GetIssuesPaginated(

     

       858
       858
       +
       			rp.db,

     

       859
       859
       +
       			page,

     

       860
       860
       +
       			orm.FilterEq("repo_at", f.RepoAt()),

     

       861
       861
       +
       			orm.FilterEq("open", openInt),

     

       862
       862
       +
       		)

     

       867
       863
        
       		if err != nil {

     

       868
       868
       -
       			l.Error("failed to search for issues", "err", err)

     

       864
       864
       +
       			l.Error("failed to get issues", "err", err)

     

       865
       865
       +
       			rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.")

     

       869
       866
        
       			return

     

       870
       867
        
       		}

     

       871
       871
       -
       		l.Debug("indexed all issues from the db", "count", len(ids))

     

       872
       872
       -
       	}

     

       873
       873
       -
       

     

       874
       874
       -
       	issues, err := db.GetIssues(

     

       875
       875
       -
       		rp.db,

     

       876
       876
       -
       		db.FilterIn("id", ids),

     

       877
       877
       -
       	)

     

       878
       878
       -
       	if err != nil {

     

       879
       879
       -
       		l.Error("failed to get issues", "err", err)

     

       880
       880
       -
       		rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.")

     

       881
       881
       -
       		return

     

       882
       868
        
       	}

     

       883
       869
        
       

     

       884
       870
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       885
       871
        
       		rp.db,

     

       886
       886
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       887
       887
       -
       		db.FilterContains("scope", tangled.RepoIssueNSID),

     

       872
       872
       +
       		orm.FilterIn("at_uri", f.Labels),

     

       873
       873
       +
       		orm.FilterContains("scope", tangled.RepoIssueNSID),

     

       888
       874
        
       	)

     

       889
       875
        
       	if err != nil {

     

       890
       876
        
       		l.Error("failed to fetch labels", "err", err)

     
···

       899
       885
        
       

     

       900
       886
        
       	rp.pages.RepoIssues(w, pages.RepoIssuesParams{

     

       901
       887
        
       		LoggedInUser:    rp.oauth.GetUser(r),

     

       902
       902
       -
       		RepoInfo:        f.RepoInfo(user),

     

       888
       888
       +
       		RepoInfo:        rp.repoResolver.GetRepoInfo(r, user),

     

       903
       889
        
       		Issues:          issues,

     

       890
       890
       +
       		IssueCount:      totalIssues,

     

       904
       891
        
       		LabelDefs:       defs,

     

       905
       892
        
       		FilteringByOpen: isOpen,

     

       906
       893
        
       		FilterQuery:     keyword,

     
···

       922
       909
        
       	case http.MethodGet:

     

       923
       910
        
       		rp.pages.RepoNewIssue(w, pages.RepoNewIssueParams{

     

       924
       911
        
       			LoggedInUser: user,

     

       925
       925
       -
       			RepoInfo:     f.RepoInfo(user),

     

       912
       912
       +
       			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       926
       913
        
       		})

     

       927
       914
        
       	case http.MethodPost:

     

       928
       915
        
       		body := r.FormValue("body")

     

       929
       929
       -
       		mentions, references := rp.refResolver.Resolve(r.Context(), body)

     

       916
       916
       +
       		mentions, references := rp.mentionsResolver.Resolve(r.Context(), body)

     

       930
       917
        
       

     

       931
       918
        
       		issue := &models.Issue{

     

       932
       919
        
       			RepoAt:     f.RepoAt(),

     
···

       938
       925
        
       			Created:    time.Now(),

     

       939
       926
        
       			Mentions:   mentions,

     

       940
       927
        
       			References: references,

     

       941
       941
       -
       			Repo:       &f.Repo,

     

       928
       928
       +
       			Repo:       f,

     

       942
       929
        
       		}

     

       943
       930
        
       

     

       944
       931
        
       		if err := rp.validator.ValidateIssue(issue); err != nil {

     
···

       1007
       994
        
       		atUri = ""

     

       1008
       995
        
       

     

       1009
       996
        
       		rp.notifier.NewIssue(r.Context(), issue, mentions)

     

       1010
       1010
       -
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId))

     

       997
       997
       +
       

     

       998
       998
       +
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       999
       999
       +
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))

     

       1011
       1000
        
       		return

     

       1012
       1001
        
       	}

     

       1013
       1002
        
       }

+3 -3

appview/issues/opengraph.go

···

       232
       232
        
       

     

       233
       233
        
       	// Get owner handle for avatar

     

       234
       234
        
       	var ownerHandle string

     

       235
       235
       -
       	owner, err := rp.idResolver.ResolveIdent(r.Context(), f.Repo.Did)

     

       235
       235
       +
       	owner, err := rp.idResolver.ResolveIdent(r.Context(), f.Did)

     

       236
       236
        
       	if err != nil {

     

       237
       237
       -
       		ownerHandle = f.Repo.Did

     

       237
       237
       +
       		ownerHandle = f.Did

     

       238
       238
        
       	} else {

     

       239
       239
        
       		ownerHandle = "@" + owner.Handle.String()

     

       240
       240
        
       	}

     

       241
       241
        
       

     

       242
       242
       -
       	card, err := rp.drawIssueSummaryCard(issue, &f.Repo, commentCount, ownerHandle)

     

       242
       242
       +
       	card, err := rp.drawIssueSummaryCard(issue, f, commentCount, ownerHandle)

     

       243
       243
        
       	if err != nil {

     

       244
       244
        
       		log.Println("failed to draw issue summary card", err)

     

       245
       245
        
       		http.Error(w, "failed to draw issue summary card", http.StatusInternalServerError)

+37 -19

appview/knots/knots.go

···

       21
       21
        
       	"tangled.org/core/appview/xrpcclient"

     

       22
       22
        
       	"tangled.org/core/eventconsumer"

     

       23
       23
        
       	"tangled.org/core/idresolver"

     

       24
       24
       +
       	"tangled.org/core/orm"

     

       24
       25
        
       	"tangled.org/core/rbac"

     

       25
       26
        
       	"tangled.org/core/tid"

     

       26
       27
        
       

     
···

       39
       40
        
       	Knotstream *eventconsumer.Consumer

     

       40
       41
        
       }

     

       41
       42
        
       

     

       43
       43
       +
       type tab = map[string]any

     

       44
       44
       +
       

     

       45
       45
       +
       var (

     

       46
       46
       +
       	knotsTabs []tab = []tab{

     

       47
       47
       +
       		{"Name": "profile", "Icon": "user"},

     

       48
       48
       +
       		{"Name": "keys", "Icon": "key"},

     

       49
       49
       +
       		{"Name": "emails", "Icon": "mail"},

     

       50
       50
       +
       		{"Name": "notifications", "Icon": "bell"},

     

       51
       51
       +
       		{"Name": "knots", "Icon": "volleyball"},

     

       52
       52
       +
       		{"Name": "spindles", "Icon": "spool"},

     

       53
       53
       +
       	}

     

       54
       54
       +
       )

     

       55
       55
       +
       

     

       42
       56
        
       func (k *Knots) Router() http.Handler {

     

       43
       57
        
       	r := chi.NewRouter()

     

       44
       58
        
       

     
···

       59
       73
        
       	user := k.OAuth.GetUser(r)

     

       60
       74
        
       	registrations, err := db.GetRegistrations(

     

       61
       75
        
       		k.Db,

     

       62
       62
       -
       		db.FilterEq("did", user.Did),

     

       76
       76
       +
       		orm.FilterEq("did", user.Did),

     

       63
       77
        
       	)

     

       64
       78
        
       	if err != nil {

     

       65
       79
        
       		k.Logger.Error("failed to fetch knot registrations", "err", err)

     
···

       70
       84
        
       	k.Pages.Knots(w, pages.KnotsParams{

     

       71
       85
        
       		LoggedInUser:  user,

     

       72
       86
        
       		Registrations: registrations,

     

       87
       87
       +
       		Tabs:          knotsTabs,

     

       88
       88
       +
       		Tab:           "knots",

     

       73
       89
        
       	})

     

       74
       90
        
       }

     

       75
       91
        
       

     
···

       87
       103
        
       

     

       88
       104
        
       	registrations, err := db.GetRegistrations(

     

       89
       105
        
       		k.Db,

     

       90
       90
       -
       		db.FilterEq("did", user.Did),

     

       91
       91
       -
       		db.FilterEq("domain", domain),

     

       106
       106
       +
       		orm.FilterEq("did", user.Did),

     

       107
       107
       +
       		orm.FilterEq("domain", domain),

     

       92
       108
        
       	)

     

       93
       109
        
       	if err != nil {

     

       94
       110
        
       		l.Error("failed to get registrations", "err", err)

     
···

       112
       128
        
       	repos, err := db.GetRepos(

     

       113
       129
        
       		k.Db,

     

       114
       130
        
       		0,

     

       115
       115
       -
       		db.FilterEq("knot", domain),

     

       131
       131
       +
       		orm.FilterEq("knot", domain),

     

       116
       132
        
       	)

     

       117
       133
        
       	if err != nil {

     

       118
       134
        
       		l.Error("failed to get knot repos", "err", err)

     
···

       132
       148
        
       		Members:      members,

     

       133
       149
        
       		Repos:        repoMap,

     

       134
       150
        
       		IsOwner:      true,

     

       151
       151
       +
       		Tabs:         knotsTabs,

     

       152
       152
       +
       		Tab:          "knots",

     

       135
       153
        
       	})

     

       136
       154
        
       }

     

       137
       155
        
       

     
···

       276
       294
        
       	// get record from db first

     

       277
       295
        
       	registrations, err := db.GetRegistrations(

     

       278
       296
        
       		k.Db,

     

       279
       279
       -
       		db.FilterEq("did", user.Did),

     

       280
       280
       -
       		db.FilterEq("domain", domain),

     

       297
       297
       +
       		orm.FilterEq("did", user.Did),

     

       298
       298
       +
       		orm.FilterEq("domain", domain),

     

       281
       299
        
       	)

     

       282
       300
        
       	if err != nil {

     

       283
       301
        
       		l.Error("failed to get registration", "err", err)

     
···

       304
       322
        
       

     

       305
       323
        
       	err = db.DeleteKnot(

     

       306
       324
        
       		tx,

     

       307
       307
       -
       		db.FilterEq("did", user.Did),

     

       308
       308
       -
       		db.FilterEq("domain", domain),

     

       325
       325
       +
       		orm.FilterEq("did", user.Did),

     

       326
       326
       +
       		orm.FilterEq("domain", domain),

     

       309
       327
        
       	)

     

       310
       328
        
       	if err != nil {

     

       311
       329
        
       		l.Error("failed to delete registration", "err", err)

     
···

       385
       403
        
       	// get record from db first

     

       386
       404
        
       	registrations, err := db.GetRegistrations(

     

       387
       405
        
       		k.Db,

     

       388
       388
       -
       		db.FilterEq("did", user.Did),

     

       389
       389
       -
       		db.FilterEq("domain", domain),

     

       406
       406
       +
       		orm.FilterEq("did", user.Did),

     

       407
       407
       +
       		orm.FilterEq("domain", domain),

     

       390
       408
        
       	)

     

       391
       409
        
       	if err != nil {

     

       392
       410
        
       		l.Error("failed to get registration", "err", err)

     
···

       476
       494
        
       	// Get updated registration to show

     

       477
       495
        
       	registrations, err = db.GetRegistrations(

     

       478
       496
        
       		k.Db,

     

       479
       479
       -
       		db.FilterEq("did", user.Did),

     

       480
       480
       -
       		db.FilterEq("domain", domain),

     

       497
       497
       +
       		orm.FilterEq("did", user.Did),

     

       498
       498
       +
       		orm.FilterEq("domain", domain),

     

       481
       499
        
       	)

     

       482
       500
        
       	if err != nil {

     

       483
       501
        
       		l.Error("failed to get registration", "err", err)

     
···

       512
       530
        
       

     

       513
       531
        
       	registrations, err := db.GetRegistrations(

     

       514
       532
        
       		k.Db,

     

       515
       515
       -
       		db.FilterEq("did", user.Did),

     

       516
       516
       -
       		db.FilterEq("domain", domain),

     

       517
       517
       -
       		db.FilterIsNot("registered", "null"),

     

       533
       533
       +
       		orm.FilterEq("did", user.Did),

     

       534
       534
       +
       		orm.FilterEq("domain", domain),

     

       535
       535
       +
       		orm.FilterIsNot("registered", "null"),

     

       518
       536
        
       	)

     

       519
       537
        
       	if err != nil {

     

       520
       538
        
       		l.Error("failed to get registration", "err", err)

     
···

       596
       614
        
       	}

     

       597
       615
        
       

     

       598
       616
        
       	// success

     

       599
       599
       -
       	k.Pages.HxRedirect(w, fmt.Sprintf("/knots/%s", domain))

     

       617
       617
       +
       	k.Pages.HxRedirect(w, fmt.Sprintf("/settings/knots/%s", domain))

     

       600
       618
        
       }

     

       601
       619
        
       

     

       602
       620
        
       func (k *Knots) removeMember(w http.ResponseWriter, r *http.Request) {

     
···

       620
       638
        
       

     

       621
       639
        
       	registrations, err := db.GetRegistrations(

     

       622
       640
        
       		k.Db,

     

       623
       623
       -
       		db.FilterEq("did", user.Did),

     

       624
       624
       -
       		db.FilterEq("domain", domain),

     

       625
       625
       -
       		db.FilterIsNot("registered", "null"),

     

       641
       641
       +
       		orm.FilterEq("did", user.Did),

     

       642
       642
       +
       		orm.FilterEq("domain", domain),

     

       643
       643
       +
       		orm.FilterIsNot("registered", "null"),

     

       626
       644
        
       	)

     

       627
       645
        
       	if err != nil {

     

       628
       646
        
       		l.Error("failed to get registration", "err", err)

+5 -4

appview/labels/labels.go

···

       16
       16
        
       	"tangled.org/core/appview/oauth"

     

       17
       17
        
       	"tangled.org/core/appview/pages"

     

       18
       18
        
       	"tangled.org/core/appview/validator"

     

       19
       19
       +
       	"tangled.org/core/orm"

     

       19
       20
        
       	"tangled.org/core/rbac"

     

       20
       21
        
       	"tangled.org/core/tid"

     

       21
       22
        
       

     
···

       88
       89
        
       	repoAt := r.Form.Get("repo")

     

       89
       90
        
       	subjectUri := r.Form.Get("subject")

     

       90
       91
        
       

     

       91
       91
       -
       	repo, err := db.GetRepo(l.db, db.FilterEq("at_uri", repoAt))

     

       92
       92
       +
       	repo, err := db.GetRepo(l.db, orm.FilterEq("at_uri", repoAt))

     

       92
       93
        
       	if err != nil {

     

       93
       94
        
       		fail("Failed to get repository.", err)

     

       94
       95
        
       		return

     

       95
       96
        
       	}

     

       96
       97
        
       

     

       97
       98
        
       	// find all the labels that this repo subscribes to

     

       98
       98
       -
       	repoLabels, err := db.GetRepoLabels(l.db, db.FilterEq("repo_at", repoAt))

     

       99
       99
       +
       	repoLabels, err := db.GetRepoLabels(l.db, orm.FilterEq("repo_at", repoAt))

     

       99
       100
        
       	if err != nil {

     

       100
       101
        
       		fail("Failed to get labels for this repository.", err)

     

       101
       102
        
       		return

     
···

       106
       107
        
       		labelAts = append(labelAts, rl.LabelAt.String())

     

       107
       108
        
       	}

     

       108
       109
        
       

     

       109
       109
       -
       	actx, err := db.NewLabelApplicationCtx(l.db, db.FilterIn("at_uri", labelAts))

     

       110
       110
       +
       	actx, err := db.NewLabelApplicationCtx(l.db, orm.FilterIn("at_uri", labelAts))

     

       110
       111
        
       	if err != nil {

     

       111
       112
        
       		fail("Invalid form data.", err)

     

       112
       113
        
       		return

     

       113
       114
        
       	}

     

       114
       115
        
       

     

       115
       116
        
       	// calculate the start state by applying already known labels

     

       116
       116
       -
       	existingOps, err := db.GetLabelOps(l.db, db.FilterEq("subject", subjectUri))

     

       117
       117
       +
       	existingOps, err := db.GetLabelOps(l.db, orm.FilterEq("subject", subjectUri))

     

       117
       118
        
       	if err != nil {

     

       118
       119
        
       		fail("Invalid form data.", err)

     

       119
       120
        
       		return

+67

appview/mentions/resolver.go

···

       1
       1
       +
       package mentions

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"log/slog"

     

       6
       6
       +
       

     

       7
       7
       +
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       8
       8
       +
       	"tangled.org/core/appview/config"

     

       9
       9
       +
       	"tangled.org/core/appview/db"

     

       10
       10
       +
       	"tangled.org/core/appview/models"

     

       11
       11
       +
       	"tangled.org/core/appview/pages/markup"

     

       12
       12
       +
       	"tangled.org/core/idresolver"

     

       13
       13
       +
       )

     

       14
       14
       +
       

     

       15
       15
       +
       type Resolver struct {

     

       16
       16
       +
       	config     *config.Config

     

       17
       17
       +
       	idResolver *idresolver.Resolver

     

       18
       18
       +
       	execer     db.Execer

     

       19
       19
       +
       	logger     *slog.Logger

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       func New(

     

       23
       23
       +
       	config *config.Config,

     

       24
       24
       +
       	idResolver *idresolver.Resolver,

     

       25
       25
       +
       	execer db.Execer,

     

       26
       26
       +
       	logger *slog.Logger,

     

       27
       27
       +
       ) *Resolver {

     

       28
       28
       +
       	return &Resolver{

     

       29
       29
       +
       		config,

     

       30
       30
       +
       		idResolver,

     

       31
       31
       +
       		execer,

     

       32
       32
       +
       		logger,

     

       33
       33
       +
       	}

     

       34
       34
       +
       }

     

       35
       35
       +
       

     

       36
       36
       +
       func (r *Resolver) Resolve(ctx context.Context, source string) ([]syntax.DID, []syntax.ATURI) {

     

       37
       37
       +
       	l := r.logger.With("method", "Resolve")

     

       38
       38
       +
       

     

       39
       39
       +
       	rawMentions, rawRefs := markup.FindReferences(r.config.Core.AppviewHost, source)

     

       40
       40
       +
       	l.Debug("found possible references", "mentions", rawMentions, "refs", rawRefs)

     

       41
       41
       +
       

     

       42
       42
       +
       	idents := r.idResolver.ResolveIdents(ctx, rawMentions)

     

       43
       43
       +
       	var mentions []syntax.DID

     

       44
       44
       +
       	for _, ident := range idents {

     

       45
       45
       +
       		if ident != nil && !ident.Handle.IsInvalidHandle() {

     

       46
       46
       +
       			mentions = append(mentions, ident.DID)

     

       47
       47
       +
       		}

     

       48
       48
       +
       	}

     

       49
       49
       +
       	l.Debug("found mentions", "mentions", mentions)

     

       50
       50
       +
       

     

       51
       51
       +
       	var resolvedRefs []models.ReferenceLink

     

       52
       52
       +
       	for _, rawRef := range rawRefs {

     

       53
       53
       +
       		ident, err := r.idResolver.ResolveIdent(ctx, rawRef.Handle)

     

       54
       54
       +
       		if err != nil || ident == nil || ident.Handle.IsInvalidHandle() {

     

       55
       55
       +
       			continue

     

       56
       56
       +
       		}

     

       57
       57
       +
       		rawRef.Handle = string(ident.DID)

     

       58
       58
       +
       		resolvedRefs = append(resolvedRefs, rawRef)

     

       59
       59
       +
       	}

     

       60
       60
       +
       	aturiRefs, err := db.ValidateReferenceLinks(r.execer, resolvedRefs)

     

       61
       61
       +
       	if err != nil {

     

       62
       62
       +
       		l.Error("failed running query", "err", err)

     

       63
       63
       +
       	}

     

       64
       64
       +
       	l.Debug("found references", "refs", aturiRefs)

     

       65
       65
       +
       

     

       66
       66
       +
       	return mentions, aturiRefs

     

       67
       67
       +
       }

+7 -4

appview/middleware/middleware.go

···

       18
       18
        
       	"tangled.org/core/appview/pagination"

     

       19
       19
        
       	"tangled.org/core/appview/reporesolver"

     

       20
       20
        
       	"tangled.org/core/idresolver"

     

       21
       21
       +
       	"tangled.org/core/orm"

     

       21
       22
        
       	"tangled.org/core/rbac"

     

       22
       23
        
       )

     

       23
       24
        
       

     
···

       164
       165
        
       			ok, err := mw.enforcer.E.Enforce(actor.Did, f.Knot, f.DidSlashRepo(), requiredPerm)

     

       165
       166
        
       			if err != nil || !ok {

     

       166
       167
        
       				// we need a logged in user

     

       167
       167
       -
       				log.Printf("%s does not have perms of a %s in repo %s", actor.Did, requiredPerm, f.OwnerSlashRepo())

     

       168
       168
       +
       				log.Printf("%s does not have perms of a %s in repo %s", actor.Did, requiredPerm, f.DidSlashRepo())

     

       168
       169
        
       				http.Error(w, "Forbiden", http.StatusUnauthorized)

     

       169
       170
        
       				return

     

       170
       171
        
       			}

     
···

       206
       207
        
       	return func(next http.Handler) http.Handler {

     

       207
       208
        
       		return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {

     

       208
       209
        
       			repoName := chi.URLParam(req, "repo")

     

       210
       210
       +
       			repoName = strings.TrimSuffix(repoName, ".git")

     

       211
       211
       +
       

     

       209
       212
        
       			id, ok := req.Context().Value("resolvedId").(identity.Identity)

     

       210
       213
        
       			if !ok {

     

       211
       214
        
       				log.Println("malformed middleware")

     
···

       215
       218
        
       

     

       216
       219
        
       			repo, err := db.GetRepo(

     

       217
       220
        
       				mw.db,

     

       218
       218
       -
       				db.FilterEq("did", id.DID.String()),

     

       219
       219
       -
       				db.FilterEq("name", repoName),

     

       221
       221
       +
       				orm.FilterEq("did", id.DID.String()),

     

       222
       222
       +
       				orm.FilterEq("name", repoName),

     

       220
       223
        
       			)

     

       221
       224
        
       			if err != nil {

     

       222
       225
        
       				log.Println("failed to resolve repo", "err", err)

     
···

       325
       328
        
       				return

     

       326
       329
        
       			}

     

       327
       330
        
       

     

       328
       328
       -
       			fullName := f.OwnerHandle() + "/" + f.Name

     

       331
       331
       +
       			fullName := reporesolver.GetBaseRepoPath(r, f)

     

       329
       332
        
       

     

       330
       333
        
       			if r.Header.Get("User-Agent") == "Go-http-client/1.1" {

     

       331
       334
        
       				if r.URL.Query().Get("go-get") == "1" {

+3 -1

appview/models/profile.go

···

       111
       111
        
       }

     

       112
       112
        
       

     

       113
       113
        
       type ByMonth struct {

     

       114
       114
       +
       	Commits     int

     

       114
       115
        
       	RepoEvents  []RepoEvent

     

       115
       116
        
       	IssueEvents IssueEvents

     

       116
       117
        
       	PullEvents  PullEvents

     
···

       119
       120
        
       func (b ByMonth) IsEmpty() bool {

     

       120
       121
        
       	return len(b.RepoEvents) == 0 &&

     

       121
       122
        
       		len(b.IssueEvents.Items) == 0 &&

     

       122
       122
       -
       		len(b.PullEvents.Items) == 0

     

       123
       123
       +
       		len(b.PullEvents.Items) == 0 &&

     

       124
       124
       +
       		b.Commits == 0

     

       123
       125
        
       }

     

       124
       126
        
       

     

       125
       127
        
       type IssueEvents struct {

+47

appview/models/repo.go

···

       104
       104
        
       	Repo   *Repo

     

       105
       105
        
       	Issues []Issue

     

       106
       106
        
       }

     

       107
       107
       +
       

     

       108
       108
       +
       type BlobContentType int

     

       109
       109
       +
       

     

       110
       110
       +
       const (

     

       111
       111
       +
       	BlobContentTypeCode BlobContentType = iota

     

       112
       112
       +
       	BlobContentTypeMarkup

     

       113
       113
       +
       	BlobContentTypeImage

     

       114
       114
       +
       	BlobContentTypeSvg

     

       115
       115
       +
       	BlobContentTypeVideo

     

       116
       116
       +
       	BlobContentTypeSubmodule

     

       117
       117
       +
       )

     

       118
       118
       +
       

     

       119
       119
       +
       func (ty BlobContentType) IsCode() bool      { return ty == BlobContentTypeCode }

     

       120
       120
       +
       func (ty BlobContentType) IsMarkup() bool    { return ty == BlobContentTypeMarkup }

     

       121
       121
       +
       func (ty BlobContentType) IsImage() bool     { return ty == BlobContentTypeImage }

     

       122
       122
       +
       func (ty BlobContentType) IsSvg() bool       { return ty == BlobContentTypeSvg }

     

       123
       123
       +
       func (ty BlobContentType) IsVideo() bool     { return ty == BlobContentTypeVideo }

     

       124
       124
       +
       func (ty BlobContentType) IsSubmodule() bool { return ty == BlobContentTypeSubmodule }

     

       125
       125
       +
       

     

       126
       126
       +
       type BlobView struct {

     

       127
       127
       +
       	HasTextView     bool // can show as code/text

     

       128
       128
       +
       	HasRenderedView bool // can show rendered (markup/image/video/submodule)

     

       129
       129
       +
       	HasRawView      bool // can download raw (everything except submodule)

     

       130
       130
       +
       

     

       131
       131
       +
       	// current display mode

     

       132
       132
       +
       	ShowingRendered bool // currently in rendered mode

     

       133
       133
       +
       	ShowingText     bool // currently in text/code mode

     

       134
       134
       +
       

     

       135
       135
       +
       	// content type flags

     

       136
       136
       +
       	ContentType BlobContentType

     

       137
       137
       +
       

     

       138
       138
       +
       	// Content data

     

       139
       139
       +
       	Contents   string

     

       140
       140
       +
       	ContentSrc string // URL for media files

     

       141
       141
       +
       	Lines      int

     

       142
       142
       +
       	SizeHint   uint64

     

       143
       143
       +
       }

     

       144
       144
       +
       

     

       145
       145
       +
       // if both views are available, then show a toggle between them

     

       146
       146
       +
       func (b BlobView) ShowToggle() bool {

     

       147
       147
       +
       	return b.HasTextView && b.HasRenderedView

     

       148
       148
       +
       }

     

       149
       149
       +
       

     

       150
       150
       +
       func (b BlobView) IsUnsupported() bool {

     

       151
       151
       +
       	// no view available, only raw

     

       152
       152
       +
       	return !(b.HasRenderedView || b.HasTextView)

     

       153
       153
       +
       }

+14 -5

appview/models/star.go

···

       7
       7
        
       )

     

       8
       8
        
       

     

       9
       9
        
       type Star struct {

     

       10
       10
       -
       	StarredByDid string

     

       11
       11
       -
       	RepoAt       syntax.ATURI

     

       12
       12
       -
       	Created      time.Time

     

       13
       13
       -
       	Rkey         string

     

       10
       10
       +
       	Did     string

     

       11
       11
       +
       	RepoAt  syntax.ATURI

     

       12
       12
       +
       	Created time.Time

     

       13
       13
       +
       	Rkey    string

     

       14
       14
       +
       }

     

       14
       15
        
       

     

       15
       15
       -
       	// optionally, populate this when querying for reverse mappings

     

       16
       16
       +
       // RepoStar is used for reverse mapping to repos

     

       17
       17
       +
       type RepoStar struct {

     

       18
       18
       +
       	Star

     

       16
       19
        
       	Repo *Repo

     

       17
       20
        
       }

     

       21
       21
       +
       

     

       22
       22
       +
       // StringStar is used for reverse mapping to strings

     

       23
       23
       +
       type StringStar struct {

     

       24
       24
       +
       	Star

     

       25
       25
       +
       	String *String

     

       26
       26
       +
       }

+1 -1

appview/models/string.go

···

       22
       22
        
       	Edited      *time.Time

     

       23
       23
        
       }

     

       24
       24
        
       

     

       25
       25
       -
       func (s *String) StringAt() syntax.ATURI {

     

       25
       25
       +
       func (s *String) AtUri() syntax.ATURI {

     

       26
       26
        
       	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", s.Did, tangled.StringNSID, s.Rkey))

     

       27
       27
        
       }

     

       28
       28

+1 -1

appview/models/timeline.go

···

       5
       5
        
       type TimelineEvent struct {

     

       6
       6
        
       	*Repo

     

       7
       7
        
       	*Follow

     

       8
       8
       -
       	*Star

     

       8
       8
       +
       	*RepoStar

     

       9
       9
        
       

     

       10
       10
        
       	EventAt time.Time

     

       11
       11

+5 -4

appview/notifications/notifications.go

···

       11
       11
        
       	"tangled.org/core/appview/oauth"

     

       12
       12
        
       	"tangled.org/core/appview/pages"

     

       13
       13
        
       	"tangled.org/core/appview/pagination"

     

       14
       14
       +
       	"tangled.org/core/orm"

     

       14
       15
        
       )

     

       15
       16
        
       

     

       16
       17
        
       type Notifications struct {

     
···

       53
       54
        
       

     

       54
       55
        
       	total, err := db.CountNotifications(

     

       55
       56
        
       		n.db,

     

       56
       56
       -
       		db.FilterEq("recipient_did", user.Did),

     

       57
       57
       +
       		orm.FilterEq("recipient_did", user.Did),

     

       57
       58
        
       	)

     

       58
       59
        
       	if err != nil {

     

       59
       60
        
       		l.Error("failed to get total notifications", "err", err)

     
···

       64
       65
        
       	notifications, err := db.GetNotificationsWithEntities(

     

       65
       66
        
       		n.db,

     

       66
       67
        
       		page,

     

       67
       67
       -
       		db.FilterEq("recipient_did", user.Did),

     

       68
       68
       +
       		orm.FilterEq("recipient_did", user.Did),

     

       68
       69
        
       	)

     

       69
       70
        
       	if err != nil {

     

       70
       71
        
       		l.Error("failed to get notifications", "err", err)

     
···

       96
       97
        
       

     

       97
       98
        
       	count, err := db.CountNotifications(

     

       98
       99
        
       		n.db,

     

       99
       99
       -
       		db.FilterEq("recipient_did", user.Did),

     

       100
       100
       -
       		db.FilterEq("read", 0),

     

       100
       100
       +
       		orm.FilterEq("recipient_did", user.Did),

     

       101
       101
       +
       		orm.FilterEq("read", 0),

     

       101
       102
        
       	)

     

       102
       103
        
       	if err != nil {

     

       103
       104
        
       		http.Error(w, "Failed to get unread count", http.StatusInternalServerError)

+83 -67

appview/notify/db/db.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"context"

     

       5
       5
        
       	"log"

     

       6
       6
       -
       	"maps"

     

       7
       6
        
       	"slices"

     

       8
       7
        
       

     

       9
       8
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       9
       9
       +
       	"tangled.org/core/api/tangled"

     

       10
       10
        
       	"tangled.org/core/appview/db"

     

       11
       11
        
       	"tangled.org/core/appview/models"

     

       12
       12
        
       	"tangled.org/core/appview/notify"

     

       13
       13
        
       	"tangled.org/core/idresolver"

     

       14
       14
       +
       	"tangled.org/core/orm"

     

       15
       15
       +
       	"tangled.org/core/sets"

     

       14
       16
        
       )

     

       15
       17
        
       

     

       16
       18
        
       const (

     

       17
       17
       -
       	maxMentions = 5

     

       19
       19
       +
       	maxMentions = 8

     

       18
       20
        
       )

     

       19
       21
        
       

     

       20
       22
        
       type databaseNotifier struct {

     
···

       36
       38
        
       }

     

       37
       39
        
       

     

       38
       40
        
       func (n *databaseNotifier) NewStar(ctx context.Context, star *models.Star) {

     

       41
       41
       +
       	if star.RepoAt.Collection().String() != tangled.RepoNSID {

     

       42
       42
       +
       		// skip string stars for now

     

       43
       43
       +
       		return

     

       44
       44
       +
       	}

     

       39
       45
        
       	var err error

     

       40
       40
       -
       	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(star.RepoAt)))

     

       46
       46
       +
       	repo, err := db.GetRepo(n.db, orm.FilterEq("at_uri", string(star.RepoAt)))

     

       41
       47
        
       	if err != nil {

     

       42
       48
        
       		log.Printf("NewStar: failed to get repos: %v", err)

     

       43
       49
        
       		return

     

       44
       50
        
       	}

     

       45
       51
        
       

     

       46
       46
       -
       	actorDid := syntax.DID(star.StarredByDid)

     

       47
       47
       -
       	recipients := []syntax.DID{syntax.DID(repo.Did)}

     

       52
       52
       +
       	actorDid := syntax.DID(star.Did)

     

       53
       53
       +
       	recipients := sets.Singleton(syntax.DID(repo.Did))

     

       48
       54
        
       	eventType := models.NotificationTypeRepoStarred

     

       49
       55
        
       	entityType := "repo"

     

       50
       56
        
       	entityId := star.RepoAt.String()

     
···

       69
       75
        
       }

     

       70
       76
        
       

     

       71
       77
        
       func (n *databaseNotifier) NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) {

     

       72
       72
       -
       

     

       73
       73
       -
       	// build the recipients list

     

       74
       74
       -
       	// - owner of the repo

     

       75
       75
       -
       	// - collaborators in the repo

     

       76
       76
       -
       	var recipients []syntax.DID

     

       77
       77
       -
       	recipients = append(recipients, syntax.DID(issue.Repo.Did))

     

       78
       78
       -
       	collaborators, err := db.GetCollaborators(n.db, db.FilterEq("repo_at", issue.Repo.RepoAt()))

     

       78
       78
       +
       	collaborators, err := db.GetCollaborators(n.db, orm.FilterEq("repo_at", issue.Repo.RepoAt()))

     

       79
       79
        
       	if err != nil {

     

       80
       80
        
       		log.Printf("failed to fetch collaborators: %v", err)

     

       81
       81
        
       		return

     

       82
       82
        
       	}

     

       83
       83
       +
       

     

       84
       84
       +
       	// build the recipients list

     

       85
       85
       +
       	// - owner of the repo

     

       86
       86
       +
       	// - collaborators in the repo

     

       87
       87
       +
       	// - remove users already mentioned

     

       88
       88
       +
       	recipients := sets.Singleton(syntax.DID(issue.Repo.Did))

     

       83
       89
        
       	for _, c := range collaborators {

     

       84
       84
       -
       		recipients = append(recipients, c.SubjectDid)

     

       90
       90
       +
       		recipients.Insert(c.SubjectDid)

     

       91
       91
       +
       	}

     

       92
       92
       +
       	for _, m := range mentions {

     

       93
       93
       +
       		recipients.Remove(m)

     

       85
       94
        
       	}

     

       86
       95
        
       

     

       87
       96
        
       	actorDid := syntax.DID(issue.Did)

     
···

       103
       112
        
       	)

     

       104
       113
        
       	n.notifyEvent(

     

       105
       114
        
       		actorDid,

     

       106
       106
       -
       		mentions,

     

       115
       115
       +
       		sets.Collect(slices.Values(mentions)),

     

       107
       116
        
       		models.NotificationTypeUserMentioned,

     

       108
       117
        
       		entityType,

     

       109
       118
        
       		entityId,

     
···

       114
       123
        
       }

     

       115
       124
        
       

     

       116
       125
        
       func (n *databaseNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) {

     

       117
       117
       -
       	issues, err := db.GetIssues(n.db, db.FilterEq("at_uri", comment.IssueAt))

     

       126
       126
       +
       	issues, err := db.GetIssues(n.db, orm.FilterEq("at_uri", comment.IssueAt))

     

       118
       127
        
       	if err != nil {

     

       119
       128
        
       		log.Printf("NewIssueComment: failed to get issues: %v", err)

     

       120
       129
        
       		return

     
···

       125
       134
        
       	}

     

       126
       135
        
       	issue := issues[0]

     

       127
       136
        
       

     

       128
       128
       -
       	var recipients []syntax.DID

     

       129
       129
       -
       	recipients = append(recipients, syntax.DID(issue.Repo.Did))

     

       137
       137
       +
       	// built the recipients list:

     

       138
       138
       +
       	// - the owner of the repo

     

       139
       139
       +
       	// - | if the comment is a reply -> everybody on that thread

     

       140
       140
       +
       	//   | if the comment is a top level -> just the issue owner

     

       141
       141
       +
       	// - remove mentioned users from the recipients list

     

       142
       142
       +
       	recipients := sets.Singleton(syntax.DID(issue.Repo.Did))

     

       130
       143
        
       

     

       131
       144
        
       	if comment.IsReply() {

     

       132
       145
        
       		// if this comment is a reply, then notify everybody in that thread

     

       133
       146
        
       		parentAtUri := *comment.ReplyTo

     

       134
       134
       -
       		allThreads := issue.CommentList()

     

       135
       147
        
       

     

       136
       148
        
       		// find the parent thread, and add all DIDs from here to the recipient list

     

       137
       137
       -
       		for _, t := range allThreads {

     

       149
       149
       +
       		for _, t := range issue.CommentList() {

     

       138
       150
        
       			if t.Self.AtUri().String() == parentAtUri {

     

       139
       139
       -
       				recipients = append(recipients, t.Participants()...)

     

       151
       151
       +
       				for _, p := range t.Participants() {

     

       152
       152
       +
       					recipients.Insert(p)

     

       153
       153
       +
       				}

     

       140
       154
        
       			}

     

       141
       155
        
       		}

     

       142
       156
        
       	} else {

     

       143
       157
        
       		// not a reply, notify just the issue author

     

       144
       144
       -
       		recipients = append(recipients, syntax.DID(issue.Did))

     

       158
       158
       +
       		recipients.Insert(syntax.DID(issue.Did))

     

       159
       159
       +
       	}

     

       160
       160
       +
       

     

       161
       161
       +
       	for _, m := range mentions {

     

       162
       162
       +
       		recipients.Remove(m)

     

       145
       163
        
       	}

     

       146
       164
        
       

     

       147
       165
        
       	actorDid := syntax.DID(comment.Did)

     
···

       163
       181
        
       	)

     

       164
       182
        
       	n.notifyEvent(

     

       165
       183
        
       		actorDid,

     

       166
       166
       -
       		mentions,

     

       184
       184
       +
       		sets.Collect(slices.Values(mentions)),

     

       167
       185
        
       		models.NotificationTypeUserMentioned,

     

       168
       186
        
       		entityType,

     

       169
       187
        
       		entityId,

     
···

       179
       197
        
       

     

       180
       198
        
       func (n *databaseNotifier) NewFollow(ctx context.Context, follow *models.Follow) {

     

       181
       199
        
       	actorDid := syntax.DID(follow.UserDid)

     

       182
       182
       -
       	recipients := []syntax.DID{syntax.DID(follow.SubjectDid)}

     

       200
       200
       +
       	recipients := sets.Singleton(syntax.DID(follow.SubjectDid))

     

       183
       201
        
       	eventType := models.NotificationTypeFollowed

     

       184
       202
        
       	entityType := "follow"

     

       185
       203
        
       	entityId := follow.UserDid

     
···

       202
       220
        
       }

     

       203
       221
        
       

     

       204
       222
        
       func (n *databaseNotifier) NewPull(ctx context.Context, pull *models.Pull) {

     

       205
       205
       -
       	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(pull.RepoAt)))

     

       223
       223
       +
       	repo, err := db.GetRepo(n.db, orm.FilterEq("at_uri", string(pull.RepoAt)))

     

       206
       224
        
       	if err != nil {

     

       207
       225
        
       		log.Printf("NewPull: failed to get repos: %v", err)

     

       208
       226
        
       		return

     

       209
       227
        
       	}

     

       210
       210
       -
       

     

       211
       211
       -
       	// build the recipients list

     

       212
       212
       -
       	// - owner of the repo

     

       213
       213
       -
       	// - collaborators in the repo

     

       214
       214
       -
       	var recipients []syntax.DID

     

       215
       215
       -
       	recipients = append(recipients, syntax.DID(repo.Did))

     

       216
       216
       -
       	collaborators, err := db.GetCollaborators(n.db, db.FilterEq("repo_at", repo.RepoAt()))

     

       228
       228
       +
       	collaborators, err := db.GetCollaborators(n.db, orm.FilterEq("repo_at", repo.RepoAt()))

     

       217
       229
        
       	if err != nil {

     

       218
       230
        
       		log.Printf("failed to fetch collaborators: %v", err)

     

       219
       231
        
       		return

     

       220
       232
        
       	}

     

       233
       233
       +
       

     

       234
       234
       +
       	// build the recipients list

     

       235
       235
       +
       	// - owner of the repo

     

       236
       236
       +
       	// - collaborators in the repo

     

       237
       237
       +
       	recipients := sets.Singleton(syntax.DID(repo.Did))

     

       221
       238
        
       	for _, c := range collaborators {

     

       222
       222
       -
       		recipients = append(recipients, c.SubjectDid)

     

       239
       239
       +
       		recipients.Insert(c.SubjectDid)

     

       223
       240
        
       	}

     

       224
       241
        
       

     

       225
       242
        
       	actorDid := syntax.DID(pull.OwnerDid)

     
···

       253
       270
        
       		return

     

       254
       271
        
       	}

     

       255
       272
        
       

     

       256
       256
       -
       	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", comment.RepoAt))

     

       273
       273
       +
       	repo, err := db.GetRepo(n.db, orm.FilterEq("at_uri", comment.RepoAt))

     

       257
       274
        
       	if err != nil {

     

       258
       275
        
       		log.Printf("NewPullComment: failed to get repos: %v", err)

     

       259
       276
        
       		return

     
···

       262
       279
        
       	// build up the recipients list:

     

       263
       280
        
       	// - repo owner

     

       264
       281
        
       	// - all pull participants

     

       265
       265
       -
       	var recipients []syntax.DID

     

       266
       266
       -
       	recipients = append(recipients, syntax.DID(repo.Did))

     

       282
       282
       +
       	// - remove those already mentioned

     

       283
       283
       +
       	recipients := sets.Singleton(syntax.DID(repo.Did))

     

       267
       284
        
       	for _, p := range pull.Participants() {

     

       268
       268
       -
       		recipients = append(recipients, syntax.DID(p))

     

       285
       285
       +
       		recipients.Insert(syntax.DID(p))

     

       286
       286
       +
       	}

     

       287
       287
       +
       	for _, m := range mentions {

     

       288
       288
       +
       		recipients.Remove(m)

     

       269
       289
        
       	}

     

       270
       290
        
       

     

       271
       291
        
       	actorDid := syntax.DID(comment.OwnerDid)

     
···

       289
       309
        
       	)

     

       290
       310
        
       	n.notifyEvent(

     

       291
       311
        
       		actorDid,

     

       292
       292
       -
       		mentions,

     

       312
       312
       +
       		sets.Collect(slices.Values(mentions)),

     

       293
       313
        
       		models.NotificationTypeUserMentioned,

     

       294
       314
        
       		entityType,

     

       295
       315
        
       		entityId,

     
···

       316
       336
        
       }

     

       317
       337
        
       

     

       318
       338
        
       func (n *databaseNotifier) NewIssueState(ctx context.Context, actor syntax.DID, issue *models.Issue) {

     

       319
       319
       -
       	// build up the recipients list:

     

       320
       320
       -
       	// - repo owner

     

       321
       321
       -
       	// - repo collaborators

     

       322
       322
       -
       	// - all issue participants

     

       323
       323
       -
       	var recipients []syntax.DID

     

       324
       324
       -
       	recipients = append(recipients, syntax.DID(issue.Repo.Did))

     

       325
       325
       -
       	collaborators, err := db.GetCollaborators(n.db, db.FilterEq("repo_at", issue.Repo.RepoAt()))

     

       339
       339
       +
       	collaborators, err := db.GetCollaborators(n.db, orm.FilterEq("repo_at", issue.Repo.RepoAt()))

     

       326
       340
        
       	if err != nil {

     

       327
       341
        
       		log.Printf("failed to fetch collaborators: %v", err)

     

       328
       342
        
       		return

     

       329
       343
        
       	}

     

       344
       344
       +
       

     

       345
       345
       +
       	// build up the recipients list:

     

       346
       346
       +
       	// - repo owner

     

       347
       347
       +
       	// - repo collaborators

     

       348
       348
       +
       	// - all issue participants

     

       349
       349
       +
       	recipients := sets.Singleton(syntax.DID(issue.Repo.Did))

     

       330
       350
        
       	for _, c := range collaborators {

     

       331
       331
       -
       		recipients = append(recipients, c.SubjectDid)

     

       351
       351
       +
       		recipients.Insert(c.SubjectDid)

     

       332
       352
        
       	}

     

       333
       353
        
       	for _, p := range issue.Participants() {

     

       334
       334
       -
       		recipients = append(recipients, syntax.DID(p))

     

       354
       354
       +
       		recipients.Insert(syntax.DID(p))

     

       335
       355
        
       	}

     

       336
       356
        
       

     

       337
       357
        
       	entityType := "pull"

     
···

       361
       381
        
       

     

       362
       382
        
       func (n *databaseNotifier) NewPullState(ctx context.Context, actor syntax.DID, pull *models.Pull) {

     

       363
       383
        
       	// Get repo details

     

       364
       364
       -
       	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(pull.RepoAt)))

     

       384
       384
       +
       	repo, err := db.GetRepo(n.db, orm.FilterEq("at_uri", string(pull.RepoAt)))

     

       365
       385
        
       	if err != nil {

     

       366
       386
        
       		log.Printf("NewPullState: failed to get repos: %v", err)

     

       367
       387
        
       		return

     

       368
       388
        
       	}

     

       369
       389
        
       

     

       370
       370
       -
       	// build up the recipients list:

     

       371
       371
       -
       	// - repo owner

     

       372
       372
       -
       	// - all pull participants

     

       373
       373
       -
       	var recipients []syntax.DID

     

       374
       374
       -
       	recipients = append(recipients, syntax.DID(repo.Did))

     

       375
       375
       -
       	collaborators, err := db.GetCollaborators(n.db, db.FilterEq("repo_at", repo.RepoAt()))

     

       390
       390
       +
       	collaborators, err := db.GetCollaborators(n.db, orm.FilterEq("repo_at", repo.RepoAt()))

     

       376
       391
        
       	if err != nil {

     

       377
       392
        
       		log.Printf("failed to fetch collaborators: %v", err)

     

       378
       393
        
       		return

     

       379
       394
        
       	}

     

       395
       395
       +
       

     

       396
       396
       +
       	// build up the recipients list:

     

       397
       397
       +
       	// - repo owner

     

       398
       398
       +
       	// - all pull participants

     

       399
       399
       +
       	recipients := sets.Singleton(syntax.DID(repo.Did))

     

       380
       400
        
       	for _, c := range collaborators {

     

       381
       381
       -
       		recipients = append(recipients, c.SubjectDid)

     

       401
       401
       +
       		recipients.Insert(c.SubjectDid)

     

       382
       402
        
       	}

     

       383
       403
        
       	for _, p := range pull.Participants() {

     

       384
       384
       -
       		recipients = append(recipients, syntax.DID(p))

     

       404
       404
       +
       		recipients.Insert(syntax.DID(p))

     

       385
       405
        
       	}

     

       386
       406
        
       

     

       387
       407
        
       	entityType := "pull"

     
···

       417
       437
        
       

     

       418
       438
        
       func (n *databaseNotifier) notifyEvent(

     

       419
       439
        
       	actorDid syntax.DID,

     

       420
       420
       -
       	recipients []syntax.DID,

     

       440
       440
       +
       	recipients sets.Set[syntax.DID],

     

       421
       441
        
       	eventType models.NotificationType,

     

       422
       442
        
       	entityType string,

     

       423
       443
        
       	entityId string,

     
···

       425
       445
        
       	issueId *int64,

     

       426
       446
        
       	pullId *int64,

     

       427
       447
        
       ) {

     

       428
       428
       -
       	if eventType == models.NotificationTypeUserMentioned && len(recipients) > maxMentions {

     

       429
       429
       -
       		recipients = recipients[:maxMentions]

     

       430
       430
       -
       	}

     

       431
       431
       -
       	recipientSet := make(map[syntax.DID]struct{})

     

       432
       432
       -
       	for _, did := range recipients {

     

       433
       433
       -
       		// everybody except actor themselves

     

       434
       434
       -
       		if did != actorDid {

     

       435
       435
       -
       			recipientSet[did] = struct{}{}

     

       436
       436
       -
       		}

     

       448
       448
       +
       	// if the user is attempting to mention >maxMentions users, this is probably spam, do not mention anybody

     

       449
       449
       +
       	if eventType == models.NotificationTypeUserMentioned && recipients.Len() > maxMentions {

     

       450
       450
       +
       		return

     

       437
       451
        
       	}

     

       438
       452
        
       

     

       453
       453
       +
       	recipients.Remove(actorDid)

     

       454
       454
       +
       

     

       439
       455
        
       	prefMap, err := db.GetNotificationPreferences(

     

       440
       456
        
       		n.db,

     

       441
       441
       -
       		db.FilterIn("user_did", slices.Collect(maps.Keys(recipientSet))),

     

       457
       457
       +
       		orm.FilterIn("user_did", slices.Collect(recipients.All())),

     

       442
       458
        
       	)

     

       443
       459
        
       	if err != nil {

     

       444
       460
        
       		// failed to get prefs for users

     
···

       454
       470
        
       	defer tx.Rollback()

     

       455
       471
        
       

     

       456
       472
        
       	// filter based on preferences

     

       457
       457
       -
       	for recipientDid := range recipientSet {

     

       473
       473
       +
       	for recipientDid := range recipients.All() {

     

       458
       474
        
       		prefs, ok := prefMap[recipientDid]

     

       459
       475
        
       		if !ok {

     

       460
       476
        
       			prefs = models.DefaultNotificationPreferences(recipientDid)

+2 -2

appview/notify/posthog/notifier.go

···

       37
       37
        
       

     

       38
       38
        
       func (n *posthogNotifier) NewStar(ctx context.Context, star *models.Star) {

     

       39
       39
        
       	err := n.client.Enqueue(posthog.Capture{

     

       40
       40
       -
       		DistinctId: star.StarredByDid,

     

       40
       40
       +
       		DistinctId: star.Did,

     

       41
       41
        
       		Event:      "star",

     

       42
       42
        
       		Properties: posthog.Properties{"repo_at": star.RepoAt.String()},

     

       43
       43
        
       	})

     
···

       48
       48
        
       

     

       49
       49
        
       func (n *posthogNotifier) DeleteStar(ctx context.Context, star *models.Star) {

     

       50
       50
        
       	err := n.client.Enqueue(posthog.Capture{

     

       51
       51
       -
       		DistinctId: star.StarredByDid,

     

       51
       51
       +
       		DistinctId: star.Did,

     

       52
       52
        
       		Event:      "unstar",

     

       53
       53
        
       		Properties: posthog.Properties{"repo_at": star.RepoAt.String()},

     

       54
       54
        
       	})

+3 -2

appview/oauth/handler.go

···

       16
       16
        
       	"tangled.org/core/api/tangled"

     

       17
       17
        
       	"tangled.org/core/appview/db"

     

       18
       18
        
       	"tangled.org/core/consts"

     

       19
       19
       +
       	"tangled.org/core/orm"

     

       19
       20
        
       	"tangled.org/core/tid"

     

       20
       21
        
       )

     

       21
       22
        
       

     
···

       97
       98
        
       	// and create an sh.tangled.spindle.member record with that

     

       98
       99
        
       	spindleMembers, err := db.GetSpindleMembers(

     

       99
       100
        
       		o.Db,

     

       100
       100
       -
       		db.FilterEq("instance", "spindle.tangled.sh"),

     

       101
       101
       -
       		db.FilterEq("subject", did),

     

       101
       101
       +
       		orm.FilterEq("instance", "spindle.tangled.sh"),

     

       102
       102
       +
       		orm.FilterEq("subject", did),

     

       102
       103
        
       	)

     

       103
       104
        
       	if err != nil {

     

       104
       105
        
       		l.Error("failed to get spindle members", "err", err)

+15 -2

appview/oauth/oauth.go

···

       202
       202
        
       	exp     int64

     

       203
       203
        
       	lxm     string

     

       204
       204
        
       	dev     bool

     

       205
       205
       +
       	timeout time.Duration

     

       205
       206
        
       }

     

       206
       207
        
       

     

       207
       208
        
       type ServiceClientOpt func(*ServiceClientOpts)

     

       209
       209
       +
       

     

       210
       210
       +
       func DefaultServiceClientOpts() ServiceClientOpts {

     

       211
       211
       +
       	return ServiceClientOpts{

     

       212
       212
       +
       		timeout: time.Second * 5,

     

       213
       213
       +
       	}

     

       214
       214
       +
       }

     

       208
       215
        
       

     

       209
       216
        
       func WithService(service string) ServiceClientOpt {

     

       210
       217
        
       	return func(s *ServiceClientOpts) {

     
···

       233
       240
        
       	}

     

       234
       241
        
       }

     

       235
       242
        
       

     

       243
       243
       +
       func WithTimeout(timeout time.Duration) ServiceClientOpt {

     

       244
       244
       +
       	return func(s *ServiceClientOpts) {

     

       245
       245
       +
       		s.timeout = timeout

     

       246
       246
       +
       	}

     

       247
       247
       +
       }

     

       248
       248
       +
       

     

       236
       249
        
       func (s *ServiceClientOpts) Audience() string {

     

       237
       250
        
       	return fmt.Sprintf("did:web:%s", s.service)

     

       238
       251
        
       }

     
···

       247
       260
        
       }

     

       248
       261
        
       

     

       249
       262
        
       func (o *OAuth) ServiceClient(r *http.Request, os ...ServiceClientOpt) (*xrpc.Client, error) {

     

       250
       250
       -
       	opts := ServiceClientOpts{}

     

       263
       263
       +
       	opts := DefaultServiceClientOpts()

     

       251
       264
        
       	for _, o := range os {

     

       252
       265
        
       		o(&opts)

     

       253
       266
        
       	}

     
···

       274
       287
        
       		},

     

       275
       288
        
       		Host: opts.Host(),

     

       276
       289
        
       		Client: &http.Client{

     

       277
       277
       -
       			Timeout: time.Second * 5,

     

       290
       290
       +
       			Timeout: opts.timeout,

     

       278
       291
        
       		},

     

       279
       292
        
       	}, nil

     

       280
       293
        
       }

+81 -10

appview/pages/funcmap.go

···

       1
       1
        
       package pages

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"bytes"

     

       4
       5
        
       	"context"

     

       5
       6
        
       	"crypto/hmac"

     

       6
       7
        
       	"crypto/sha256"

     
···

       17
       18
        
       	"strings"

     

       18
       19
        
       	"time"

     

       19
       20
        
       

     

       20
       20
       -
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       21
       21
       +
       	"github.com/alecthomas/chroma/v2"

     

       22
       22
       +
       	chromahtml "github.com/alecthomas/chroma/v2/formatters/html"

     

       23
       23
       +
       	"github.com/alecthomas/chroma/v2/lexers"

     

       24
       24
       +
       	"github.com/alecthomas/chroma/v2/styles"

     

       21
       25
        
       	"github.com/dustin/go-humanize"

     

       22
       26
        
       	"github.com/go-enry/go-enry/v2"

     

       27
       27
       +
       	"github.com/yuin/goldmark"

     

       23
       28
        
       	"tangled.org/core/appview/filetree"

     

       29
       29
       +
       	"tangled.org/core/appview/models"

     

       24
       30
        
       	"tangled.org/core/appview/pages/markup"

     

       25
       31
        
       	"tangled.org/core/crypto"

     

       26
       32
        
       )

     
···

       66
       72
        
       

     

       67
       73
        
       			return identity.Handle.String()

     

       68
       74
        
       		},

     

       75
       75
       +
       		"ownerSlashRepo": func(repo *models.Repo) string {

     

       76
       76
       +
       			ownerId, err := p.resolver.ResolveIdent(context.Background(), repo.Did)

     

       77
       77
       +
       			if err != nil {

     

       78
       78
       +
       				return repo.DidSlashRepo()

     

       79
       79
       +
       			}

     

       80
       80
       +
       			handle := ownerId.Handle

     

       81
       81
       +
       			if handle != "" && !handle.IsInvalidHandle() {

     

       82
       82
       +
       				return string(handle) + "/" + repo.Name

     

       83
       83
       +
       			}

     

       84
       84
       +
       			return repo.DidSlashRepo()

     

       85
       85
       +
       		},

     

       69
       86
        
       		"truncateAt30": func(s string) string {

     

       70
       87
        
       			if len(s) <= 30 {

     

       71
       88
        
       				return s

     
···

       94
       111
        
       		"sub": func(a, b int) int {

     

       95
       112
        
       			return a - b

     

       96
       113
        
       		},

     

       114
       114
       +
       		"mul": func(a, b int) int {

     

       115
       115
       +
       			return a * b

     

       116
       116
       +
       		},

     

       117
       117
       +
       		"div": func(a, b int) int {

     

       118
       118
       +
       			return a / b

     

       119
       119
       +
       		},

     

       120
       120
       +
       		"mod": func(a, b int) int {

     

       121
       121
       +
       			return a % b

     

       122
       122
       +
       		},

     

       97
       123
        
       		"f64": func(a int) float64 {

     

       98
       124
        
       			return float64(a)

     

       99
       125
        
       		},

     
···

       126
       152
        
       

     

       127
       153
        
       			return b

     

       128
       154
        
       		},

     

       129
       129
       -
       		"didOrHandle": func(did, handle string) string {

     

       130
       130
       -
       			if handle != "" && handle != syntax.HandleInvalid.String() {

     

       131
       131
       -
       				return handle

     

       132
       132
       -
       			} else {

     

       133
       133
       -
       				return did

     

       134
       134
       -
       			}

     

       135
       135
       -
       		},

     

       136
       155
        
       		"assoc": func(values ...string) ([][]string, error) {

     

       137
       156
        
       			if len(values)%2 != 0 {

     

       138
       157
        
       				return nil, fmt.Errorf("invalid assoc call, must have an even number of arguments")

     
···

       143
       162
        
       			}

     

       144
       163
        
       			return pairs, nil

     

       145
       164
        
       		},

     

       146
       146
       -
       		"append": func(s []string, values ...string) []string {

     

       165
       165
       +
       		"append": func(s []any, values ...any) []any {

     

       147
       166
        
       			s = append(s, values...)

     

       148
       167
        
       			return s

     

       149
       168
        
       		},

     
···

       242
       261
        
       		},

     

       243
       262
        
       		"description": func(text string) template.HTML {

     

       244
       263
        
       			p.rctx.RendererType = markup.RendererTypeDefault

     

       264
       264
       +
       			htmlString := p.rctx.RenderMarkdownWith(text, goldmark.New())

     

       265
       265
       +
       			sanitized := p.rctx.SanitizeDescription(htmlString)

     

       266
       266
       +
       			return template.HTML(sanitized)

     

       267
       267
       +
       		},

     

       268
       268
       +
       		"readme": func(text string) template.HTML {

     

       269
       269
       +
       			p.rctx.RendererType = markup.RendererTypeRepoMarkdown

     

       245
       270
        
       			htmlString := p.rctx.RenderMarkdown(text)

     

       246
       246
       -
       			sanitized := p.rctx.SanitizeDescription(htmlString)

     

       271
       271
       +
       			sanitized := p.rctx.SanitizeDefault(htmlString)

     

       247
       272
        
       			return template.HTML(sanitized)

     

       248
       273
        
       		},

     

       274
       274
       +
       		"code": func(content, path string) string {

     

       275
       275
       +
       			var style *chroma.Style = styles.Get("catpuccin-latte")

     

       276
       276
       +
       			formatter := chromahtml.New(

     

       277
       277
       +
       				chromahtml.InlineCode(false),

     

       278
       278
       +
       				chromahtml.WithLineNumbers(true),

     

       279
       279
       +
       				chromahtml.WithLinkableLineNumbers(true, "L"),

     

       280
       280
       +
       				chromahtml.Standalone(false),

     

       281
       281
       +
       				chromahtml.WithClasses(true),

     

       282
       282
       +
       			)

     

       283
       283
       +
       

     

       284
       284
       +
       			lexer := lexers.Get(filepath.Base(path))

     

       285
       285
       +
       			if lexer == nil {

     

       286
       286
       +
       				lexer = lexers.Fallback

     

       287
       287
       +
       			}

     

       288
       288
       +
       

     

       289
       289
       +
       			iterator, err := lexer.Tokenise(nil, content)

     

       290
       290
       +
       			if err != nil {

     

       291
       291
       +
       				p.logger.Error("chroma tokenize", "err", "err")

     

       292
       292
       +
       				return ""

     

       293
       293
       +
       			}

     

       294
       294
       +
       

     

       295
       295
       +
       			var code bytes.Buffer

     

       296
       296
       +
       			err = formatter.Format(&code, style, iterator)

     

       297
       297
       +
       			if err != nil {

     

       298
       298
       +
       				p.logger.Error("chroma format", "err", "err")

     

       299
       299
       +
       				return ""

     

       300
       300
       +
       			}

     

       301
       301
       +
       

     

       302
       302
       +
       			return code.String()

     

       303
       303
       +
       		},

     

       249
       304
        
       		"trimUriScheme": func(text string) string {

     

       250
       305
        
       			text = strings.TrimPrefix(text, "https://")

     

       251
       306
        
       			text = strings.TrimPrefix(text, "http://")

     
···

       328
       383
        
       	}

     

       329
       384
        
       }

     

       330
       385
        
       

     

       386
       386
       +
       func (p *Pages) resolveDid(did string) string {

     

       387
       387
       +
       	identity, err := p.resolver.ResolveIdent(context.Background(), did)

     

       388
       388
       +
       

     

       389
       389
       +
       	if err != nil {

     

       390
       390
       +
       		return did

     

       391
       391
       +
       	}

     

       392
       392
       +
       

     

       393
       393
       +
       	if identity.Handle.IsInvalidHandle() {

     

       394
       394
       +
       		return "handle.invalid"

     

       395
       395
       +
       	}

     

       396
       396
       +
       

     

       397
       397
       +
       	return identity.Handle.String()

     

       398
       398
       +
       }

     

       399
       399
       +
       

     

       331
       400
        
       func (p *Pages) AvatarUrl(handle, size string) string {

     

       332
       401
        
       	handle = strings.TrimPrefix(handle, "@")

     

       402
       402
       +
       

     

       403
       403
       +
       	handle = p.resolveDid(handle)

     

       333
       404
        
       

     

       334
       405
        
       	secret := p.avatar.SharedSecret

     

       335
       406
        
       	h := hmac.New(sha256.New, []byte(secret))

+1 -1

appview/pages/markup/extension/atlink.go

···

       89
       89
        
       	if entering {

     

       90
       90
        
       		w.WriteString(`<a href="/@`)

     

       91
       91
        
       		w.WriteString(n.(*AtNode).Handle)

     

       92
       92
       -
       		w.WriteString(`" class="mention">`)

     

       92
       92
       +
       		w.WriteString(`" class="mention font-bold">`)

     

       93
       93
        
       	} else {

     

       94
       94
        
       		w.WriteString("</a>")

     

       95
       95
        
       	}

+4 -4

appview/pages/markup/markdown.go

···

       12
       12
        
       

     

       13
       13
        
       	chromahtml "github.com/alecthomas/chroma/v2/formatters/html"

     

       14
       14
        
       	"github.com/alecthomas/chroma/v2/styles"

     

       15
       15
       -
       	treeblood "github.com/wyatt915/goldmark-treeblood"

     

       16
       15
        
       	"github.com/yuin/goldmark"

     

       17
       16
        
       	highlighting "github.com/yuin/goldmark-highlighting/v2"

     

       18
       17
        
       	"github.com/yuin/goldmark/ast"

     
···

       65
       64
        
       			extension.NewFootnote(

     

       66
       65
        
       				extension.WithFootnoteIDPrefix([]byte("footnote")),

     

       67
       66
        
       			),

     

       68
       68
       -
       			treeblood.MathML(),

     

       69
       67
        
       			callout.CalloutExtention,

     

       70
       68
        
       			textension.AtExt,

     

       71
       69
        
       		),

     
···

       78
       76
        
       }

     

       79
       77
        
       

     

       80
       78
        
       func (rctx *RenderContext) RenderMarkdown(source string) string {

     

       81
       81
       -
       	md := NewMarkdown()

     

       79
       79
       +
       	return rctx.RenderMarkdownWith(source, NewMarkdown())

     

       80
       80
       +
       }

     

       82
       81
        
       

     

       82
       82
       +
       func (rctx *RenderContext) RenderMarkdownWith(source string, md goldmark.Markdown) string {

     

       83
       83
        
       	if rctx != nil {

     

       84
       84
        
       		var transformers []util.PrioritizedValue

     

       85
       85
        
       

     
···

       247
       247
        
       	repoName := fmt.Sprintf("%s/%s", rctx.RepoInfo.OwnerDid, rctx.RepoInfo.Name)

     

       248
       248
        
       

     

       249
       249
        
       	query := fmt.Sprintf("repo=%s&ref=%s&path=%s&raw=true",

     

       250
       250
       -
       		url.PathEscape(repoName), url.PathEscape(rctx.RepoInfo.Ref), actualPath)

     

       250
       250
       +
       		url.QueryEscape(repoName), url.QueryEscape(rctx.RepoInfo.Ref), actualPath)

     

       251
       251
        
       

     

       252
       252
        
       	parsedURL := &url.URL{

     

       253
       253
        
       		Scheme:   scheme,

+37 -116

appview/pages/pages.go

···

       1
       1
        
       package pages

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"bytes"

     

       5
       4
        
       	"crypto/sha256"

     

       6
       5
        
       	"embed"

     

       7
       6
        
       	"encoding/hex"

     
···

       29
       28
        
       	"tangled.org/core/patchutil"

     

       30
       29
        
       	"tangled.org/core/types"

     

       31
       30
        
       

     

       32
       32
       -
       	"github.com/alecthomas/chroma/v2"

     

       33
       33
       -
       	chromahtml "github.com/alecthomas/chroma/v2/formatters/html"

     

       34
       34
       -
       	"github.com/alecthomas/chroma/v2/lexers"

     

       35
       35
       -
       	"github.com/alecthomas/chroma/v2/styles"

     

       36
       31
        
       	"github.com/bluesky-social/indigo/atproto/identity"

     

       37
       32
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       38
       33
        
       	"github.com/go-git/go-git/v5/plumbing"

     

       39
       39
       -
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       40
       34
        
       )

     

       41
       35
        
       

     

       42
       36
        
       //go:embed templates/* static legal

     
···

       412
       406
        
       type KnotsParams struct {

     

       413
       407
        
       	LoggedInUser  *oauth.User

     

       414
       408
        
       	Registrations []models.Registration

     

       409
       409
       +
       	Tabs          []map[string]any

     

       410
       410
       +
       	Tab           string

     

       415
       411
        
       }

     

       416
       412
        
       

     

       417
       413
        
       func (p *Pages) Knots(w io.Writer, params KnotsParams) error {

     
···

       424
       420
        
       	Members      []string

     

       425
       421
        
       	Repos        map[string][]models.Repo

     

       426
       422
        
       	IsOwner      bool

     

       423
       423
       +
       	Tabs         []map[string]any

     

       424
       424
       +
       	Tab          string

     

       427
       425
        
       }

     

       428
       426
        
       

     

       429
       427
        
       func (p *Pages) Knot(w io.Writer, params KnotParams) error {

     
···

       441
       439
        
       type SpindlesParams struct {

     

       442
       440
        
       	LoggedInUser *oauth.User

     

       443
       441
        
       	Spindles     []models.Spindle

     

       442
       442
       +
       	Tabs         []map[string]any

     

       443
       443
       +
       	Tab          string

     

       444
       444
        
       }

     

       445
       445
        
       

     

       446
       446
        
       func (p *Pages) Spindles(w io.Writer, params SpindlesParams) error {

     
···

       449
       449
        
       

     

       450
       450
        
       type SpindleListingParams struct {

     

       451
       451
        
       	models.Spindle

     

       452
       452
       +
       	Tabs []map[string]any

     

       453
       453
       +
       	Tab  string

     

       452
       454
        
       }

     

       453
       455
        
       

     

       454
       456
        
       func (p *Pages) SpindleListing(w io.Writer, params SpindleListingParams) error {

     
···

       460
       462
        
       	Spindle      models.Spindle

     

       461
       463
        
       	Members      []string

     

       462
       464
        
       	Repos        map[string][]models.Repo

     

       465
       465
       +
       	Tabs         []map[string]any

     

       466
       466
       +
       	Tab          string

     

       463
       467
        
       }

     

       464
       468
        
       

     

       465
       469
        
       func (p *Pages) SpindleDashboard(w io.Writer, params SpindleDashboardParams) error {

     
···

       487
       491
        
       

     

       488
       492
        
       type ProfileCard struct {

     

       489
       493
        
       	UserDid      string

     

       490
       490
       -
       	UserHandle   string

     

       491
       494
        
       	FollowStatus models.FollowStatus

     

       492
       495
        
       	Punchcard    *models.Punchcard

     

       493
       496
        
       	Profile      *models.Profile

     
···

       630
       633
        
       	return p.executePlain("user/fragments/editPins", w, params)

     

       631
       634
        
       }

     

       632
       635
        
       

     

       633
       633
       -
       type RepoStarFragmentParams struct {

     

       636
       636
       +
       type StarBtnFragmentParams struct {

     

       634
       637
        
       	IsStarred bool

     

       635
       635
       -
       	RepoAt    syntax.ATURI

     

       636
       636
       -
       	Stats     models.RepoStats

     

       638
       638
       +
       	SubjectAt syntax.ATURI

     

       639
       639
       +
       	StarCount int

     

       637
       640
        
       }

     

       638
       641
        
       

     

       639
       639
       -
       func (p *Pages) RepoStarFragment(w io.Writer, params RepoStarFragmentParams) error {

     

       640
       640
       -
       	return p.executePlain("repo/fragments/repoStar", w, params)

     

       642
       642
       +
       func (p *Pages) StarBtnFragment(w io.Writer, params StarBtnFragmentParams) error {

     

       643
       643
       +
       	return p.executePlain("fragments/starBtn", w, params)

     

       641
       644
        
       }

     

       642
       645
        
       

     

       643
       646
        
       type RepoIndexParams struct {

     
···

       645
       648
        
       	RepoInfo      repoinfo.RepoInfo

     

       646
       649
        
       	Active        string

     

       647
       650
        
       	TagMap        map[string][]string

     

       648
       648
       -
       	CommitsTrunc  []*object.Commit

     

       651
       651
       +
       	CommitsTrunc  []types.Commit

     

       649
       652
        
       	TagsTrunc     []*types.TagReference

     

       650
       653
        
       	BranchesTrunc []types.Branch

     

       651
       654
        
       	// ForkInfo           *types.ForkInfo

     
···

       744
       747
        
       func (r RepoTreeParams) TreeStats() RepoTreeStats {

     

       745
       748
        
       	numFolders, numFiles := 0, 0

     

       746
       749
        
       	for _, f := range r.Files {

     

       747
       747
       -
       		if !f.IsFile {

     

       750
       750
       +
       		if !f.IsFile() {

     

       748
       751
        
       			numFolders += 1

     

       749
       749
       -
       		} else if f.IsFile {

     

       752
       752
       +
       		} else if f.IsFile() {

     

       750
       753
        
       			numFiles += 1

     

       751
       754
        
       		}

     

       752
       755
        
       	}

     
···

       817
       820
        
       }

     

       818
       821
        
       

     

       819
       822
        
       type RepoBlobParams struct {

     

       820
       820
       -
       	LoggedInUser     *oauth.User

     

       821
       821
       -
       	RepoInfo         repoinfo.RepoInfo

     

       822
       822
       -
       	Active           string

     

       823
       823
       -
       	Unsupported      bool

     

       824
       824
       -
       	IsImage          bool

     

       825
       825
       -
       	IsVideo          bool

     

       826
       826
       -
       	ContentSrc       string

     

       827
       827
       -
       	BreadCrumbs      [][]string

     

       828
       828
       -
       	ShowRendered     bool

     

       829
       829
       -
       	RenderToggle     bool

     

       830
       830
       -
       	RenderedContents template.HTML

     

       823
       823
       +
       	LoggedInUser *oauth.User

     

       824
       824
       +
       	RepoInfo     repoinfo.RepoInfo

     

       825
       825
       +
       	Active       string

     

       826
       826
       +
       	BreadCrumbs  [][]string

     

       827
       827
       +
       	BlobView     models.BlobView

     

       831
       828
        
       	*tangled.RepoBlob_Output

     

       832
       832
       -
       	// Computed fields for template compatibility

     

       833
       833
       -
       	Contents string

     

       834
       834
       -
       	Lines    int

     

       835
       835
       -
       	SizeHint uint64

     

       836
       836
       -
       	IsBinary bool

     

       837
       829
        
       }

     

       838
       830
        
       

     

       839
       831
        
       func (p *Pages) RepoBlob(w io.Writer, params RepoBlobParams) error {

     

       840
       840
       -
       	var style *chroma.Style = styles.Get("catpuccin-latte")

     

       841
       841
       -
       

     

       842
       842
       -
       	if params.ShowRendered {

     

       843
       843
       -
       		switch markup.GetFormat(params.Path) {

     

       844
       844
       -
       		case markup.FormatMarkdown:

     

       845
       845
       -
       			p.rctx.RepoInfo = params.RepoInfo

     

       846
       846
       -
       			p.rctx.RendererType = markup.RendererTypeRepoMarkdown

     

       847
       847
       -
       			htmlString := p.rctx.RenderMarkdown(params.Contents)

     

       848
       848
       -
       			sanitized := p.rctx.SanitizeDefault(htmlString)

     

       849
       849
       -
       			params.RenderedContents = template.HTML(sanitized)

     

       850
       850
       -
       		}

     

       832
       832
       +
       	switch params.BlobView.ContentType {

     

       833
       833
       +
       	case models.BlobContentTypeMarkup:

     

       834
       834
       +
       		p.rctx.RepoInfo = params.RepoInfo

     

       851
       835
        
       	}

     

       852
       836
        
       

     

       853
       853
       -
       	c := params.Contents

     

       854
       854
       -
       	formatter := chromahtml.New(

     

       855
       855
       -
       		chromahtml.InlineCode(false),

     

       856
       856
       -
       		chromahtml.WithLineNumbers(true),

     

       857
       857
       -
       		chromahtml.WithLinkableLineNumbers(true, "L"),

     

       858
       858
       -
       		chromahtml.Standalone(false),

     

       859
       859
       -
       		chromahtml.WithClasses(true),

     

       860
       860
       -
       	)

     

       861
       861
       -
       

     

       862
       862
       -
       	lexer := lexers.Get(filepath.Base(params.Path))

     

       863
       863
       -
       	if lexer == nil {

     

       864
       864
       -
       		lexer = lexers.Fallback

     

       865
       865
       -
       	}

     

       866
       866
       -
       

     

       867
       867
       -
       	iterator, err := lexer.Tokenise(nil, c)

     

       868
       868
       -
       	if err != nil {

     

       869
       869
       -
       		return fmt.Errorf("chroma tokenize: %w", err)

     

       870
       870
       -
       	}

     

       871
       871
       -
       

     

       872
       872
       -
       	var code bytes.Buffer

     

       873
       873
       -
       	err = formatter.Format(&code, style, iterator)

     

       874
       874
       -
       	if err != nil {

     

       875
       875
       -
       		return fmt.Errorf("chroma format: %w", err)

     

       876
       876
       -
       	}

     

       877
       877
       -
       

     

       878
       878
       -
       	params.Contents = code.String()

     

       879
       837
        
       	params.Active = "overview"

     

       880
       838
        
       	return p.executeRepo("repo/blob", w, params)

     

       881
       839
        
       }

     

       882
       840
        
       

     

       883
       841
        
       type Collaborator struct {

     

       884
       884
       -
       	Did    string

     

       885
       885
       -
       	Handle string

     

       886
       886
       -
       	Role   string

     

       842
       842
       +
       	Did  string

     

       843
       843
       +
       	Role string

     

       887
       844
        
       }

     

       888
       845
        
       

     

       889
       846
        
       type RepoSettingsParams struct {

     
···

       958
       915
        
       	RepoInfo        repoinfo.RepoInfo

     

       959
       916
        
       	Active          string

     

       960
       917
        
       	Issues          []models.Issue

     

       918
       918
       +
       	IssueCount      int

     

       961
       919
        
       	LabelDefs       map[string]*models.LabelDefinition

     

       962
       920
        
       	Page            pagination.Page

     

       963
       921
        
       	FilteringByOpen bool

     
···

       1301
       1259
        
       	return p.executePlain("repo/fragments/compareAllowPull", w, params)

     

       1302
       1260
        
       }

     

       1303
       1261
        
       

     

       1304
       1304
       -
       type RepoCompareDiffParams struct {

     

       1305
       1305
       -
       	LoggedInUser *oauth.User

     

       1306
       1306
       -
       	RepoInfo     repoinfo.RepoInfo

     

       1307
       1307
       -
       	Diff         types.NiceDiff

     

       1262
       1262
       +
       type RepoCompareDiffFragmentParams struct {

     

       1263
       1263
       +
       	Diff     types.NiceDiff

     

       1264
       1264
       +
       	DiffOpts types.DiffOpts

     

       1308
       1265
        
       }

     

       1309
       1266
        
       

     

       1310
       1310
       -
       func (p *Pages) RepoCompareDiff(w io.Writer, params RepoCompareDiffParams) error {

     

       1311
       1311
       -
       	return p.executePlain("repo/fragments/diff", w, []any{params.RepoInfo.FullName, &params.Diff})

     

       1267
       1267
       +
       func (p *Pages) RepoCompareDiffFragment(w io.Writer, params RepoCompareDiffFragmentParams) error {

     

       1268
       1268
       +
       	return p.executePlain("repo/fragments/diff", w, []any{&params.Diff, &params.DiffOpts})

     

       1312
       1269
        
       }

     

       1313
       1270
        
       

     

       1314
       1271
        
       type LabelPanelParams struct {

     
···

       1428
       1385
        
       	ShowRendered     bool

     

       1429
       1386
        
       	RenderToggle     bool

     

       1430
       1387
        
       	RenderedContents template.HTML

     

       1431
       1431
       -
       	String           models.String

     

       1388
       1388
       +
       	String           *models.String

     

       1432
       1389
        
       	Stats            models.StringStats

     

       1390
       1390
       +
       	IsStarred        bool

     

       1391
       1391
       +
       	StarCount        int

     

       1433
       1392
        
       	Owner            identity.Identity

     

       1434
       1393
        
       }

     

       1435
       1394
        
       

     

       1436
       1395
        
       func (p *Pages) SingleString(w io.Writer, params SingleStringParams) error {

     

       1437
       1437
       -
       	var style *chroma.Style = styles.Get("catpuccin-latte")

     

       1438
       1438
       -
       

     

       1439
       1439
       -
       	if params.ShowRendered {

     

       1440
       1440
       -
       		switch markup.GetFormat(params.String.Filename) {

     

       1441
       1441
       -
       		case markup.FormatMarkdown:

     

       1442
       1442
       -
       			p.rctx.RendererType = markup.RendererTypeRepoMarkdown

     

       1443
       1443
       -
       			htmlString := p.rctx.RenderMarkdown(params.String.Contents)

     

       1444
       1444
       -
       			sanitized := p.rctx.SanitizeDefault(htmlString)

     

       1445
       1445
       -
       			params.RenderedContents = template.HTML(sanitized)

     

       1446
       1446
       -
       		}

     

       1447
       1447
       -
       	}

     

       1448
       1448
       -
       

     

       1449
       1449
       -
       	c := params.String.Contents

     

       1450
       1450
       -
       	formatter := chromahtml.New(

     

       1451
       1451
       -
       		chromahtml.InlineCode(false),

     

       1452
       1452
       -
       		chromahtml.WithLineNumbers(true),

     

       1453
       1453
       -
       		chromahtml.WithLinkableLineNumbers(true, "L"),

     

       1454
       1454
       -
       		chromahtml.Standalone(false),

     

       1455
       1455
       -
       		chromahtml.WithClasses(true),

     

       1456
       1456
       -
       	)

     

       1457
       1457
       -
       

     

       1458
       1458
       -
       	lexer := lexers.Get(filepath.Base(params.String.Filename))

     

       1459
       1459
       -
       	if lexer == nil {

     

       1460
       1460
       -
       		lexer = lexers.Fallback

     

       1461
       1461
       -
       	}

     

       1462
       1462
       -
       

     

       1463
       1463
       -
       	iterator, err := lexer.Tokenise(nil, c)

     

       1464
       1464
       -
       	if err != nil {

     

       1465
       1465
       -
       		return fmt.Errorf("chroma tokenize: %w", err)

     

       1466
       1466
       -
       	}

     

       1467
       1467
       -
       

     

       1468
       1468
       -
       	var code bytes.Buffer

     

       1469
       1469
       -
       	err = formatter.Format(&code, style, iterator)

     

       1470
       1470
       -
       	if err != nil {

     

       1471
       1471
       -
       		return fmt.Errorf("chroma format: %w", err)

     

       1472
       1472
       -
       	}

     

       1473
       1473
       -
       

     

       1474
       1474
       -
       	params.String.Contents = code.String()

     

       1475
       1396
        
       	return p.execute("strings/string", w, params)

     

       1476
       1397
        
       }

     

       1477
       1398

+25 -22

appview/pages/repoinfo/repoinfo.go

···

       1
       1
        
       package repoinfo

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"fmt"

     

       4
       5
        
       	"path"

     

       5
       6
        
       	"slices"

     

       6
       7
        
       

     

       7
       8
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       9
       9
       +
       	"tangled.org/core/api/tangled"

     

       8
       10
        
       	"tangled.org/core/appview/models"

     

       9
       11
        
       	"tangled.org/core/appview/state/userutil"

     

       10
       12
        
       )

     

       11
       13
        
       

     

       12
       12
       -
       func (r RepoInfo) Owner() string {

     

       14
       14
       +
       func (r RepoInfo) owner() string {

     

       13
       15
        
       	if r.OwnerHandle != "" {

     

       14
       16
        
       		return r.OwnerHandle

     

       15
       17
        
       	} else {

     
···

       18
       20
        
       }

     

       19
       21
        
       

     

       20
       22
        
       func (r RepoInfo) FullName() string {

     

       21
       21
       -
       	return path.Join(r.Owner(), r.Name)

     

       23
       23
       +
       	return path.Join(r.owner(), r.Name)

     

       22
       24
        
       }

     

       23
       25
        
       

     

       24
       24
       -
       func (r RepoInfo) OwnerWithoutAt() string {

     

       26
       26
       +
       func (r RepoInfo) ownerWithoutAt() string {

     

       25
       27
        
       	if r.OwnerHandle != "" {

     

       26
       28
        
       		return r.OwnerHandle

     

       27
       29
        
       	} else {

     
···

       30
       32
        
       }

     

       31
       33
        
       

     

       32
       34
        
       func (r RepoInfo) FullNameWithoutAt() string {

     

       33
       33
       -
       	return path.Join(r.OwnerWithoutAt(), r.Name)

     

       35
       35
       +
       	return path.Join(r.ownerWithoutAt(), r.Name)

     

       34
       36
        
       }

     

       35
       37
        
       

     

       36
       38
        
       func (r RepoInfo) GetTabs() [][]string {

     
···

       48
       50
        
       	return tabs

     

       49
       51
        
       }

     

       50
       52
        
       

     

       53
       53
       +
       func (r RepoInfo) RepoAt() syntax.ATURI {

     

       54
       54
       +
       	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", r.OwnerDid, tangled.RepoNSID, r.Rkey))

     

       55
       55
       +
       }

     

       56
       56
       +
       

     

       51
       57
        
       type RepoInfo struct {

     

       52
       52
       -
       	Name         string

     

       53
       53
       -
       	Rkey         string

     

       54
       54
       -
       	OwnerDid     string

     

       55
       55
       -
       	OwnerHandle  string

     

       56
       56
       -
       	Description  string

     

       57
       57
       -
       	Website      string

     

       58
       58
       -
       	Topics       []string

     

       59
       59
       -
       	Knot         string

     

       60
       60
       -
       	Spindle      string

     

       61
       61
       -
       	RepoAt       syntax.ATURI

     

       62
       62
       -
       	IsStarred    bool

     

       63
       63
       -
       	Stats        models.RepoStats

     

       64
       64
       -
       	Roles        RolesInRepo

     

       65
       65
       -
       	Source       *models.Repo

     

       66
       66
       -
       	SourceHandle string

     

       67
       67
       -
       	Ref          string

     

       68
       68
       -
       	DisableFork  bool

     

       69
       69
       -
       	CurrentDir   string

     

       58
       58
       +
       	Name        string

     

       59
       59
       +
       	Rkey        string

     

       60
       60
       +
       	OwnerDid    string

     

       61
       61
       +
       	OwnerHandle string

     

       62
       62
       +
       	Description string

     

       63
       63
       +
       	Website     string

     

       64
       64
       +
       	Topics      []string

     

       65
       65
       +
       	Knot        string

     

       66
       66
       +
       	Spindle     string

     

       67
       67
       +
       	IsStarred   bool

     

       68
       68
       +
       	Stats       models.RepoStats

     

       69
       69
       +
       	Roles       RolesInRepo

     

       70
       70
       +
       	Source      *models.Repo

     

       71
       71
       +
       	Ref         string

     

       72
       72
       +
       	CurrentDir  string

     

       70
       73
        
       }

     

       71
       74
        
       

     

       72
       75
        
       // each tab on a repo could have some metadata:

+28

appview/pages/templates/fragments/starBtn.html

···

       1
       1
       +
       {{ define "fragments/starBtn" }}

     

       2
       2
       +
           <button

     

       3
       3
       +
               id="starBtn"

     

       4
       4
       +
               class="btn disabled:opacity-50 disabled:cursor-not-allowed flex gap-2 items-center group"

     

       5
       5
       +
               data-star-subject-at="{{ .SubjectAt }}"

     

       6
       6
       +
               {{ if .IsStarred }}

     

       7
       7
       +
                   hx-delete="/star?subject={{ .SubjectAt }}&countHint={{ .StarCount }}"

     

       8
       8
       +
               {{ else }}

     

       9
       9
       +
                   hx-post="/star?subject={{ .SubjectAt }}&countHint={{ .StarCount }}"

     

       10
       10
       +
               {{ end }}

     

       11
       11
       +
       

     

       12
       12
       +
               hx-trigger="click"

     

       13
       13
       +
               hx-target="this"

     

       14
       14
       +
               hx-swap="outerHTML"

     

       15
       15
       +
               hx-swap-oob='outerHTML:#starBtn[data-star-subject-at="{{ .SubjectAt }}"]'

     

       16
       16
       +
               hx-disabled-elt="#starBtn"

     

       17
       17
       +
           >

     

       18
       18
       +
               {{ if .IsStarred }}

     

       19
       19
       +
                   {{ i "star" "w-4 h-4 fill-current" }}

     

       20
       20
       +
               {{ else }}

     

       21
       21
       +
                   {{ i "star" "w-4 h-4" }}

     

       22
       22
       +
               {{ end }}

     

       23
       23
       +
               <span class="text-sm">

     

       24
       24
       +
                   {{ .StarCount }}

     

       25
       25
       +
               </span>

     

       26
       26
       +
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       27
       27
       +
           </button>

     

       28
       28
       +
       {{ end }}

appview/pages/templates/fragments/tabSelector.html

···

       2
       2
        
         {{ $name := .Name }}

     

       3
       3
        
         {{ $all := .Values }}

     

       4
       4
        
         {{ $active := .Active }}

     

       5
       5
       +
         {{ $include := .Include }}

     

       5
       6
        
         <div class="flex justify-between divide-x divide-gray-200 dark:divide-gray-700 rounded border border-gray-200 dark:border-gray-700 overflow-hidden">

     

       6
       7
        
           {{ $activeTab := "bg-white dark:bg-gray-700 shadow-sm" }}

     

       7
       8
        
           {{ $inactiveTab := "bg-gray-100 dark:bg-gray-800 shadow-inner" }}

     

       8
       9
        
           {{ range $index, $value := $all }}

     

       9
       10
        
             {{ $isActive := eq $value.Key $active }}

     

       10
       11
        
             <a href="?{{ $name }}={{ $value.Key }}"

     

       12
       12
       +
                {{ if $include }}

     

       13
       13
       +
                hx-get="?{{ $name }}={{ $value.Key }}"

     

       14
       14
       +
                hx-include="{{ $include }}"

     

       15
       15
       +
                hx-push-url="true"

     

       16
       16
       +
                hx-target="body"

     

       17
       17
       +
                hx-on:htmx:config-request="if(!event.detail.parameters.q) delete event.detail.parameters.q"

     

       18
       18
       +
                {{ end }}

     

       11
       19
        
                class="p-2 whitespace-nowrap flex justify-center items-center gap-2 text-sm w-full block hover:no-underline text-center {{ if $isActive }} {{$activeTab }} {{ else }} {{ $inactiveTab }} {{ end }}">

     

       12
       20
        
              {{ if $value.Icon }}

     

       13
       21
        
                {{ i $value.Icon "size-4" }}

+22

appview/pages/templates/fragments/tinyAvatarList.html

···

       1
       1
       +
       {{ define "fragments/tinyAvatarList" }}

     

       2
       2
       +
         {{ $all := .all }}

     

       3
       3
       +
         {{ $classes := .classes }}

     

       4
       4
       +
         {{ $ps := take $all 5 }}

     

       5
       5
       +
         <div class="inline-flex items-center -space-x-3">

     

       6
       6
       +
           {{ $c := "z-50 z-40 z-30 z-20 z-10" }}

     

       7
       7
       +
           {{ range $i, $p := $ps }}

     

       8
       8
       +
             <img

     

       9
       9
       +
                 src="{{ tinyAvatar . }}"

     

       10
       10
       +
                 alt=""

     

       11
       11
       +
                 class="rounded-full size-8 mr-1 border-2 border-gray-100 dark:border-gray-900 z-{{sub 5 $i}}0 {{ $classes }}"

     

       12
       12
       +
             />

     

       13
       13
       +
           {{ end }}

     

       14
       14
       +
       

     

       15
       15
       +
           {{ if gt (len $all) 5 }}

     

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

     

       17
       17
       +
               +{{ sub (len $all) 5 }}

     

       18
       18
       +
             </span>

     

       19
       19
       +
           {{ end }}

     

       20
       20
       +
         </div>

     

       21
       21
       +
       {{ end }}

     

       22
       22
       +

+23 -7

appview/pages/templates/knots/dashboard.html

···

       1
       1
       -
       {{ define "title" }}{{ .Registration.Domain }} &middot; knots{{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ .Registration.Domain }} &middot; {{ .Tab }} settings{{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "content" }}

     

       4
       4
       -
       <div class="px-6 py-4">

     

       4
       4
       +
         <div class="p-6">

     

       5
       5
       +
           <p class="text-xl font-bold dark:text-white">Settings</p>

     

       6
       6
       +
         </div>

     

       7
       7
       +
         <div class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       8
       8
       +
           <section class="w-full grid grid-cols-1 md:grid-cols-4 gap-6">

     

       9
       9
       +
             <div class="col-span-1">

     

       10
       10
       +
               {{ template "user/settings/fragments/sidebar" . }}

     

       11
       11
       +
             </div>

     

       12
       12
       +
             <div class="col-span-1 md:col-span-3 flex flex-col gap-6">

     

       13
       13
       +
               {{ template "knotDash" . }}

     

       14
       14
       +
             </div>

     

       15
       15
       +
           </section>

     

       16
       16
       +
         </div>

     

       17
       17
       +
       {{ end }}

     

       18
       18
       +
       

     

       19
       19
       +
       {{ define "knotDash" }}

     

       20
       20
       +
       <div>

     

       5
       21
        
         <div class="flex justify-between items-center">

     

       6
       6
       -
           <h1 class="text-xl font-bold dark:text-white">{{ .Registration.Domain }}</h1>

     

       22
       22
       +
           <h2 class="text-sm pb-2 uppercase font-bold">{{ .Tab }} &middot; {{ .Registration.Domain }}</h2>

     

       7
       23
        
           <div id="right-side" class="flex gap-2">

     

       8
       24
        
             {{ $style := "px-2 py-1 rounded flex items-center flex-shrink-0 gap-2" }}

     

       9
       25
        
             {{ $isOwner := and .LoggedInUser (eq .LoggedInUser.Did .Registration.ByDid)  }}

     
···

       35
       51
        
       </div>

     

       36
       52
        
       

     

       37
       53
        
       {{ if .Members }}

     

       38
       38
       -
         <section class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       54
       54
       +
         <section class="bg-white dark:bg-gray-800 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       39
       55
        
           <div class="flex flex-col gap-2">

     

       40
       56
        
             {{ block "member" . }} {{ end }}

     

       41
       57
        
           </div>

     
···

       79
       95
        
         <button

     

       80
       96
        
           class="btn text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 gap-2 group"

     

       81
       97
        
           title="Delete knot"

     

       82
       82
       -
           hx-delete="/knots/{{ .Domain }}"

     

       98
       98
       +
           hx-delete="/settings/knots/{{ .Domain }}"

     

       83
       99
        
           hx-swap="outerHTML"

     

       84
       100
        
           hx-confirm="Are you sure you want to delete the knot '{{ .Domain }}'?"

     

       85
       101
        
           hx-headers='{"shouldRedirect": "true"}'

     
···

       95
       111
        
         <button

     

       96
       112
        
           class="btn gap-2 group"

     

       97
       113
        
           title="Retry knot verification"

     

       98
       98
       -
           hx-post="/knots/{{ .Domain }}/retry"

     

       114
       114
       +
           hx-post="/settings/knots/{{ .Domain }}/retry"

     

       99
       115
        
           hx-swap="none"

     

       100
       116
        
           hx-headers='{"shouldRefresh": "true"}'

     

       101
       117
        
         >

     
···

       113
       129
        
           <button

     

       114
       130
        
             class="btn text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 gap-2 group"

     

       115
       131
        
             title="Remove member"

     

       116
       116
       -
             hx-post="/knots/{{ $root.Registration.Domain }}/remove"

     

       132
       132
       +
             hx-post="/settings/knots/{{ $root.Registration.Domain }}/remove"

     

       117
       133
        
             hx-swap="none"

     

       118
       134
        
             hx-vals='{"member": "{{$member}}" }'

     

       119
       135
        
             hx-confirm="Are you sure you want to remove {{ $memberHandle }} from this knot?"

+18 -13

appview/pages/templates/knots/fragments/addMemberModal.html

···

       13
       13
        
         <div

     

       14
       14
        
           id="add-member-{{ .Id }}"

     

       15
       15
        
           popover

     

       16
       16
       -
           class="bg-white w-full md:w-96 dark:bg-gray-800 p-4 rounded border border-gray-200 dark:border-gray-700 drop-shadow dark:text-white backdrop:bg-gray-400/50 dark:backdrop:bg-gray-800/50">

     

       16
       16
       +
           class="

     

       17
       17
       +
           bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 dark:text-white backdrop:bg-gray-400/50 dark:backdrop:bg-gray-800/50

     

       18
       18
       +
           w-full md:w-96 p-4 rounded drop-shadow overflow-visible">

     

       17
       19
        
           {{ block "addKnotMemberPopover" . }} {{ end }}

     

       18
       20
        
         </div>

     

       19
       21
        
       {{ end }}

     

       20
       22
        
       

     

       21
       23
        
       {{ define "addKnotMemberPopover" }}

     

       22
       24
        
       <form

     

       23
       23
       -
         hx-post="/knots/{{ .Domain }}/add"

     

       25
       25
       +
         hx-post="/settings/knots/{{ .Domain }}/add"

     

       24
       26
        
         hx-indicator="#spinner"

     

       25
       27
        
         hx-swap="none"

     

       26
       28
        
         class="flex flex-col gap-2"

     
···

       29
       31
        
           ADD MEMBER

     

       30
       32
        
         </label>

     

       31
       33
        
         <p class="text-sm text-gray-500 dark:text-gray-400">Members can create repositories and run workflows on this knot.</p>

     

       32
       32
       -
         <input

     

       33
       33
       -
           autocapitalize="none"

     

       34
       34
       -
           autocorrect="off"

     

       35
       35
       -
           autocomplete="off"

     

       36
       36
       -
           type="text"

     

       37
       37
       -
           id="member-did-{{ .Id }}"

     

       38
       38
       -
           name="member"

     

       39
       39
       -
           required

     

       40
       40
       -
           placeholder="foo.bsky.social"

     

       41
       41
       -
         />

     

       34
       34
       +
         <actor-typeahead>

     

       35
       35
       +
           <input

     

       36
       36
       +
             autocapitalize="none"

     

       37
       37
       +
             autocorrect="off"

     

       38
       38
       +
             autocomplete="off"

     

       39
       39
       +
             type="text"

     

       40
       40
       +
             id="member-did-{{ .Id }}"

     

       41
       41
       +
             name="member"

     

       42
       42
       +
             required

     

       43
       43
       +
             placeholder="user.tngl.sh"

     

       44
       44
       +
             class="w-full"

     

       45
       45
       +
           />

     

       46
       46
       +
         </actor-typeahead>

     

       42
       47
        
         <div class="flex gap-2 pt-2">

     

       43
       48
        
           <button 

     

       44
       49
        
             type="button"

     
···

       57
       62
        
         </div>

     

       58
       63
        
         <div id="add-member-error-{{ .Id }}" class="text-red-500 dark:text-red-400"></div>

     

       59
       64
        
       </form>

     

       60
       60
       -
       {{ end }}
     

       65
       65
       +
       {{ end }}

+3 -3

appview/pages/templates/knots/fragments/knotListing.html

···

       7
       7
        
       

     

       8
       8
        
       {{ define "knotLeftSide" }}

     

       9
       9
        
         {{ if .Registered }}

     

       10
       10
       -
         <a href="/knots/{{ .Domain }}" class="hover:no-underline flex items-center gap-2 min-w-0 max-w-[60%]">

     

       10
       10
       +
         <a href="/settings/knots/{{ .Domain }}" class="hover:no-underline flex items-center gap-2 min-w-0 max-w-[60%]">

     

       11
       11
        
           {{ i "hard-drive" "w-4 h-4" }}

     

       12
       12
        
           <span class="hover:underline">

     

       13
       13
        
             {{ .Domain }}

     
···

       56
       56
        
         <button

     

       57
       57
        
           class="btn text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 gap-2 group"

     

       58
       58
        
           title="Delete knot"

     

       59
       59
       -
           hx-delete="/knots/{{ .Domain }}"

     

       59
       59
       +
           hx-delete="/settings/knots/{{ .Domain }}"

     

       60
       60
        
           hx-swap="outerHTML"

     

       61
       61
        
           hx-target="#knot-{{.Id}}"

     

       62
       62
        
           hx-confirm="Are you sure you want to delete the knot '{{ .Domain }}'?"

     
···

       72
       72
        
         <button

     

       73
       73
        
           class="btn gap-2 group"

     

       74
       74
        
           title="Retry knot verification"

     

       75
       75
       -
           hx-post="/knots/{{ .Domain }}/retry"

     

       75
       75
       +
           hx-post="/settings/knots/{{ .Domain }}/retry"

     

       76
       76
        
           hx-swap="none"

     

       77
       77
        
           hx-target="#knot-{{.Id}}"

     

       78
       78
        
         >

+42 -11

appview/pages/templates/knots/index.html

···

       1
       1
       -
       {{ define "title" }}knots{{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ .Tab }} settings{{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "content" }}

     

       4
       4
       -
       <div class="px-6 py-4 flex items-center justify-between gap-4 align-bottom">

     

       5
       5
       -
         <h1 class="text-xl font-bold dark:text-white">Knots</h1>

     

       6
       6
       -
         <span class="flex items-center gap-1">

     

       7
       7
       -
             {{ i "book" "w-3 h-3" }}

     

       8
       8
       -
             <a href="https://tangled.org/@tangled.org/core/blob/master/docs/knot-hosting.md">docs</a>

     

       9
       9
       -
         </span>

     

       10
       10
       -
       </div>

     

       4
       4
       +
         <div class="p-6">

     

       5
       5
       +
           <p class="text-xl font-bold dark:text-white">Settings</p>

     

       6
       6
       +
         </div>

     

       7
       7
       +
         <div class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       8
       8
       +
           <section class="w-full grid grid-cols-1 md:grid-cols-4 gap-6">

     

       9
       9
       +
             <div class="col-span-1">

     

       10
       10
       +
               {{ template "user/settings/fragments/sidebar" . }}

     

       11
       11
       +
             </div>

     

       12
       12
       +
             <div class="col-span-1 md:col-span-3 flex flex-col gap-6">

     

       13
       13
       +
               {{ template "knotsList" . }}

     

       14
       14
       +
             </div>

     

       15
       15
       +
           </section>

     

       16
       16
       +
         </div>

     

       17
       17
       +
       {{ end }}

     

       18
       18
       +
       

     

       19
       19
       +
       {{ define "knotsList" }}

     

       20
       20
       +
         <div class="grid grid-cols-1 md:grid-cols-3 gap-4 items-center">

     

       21
       21
       +
           <div class="col-span-1 md:col-span-2">

     

       22
       22
       +
             <h2 class="text-sm pb-2 uppercase font-bold">Knots</h2>

     

       23
       23
       +
             {{ block "about" . }} {{ end }}

     

       24
       24
       +
           </div>

     

       25
       25
       +
           <div class="col-span-1 md:col-span-1 md:justify-self-end">

     

       26
       26
       +
             {{ template "docsButton" . }}

     

       27
       27
       +
           </div>

     

       28
       28
       +
         </div>

     

       11
       29
        
       

     

       12
       12
       -
       <section class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       30
       30
       +
       <section>

     

       13
       31
        
         <div class="flex flex-col gap-6">

     

       14
       14
       -
           {{ block "about" . }} {{ end }}

     

       15
       32
        
           {{ block "list" . }} {{ end }}

     

       16
       33
        
           {{ block "register" . }} {{ end }}

     

       17
       34
        
         </div>

     
···

       50
       67
        
           <h2 class="text-sm font-bold py-2 uppercase dark:text-gray-300">register a knot</h2>

     

       51
       68
        
           <p class="mb-2 dark:text-gray-300">Enter the hostname of your knot to get started.</p>

     

       52
       69
        
           <form

     

       53
       53
       -
             hx-post="/knots/register"

     

       70
       70
       +
             hx-post="/settings/knots/register"

     

       54
       71
        
             class="max-w-2xl mb-2 space-y-4"

     

       55
       72
        
             hx-indicator="#register-button"

     

       56
       73
        
             hx-swap="none"

     
···

       84
       101
        
       

     

       85
       102
        
         </section>

     

       86
       103
        
       {{ end }}

     

       104
       104
       +
       

     

       105
       105
       +
       {{ define "docsButton" }}

     

       106
       106
       +
       <a

     

       107
       107
       +
       class="btn flex items-center gap-2"

     

       108
       108
       +
       href="https://tangled.org/@tangled.org/core/blob/master/docs/spindle/hosting.md">

     

       109
       109
       +
       {{ i "book" "size-4" }}

     

       110
       110
       +
       docs

     

       111
       111
       +
       </a>

     

       112
       112
       +
       <div

     

       113
       113
       +
       id="add-email-modal"

     

       114
       114
       +
       popover

     

       115
       115
       +
       class="bg-white w-full md:w-96 dark:bg-gray-800 p-4 rounded border border-gray-200 dark:border-gray-700 drop-shadow dark:text-white backdrop:bg-gray-400/50 dark:backdrop:bg-gray-800/50">

     

       116
       116
       +
       </div>

     

       117
       117
       +
       {{ end }}

appview/pages/templates/layouts/base.html

···

       9
       9
        
       

     

       10
       10
        
                   <script defer src="/static/htmx.min.js"></script>

     

       11
       11
        
                   <script defer src="/static/htmx-ext-ws.min.js"></script>

     

       12
       12
       +
                   <script defer src="/static/actor-typeahead.js" type="module"></script>

     

       12
       13
        
       

     

       13
       14
        
                   <!-- preconnect to image cdn -->

     

       14
       15
        
                   <link rel="preconnect" href="https://avatar.tangled.sh" />

-2

appview/pages/templates/layouts/fragments/topbar.html

···

       61
       61
        
               <a href="/{{ $user }}">profile</a>

     

       62
       62
        
               <a href="/{{ $user }}?tab=repos">repositories</a>

     

       63
       63
        
               <a href="/{{ $user }}?tab=strings">strings</a>

     

       64
       64
       -
               <a href="/knots">knots</a>

     

       65
       65
       -
               <a href="/spindles">spindles</a>

     

       66
       64
        
               <a href="/settings">settings</a>

     

       67
       65
        
               <a href="#"

     

       68
       66
        
                  hx-post="/logout"

+8 -7

appview/pages/templates/layouts/profilebase.html

···

       1
       1
       -
       {{ define "title" }}{{ or .Card.UserHandle .Card.UserDid }}{{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ resolve .Card.UserDid }}{{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "extrameta" }}

     

       4
       4
       -
           {{ $avatarUrl := fullAvatar .Card.UserHandle }}

     

       5
       5
       -
           <meta property="og:title" content="{{ or .Card.UserHandle .Card.UserDid }}" />

     

       4
       4
       +
           {{ $handle := resolve .Card.UserDid }}

     

       5
       5
       +
           {{ $avatarUrl := fullAvatar $handle }}

     

       6
       6
       +
           <meta property="og:title" content="{{ $handle }}" />

     

       6
       7
        
           <meta property="og:type" content="profile" />

     

       7
       7
       -
           <meta property="og:url" content="https://tangled.org/{{ or .Card.UserHandle .Card.UserDid }}?tab={{ .Active }}" />

     

       8
       8
       -
           <meta property="og:description" content="{{ or .Card.Profile.Description .Card.UserHandle .Card.UserDid }}" />

     

       8
       8
       +
           <meta property="og:url" content="https://tangled.org/{{ $handle }}?tab={{ .Active }}" />

     

       9
       9
       +
           <meta property="og:description" content="{{ or .Card.Profile.Description $handle }}" />

     

       9
       10
        
           <meta property="og:image" content="{{ $avatarUrl }}" />

     

       10
       11
        
           <meta property="og:image:width" content="512" />

     

       11
       12
        
           <meta property="og:image:height" content="512" />

     

       12
       13
        
           

     

       13
       14
        
           <meta name="twitter:card" content="summary" />

     

       14
       14
       -
           <meta name="twitter:title" content="{{ or .Card.UserHandle .Card.UserDid }}" />

     

       15
       15
       -
           <meta name="twitter:description" content="{{ or .Card.Profile.Description .Card.UserHandle .Card.UserDid }}" />

     

       15
       15
       +
           <meta name="twitter:title" content="{{ $handle }}" />

     

       16
       16
       +
           <meta name="twitter:description" content="{{ or .Card.Profile.Description $handle }}" />

     

       16
       17
        
           <meta name="twitter:image" content="{{ $avatarUrl }}" />

     

       17
       18
        
       {{ end }}

     

       18
       19

+4 -1

appview/pages/templates/layouts/repobase.html

···

       49
       49
        
               </div>

     

       50
       50
        
       

     

       51
       51
        
               <div class="w-full sm:w-fit grid grid-cols-3 gap-2 z-auto">

     

       52
       52
       -
                 {{ template "repo/fragments/repoStar" .RepoInfo }}

     

       52
       52
       +
                 {{ template "fragments/starBtn"

     

       53
       53
       +
                   (dict "SubjectAt" .RepoInfo.RepoAt

     

       54
       54
       +
                         "IsStarred" .RepoInfo.IsStarred

     

       55
       55
       +
                         "StarCount" .RepoInfo.Stats.StarCount) }}

     

       53
       56
        
                 <a

     

       54
       57
        
                   class="btn text-sm no-underline hover:no-underline flex items-center gap-2 group"

     

       55
       58
        
                   hx-boost="true"

+64 -39

appview/pages/templates/repo/blob.html

···

       11
       11
        
       {{ end }}

     

       12
       12
        
       

     

       13
       13
        
       {{ define "repoContent" }}

     

       14
       14
       -
           {{ $lines := split .Contents }}

     

       15
       15
       -
           {{ $tot_lines := len $lines }}

     

       16
       16
       -
           {{ $tot_chars := len (printf "%d" $tot_lines) }}

     

       17
       17
       -
           {{ $code_number_style := "text-gray-400 dark:text-gray-500 left-0 bg-white dark:bg-gray-800 text-right mr-6 select-none inline-block w-12" }}

     

       18
       14
        
           {{ $linkstyle := "no-underline hover:underline" }}

     

       19
       15
        
           <div class="pb-2 mb-3 text-base border-b border-gray-200 dark:border-gray-700">

     

       20
       16
        
               <div class="flex flex-col md:flex-row md:justify-between gap-2">

     
···

       36
       32
        
                   </div>

     

       37
       33
        
                   <div id="file-info" class="text-gray-500 dark:text-gray-400 text-xs md:text-sm flex flex-wrap items-center gap-1 md:gap-0">

     

       38
       34
        
                       <span>at <a href="/{{ .RepoInfo.FullName }}/tree/{{ .Ref }}">{{ .Ref }}</a></span>

     

       39
       39
       -
                       <span class="select-none px-1 md:px-2 [&:before]:content-['·']"></span>

     

       40
       40
       -
                       <span>{{ .Lines }} lines</span>

     

       41
       41
       -
                       <span class="select-none px-1 md:px-2 [&:before]:content-['·']"></span>

     

       42
       42
       -
                       <span>{{ byteFmt .SizeHint }}</span>

     

       43
       43
       -
                       <span class="select-none px-1 md:px-2 [&:before]:content-['·']"></span>

     

       44
       44
       -
                       <a href="/{{ .RepoInfo.FullName }}/raw/{{ .Ref }}/{{ .Path }}">view raw</a>

     

       45
       45
       -
                       {{ if .RenderToggle }}

     

       46
       46
       -
                       <span class="select-none px-1 md:px-2 [&:before]:content-['·']"></span>

     

       47
       47
       -
                       <a

     

       48
       48
       -
                       href="/{{ .RepoInfo.FullName }}/blob/{{ .Ref }}/{{ .Path }}?code={{ .ShowRendered }}"

     

       49
       49
       -
                       hx-boost="true"

     

       50
       50
       -
                       >view {{ if .ShowRendered }}code{{ else }}rendered{{ end }}</a>

     

       35
       35
       +
       

     

       36
       36
       +
                       {{ if .BlobView.ShowingText }}

     

       37
       37
       +
                         <span class="select-none px-1 md:px-2 [&:before]:content-['·']"></span>

     

       38
       38
       +
                         <span>{{ .Lines }} lines</span>

     

       39
       39
       +
                       {{ end }}

     

       40
       40
       +
       

     

       41
       41
       +
                       {{ if .BlobView.SizeHint }}

     

       42
       42
       +
                         <span class="select-none px-1 md:px-2 [&:before]:content-['·']"></span>

     

       43
       43
       +
                         <span>{{ byteFmt .BlobView.SizeHint }}</span>

     

       44
       44
       +
                       {{ end }}

     

       45
       45
       +
       

     

       46
       46
       +
                       {{ if .BlobView.HasRawView }}

     

       47
       47
       +
                         <span class="select-none px-1 md:px-2 [&:before]:content-['·']"></span>

     

       48
       48
       +
                         <a href="/{{ .RepoInfo.FullName }}/raw/{{ .Ref }}/{{ .Path }}">view raw</a>

     

       49
       49
       +
                       {{ end }}

     

       50
       50
       +
       

     

       51
       51
       +
                       {{ if .BlobView.ShowToggle }}

     

       52
       52
       +
                         <span class="select-none px-1 md:px-2 [&:before]:content-['·']"></span>

     

       53
       53
       +
                         <a href="/{{ .RepoInfo.FullName }}/blob/{{ .Ref }}/{{ .Path }}?code={{ .BlobView.ShowingRendered }}" hx-boost="true">

     

       54
       54
       +
                           view {{ if .BlobView.ShowingRendered }}code{{ else }}rendered{{ end }}

     

       55
       55
       +
                         </a>

     

       51
       56
        
                       {{ end }}

     

       52
       57
        
                   </div>

     

       53
       58
        
               </div>

     

       54
       59
        
           </div>

     

       55
       55
       -
           {{ if and .IsBinary .Unsupported }}

     

       56
       56
       -
               <p class="text-center text-gray-400 dark:text-gray-500">

     

       57
       57
       -
                   Previews are not supported for this file type.

     

       58
       58
       -
               </p>

     

       59
       59
       -
           {{ else if .IsBinary }}

     

       60
       60
       -
               <div class="text-center">

     

       61
       61
       -
                   {{ if .IsImage }}

     

       62
       62
       -
                       <img src="{{ .ContentSrc }}"

     

       63
       63
       -
                            alt="{{ .Path }}"

     

       64
       64
       -
                            class="max-w-full h-auto mx-auto border border-gray-200 dark:border-gray-700 rounded" />

     

       65
       65
       -
                   {{ else if .IsVideo }}

     

       66
       66
       -
                       <video controls class="max-w-full h-auto mx-auto border border-gray-200 dark:border-gray-700 rounded">

     

       67
       67
       -
                           <source src="{{ .ContentSrc }}">

     

       68
       68
       -
                           Your browser does not support the video tag.

     

       69
       69
       -
                       </video>

     

       70
       70
       -
                   {{ end }}

     

       71
       71
       -
               </div>

     

       72
       72
       -
           {{ else }}

     

       73
       73
       -
           <div class="overflow-auto relative">

     

       74
       74
       -
               {{ if .ShowRendered }}

     

       75
       75
       -
               <div id="blob-contents" class="prose dark:prose-invert">{{ .RenderedContents }}</div>

     

       60
       60
       +
           {{ if .BlobView.IsUnsupported }}

     

       61
       61
       +
             <p class="text-center text-gray-400 dark:text-gray-500">

     

       62
       62
       +
                 Previews are not supported for this file type.

     

       63
       63
       +
             </p>

     

       64
       64
       +
           {{ else if .BlobView.ContentType.IsSubmodule }}

     

       65
       65
       +
             <p class="text-center text-gray-400 dark:text-gray-500">

     

       66
       66
       +
               This directory is a git submodule of <a href="{{ .BlobView.ContentSrc }}">{{ .BlobView.ContentSrc }}</a>.

     

       67
       67
       +
             </p>

     

       68
       68
       +
           {{ else if .BlobView.ContentType.IsImage }}

     

       69
       69
       +
             <div class="text-center">

     

       70
       70
       +
               <img src="{{ .BlobView.ContentSrc }}"

     

       71
       71
       +
                    alt="{{ .Path }}"

     

       72
       72
       +
                    class="max-w-full h-auto mx-auto border border-gray-200 dark:border-gray-700 rounded" />

     

       73
       73
       +
             </div>

     

       74
       74
       +
           {{ else if .BlobView.ContentType.IsVideo }}

     

       75
       75
       +
             <div class="text-center">

     

       76
       76
       +
               <video controls class="max-w-full h-auto mx-auto border border-gray-200 dark:border-gray-700 rounded">

     

       77
       77
       +
                   <source src="{{ .BlobView.ContentSrc }}">

     

       78
       78
       +
                   Your browser does not support the video tag.

     

       79
       79
       +
               </video>

     

       80
       80
       +
             </div>

     

       81
       81
       +
           {{ else if .BlobView.ContentType.IsSvg }}

     

       82
       82
       +
             <div class="overflow-auto relative">

     

       83
       83
       +
               {{ if .BlobView.ShowingRendered }}

     

       84
       84
       +
                 <div class="text-center">

     

       85
       85
       +
                   <img src="{{ .BlobView.ContentSrc }}"

     

       86
       86
       +
                        alt="{{ .Path }}"

     

       87
       87
       +
                        class="max-w-full h-auto mx-auto border border-gray-200 dark:border-gray-700 rounded" />

     

       88
       88
       +
                 </div>

     

       89
       89
       +
               {{ else }}

     

       90
       90
       +
                 <div id="blob-contents" class="whitespace-pre peer-target:bg-yellow-200 dark:peer-target:bg-yellow-900">{{ code .BlobView.Contents .Path | escapeHtml }}</div>

     

       91
       91
       +
               {{ end }}

     

       92
       92
       +
             </div>

     

       93
       93
       +
           {{ else if .BlobView.ContentType.IsMarkup }}

     

       94
       94
       +
             <div class="overflow-auto relative">

     

       95
       95
       +
               {{ if .BlobView.ShowingRendered }}

     

       96
       96
       +
                 <div id="blob-contents" class="prose dark:prose-invert">{{ .BlobView.Contents | readme }}</div>

     

       76
       97
        
               {{ else }}

     

       77
       77
       -
               <div id="blob-contents" class="whitespace-pre peer-target:bg-yellow-200 dark:peer-target:bg-yellow-900">{{ $.Contents | escapeHtml }}</div>

     

       98
       98
       +
                 <div id="blob-contents" class="whitespace-pre peer-target:bg-yellow-200 dark:peer-target:bg-yellow-900">{{ code .BlobView.Contents .Path | escapeHtml }}</div>

     

       78
       99
        
               {{ end }}

     

       79
       79
       -
           </div>

     

       100
       100
       +
             </div>

     

       101
       101
       +
           {{ else if .BlobView.ContentType.IsCode }}

     

       102
       102
       +
             <div class="overflow-auto relative">

     

       103
       103
       +
               <div id="blob-contents" class="whitespace-pre peer-target:bg-yellow-200 dark:peer-target:bg-yellow-900">{{ code .BlobView.Contents .Path | escapeHtml }}</div>

     

       104
       104
       +
             </div>

     

       80
       105
        
           {{ end }}

     

       81
       106
        
           {{ template "fragments/multiline-select" }}

     

       82
       107
        
       {{ end }}

+35 -10

appview/pages/templates/repo/commit.html

···

       25
       25
        
         </div>

     

       26
       26
        
       

     

       27
       27
        
         <div class="flex flex-wrap items-center space-x-2">

     

       28
       28
       -
             <p class="flex flex-wrap items-center gap-2 text-sm text-gray-500 dark:text-gray-300">

     

       29
       29
       -
                 {{ $did := index $.EmailToDid $commit.Author.Email }}

     

       30
       30
       -
       

     

       31
       31
       -
                 {{ if $did }}

     

       32
       32
       -
                   {{ template "user/fragments/picHandleLink" $did }}

     

       33
       33
       -
                 {{ else }}

     

       34
       34
       -
                   <a href="mailto:{{ $commit.Author.Email }}" class="no-underline hover:underline text-gray-500 dark:text-gray-300">{{ $commit.Author.Name }}</a>

     

       35
       35
       -
                 {{ end }}

     

       28
       28
       +
             <p class="flex flex-wrap items-center gap-1 text-sm text-gray-500 dark:text-gray-300">

     

       29
       29
       +
                 {{ template "attribution" . }}

     

       36
       30
        
       

     

       37
       31
        
                 <span class="px-1 select-none before:content-['\00B7']"></span>

     

       38
       38
       -
                 {{ template "repo/fragments/time" $commit.Author.When }}

     

       32
       32
       +
                   {{ template "repo/fragments/time" $commit.Committer.When }}

     

       39
       33
        
                 <span class="px-1 select-none before:content-['\00B7']"></span>

     

       40
       34
        
       

     

       41
       35
        
                 <a href="/{{ $repo }}/commit/{{ $commit.This }}" class="no-underline hover:underline text-gray-500 dark:text-gray-300">{{ slice $commit.This 0 8 }}</a>

     
···

       79
       73
        
       </section>

     

       80
       74
        
       {{end}}

     

       81
       75
        
       

     

       76
       76
       +
       {{ define "attribution" }}

     

       77
       77
       +
         {{ $commit := .Diff.Commit }}

     

       78
       78
       +
         {{ $showCommitter := true }}

     

       79
       79
       +
         {{ if eq $commit.Author.Email $commit.Committer.Email }}

     

       80
       80
       +
           {{ $showCommitter = false }}

     

       81
       81
       +
         {{ end }}

     

       82
       82
       +
       

     

       83
       83
       +
         {{ if $showCommitter }}

     

       84
       84
       +
           authored by {{ template "attributedUser" (list $commit.Author.Email $commit.Author.Name $.EmailToDid) }}

     

       85
       85
       +
           {{ range $commit.CoAuthors }} 

     

       86
       86
       +
             {{ template "attributedUser" (list .Email .Name $.EmailToDid) }}

     

       87
       87
       +
           {{ end }}

     

       88
       88
       +
           and committed by  {{ template "attributedUser" (list $commit.Committer.Email $commit.Committer.Name $.EmailToDid) }}

     

       89
       89
       +
         {{ else }}

     

       90
       90
       +
           {{ template "attributedUser" (list $commit.Author.Email $commit.Author.Name $.EmailToDid )}}

     

       91
       91
       +
         {{ end }}

     

       92
       92
       +
       {{ end }}

     

       93
       93
       +
       

     

       94
       94
       +
       {{ define "attributedUser" }}

     

       95
       95
       +
         {{ $email := index . 0 }}

     

       96
       96
       +
         {{ $name := index . 1 }}

     

       97
       97
       +
         {{ $map := index . 2 }}

     

       98
       98
       +
         {{ $did := index $map $email }}

     

       99
       99
       +
       

     

       100
       100
       +
         {{ if $did }}

     

       101
       101
       +
           {{ template "user/fragments/picHandleLink" $did }}

     

       102
       102
       +
         {{ else }}

     

       103
       103
       +
           <a href="mailto:{{ $email }}" class="no-underline hover:underline text-gray-500 dark:text-gray-300">{{ $name }}</a>

     

       104
       104
       +
         {{ end }}

     

       105
       105
       +
       {{ end }}

     

       106
       106
       +
       

     

       82
       107
        
       {{ define "topbarLayout" }}

     

       83
       108
        
         <header class="col-span-full" style="z-index: 20;">

     

       84
       109
        
           {{ template "layouts/fragments/topbar" . }}

     
···

       111
       136
        
       {{ end }}

     

       112
       137
        
       

     

       113
       138
        
       {{ define "contentAfter" }}

     

       114
       114
       -
         {{ template "repo/fragments/diff" (list .RepoInfo.FullName .Diff .DiffOpts) }}

     

       139
       139
       +
         {{ template "repo/fragments/diff" (list .Diff .DiffOpts) }}

     

       115
       140
        
       {{end}}

     

       116
       141
        
       

     

       117
       142
        
       {{ define "contentAfterLeft" }}

+2 -2

appview/pages/templates/repo/compare/compare.html

···

       17
       17
        
       {{ end }}

     

       18
       18
        
       

     

       19
       19
        
       {{ define "mainLayout" }}

     

       20
       20
       -
         <div class="px-1 col-span-full flex flex-col gap-4">

     

       20
       20
       +
         <div class="px-1 flex-grow col-span-full flex flex-col gap-4">

     

       21
       21
        
           {{ block "contentLayout" . }}

     

       22
       22
        
             {{ block "content" . }}{{ end }}

     

       23
       23
        
           {{ end }}

     
···

       42
       42
        
       {{ end }}

     

       43
       43
        
       

     

       44
       44
        
       {{ define "contentAfter" }}

     

       45
       45
       -
         {{ template "repo/fragments/diff" (list .RepoInfo.FullName .Diff .DiffOpts) }}

     

       45
       45
       +
         {{ template "repo/fragments/diff" (list .Diff .DiffOpts) }}

     

       46
       46
        
       {{end}}

     

       47
       47
        
       

     

       48
       48
        
       {{ define "contentAfterLeft" }}

+1 -1

appview/pages/templates/repo/empty.html

···

       35
       35
        
       

     

       36
       36
        
                 <p><span class="{{$bullet}}">1</span>First, generate a new <a href="https://git-scm.com/book/en/v2/Git-on-the-Server-Generating-Your-SSH-Public-Key" class="underline">SSH key pair</a>.</p>

     

       37
       37
        
                 <p><span class="{{$bullet}}">2</span>Then add the public key to your account from the <a href="/settings" class="underline">settings</a> page.</p>

     

       38
       38
       -
                 <p><span class="{{$bullet}}">3</span>Configure your remote to <code>git@{{ $knot | stripPort }}:{{ .RepoInfo.OwnerHandle }}/{{ .RepoInfo.Name }}</code></p>

     

       38
       38
       +
                 <p><span class="{{$bullet}}">3</span>Configure your remote to <code>git@{{ $knot | stripPort }}:{{ resolve .RepoInfo.OwnerDid }}/{{ .RepoInfo.Name }}</code></p>

     

       39
       39
        
                 <p><span class="{{$bullet}}">4</span>Push!</p>

     

       40
       40
        
               </div>

     

       41
       41
        
             </div>

+2 -1

appview/pages/templates/repo/fork.html

···

       25
       25
        
                       value="{{ . }}"

     

       26
       26
        
                       class="mr-2"

     

       27
       27
        
                       id="domain-{{ . }}"

     

       28
       28
       +
                       {{if eq (len $.Knots) 1}}checked{{end}}                

     

       28
       29
        
                       />

     

       29
       30
        
                   <label for="domain-{{ . }}" class="dark:text-white">{{ . }}</label>

     

       30
       31
        
                 </div>

     
···

       33
       34
        
               {{ end }}

     

       34
       35
        
               </div>

     

       35
       36
        
             </div>

     

       36
       36
       -
             <p class="text-sm text-gray-500 dark:text-gray-400">A knot hosts repository data. <a href="/knots" class="underline">Learn how to register your own knot.</a></p>

     

       37
       37
       +
             <p class="text-sm text-gray-500 dark:text-gray-400">A knot hosts repository data. <a href="/settings/knots" class="underline">Learn how to register your own knot.</a></p>

     

       37
       38
        
           </fieldset>

     

       38
       39
        
       

     

       39
       40
        
           <div class="space-y-2">

+3 -2

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

···

       43
       43
        
       

     

       44
       44
        
                       <!-- SSH Clone -->

     

       45
       45
        
                       <div class="mb-3">

     

       46
       46
       +
                           {{ $repoOwnerHandle := resolve .RepoInfo.OwnerDid }}

     

       46
       47
        
                           <label class="block text-xs font-medium text-gray-700 dark:text-gray-300 mb-1">SSH</label>

     

       47
       48
        
                           <div class="flex items-center border border-gray-300 dark:border-gray-600 rounded">

     

       48
       49
        
                               <code

     

       49
       50
        
                                   class="flex-1 px-3 py-2 text-sm bg-gray-50 dark:bg-gray-700 text-gray-900 dark:text-gray-100 rounded-l select-all cursor-pointer whitespace-nowrap overflow-x-auto"

     

       50
       51
        
                                   onclick="window.getSelection().selectAllChildren(this)"

     

       51
       51
       -
                                   data-url="git@{{ $knot | stripPort }}:{{ .RepoInfo.OwnerHandle }}/{{ .RepoInfo.Name }}"

     

       52
       52
       -
                               >git@{{ $knot | stripPort }}:{{ .RepoInfo.OwnerHandle }}/{{ .RepoInfo.Name }}</code>

     

       52
       52
       +
                                   data-url="git@{{ $knot | stripPort }}:{{ $repoOwnerHandle }}/{{ .RepoInfo.Name }}"

     

       53
       53
       +
                               >git@{{ $knot | stripPort }}:{{ $repoOwnerHandle }}/{{ .RepoInfo.Name }}</code>

     

       53
       54
        
                               <button

     

       54
       55
        
                                   onclick="copyToClipboard(this, this.previousElementSibling.getAttribute('data-url'))"

     

       55
       56
        
                                   class="px-3 py-2 text-gray-500 hover:text-gray-700 dark:text-gray-400 dark:hover:text-gray-200 border-l border-gray-300 dark:border-gray-600"

+2 -3

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

···

       1
       1
        
       {{ define "repo/fragments/diff" }}

     

       2
       2
       -
         {{ $repo := index . 0 }}

     

       3
       3
       -
         {{ $diff := index . 1 }}

     

       4
       4
       -
         {{ $opts := index . 2 }}

     

       2
       2
       +
         {{ $diff := index . 0 }}

     

       3
       3
       +
         {{ $opts := index . 1 }}

     

       5
       4
        
       

     

       6
       5
        
         {{ $commit := $diff.Commit }}

     

       7
       6
        
         {{ $diff := $diff.Diff }}

+15 -1

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

···

       170
       170
        
         {{ $fieldName := $def.AtUri }}

     

       171
       171
        
         {{ $valueType := $def.ValueType }}

     

       172
       172
        
         {{ $value := .value }}

     

       173
       173
       +
       

     

       173
       174
        
         {{ if $valueType.IsDidFormat }}

     

       174
       175
        
           {{ $value = trimPrefix (resolve .value) "@" }}

     

       176
       176
       +
           <actor-typeahead>

     

       177
       177
       +
             <input

     

       178
       178
       +
               autocapitalize="none"

     

       179
       179
       +
               autocorrect="off"

     

       180
       180
       +
               autocomplete="off"

     

       181
       181
       +
               placeholder="user.tngl.sh"

     

       182
       182
       +
               value="{{$value}}"

     

       183
       183
       +
               name="{{$fieldName}}"

     

       184
       184
       +
               type="text"

     

       185
       185
       +
               class="p-1 w-full text-sm"

     

       186
       186
       +
             />

     

       187
       187
       +
           </actor-typeahead>

     

       188
       188
       +
         {{ else }}

     

       189
       189
       +
           <input class="p-1 w-full" type="text" name="{{$fieldName}}" value="{{$value}}">

     

       175
       190
        
         {{ end }}

     

       176
       176
       -
         <input class="p-1 w-full" type="text" name="{{$fieldName}}" value="{{$value}}">

     

       177
       191
        
       {{ end }}

     

       178
       192
        
       

     

       179
       193
        
       {{ define "nullTypeInput" }}

+1 -16

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

···

       6
       6
        
             <span class="font-bold text-gray-500 dark:text-gray-400 capitalize">Participants</span>

     

       7
       7
        
             <span class="bg-gray-200 dark:bg-gray-700 rounded py-1/2 px-1 ml-1">{{ len $all }}</span>

     

       8
       8
        
           </div>

     

       9
       9
       -
           <div class="flex items-center -space-x-3 mt-2">

     

       10
       10
       -
             {{ $c := "z-50 z-40 z-30 z-20 z-10" }}

     

       11
       11
       -
             {{ range $i, $p := $ps }}

     

       12
       12
       -
               <img

     

       13
       13
       -
                   src="{{ tinyAvatar . }}"

     

       14
       14
       -
                   alt=""

     

       15
       15
       -
                   class="rounded-full h-8 w-8 mr-1 border-2 border-gray-100 dark:border-gray-900 z-{{sub 5 $i}}0"

     

       16
       16
       -
               />

     

       17
       17
       -
             {{ end }}

     

       18
       18
       -
       

     

       19
       19
       -
             {{ if gt (len $all) 5 }}

     

       20
       20
       -
               <span class="pl-4 text-gray-500 dark:text-gray-400 text-sm">

     

       21
       21
       -
                 +{{ sub (len $all) 5 }}

     

       22
       22
       -
               </span>

     

       23
       23
       -
             {{ end }}

     

       24
       24
       -
           </div>

     

       9
       9
       +
           {{ template "fragments/tinyAvatarList" (dict "all" $all "classes" "w-8 h-8") }}

     

       25
       10
        
         </div>

     

       26
       11
        
       {{ end }}

-26

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

···

       1
       1
       -
       {{ define "repo/fragments/repoStar" }}

     

       2
       2
       -
           <button

     

       3
       3
       -
               id="starBtn"

     

       4
       4
       -
               class="btn disabled:opacity-50 disabled:cursor-not-allowed flex gap-2 items-center group"

     

       5
       5
       -
               {{ if .IsStarred }}

     

       6
       6
       -
                   hx-delete="/star?subject={{ .RepoAt }}&countHint={{ .Stats.StarCount }}"

     

       7
       7
       -
               {{ else }}

     

       8
       8
       -
                   hx-post="/star?subject={{ .RepoAt }}&countHint={{ .Stats.StarCount }}"

     

       9
       9
       -
               {{ end }}

     

       10
       10
       -
       

     

       11
       11
       -
               hx-trigger="click"

     

       12
       12
       -
               hx-target="this"

     

       13
       13
       -
               hx-swap="outerHTML"

     

       14
       14
       -
               hx-disabled-elt="#starBtn"

     

       15
       15
       -
           >

     

       16
       16
       -
               {{ if .IsStarred }}

     

       17
       17
       -
                   {{ i "star" "w-4 h-4 fill-current" }}

     

       18
       18
       -
               {{ else }}

     

       19
       19
       -
                   {{ i "star" "w-4 h-4" }}

     

       20
       20
       -
               {{ end }}

     

       21
       21
       -
               <span class="text-sm">

     

       22
       22
       -
                   {{ .Stats.StarCount }}

     

       23
       23
       -
               </span>

     

       24
       24
       -
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       25
       25
       -
           </button>

     

       26
       26
       -
       {{ end }}

+39 -10

appview/pages/templates/repo/index.html

···

       14
       14
        
               {{ end }}

     

       15
       15
        
               <div class="flex items-center justify-between pb-5">

     

       16
       16
        
                 {{ block "branchSelector" . }}{{ end }}

     

       17
       17
       -
                 <div class="flex md:hidden items-center gap-2">

     

       17
       17
       +
                 <div class="flex md:hidden items-center gap-3">

     

       18
       18
        
                   <a href="/{{ .RepoInfo.FullName }}/commits/{{ .Ref | urlquery }}" class="inline-flex items-center text-sm gap-1 font-bold">

     

       19
       19
        
                     {{ i "git-commit-horizontal" "w-4" "h-4" }} {{ .TotalCommits }}

     

       20
       20
        
                   </a>

     
···

       35
       35
        
       {{ end }}

     

       36
       36
        
       

     

       37
       37
        
       {{ define "repoLanguages" }}

     

       38
       38
       -
           <details class="group -m-6 mb-4">

     

       38
       38
       +
           <details class="group -my-4 -m-6 mb-4">

     

       39
       39
        
             <summary class="flex gap-[1px] h-4 scale-y-50 hover:scale-y-100 origin-top group-open:scale-y-100 transition-all hover:cursor-pointer overflow-hidden rounded-t">

     

       40
       40
        
               {{ range $value := .Languages }}

     

       41
       41
        
               <div

     
···

       47
       47
        
             <div class="px-4 py-2 border-b border-gray-200 dark:border-gray-600 flex items-center gap-4 flex-wrap">

     

       48
       48
        
               {{ range $value := .Languages }}

     

       49
       49
        
               <div

     

       50
       50
       -
                 class="flex flex-grow items-center gap-2 text-xs align-items-center justify-center"

     

       50
       50
       +
                 class="flex items-center gap-2 text-xs align-items-center justify-center"

     

       51
       51
        
               >

     

       52
       52
        
                 {{ template "repo/fragments/colorBall" (dict "color" (langColor $value.Name)) }}

     

       53
       53
        
                 <div>{{ or $value.Name "Other" }}

     
···

       66
       66
        
       

     

       67
       67
        
       {{ define "branchSelector" }}

     

       68
       68
        
         <div class="flex gap-2 items-center justify-between w-full">

     

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

     

       69
       69
       +
           <div class="flex gap-2 items-stretch">

     

       70
       70
        
             <select

     

       71
       71
        
                 onchange="window.location.href = '/{{ .RepoInfo.FullName }}/tree/' + encodeURIComponent(this.value)"

     

       72
       72
        
                 class="p-1 border max-w-32 border-gray-200 bg-white dark:bg-gray-800 dark:text-white dark:border-gray-700"

     
···

       129
       129
        
                 {{ $icon := "folder" }}

     

       130
       130
        
                 {{ $iconStyle := "size-4 fill-current" }}

     

       131
       131
        
       

     

       132
       132
       +
                 {{ if .IsSubmodule }}

     

       133
       133
       +
                   {{ $link = printf "/%s/%s/%s/%s" $.RepoInfo.FullName "blob" (urlquery $.Ref) .Name }}

     

       134
       134
       +
                   {{ $icon = "folder-input" }}

     

       135
       135
       +
                   {{ $iconStyle = "size-4" }}

     

       136
       136
       +
                 {{ end }}

     

       137
       137
       +
       

     

       132
       138
        
                 {{ if .IsFile }}

     

       133
       139
        
                   {{ $link = printf "/%s/%s/%s/%s" $.RepoInfo.FullName "blob" (urlquery $.Ref) .Name }}

     

       134
       140
        
                   {{ $icon = "file" }}

     

       135
       141
        
                   {{ $iconStyle = "size-4" }}

     

       136
       142
        
                 {{ end }}

     

       143
       143
       +
       

     

       137
       144
        
                 <a href="{{ $link }}" class="{{ $linkstyle }}">

     

       138
       145
        
                   <div class="flex items-center gap-2">

     

       139
       146
        
                     {{ i $icon $iconStyle "flex-shrink-0" }}

     
···

       221
       228
        
               <span

     

       222
       229
        
                 class="mx-1 before:content-['·'] before:select-none"

     

       223
       230
        
                 ></span>

     

       224
       224
       -
               <span>

     

       225
       225
       -
                 {{ $did := index $.EmailToDid .Author.Email }}

     

       226
       226
       -
                 <a href="{{ if $did }}/{{ resolve $did }}{{ else }}mailto:{{ .Author.Email }}{{ end }}"

     

       227
       227
       -
                   class="text-gray-500 dark:text-gray-400 no-underline hover:underline"

     

       228
       228
       -
                   >{{ if $did }}{{ template "user/fragments/picHandleLink" $did }}{{ else }}{{ .Author.Name }}{{ end }}</a>

     

       229
       229
       -
               </span>

     

       231
       231
       +
               {{ template "attribution" (list . $.EmailToDid) }}

     

       230
       232
        
               <div class="inline-block px-1 select-none after:content-['·']"></div>

     

       231
       233
        
               {{ template "repo/fragments/time" .Committer.When }}

     

       232
       234
        
       

     
···

       252
       254
        
           {{ end }}

     

       253
       255
        
         </div>

     

       254
       256
        
       </div>

     

       257
       257
       +
       {{ end }}

     

       258
       258
       +
       

     

       259
       259
       +
       {{ define "attribution" }}

     

       260
       260
       +
         {{ $commit := index . 0 }}

     

       261
       261
       +
         {{ $map := index . 1 }}

     

       262
       262
       +
         <span class="flex items-center">

     

       263
       263
       +
           {{ $author := index $map $commit.Author.Email }}

     

       264
       264
       +
           {{ $coauthors := $commit.CoAuthors }}

     

       265
       265
       +
           {{ $all := list }}

     

       266
       266
       +
       

     

       267
       267
       +
           {{ if $author }}

     

       268
       268
       +
               {{ $all = append $all $author }}

     

       269
       269
       +
           {{ end }}

     

       270
       270
       +
           {{ range $coauthors }}

     

       271
       271
       +
             {{ $co := index $map .Email }}

     

       272
       272
       +
             {{ if $co }}

     

       273
       273
       +
               {{ $all = append $all $co }}

     

       274
       274
       +
             {{ end }}

     

       275
       275
       +
           {{ end }}

     

       276
       276
       +
       

     

       277
       277
       +
           {{ template "fragments/tinyAvatarList" (dict "all" $all "classes" "size-6") }}

     

       278
       278
       +
           <a href="{{ if $author }}/{{ $author }}{{ else }}mailto:{{ $commit.Author.Email }}{{ end }}"

     

       279
       279
       +
              class="no-underline hover:underline">

     

       280
       280
       +
              {{ if $author }}{{ resolve $author }}{{ else }}{{ $commit.Author.Name }}{{ end }}

     

       281
       281
       +
              {{ if $coauthors }} +{{ length $coauthors }}{{ end }}

     

       282
       282
       +
           </a>

     

       283
       283
       +
         </span>

     

       255
       284
        
       {{ end }}

     

       256
       285
        
       

     

       257
       286
        
       {{ define "branchList" }}

+125 -49

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

···

       27
       27
        
              "Meta" (string .RepoInfo.Stats.IssueCount.Closed)) }}

     

       28
       28
        
         {{ $values := list $open $closed }}

     

       29
       29
        
       

     

       30
       30
       -
         <div class="flex flex-col gap-2">

     

       31
       31
       -
           <div class="flex justify-between items-stretch gap-4">

     

       32
       32
       -
             <form class="flex flex-1 relative" method="GET">

     

       33
       33
       -
               <input type="hidden" name="state" value="{{ if .FilteringByOpen }}open{{ else }}closed{{ end }}">

     

       34
       34
       -
               <div class="absolute left-3 top-1/2 -translate-y-1/2 text-gray-400 pointer-events-none">

     

       35
       35
       -
                 {{ i "search" "w-4 h-4" }}

     

       36
       36
       -
               </div>

     

       37
       37
       -
               <input class="flex-1 p-1 pl-10 pr-10 peer" type="text" name="q" value="{{ .FilterQuery }}" placeholder=" ">

     

       38
       38
       -
               <a 

     

       30
       30
       +
         <div class="grid gap-2 grid-cols-[auto_1fr_auto] grid-row-2">

     

       31
       31
       +
           <form class="flex relative col-span-3 sm:col-span-1 sm:col-start-2" method="GET">

     

       32
       32
       +
             <input type="hidden" name="state" value="{{ if .FilteringByOpen }}open{{ else }}closed{{ end }}">

     

       33
       33
       +
             <div class="flex-1 flex relative">

     

       34
       34
       +
               <input

     

       35
       35
       +
                 id="search-q"

     

       36
       36
       +
                 class="flex-1 py-1 pl-2 pr-10 mr-[-1px] rounded-r-none focus:border-0 focus:outline-none focus:ring focus:ring-blue-400 ring-inset peer"

     

       37
       37
       +
                 type="text"

     

       38
       38
       +
                 name="q"

     

       39
       39
       +
                 value="{{ .FilterQuery }}"

     

       40
       40
       +
                 placeholder=" "

     

       41
       41
       +
               >

     

       42
       42
       +
               <a

     

       39
       43
        
                 href="?state={{ if .FilteringByOpen }}open{{ else }}closed{{ end }}"

     

       40
       44
        
                 class="absolute right-3 top-1/2 -translate-y-1/2 text-gray-400 hover:text-gray-600 dark:hover:text-gray-300 hidden peer-[:not(:placeholder-shown)]:block"

     

       41
       41
       -
                 >

     

       45
       45
       +
               >

     

       42
       46
        
                 {{ i "x" "w-4 h-4" }}

     

       43
       47
        
               </a>

     

       44
       44
       -
             </form>

     

       45
       45
       -
             <div class="hidden sm:block">

     

       46
       46
       -
               {{ template "fragments/tabSelector" (dict "Name" "state" "Values" $values "Active" $active) }}

     

       47
       48
        
             </div>

     

       48
       48
       -
             <a

     

       49
       49
       -
               href="/{{ .RepoInfo.FullName }}/issues/new"

     

       50
       50
       -
               class="btn-create text-sm flex items-center justify-center gap-2 no-underline hover:no-underline hover:text-white"

     

       51
       51
       -
               >

     

       52
       52
       -
               {{ i "circle-plus" "w-4 h-4" }}

     

       53
       53
       -
               <span>new</span>

     

       54
       54
       -
             </a>

     

       49
       49
       +
             <button

     

       50
       50
       +
               type="submit"

     

       51
       51
       +
               class="p-2 text-gray-400 border rounded-r border-gray-400 dark:border-gray-600"

     

       52
       52
       +
             >

     

       53
       53
       +
               {{ i "search" "w-4 h-4" }}

     

       54
       54
       +
             </button>

     

       55
       55
       +
           </form>

     

       56
       56
       +
           <div class="sm:row-start-1">

     

       57
       57
       +
             {{ template "fragments/tabSelector" (dict "Name" "state" "Values" $values "Active" $active "Include" "#search-q") }}

     

       55
       58
        
           </div>

     

       56
       56
       -
           <div class="sm:hidden">

     

       57
       57
       -
             {{ template "fragments/tabSelector" (dict "Name" "state" "Values" $values "Active" $active) }}

     

       58
       58
       -
           </div>

     

       59
       59
       +
           <a

     

       60
       60
       +
             href="/{{ .RepoInfo.FullName }}/issues/new"

     

       61
       61
       +
             class="col-start-3 btn-create text-sm flex items-center justify-center gap-2 no-underline hover:no-underline hover:text-white"

     

       62
       62
       +
           >

     

       63
       63
       +
             {{ i "circle-plus" "w-4 h-4" }}

     

       64
       64
       +
             <span>new</span>

     

       65
       65
       +
           </a>

     

       59
       66
        
         </div>

     

       60
       67
        
         <div class="error" id="issues"></div>

     

       61
       68
        
       {{ end }}

     
···

       64
       71
        
         <div class="mt-2">

     

       65
       72
        
           {{ template "repo/issues/fragments/issueListing" (dict "Issues" .Issues "RepoPrefix" .RepoInfo.FullName "LabelDefs" .LabelDefs) }}

     

       66
       73
        
         </div>

     

       67
       67
       -
         {{ block "pagination" . }} {{ end }}

     

       74
       74
       +
         {{if gt .IssueCount .Page.Limit }} 

     

       75
       75
       +
           {{ block "pagination" . }} {{ end }} 

     

       76
       76
       +
         {{ end }}

     

       68
       77
        
       {{ end }}

     

       69
       78
        
       

     

       70
       79
        
       {{ define "pagination" }}

     

       71
       71
       -
       <div class="flex justify-end mt-4 gap-2">

     

       72
       72
       -
           {{ $currentState := "closed" }}

     

       73
       73
       -
           {{ if .FilteringByOpen }}

     

       74
       74
       -
             {{ $currentState = "open" }}

     

       75
       75
       -
           {{ end }}

     

       80
       80
       +
       <div class="flex justify-center items-center mt-4 gap-2">

     

       81
       81
       +
         {{ $currentState := "closed" }}

     

       82
       82
       +
         {{ if .FilteringByOpen }}

     

       83
       83
       +
           {{ $currentState = "open" }}

     

       84
       84
       +
         {{ end }}

     

       85
       85
       +
       

     

       86
       86
       +
         {{ $prev := .Page.Previous.Offset }}

     

       87
       87
       +
         {{ $next := .Page.Next.Offset }}

     

       88
       88
       +
         {{ $lastPage := sub .IssueCount (mod .IssueCount .Page.Limit) }}

     

       76
       89
        
       

     

       90
       90
       +
         <a

     

       91
       91
       +
           class="

     

       92
       92
       +
             btn flex items-center gap-2 no-underline hover:no-underline 

     

       93
       93
       +
             dark:text-white dark:hover:bg-gray-700

     

       94
       94
       +
             {{ if le .Page.Offset 0 }}

     

       95
       95
       +
               cursor-not-allowed opacity-50

     

       96
       96
       +
             {{ end }}

     

       97
       97
       +
           "

     

       77
       98
        
           {{ if gt .Page.Offset 0 }}

     

       78
       78
       -
              {{ $prev := .Page.Previous }}

     

       79
       79
       -
               <a

     

       80
       80
       -
                   class="btn flex items-center gap-2 no-underline hover:no-underline dark:text-white dark:hover:bg-gray-700"

     

       81
       81
       -
                   hx-boost="true"

     

       82
       82
       -
                   href = "/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&q={{ .FilterQuery }}&offset={{ $prev.Offset }}&limit={{ $prev.Limit }}"

     

       83
       83
       -
               >

     

       84
       84
       -
                   {{ i "chevron-left" "w-4 h-4" }}

     

       85
       85
       -
                   previous

     

       86
       86
       -
               </a>

     

       87
       87
       -
           {{ else }}

     

       88
       88
       -
               <div></div>

     

       99
       99
       +
             hx-boost="true"

     

       100
       100
       +
             href = "/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&q={{ .FilterQuery }}&offset={{ $prev }}&limit={{ .Page.Limit }}"

     

       89
       101
        
           {{ end }}

     

       102
       102
       +
         >

     

       103
       103
       +
           {{ i "chevron-left" "w-4 h-4" }}

     

       104
       104
       +
           previous

     

       105
       105
       +
         </a>

     

       90
       106
        
       

     

       107
       107
       +
         <!-- dont show first page if current page is first page -->

     

       108
       108
       +
         {{ if gt .Page.Offset 0 }}

     

       109
       109
       +
           <a

     

       110
       110
       +
             hx-boost="true"

     

       111
       111
       +
             href = "/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&q={{ .FilterQuery }}&offset=0&limit={{ .Page.Limit }}"

     

       112
       112
       +
           >

     

       113
       113
       +
             1

     

       114
       114
       +
           </a>

     

       115
       115
       +
         {{ end }}

     

       116
       116
       +
       

     

       117
       117
       +
         <!-- if previous page is not first or second page (prev > limit) -->

     

       118
       118
       +
         {{ if gt $prev .Page.Limit }}

     

       119
       119
       +
           <span>...</span>

     

       120
       120
       +
         {{ end }}

     

       121
       121
       +
       

     

       122
       122
       +
         <!-- if previous page is not the first page -->

     

       123
       123
       +
         {{ if gt $prev 0 }}

     

       124
       124
       +
           <a

     

       125
       125
       +
             hx-boost="true"

     

       126
       126
       +
             href = "/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&q={{ .FilterQuery }}&offset={{ $prev }}&limit={{ .Page.Limit }}"

     

       127
       127
       +
           >

     

       128
       128
       +
             {{ add (div $prev .Page.Limit) 1 }}

     

       129
       129
       +
           </a>

     

       130
       130
       +
         {{ end }}

     

       131
       131
       +
       

     

       132
       132
       +
         <!-- current page. this is always visible -->

     

       133
       133
       +
         <span class="font-bold">

     

       134
       134
       +
           {{ add (div .Page.Offset .Page.Limit) 1 }}

     

       135
       135
       +
         </span>

     

       136
       136
       +
       

     

       137
       137
       +
         <!-- if next page is not last page -->

     

       138
       138
       +
         {{ if lt $next $lastPage }}

     

       139
       139
       +
           <a

     

       140
       140
       +
             hx-boost="true"

     

       141
       141
       +
             href = "/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&q={{ .FilterQuery }}&offset={{ $next }}&limit={{ .Page.Limit }}"

     

       142
       142
       +
           >

     

       143
       143
       +
             {{ add (div $next .Page.Limit) 1 }}

     

       144
       144
       +
           </a>

     

       145
       145
       +
         {{ end }}

     

       146
       146
       +
       

     

       147
       147
       +
         <!-- if next page is not second last or last page (next < issues - 2 * limit) -->

     

       148
       148
       +
         {{ if lt ($next) (sub .IssueCount (mul (2) .Page.Limit)) }}

     

       149
       149
       +
           <span>...</span>

     

       150
       150
       +
         {{ end }}

     

       151
       151
       +
       

     

       152
       152
       +
         <!-- if its not the last page -->

     

       153
       153
       +
         {{ if lt .Page.Offset $lastPage }} 

     

       154
       154
       +
           <a

     

       155
       155
       +
             hx-boost="true"

     

       156
       156
       +
             href = "/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&q={{ .FilterQuery }}&offset={{ $lastPage }}&limit={{ .Page.Limit }}"

     

       157
       157
       +
           >

     

       158
       158
       +
             {{ add (div $lastPage .Page.Limit) 1 }}

     

       159
       159
       +
           </a>

     

       160
       160
       +
         {{ end }}

     

       161
       161
       +
       

     

       162
       162
       +
         <a

     

       163
       163
       +
           class="

     

       164
       164
       +
             btn flex items-center gap-2 no-underline hover:no-underline 

     

       165
       165
       +
             dark:text-white dark:hover:bg-gray-700

     

       166
       166
       +
             {{ if ne (len .Issues) .Page.Limit }}

     

       167
       167
       +
                 cursor-not-allowed opacity-50

     

       168
       168
       +
             {{ end }}

     

       169
       169
       +
           "

     

       91
       170
        
           {{ if eq (len .Issues) .Page.Limit }}

     

       92
       92
       -
              {{ $next := .Page.Next }}

     

       93
       93
       -
               <a

     

       94
       94
       -
                   class="btn flex items-center gap-2 no-underline hover:no-underline dark:text-white dark:hover:bg-gray-700"

     

       95
       95
       -
                   hx-boost="true"

     

       96
       96
       -
                   href = "/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&q={{ .FilterQuery }}&offset={{ $next.Offset }}&limit={{ $next.Limit }}"

     

       97
       97
       -
               >

     

       98
       98
       -
                   next

     

       99
       99
       -
                   {{ i "chevron-right" "w-4 h-4" }}

     

       100
       100
       -
               </a>

     

       171
       171
       +
             hx-boost="true"

     

       172
       172
       +
             href="/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&q={{ .FilterQuery }}&offset={{ $next }}&limit={{ .Page.Limit }}"

     

       101
       173
        
           {{ end }}

     

       174
       174
       +
         >

     

       175
       175
       +
           next

     

       176
       176
       +
           {{ i "chevron-right" "w-4 h-4" }}

     

       177
       177
       +
         </a>

     

       102
       178
        
       </div>

     

       103
       179
        
       {{ end }}

+40 -23

appview/pages/templates/repo/log.html

···

       17
       17
        
           <div class="hidden md:flex md:flex-col divide-y divide-gray-200 dark:divide-gray-700">

     

       18
       18
        
             {{ $grid := "grid grid-cols-14 gap-4" }}

     

       19
       19
        
             <div class="{{ $grid }}">

     

       20
       20
       -
               <div class="py-2 text-sm text-left text-gray-700 dark:text-gray-300 uppercase font-bold col-span-2">Author</div>

     

       20
       20
       +
               <div class="py-2 text-sm text-left text-gray-700 dark:text-gray-300 uppercase font-bold col-span-3">Author</div>

     

       21
       21
        
               <div class="py-2 text-sm text-left text-gray-700 dark:text-gray-300 uppercase font-bold col-span-3">Commit</div>

     

       22
       22
        
               <div class="py-2 text-sm text-left text-gray-700 dark:text-gray-300 uppercase font-bold col-span-6">Message</div>

     

       23
       23
       -
               <div class="py-2 text-sm text-left text-gray-700 dark:text-gray-300 uppercase font-bold col-span-1"></div>

     

       24
       23
        
               <div class="py-2 text-sm text-left text-gray-700 dark:text-gray-300 uppercase font-bold col-span-2 justify-self-end">Date</div>

     

       25
       24
        
             </div>

     

       26
       25
        
             {{ range $index, $commit := .Commits }}

     

       27
       26
        
               {{ $messageParts := splitN $commit.Message "\n\n" 2 }}

     

       28
       27
        
               <div class="{{ $grid }} py-3">

     

       29
       29
       -
                 <div class="align-top truncate col-span-2">

     

       30
       30
       -
                     {{ $did := index $.EmailToDid $commit.Author.Email }}

     

       31
       31
       -
                     {{ if $did }}

     

       32
       32
       -
                         {{ template "user/fragments/picHandleLink" $did }}

     

       33
       33
       -
                     {{ else }}

     

       34
       34
       -
                         <a href="mailto:{{ $commit.Author.Email }}" class="text-gray-700 dark:text-gray-300 no-underline hover:underline">{{ $commit.Author.Name }}</a>

     

       35
       35
       -
                     {{ end }}

     

       28
       28
       +
                 <div class="align-top col-span-3">

     

       29
       29
       +
                   {{ template "attribution" (list $commit $.EmailToDid) }}

     

       36
       30
        
                 </div>

     

       37
       31
        
                 <div class="align-top font-mono flex items-start col-span-3">

     

       38
       32
        
                     {{ $verified := $.VerifiedCommits.IsVerified $commit.Hash.String }}

     
···

       61
       55
        
                 <div class="align-top col-span-6">

     

       62
       56
        
                   <div>

     

       63
       57
        
                       <a href="/{{ $.RepoInfo.FullName }}/commit/{{ $commit.Hash.String }}" class="dark:text-white no-underline hover:underline">{{ index $messageParts 0 }}</a>

     

       58
       58
       +
       

     

       64
       59
        
                       {{ if gt (len $messageParts) 1 }}

     

       65
       60
        
                       <button class="py-1/2 px-1 bg-gray-200 hover:bg-gray-400 dark:bg-gray-700 dark:hover:bg-gray-600 rounded" hx-on:click="this.parentElement.nextElementSibling.classList.toggle('hidden')">{{ i "ellipsis" "w-3 h-3" }}</button>

     

       66
       61
        
                       {{ end }}

     
···

       72
       67
        
                           </span>

     

       73
       68
        
                         {{ end }}

     

       74
       69
        
                       {{ end }}

     

       70
       70
       +
       

     

       71
       71
       +
                       <!-- ci status -->

     

       72
       72
       +
                       <span class="text-xs">

     

       73
       73
       +
                         {{ $pipeline := index $.Pipelines .Hash.String }}

     

       74
       74
       +
                         {{ if and $pipeline (gt (len $pipeline.Statuses) 0) }}

     

       75
       75
       +
                           {{ template "repo/pipelines/fragments/pipelineSymbolLong" (dict "Pipeline" $pipeline "RepoInfo" $.RepoInfo) }}

     

       76
       76
       +
                         {{ end }}

     

       77
       77
       +
                       </span>

     

       75
       78
        
                   </div>

     

       76
       79
        
       

     

       77
       80
        
                   {{ if gt (len $messageParts) 1 }}

     

       78
       81
        
                     <p class="hidden mt-1 text-sm text-gray-600 dark:text-gray-400">{{ nl2br (index $messageParts 1) }}</p>

     

       79
       82
        
                   {{ end }}

     

       80
       80
       -
                 </div>

     

       81
       81
       -
                 <div class="align-top col-span-1">

     

       82
       82
       -
                     <!-- ci status -->

     

       83
       83
       -
                     {{ $pipeline := index $.Pipelines .Hash.String }}

     

       84
       84
       -
                     {{ if and $pipeline (gt (len $pipeline.Statuses) 0) }}

     

       85
       85
       -
                       {{ template "repo/pipelines/fragments/pipelineSymbolLong" (dict "Pipeline" $pipeline "RepoInfo" $.RepoInfo) }}

     

       86
       86
       -
                     {{ end }}

     

       87
       83
        
                 </div>

     

       88
       84
        
                 <div class="align-top justify-self-end text-gray-500 dark:text-gray-400 col-span-2">{{ template "repo/fragments/shortTimeAgo" $commit.Committer.When }}</div>

     

       89
       85
        
               </div>

     
···

       152
       148
        
                               </a>

     

       153
       149
        
                           </span>

     

       154
       150
        
                           <span class="mx-2 before:content-['·'] before:select-none"></span>

     

       155
       155
       -
                           <span>

     

       156
       156
       -
                               {{ $did := index $.EmailToDid $commit.Author.Email }}

     

       157
       157
       -
                               <a href="{{ if $did }}/{{ $did }}{{ else }}mailto:{{ $commit.Author.Email }}{{ end }}"

     

       158
       158
       -
                                  class="text-gray-500 dark:text-gray-400 no-underline hover:underline">

     

       159
       159
       -
                                  {{ if $did }}{{ template "user/fragments/picHandleLink" $did }}{{ else }}{{ $commit.Author.Name }}{{ end }}

     

       160
       160
       -
                               </a>

     

       161
       161
       -
                           </span>

     

       151
       151
       +
                           {{ template "attribution" (list $commit $.EmailToDid) }}

     

       162
       152
        
                           <div class="inline-block px-1 select-none after:content-['·']"></div>

     

       163
       153
        
                           <span>{{ template "repo/fragments/shortTime" $commit.Committer.When }}</span>

     

       164
       154
        
       

     
···

       176
       166
        
           </div>

     

       177
       167
        
       </section>

     

       178
       168
        
       

     

       169
       169
       +
       {{ end }}

     

       170
       170
       +
       

     

       171
       171
       +
       {{ define "attribution" }}

     

       172
       172
       +
         {{ $commit := index . 0 }}

     

       173
       173
       +
         {{ $map := index . 1 }}

     

       174
       174
       +
         <span class="flex items-center gap-1">

     

       175
       175
       +
           {{ $author := index $map $commit.Author.Email }}

     

       176
       176
       +
           {{ $coauthors := $commit.CoAuthors }}

     

       177
       177
       +
           {{ $all := list }}

     

       178
       178
       +
       

     

       179
       179
       +
           {{ if $author }}

     

       180
       180
       +
               {{ $all = append $all $author }}

     

       181
       181
       +
           {{ end }}

     

       182
       182
       +
           {{ range $coauthors }}

     

       183
       183
       +
             {{ $co := index $map .Email }}

     

       184
       184
       +
             {{ if $co }}

     

       185
       185
       +
               {{ $all = append $all $co }}

     

       186
       186
       +
             {{ end }}

     

       187
       187
       +
           {{ end }}

     

       188
       188
       +
       

     

       189
       189
       +
           {{ template "fragments/tinyAvatarList" (dict "all" $all "classes" "size-6") }}

     

       190
       190
       +
           <a href="{{ if $author }}/{{ $author }}{{ else }}mailto:{{ $commit.Author.Email }}{{ end }}"

     

       191
       191
       +
              class="no-underline hover:underline">

     

       192
       192
       +
              {{ if $author }}{{ resolve $author }}{{ else }}{{ $commit.Author.Name }}{{ end }}

     

       193
       193
       +
              {{ if $coauthors }} +{{ length $coauthors }}{{ end }}

     

       194
       194
       +
           </a>

     

       195
       195
       +
         </span>

     

       179
       196
        
       {{ end }}

     

       180
       197
        
       

     

       181
       198
        
       {{ define "repoAfter" }}

+2 -1

appview/pages/templates/repo/new.html

···

       155
       155
        
                   class="mr-2"

     

       156
       156
        
                   id="domain-{{ . }}"

     

       157
       157
        
                   required

     

       158
       158
       +
                   {{if eq (len $.Knots) 1}}checked{{end}}

     

       158
       159
        
                 />

     

       159
       160
        
                 <label for="domain-{{ . }}" class="dark:text-white lowercase">{{ . }}</label>

     

       160
       161
        
               </div>

     
···

       164
       165
        
           </div>

     

       165
       166
        
           <p class="text-sm text-gray-500 dark:text-gray-400 mt-1">

     

       166
       167
        
             A knot hosts repository data and handles Git operations.

     

       167
       167
       -
             You can also <a href="/knots" class="underline">register your own knot</a>.

     

       168
       168
       +
             You can also <a href="/settings/knots" class="underline">register your own knot</a>.

     

       168
       169
        
           </p>

     

       169
       170
        
         </div>

     

       170
       171
        
       {{ end }}

+3 -3

appview/pages/templates/repo/pipelines/fragments/logBlock.html

···

       2
       2
        
       <div id="lines" hx-swap-oob="beforeend">

     

       3
       3
        
         <details id="step-{{ .Id }}" {{if not .Collapsed}}open{{end}} class="group pb-2 rounded-sm border border-gray-200 dark:border-gray-700">

     

       4
       4
        
           <summary class="sticky top-0 pt-2 px-2 group-open:pb-2 group-open:mb-2 list-none cursor-pointer group-open:border-b border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 hover:text-gray-500 hover:dark:text-gray-400">

     

       5
       5
       -
             <div class="group-open:hidden flex items-center gap-1">{{ template "stepHeader" . }}</div>

     

       6
       6
       -
             <div class="hidden group-open:flex items-center gap-1">{{ template "stepHeader" . }}</div>

     

       5
       5
       +
             <div class="group-open:hidden flex items-center gap-1">{{ i "chevron-right" "w-4 h-4" }} {{ template "stepHeader" . }}</div>

     

       6
       6
       +
             <div class="hidden group-open:flex items-center gap-1">{{ i "chevron-down" "w-4 h-4" }} {{ template "stepHeader" . }}</div>

     

       7
       7
        
           </summary>

     

       8
       8
        
           <div class="font-mono whitespace-pre overflow-x-auto px-2"><div class="text-blue-600 dark:text-blue-300">{{ .Command }}</div><div id="step-body-{{ .Id }}"></div></div>

     

       9
       9
        
         </details>

     
···

       11
       11
        
       {{ end }}

     

       12
       12
        
       

     

       13
       13
        
       {{ define "stepHeader" }}

     

       14
       14
       -
        {{ i "chevron-right" "w-4 h-4" }} {{ .Name }}

     

       14
       14
       +
        {{ .Name }}

     

       15
       15
        
        <span class="ml-auto text-sm text-gray-500 tabular-nums" data-timer="{{ .Id }}" data-start="{{ .StartTime.Unix }}"></span>

     

       16
       16
        
       {{ end }}

+81 -83

appview/pages/templates/repo/pulls/fragments/pullActions.html

···

       22
       22
        
         {{ $isLastRound := eq $roundNumber $lastIdx }}

     

       23
       23
        
         {{ $isSameRepoBranch := .Pull.IsBranchBased }}

     

       24
       24
        
         {{ $isUpToDate := .ResubmitCheck.No }}

     

       25
       25
       -
         <div class="relative w-fit">

     

       26
       26
       -
           <div id="actions-{{$roundNumber}}" class="flex flex-wrap gap-2">

     

       27
       27
       -
               <button 

     

       28
       28
       -
                 hx-get="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/round/{{ $roundNumber }}/comment"

     

       29
       29
       -
                 hx-target="#actions-{{$roundNumber}}"

     

       30
       30
       -
                 hx-swap="outerHtml"

     

       31
       31
       -
                 class="btn p-2 flex items-center gap-2 no-underline hover:no-underline group">

     

       32
       32
       -
                   {{ i "message-square-plus" "w-4 h-4" }}

     

       33
       33
       -
                   <span>comment</span>

     

       34
       34
       -
                   {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       35
       35
       -
               </button>

     

       36
       36
       -
               {{ if .BranchDeleteStatus }}

     

       37
       37
       -
                 <button 

     

       38
       38
       -
                   hx-delete="/{{ .BranchDeleteStatus.Repo.Did }}/{{ .BranchDeleteStatus.Repo.Name }}/branches"

     

       39
       39
       -
                   hx-vals='{"branch": "{{ .BranchDeleteStatus.Branch }}" }'

     

       40
       40
       -
                   hx-swap="none"

     

       41
       41
       -
                   class="btn p-2 flex items-center gap-2 no-underline hover:no-underline group text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300">

     

       42
       42
       -
                     {{ i "git-branch" "w-4 h-4" }}

     

       43
       43
       -
                     <span>delete branch</span>

     

       44
       44
       -
                     {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       45
       45
       -
                 </button>

     

       46
       46
       -
               {{ end }}

     

       47
       47
       -
               {{ if and $isPushAllowed $isOpen $isLastRound }}

     

       48
       48
       -
                 {{ $disabled := "" }}

     

       49
       49
       -
                 {{ if $isConflicted }}

     

       50
       50
       -
                   {{ $disabled = "disabled" }}

     

       51
       51
       -
                 {{ end }}

     

       52
       52
       -
                 <button 

     

       53
       53
       -
                   hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/merge"

     

       54
       54
       -
                   hx-swap="none"

     

       55
       55
       -
                   hx-confirm="Are you sure you want to merge pull #{{ .Pull.PullId }} into the `{{ .Pull.TargetBranch }}` branch?"

     

       56
       56
       -
                   class="btn p-2 flex items-center gap-2 group" {{ $disabled }}>

     

       57
       57
       -
                   {{ i "git-merge" "w-4 h-4" }}

     

       58
       58
       -
                   <span>merge{{if $stackCount}} {{$stackCount}}{{end}}</span>

     

       59
       59
       -
                   {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       60
       60
       -
                 </button>

     

       61
       61
       -
               {{ end }}

     

       25
       25
       +
         <div id="actions-{{$roundNumber}}" class="flex flex-wrap gap-2 relative">

     

       26
       26
       +
           <button 

     

       27
       27
       +
             hx-get="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/round/{{ $roundNumber }}/comment"

     

       28
       28
       +
             hx-target="#actions-{{$roundNumber}}"

     

       29
       29
       +
             hx-swap="outerHtml"

     

       30
       30
       +
             class="btn p-2 flex items-center gap-2 no-underline hover:no-underline group">

     

       31
       31
       +
               {{ i "message-square-plus" "w-4 h-4" }}

     

       32
       32
       +
               <span>comment</span>

     

       33
       33
       +
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       34
       34
       +
           </button>

     

       35
       35
       +
           {{ if .BranchDeleteStatus }}

     

       36
       36
       +
             <button 

     

       37
       37
       +
               hx-delete="/{{ .BranchDeleteStatus.Repo.Did }}/{{ .BranchDeleteStatus.Repo.Name }}/branches"

     

       38
       38
       +
               hx-vals='{"branch": "{{ .BranchDeleteStatus.Branch }}" }'

     

       39
       39
       +
               hx-swap="none"

     

       40
       40
       +
               class="btn p-2 flex items-center gap-2 no-underline hover:no-underline group text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300">

     

       41
       41
       +
                 {{ i "git-branch" "w-4 h-4" }}

     

       42
       42
       +
                 <span>delete branch</span>

     

       43
       43
       +
                 {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       44
       44
       +
             </button>

     

       45
       45
       +
           {{ end }}

     

       46
       46
       +
           {{ if and $isPushAllowed $isOpen $isLastRound }}

     

       47
       47
       +
             {{ $disabled := "" }}

     

       48
       48
       +
             {{ if $isConflicted }}

     

       49
       49
       +
               {{ $disabled = "disabled" }}

     

       50
       50
       +
             {{ end }}

     

       51
       51
       +
             <button 

     

       52
       52
       +
               hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/merge"

     

       53
       53
       +
               hx-swap="none"

     

       54
       54
       +
               hx-confirm="Are you sure you want to merge pull #{{ .Pull.PullId }} into the `{{ .Pull.TargetBranch }}` branch?"

     

       55
       55
       +
               class="btn p-2 flex items-center gap-2 group" {{ $disabled }}>

     

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

     

       57
       57
       +
               <span>merge{{if $stackCount}} {{$stackCount}}{{end}}</span>

     

       58
       58
       +
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       59
       59
       +
             </button>

     

       60
       60
       +
           {{ end }}

     

       62
       61
        
       

     

       63
       63
       -
               {{ if and $isPullAuthor $isOpen $isLastRound }}

     

       64
       64
       -
                 {{ $disabled := "" }}

     

       65
       65
       -
                 {{ if $isUpToDate }}

     

       66
       66
       -
                   {{ $disabled = "disabled" }}

     

       62
       62
       +
           {{ if and $isPullAuthor $isOpen $isLastRound }}

     

       63
       63
       +
             {{ $disabled := "" }}

     

       64
       64
       +
             {{ if $isUpToDate }}

     

       65
       65
       +
               {{ $disabled = "disabled" }}

     

       66
       66
       +
             {{ end }}

     

       67
       67
       +
             <button id="resubmitBtn"

     

       68
       68
       +
                 {{ if not .Pull.IsPatchBased }}

     

       69
       69
       +
                   hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/resubmit"

     

       70
       70
       +
                 {{ else }}

     

       71
       71
       +
                   hx-get="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/resubmit"

     

       72
       72
       +
                   hx-target="#actions-{{$roundNumber}}"

     

       73
       73
       +
                   hx-swap="outerHtml"

     

       67
       74
        
                 {{ end }}

     

       68
       68
       -
                 <button id="resubmitBtn"

     

       69
       69
       -
                     {{ if not .Pull.IsPatchBased }}

     

       70
       70
       -
                       hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/resubmit"

     

       71
       71
       -
                     {{ else }}

     

       72
       72
       -
                       hx-get="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/resubmit"

     

       73
       73
       -
                       hx-target="#actions-{{$roundNumber}}"

     

       74
       74
       -
                       hx-swap="outerHtml"

     

       75
       75
       -
                     {{ end }}

     

       76
       75
        
       

     

       77
       77
       -
                     hx-disabled-elt="#resubmitBtn"

     

       78
       78
       -
                     class="btn p-2 flex items-center gap-2 disabled:opacity-50 disabled:cursor-not-allowed group" {{ $disabled }}

     

       76
       76
       +
                 hx-disabled-elt="#resubmitBtn"

     

       77
       77
       +
                 class="btn p-2 flex items-center gap-2 disabled:opacity-50 disabled:cursor-not-allowed group" {{ $disabled }}

     

       79
       78
        
       

     

       80
       80
       -
                     {{ if $disabled }}

     

       81
       81
       -
                     title="Update this branch to resubmit this pull request"

     

       82
       82
       -
                     {{ else }}

     

       83
       83
       -
                     title="Resubmit this pull request"

     

       84
       84
       -
                     {{ end }}

     

       85
       85
       -
                     >

     

       86
       86
       -
                     {{ i "rotate-ccw" "w-4 h-4" }}

     

       87
       87
       -
                     <span>resubmit</span>

     

       88
       88
       -
                     {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       89
       89
       -
                 </button>

     

       90
       90
       -
               {{ end }}

     

       79
       79
       +
                 {{ if $disabled }}

     

       80
       80
       +
                 title="Update this branch to resubmit this pull request"

     

       81
       81
       +
                 {{ else }}

     

       82
       82
       +
                 title="Resubmit this pull request"

     

       83
       83
       +
                 {{ end }}

     

       84
       84
       +
                 >

     

       85
       85
       +
                 {{ i "rotate-ccw" "w-4 h-4" }}

     

       86
       86
       +
                 <span>resubmit</span>

     

       87
       87
       +
                 {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       88
       88
       +
             </button>

     

       89
       89
       +
           {{ end }}

     

       91
       90
        
       

     

       92
       92
       -
               {{ if and (or $isPullAuthor $isPushAllowed) $isOpen $isLastRound }}

     

       93
       93
       -
               <button 

     

       94
       94
       -
                 hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/close"

     

       95
       95
       -
                 hx-swap="none"

     

       96
       96
       -
                 class="btn p-2 flex items-center gap-2 group">

     

       97
       97
       -
                   {{ i "ban" "w-4 h-4" }}

     

       98
       98
       -
                   <span>close</span>

     

       99
       99
       -
                   {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       100
       100
       -
               </button>

     

       101
       101
       -
               {{ end }}

     

       91
       91
       +
           {{ if and (or $isPullAuthor $isPushAllowed) $isOpen $isLastRound }}

     

       92
       92
       +
           <button 

     

       93
       93
       +
             hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/close"

     

       94
       94
       +
             hx-swap="none"

     

       95
       95
       +
             class="btn p-2 flex items-center gap-2 group">

     

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

     

       97
       97
       +
               <span>close</span>

     

       98
       98
       +
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       99
       99
       +
           </button>

     

       100
       100
       +
           {{ end }}

     

       102
       101
        
       

     

       103
       103
       -
               {{ if and (or $isPullAuthor $isPushAllowed) $isClosed $isLastRound }}

     

       104
       104
       -
               <button 

     

       105
       105
       -
                 hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/reopen"

     

       106
       106
       -
                 hx-swap="none"

     

       107
       107
       -
                 class="btn p-2 flex items-center gap-2 group">

     

       108
       108
       -
                   {{ i "refresh-ccw-dot" "w-4 h-4" }}

     

       109
       109
       -
                   <span>reopen</span>

     

       110
       110
       -
                   {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       111
       111
       -
               </button>

     

       112
       112
       -
               {{ end }}

     

       113
       113
       -
           </div>

     

       102
       102
       +
           {{ if and (or $isPullAuthor $isPushAllowed) $isClosed $isLastRound }}

     

       103
       103
       +
           <button 

     

       104
       104
       +
             hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/reopen"

     

       105
       105
       +
             hx-swap="none"

     

       106
       106
       +
             class="btn p-2 flex items-center gap-2 group">

     

       107
       107
       +
               {{ i "refresh-ccw-dot" "w-4 h-4" }}

     

       108
       108
       +
               <span>reopen</span>

     

       109
       109
       +
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       110
       110
       +
           </button>

     

       111
       111
       +
           {{ end }}

     

       114
       112
        
         </div>

     

       115
       113
        
       {{ end }}

     

       116
       114

+1 -1

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

···

       54
       54
        
       {{ end }}

     

       55
       55
        
       

     

       56
       56
        
       {{ define "contentAfter" }}

     

       57
       57
       -
         {{ template "repo/fragments/diff" (list .RepoInfo.FullName .Diff .DiffOpts) }}

     

       57
       57
       +
         {{ template "repo/fragments/diff" (list .Diff .DiffOpts) }}

     

       58
       58
        
       {{end}}

     

       59
       59
        
       

     

       60
       60
        
       {{ define "contentAfterLeft" }}

+30 -22

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

···

       31
       31
        
              "Key" "closed"

     

       32
       32
        
              "Value" "closed"

     

       33
       33
        
              "Icon" "ban"

     

       34
       34
       -
              "Meta" (string .RepoInfo.Stats.IssueCount.Closed)) }}

     

       34
       34
       +
              "Meta" (string .RepoInfo.Stats.PullCount.Closed)) }}

     

       35
       35
        
         {{ $values := list $open $merged $closed }}

     

       36
       36
       -
         <div class="flex flex-col gap-2">

     

       37
       37
       -
           <div class="flex justify-between items-stretch gap-2">

     

       38
       38
       -
             <form class="flex flex-1 relative" method="GET">

     

       39
       39
       -
               <input type="hidden" name="state" value="{{ .FilteringBy.String }}">

     

       40
       40
       -
               <div class="absolute left-3 top-1/2 -translate-y-1/2 text-gray-400 pointer-events-none">

     

       41
       41
       -
                 {{ i "search" "w-4 h-4" }}

     

       42
       42
       -
               </div>

     

       43
       43
       -
               <input class="flex-1 p-1 pl-10 pr-10 peer" type="text" name="q" value="{{ .FilterQuery }}" placeholder=" ">

     

       44
       44
       -
               <a 

     

       36
       36
       +
         <div class="grid gap-2 grid-cols-[auto_1fr_auto] grid-row-2">

     

       37
       37
       +
           <form class="flex relative col-span-3 sm:col-span-1 sm:col-start-2" method="GET">

     

       38
       38
       +
             <input type="hidden" name="state" value="{{ .FilteringBy.String }}">

     

       39
       39
       +
             <div class="flex-1 flex relative">

     

       40
       40
       +
               <input

     

       41
       41
       +
                 id="search-q"

     

       42
       42
       +
                 class="flex-1 py-1 pl-2 pr-10 mr-[-1px] rounded-r-none focus:border-0 focus:outline-none focus:ring focus:ring-blue-400 ring-inset peer"

     

       43
       43
       +
                 type="text"

     

       44
       44
       +
                 name="q"

     

       45
       45
       +
                 value="{{ .FilterQuery }}"

     

       46
       46
       +
                 placeholder=" "

     

       47
       47
       +
               >

     

       48
       48
       +
               <a

     

       45
       49
        
                 href="?state={{ .FilteringBy.String }}"

     

       46
       50
        
                 class="absolute right-3 top-1/2 -translate-y-1/2 text-gray-400 hover:text-gray-600 dark:hover:text-gray-300 hidden peer-[:not(:placeholder-shown)]:block"

     

       47
       47
       -
                 >

     

       51
       51
       +
               >

     

       48
       52
        
                 {{ i "x" "w-4 h-4" }}

     

       49
       53
        
               </a>

     

       50
       50
       -
             </form>

     

       51
       51
       -
             <div class="hidden sm:block">

     

       52
       52
       -
               {{ template "fragments/tabSelector" (dict "Name" "state" "Values" $values "Active" $active) }}

     

       53
       54
        
             </div>

     

       54
       54
       -
             <a href="/{{ .RepoInfo.FullName }}/pulls/new"

     

       55
       55
       -
                 class="btn-create text-sm flex items-center gap-2 no-underline hover:no-underline hover:text-white"

     

       55
       55
       +
             <button

     

       56
       56
       +
               type="submit"

     

       57
       57
       +
               class="p-2 text-gray-400 border rounded-r border-gray-400 dark:border-gray-600"

     

       56
       58
        
             >

     

       57
       57
       -
               {{ i "git-pull-request-create" "w-4 h-4" }}

     

       58
       58
       -
               <span>new</span>

     

       59
       59
       -
             </a>

     

       60
       60
       -
           </div>

     

       61
       61
       -
           <div class="sm:hidden">

     

       62
       62
       -
             {{ template "fragments/tabSelector" (dict "Name" "state" "Values" $values "Active" $active) }}

     

       59
       59
       +
               {{ i "search" "w-4 h-4" }}

     

       60
       60
       +
             </button>

     

       61
       61
       +
           </form>

     

       62
       62
       +
           <div class="sm:row-start-1">

     

       63
       63
       +
             {{ template "fragments/tabSelector" (dict "Name" "state" "Values" $values "Active" $active "Include" "#search-q") }}

     

       63
       64
        
           </div>

     

       65
       65
       +
           <a

     

       66
       66
       +
             href="/{{ .RepoInfo.FullName }}/pulls/new"

     

       67
       67
       +
             class="col-start-3 btn-create text-sm flex items-center gap-2 no-underline hover:no-underline hover:text-white"

     

       68
       68
       +
           >

     

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

     

       70
       70
       +
             <span>new</span>

     

       71
       71
       +
           </a>

     

       64
       72
        
         </div>

     

       65
       73
        
         <div class="error" id="pulls"></div>

     

       66
       74
        
       {{ end }}

+22 -14

appview/pages/templates/repo/settings/access.html

···

       29
       29
        
             {{ template "addCollaboratorButton" . }}

     

       30
       30
        
           {{ end }}

     

       31
       31
        
           {{ range .Collaborators }}

     

       32
       32
       +
             {{ $handle := resolve .Did }}

     

       32
       33
        
             <div class="border border-gray-200 dark:border-gray-700 rounded p-4">

     

       33
       34
        
               <div class="flex items-center gap-3">

     

       34
       35
        
                 <img

     

       35
       35
       -
                   src="{{ fullAvatar .Handle }}"

     

       36
       36
       -
                   alt="{{ .Handle }}"

     

       36
       36
       +
                   src="{{ fullAvatar $handle }}"

     

       37
       37
       +
                   alt="{{ $handle }}"

     

       37
       38
        
                   class="rounded-full h-10 w-10 border border-gray-300 dark:border-gray-600 flex-shrink-0"/>

     

       38
       39
        
       

     

       39
       40
        
                 <div class="flex-1 min-w-0">

     

       40
       40
       -
                   <a href="/{{ .Handle }}" class="block truncate">

     

       41
       41
       -
                     {{ didOrHandle .Did .Handle }}

     

       41
       41
       +
                   <a href="/{{ $handle }}" class="block truncate">

     

       42
       42
       +
                     {{ $handle }}

     

       42
       43
        
                   </a>

     

       43
       44
        
                   <p class="text-sm text-gray-500 dark:text-gray-400">{{ .Role }}</p>

     

       44
       45
        
                 </div>

     
···

       66
       67
        
         <div

     

       67
       68
        
           id="add-collaborator-modal"

     

       68
       69
        
           popover

     

       69
       69
       -
           class="bg-white w-full md:w-96 dark:bg-gray-800 p-4 rounded border border-gray-200 dark:border-gray-700 drop-shadow dark:text-white backdrop:bg-gray-400/50 dark:backdrop:bg-gray-800/50">

     

       70
       70
       +
           class="

     

       71
       71
       +
             bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 

     

       72
       72
       +
             dark:text-white backdrop:bg-gray-400/50 dark:backdrop:bg-gray-800/50 

     

       73
       73
       +
             w-full md:w-96 p-4 rounded drop-shadow overflow-visible">

     

       70
       74
        
           {{ template "addCollaboratorModal" . }}

     

       71
       75
        
         </div>

     

       72
       76
        
       {{ end }}

     
···

       82
       86
        
           ADD COLLABORATOR

     

       83
       87
        
         </label>

     

       84
       88
        
         <p class="text-sm text-gray-500 dark:text-gray-400">Collaborators can push to this repository.</p>

     

       85
       85
       -
         <input

     

       86
       86
       -
           autocapitalize="none"

     

       87
       87
       -
           autocorrect="off"

     

       88
       88
       -
           type="text"

     

       89
       89
       -
           id="add-collaborator"

     

       90
       90
       -
           name="collaborator"

     

       91
       91
       -
           required

     

       92
       92
       -
           placeholder="foo.bsky.social"

     

       93
       93
       -
         />

     

       89
       89
       +
         <actor-typeahead>

     

       90
       90
       +
           <input

     

       91
       91
       +
             autocapitalize="none"

     

       92
       92
       +
             autocorrect="off"

     

       93
       93
       +
             autocomplete="off"

     

       94
       94
       +
             type="text"

     

       95
       95
       +
             id="add-collaborator"

     

       96
       96
       +
             name="collaborator"

     

       97
       97
       +
             required

     

       98
       98
       +
             placeholder="user.tngl.sh"

     

       99
       99
       +
             class="w-full"

     

       100
       100
       +
           />

     

       101
       101
       +
         </actor-typeahead>

     

       94
       102
        
         <div class="flex gap-2 pt-2">

     

       95
       103
        
           <button

     

       96
       104
        
             type="button"

+1 -1

appview/pages/templates/repo/settings/general.html

···

       58
       58
        
                 {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       59
       59
        
               </button>

     

       60
       60
        
             </div>

     

       61
       61
       -
           <fieldset>

     

       61
       61
       +
           </fieldset>

     

       62
       62
        
         </form>

     

       63
       63
        
       {{ end }}

     

       64
       64

appview/pages/templates/repo/tree.html

···

       59
       59
        
                 {{ $icon := "folder" }}

     

       60
       60
        
                 {{ $iconStyle := "size-4 fill-current" }}

     

       61
       61
        
       

     

       62
       62
       +
                 {{ if .IsSubmodule }}

     

       63
       63
       +
                   {{ $link = printf "/%s/%s/%s/%s/%s" $.RepoInfo.FullName "blob" (urlquery $.Ref) $.TreePath .Name }}

     

       64
       64
       +
                   {{ $icon = "folder-input" }}

     

       65
       65
       +
                   {{ $iconStyle = "size-4" }}

     

       66
       66
       +
                 {{ end }}

     

       67
       67
       +
       

     

       62
       68
        
                 {{ if .IsFile }}

     

       69
       69
       +
                   {{ $link = printf "/%s/%s/%s/%s/%s" $.RepoInfo.FullName "blob" (urlquery $.Ref) $.TreePath .Name }}

     

       63
       70
        
                   {{ $icon = "file" }}

     

       64
       71
        
                   {{ $iconStyle = "size-4" }}

     

       65
       72
        
                 {{ end }}

     

       73
       73
       +
       

     

       66
       74
        
                 <a href="{{ $link }}" class="{{ $linkstyle }}">

     

       67
       75
        
                   <div class="flex items-center gap-2">

     

       68
       76
        
                     {{ i $icon $iconStyle "flex-shrink-0" }}

+22 -6

appview/pages/templates/spindles/dashboard.html

···

       1
       1
       -
       {{ define "title" }}{{.Spindle.Instance}} &middot; spindles{{ end }}

     

       1
       1
       +
       {{ define "title" }}{{.Spindle.Instance}} &middot; {{ .Tab }} settings{{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "content" }}

     

       4
       4
       -
       <div class="px-6 py-4">

     

       4
       4
       +
         <div class="p-6">

     

       5
       5
       +
           <p class="text-xl font-bold dark:text-white">Settings</p>

     

       6
       6
       +
         </div>

     

       7
       7
       +
         <div class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       8
       8
       +
           <section class="w-full grid grid-cols-1 md:grid-cols-4 gap-6">

     

       9
       9
       +
             <div class="col-span-1">

     

       10
       10
       +
               {{ template "user/settings/fragments/sidebar" . }}

     

       11
       11
       +
             </div>

     

       12
       12
       +
             <div class="col-span-1 md:col-span-3 flex flex-col gap-6">

     

       13
       13
       +
               {{ template "spindleDash" . }}

     

       14
       14
       +
             </div>

     

       15
       15
       +
           </section>

     

       16
       16
       +
         </div>

     

       17
       17
       +
       {{ end }}

     

       18
       18
       +
       

     

       19
       19
       +
       {{ define "spindleDash" }}

     

       20
       20
       +
       <div>

     

       5
       21
        
         <div class="flex justify-between items-center">

     

       6
       6
       -
           <h1 class="text-xl font-bold dark:text-white">{{ .Spindle.Instance }}</h1>

     

       22
       22
       +
           <h2 class="text-sm pb-2 uppercase font-bold">{{ .Tab }} &middot; {{ .Spindle.Instance }}</h2>

     

       7
       23
        
           <div id="right-side" class="flex gap-2">

     

       8
       24
        
             {{ $style := "px-2 py-1 rounded flex items-center flex-shrink-0 gap-2" }}

     

       9
       25
        
             {{ $isOwner := and .LoggedInUser (eq .LoggedInUser.Did .Spindle.Owner)  }}

     
···

       71
       87
        
         <button

     

       72
       88
        
           class="btn text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 gap-2 group"

     

       73
       89
        
           title="Delete spindle"

     

       74
       74
       -
           hx-delete="/spindles/{{ .Instance }}"

     

       90
       90
       +
           hx-delete="/settings/spindles/{{ .Instance }}"

     

       75
       91
        
           hx-swap="outerHTML"

     

       76
       92
        
           hx-confirm="Are you sure you want to delete the spindle '{{ .Instance }}'?"

     

       77
       93
        
           hx-headers='{"shouldRedirect": "true"}'

     
···

       87
       103
        
         <button

     

       88
       104
        
           class="btn gap-2 group"

     

       89
       105
        
           title="Retry spindle verification"

     

       90
       90
       -
           hx-post="/spindles/{{ .Instance }}/retry"

     

       106
       106
       +
           hx-post="/settings/spindles/{{ .Instance }}/retry"

     

       91
       107
        
           hx-swap="none"

     

       92
       108
        
           hx-headers='{"shouldRefresh": "true"}'

     

       93
       109
        
         >

     
···

       104
       120
        
           <button

     

       105
       121
        
             class="btn text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 gap-2 group"

     

       106
       122
        
             title="Remove member"

     

       107
       107
       -
             hx-post="/spindles/{{ $root.Spindle.Instance }}/remove"

     

       123
       123
       +
             hx-post="/settings/spindles/{{ $root.Spindle.Instance }}/remove"

     

       108
       124
        
             hx-swap="none"

     

       109
       125
        
             hx-vals='{"member": "{{$member}}" }'

     

       110
       126
        
             hx-confirm="Are you sure you want to remove {{ resolve $member }} from this instance?"

+17 -12

appview/pages/templates/spindles/fragments/addMemberModal.html

···

       13
       13
        
         <div

     

       14
       14
        
           id="add-member-{{ .Instance }}"

     

       15
       15
        
           popover

     

       16
       16
       -
           class="bg-white w-full md:w-96 dark:bg-gray-800 p-4 rounded border border-gray-200 dark:border-gray-700 drop-shadow dark:text-white backdrop:bg-gray-400/50 dark:backdrop:bg-gray-800/50">

     

       16
       16
       +
           class="

     

       17
       17
       +
           bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 dark:text-white backdrop:bg-gray-400/50 dark:backdrop:bg-gray-800/50

     

       18
       18
       +
           w-full md:w-96 p-4 rounded drop-shadow overflow-visible">

     

       17
       19
        
           {{ block "addSpindleMemberPopover" . }} {{ end }}

     

       18
       20
        
         </div>

     

       19
       21
        
       {{ end }}

     

       20
       22
        
       

     

       21
       23
        
       {{ define "addSpindleMemberPopover" }}

     

       22
       24
        
       <form

     

       23
       23
       -
         hx-post="/spindles/{{ .Instance }}/add"

     

       25
       25
       +
         hx-post="/settings/spindles/{{ .Instance }}/add"

     

       24
       26
        
         hx-indicator="#spinner"

     

       25
       27
        
         hx-swap="none"

     

       26
       28
        
         class="flex flex-col gap-2"

     
···

       29
       31
        
           ADD MEMBER

     

       30
       32
        
         </label>

     

       31
       33
        
         <p class="text-sm text-gray-500 dark:text-gray-400">Members can register repositories and run workflows on this spindle.</p>

     

       32
       32
       -
         <input

     

       33
       33
       -
           autocapitalize="none"

     

       34
       34
       -
           autocorrect="off"

     

       35
       35
       -
           autocomplete="off"

     

       36
       36
       -
           type="text"

     

       37
       37
       -
           id="member-did-{{ .Id }}"

     

       38
       38
       -
           name="member"

     

       39
       39
       -
           required

     

       40
       40
       -
           placeholder="foo.bsky.social"

     

       41
       41
       -
         />

     

       34
       34
       +
         <actor-typeahead>

     

       35
       35
       +
           <input

     

       36
       36
       +
             autocapitalize="none"

     

       37
       37
       +
             autocorrect="off"

     

       38
       38
       +
             autocomplete="off"

     

       39
       39
       +
             type="text"

     

       40
       40
       +
             id="member-did-{{ .Id }}"

     

       41
       41
       +
             name="member"

     

       42
       42
       +
             required

     

       43
       43
       +
             placeholder="user.tngl.sh"

     

       44
       44
       +
             class="w-full"

     

       45
       45
       +
           />

     

       46
       46
       +
         </actor-typeahead>

     

       42
       47
        
         <div class="flex gap-2 pt-2">

     

       43
       48
        
           <button 

     

       44
       49
        
             type="button"

+3 -3

appview/pages/templates/spindles/fragments/spindleListing.html

···

       7
       7
        
       

     

       8
       8
        
       {{ define "spindleLeftSide" }}

     

       9
       9
        
         {{ if .Verified }}

     

       10
       10
       -
         <a href="/spindles/{{ .Instance }}" class="hover:no-underline flex items-center gap-2 min-w-0 max-w-[60%]">

     

       10
       10
       +
         <a href="/settings/spindles/{{ .Instance }}" class="hover:no-underline flex items-center gap-2 min-w-0 max-w-[60%]">

     

       11
       11
        
           {{ i "hard-drive" "w-4 h-4" }}

     

       12
       12
        
           <span class="hover:underline">

     

       13
       13
        
             {{ .Instance }}

     
···

       50
       50
        
         <button

     

       51
       51
        
           class="btn text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 gap-2 group"

     

       52
       52
        
           title="Delete spindle"

     

       53
       53
       -
           hx-delete="/spindles/{{ .Instance }}"

     

       53
       53
       +
           hx-delete="/settings/spindles/{{ .Instance }}"

     

       54
       54
        
           hx-swap="outerHTML"

     

       55
       55
        
           hx-target="#spindle-{{.Id}}"

     

       56
       56
        
           hx-confirm="Are you sure you want to delete the spindle '{{ .Instance }}'?"

     
···

       66
       66
        
         <button

     

       67
       67
        
           class="btn gap-2 group"

     

       68
       68
        
           title="Retry spindle verification"

     

       69
       69
       -
           hx-post="/spindles/{{ .Instance }}/retry"

     

       69
       69
       +
           hx-post="/settings/spindles/{{ .Instance }}/retry"

     

       70
       70
        
           hx-swap="none"

     

       71
       71
        
           hx-target="#spindle-{{.Id}}"

     

       72
       72
        
         >

+90 -59

appview/pages/templates/spindles/index.html

···

       1
       1
       -
       {{ define "title" }}spindles{{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ .Tab }} settings{{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "content" }}

     

       4
       4
       -
       <div class="px-6 py-4 flex items-center justify-between gap-4 align-bottom">

     

       5
       5
       -
           <h1 class="text-xl font-bold dark:text-white">Spindles</h1>

     

       6
       6
       -
           <span class="flex items-center gap-1">

     

       7
       7
       -
               {{ i "book" "w-3 h-3" }}

     

       8
       8
       -
               <a href="https://tangled.org/@tangled.org/core/blob/master/docs/spindle/hosting.md">docs</a>

     

       9
       9
       -
           </span>

     

       4
       4
       +
         <div class="p-6">

     

       5
       5
       +
           <p class="text-xl font-bold dark:text-white">Settings</p>

     

       6
       6
       +
         </div>

     

       7
       7
       +
         <div class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       8
       8
       +
           <section class="w-full grid grid-cols-1 md:grid-cols-4 gap-6">

     

       9
       9
       +
             <div class="col-span-1">

     

       10
       10
       +
               {{ template "user/settings/fragments/sidebar" . }}

     

       11
       11
       +
             </div>

     

       12
       12
       +
             <div class="col-span-1 md:col-span-3 flex flex-col gap-6">

     

       13
       13
       +
               {{ template "spindleList" . }}

     

       14
       14
       +
             </div>

     

       15
       15
       +
           </section>

     

       16
       16
       +
         </div>

     

       17
       17
       +
       {{ end }}

     

       18
       18
       +
       

     

       19
       19
       +
       {{ define "spindleList" }}

     

       20
       20
       +
       <div class="grid grid-cols-1 md:grid-cols-3 gap-4 items-center">

     

       21
       21
       +
         <div class="col-span-1 md:col-span-2">

     

       22
       22
       +
           <h2 class="text-sm pb-2 uppercase font-bold">Spindle</h2>

     

       23
       23
       +
           {{ block "about" . }} {{ end }}

     

       24
       24
       +
         </div>

     

       25
       25
       +
         <div class="col-span-1 md:col-span-1 md:justify-self-end">

     

       26
       26
       +
           {{ template "docsButton" . }}

     

       27
       27
       +
         </div>

     

       10
       28
        
       </div>

     

       11
       29
        
       

     

       12
       12
       -
       <section class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       30
       30
       +
       <section>

     

       13
       31
        
         <div class="flex flex-col gap-6">

     

       14
       14
       -
           {{ block "about" . }} {{ end }}

     

       15
       32
        
           {{ block "list" . }} {{ end }}

     

       16
       33
        
           {{ block "register" . }} {{ end }}

     

       17
       34
        
         </div>

     
···

       20
       37
        
       

     

       21
       38
        
       {{ define "about" }}

     

       22
       39
        
       <section class="rounded flex items-center gap-2">

     

       23
       23
       -
           <p class="text-gray-500 dark:text-gray-400">

     

       24
       24
       -
               Spindles are small CI runners.

     

       25
       25
       -
           </p>

     

       40
       40
       +
         <p class="text-gray-500 dark:text-gray-400">

     

       41
       41
       +
           Spindles are small CI runners.

     

       42
       42
       +
         </p>

     

       26
       43
        
       </section>

     

       27
       44
        
       {{ end }}

     

       28
       45
        
       

     

       29
       46
        
       {{ define "list" }}

     

       30
       30
       -
         <section class="rounded w-full flex flex-col gap-2">

     

       31
       31
       -
           <h2 class="text-sm font-bold py-2 uppercase dark:text-gray-300">your spindles</h2>

     

       32
       32
       -
           <div class="flex flex-col rounded border border-gray-200 dark:border-gray-700 w-full">

     

       33
       33
       -
             {{ range $spindle := .Spindles }}

     

       34
       34
       -
               {{ template "spindles/fragments/spindleListing" . }}

     

       35
       35
       -
             {{ else }}

     

       36
       36
       -
               <div class="flex items-center justify-center p-2 border-b border-gray-200 dark:border-gray-700 text-gray-500">

     

       37
       37
       -
                 no spindles registered yet

     

       38
       38
       -
               </div>

     

       39
       39
       -
             {{ end }}

     

       47
       47
       +
       <section class="rounded w-full flex flex-col gap-2">

     

       48
       48
       +
         <h2 class="text-sm font-bold py-2 uppercase dark:text-gray-300">your spindles</h2>

     

       49
       49
       +
         <div class="flex flex-col rounded border border-gray-200 dark:border-gray-700 w-full">

     

       50
       50
       +
           {{ range $spindle := .Spindles }}

     

       51
       51
       +
           {{ template "spindles/fragments/spindleListing" . }}

     

       52
       52
       +
           {{ else }}

     

       53
       53
       +
           <div class="flex items-center justify-center p-2 border-b border-gray-200 dark:border-gray-700 text-gray-500">

     

       54
       54
       +
             no spindles registered yet

     

       40
       55
        
           </div>

     

       41
       41
       -
           <div id="operation-error" class="text-red-500 dark:text-red-400"></div>

     

       42
       42
       -
         </section>

     

       56
       56
       +
           {{ end }}

     

       57
       57
       +
         </div>

     

       58
       58
       +
         <div id="operation-error" class="text-red-500 dark:text-red-400"></div>

     

       59
       59
       +
       </section>

     

       43
       60
        
       {{ end }}

     

       44
       61
        
       

     

       45
       62
        
       {{ define "register" }}

     

       46
       46
       -
         <section class="rounded w-full lg:w-fit flex flex-col gap-2">

     

       47
       47
       -
           <h2 class="text-sm font-bold py-2 uppercase dark:text-gray-300">register a spindle</h2>

     

       48
       48
       -
           <p class="mb-2 dark:text-gray-300">Enter the hostname of your spindle to get started.</p>

     

       49
       49
       -
           <form

     

       50
       50
       -
             hx-post="/spindles/register"

     

       51
       51
       -
             class="max-w-2xl mb-2 space-y-4"

     

       52
       52
       -
             hx-indicator="#register-button"

     

       53
       53
       -
             hx-swap="none"

     

       54
       54
       -
             >

     

       55
       55
       -
             <div class="flex gap-2">

     

       56
       56
       -
               <input

     

       57
       57
       -
                 type="text"

     

       58
       58
       -
                 id="instance"

     

       59
       59
       -
                 name="instance"

     

       60
       60
       -
                 placeholder="spindle.example.com"

     

       61
       61
       -
                 required

     

       62
       62
       -
                 class="flex-1 w-full dark:bg-gray-700 dark:text-white dark:border-gray-600 dark:placeholder-gray-400 px-3 py-2 border rounded"

     

       63
       63
       -
               >

     

       64
       64
       -
               <button

     

       65
       65
       -
                 type="submit"

     

       66
       66
       -
                 id="register-button"

     

       67
       67
       -
                 class="btn rounded flex items-center py-2 dark:bg-gray-700 dark:text-white dark:hover:bg-gray-600 group"

     

       68
       68
       -
                 >

     

       69
       69
       -
                 <span class="inline-flex items-center gap-2">

     

       70
       70
       -
                   {{ i "plus" "w-4 h-4" }}

     

       71
       71
       -
                   register

     

       72
       72
       -
                 </span>

     

       73
       73
       -
                 <span class="pl-2 hidden group-[.htmx-request]:inline">

     

       74
       74
       -
                   {{ i "loader-circle" "w-4 h-4 animate-spin" }}

     

       75
       75
       -
                 </span>

     

       76
       76
       -
               </button>

     

       77
       77
       -
             </div>

     

       63
       63
       +
       <section class="rounded w-full lg:w-fit flex flex-col gap-2">

     

       64
       64
       +
         <h2 class="text-sm font-bold py-2 uppercase dark:text-gray-300">register a spindle</h2>

     

       65
       65
       +
         <p class="mb-2 dark:text-gray-300">Enter the hostname of your spindle to get started.</p>

     

       66
       66
       +
         <form

     

       67
       67
       +
         hx-post="/settings/spindles/register"

     

       68
       68
       +
         class="max-w-2xl mb-2 space-y-4"

     

       69
       69
       +
         hx-indicator="#register-button"

     

       70
       70
       +
         hx-swap="none"

     

       71
       71
       +
         >

     

       72
       72
       +
         <div class="flex gap-2">

     

       73
       73
       +
           <input

     

       74
       74
       +
           type="text"

     

       75
       75
       +
           id="instance"

     

       76
       76
       +
           name="instance"

     

       77
       77
       +
           placeholder="spindle.example.com"

     

       78
       78
       +
           required

     

       79
       79
       +
           class="flex-1 w-full dark:bg-gray-700 dark:text-white dark:border-gray-600 dark:placeholder-gray-400 px-3 py-2 border rounded"

     

       80
       80
       +
           >

     

       81
       81
       +
           <button

     

       82
       82
       +
           type="submit"

     

       83
       83
       +
           id="register-button"

     

       84
       84
       +
           class="btn rounded flex items-center py-2 dark:bg-gray-700 dark:text-white dark:hover:bg-gray-600 group"

     

       85
       85
       +
           >

     

       86
       86
       +
           <span class="inline-flex items-center gap-2">

     

       87
       87
       +
             {{ i "plus" "w-4 h-4" }}

     

       88
       88
       +
             register

     

       89
       89
       +
           </span>

     

       90
       90
       +
           <span class="pl-2 hidden group-[.htmx-request]:inline">

     

       91
       91
       +
             {{ i "loader-circle" "w-4 h-4 animate-spin" }}

     

       92
       92
       +
           </span>

     

       93
       93
       +
         </button>

     

       94
       94
       +
       </div>

     

       78
       95
        
       

     

       79
       79
       -
             <div id="register-error" class="dark:text-red-400"></div>

     

       80
       80
       -
           </form>

     

       96
       96
       +
       <div id="register-error" class="dark:text-red-400"></div>

     

       97
       97
       +
       </form>

     

       98
       98
       +
       

     

       99
       99
       +
       </section>

     

       100
       100
       +
       {{ end }}

     

       81
       101
        
       

     

       82
       82
       -
         </section>

     

       102
       102
       +
       {{ define "docsButton" }}

     

       103
       103
       +
       <a

     

       104
       104
       +
       class="btn flex items-center gap-2"

     

       105
       105
       +
       href="https://tangled.org/@tangled.org/core/blob/master/docs/spindle/hosting.md">

     

       106
       106
       +
       {{ i "book" "size-4" }}

     

       107
       107
       +
       docs

     

       108
       108
       +
       </a>

     

       109
       109
       +
       <div

     

       110
       110
       +
       id="add-email-modal"

     

       111
       111
       +
       popover

     

       112
       112
       +
       class="bg-white w-full md:w-96 dark:bg-gray-800 p-4 rounded border border-gray-200 dark:border-gray-700 drop-shadow dark:text-white backdrop:bg-gray-400/50 dark:backdrop:bg-gray-800/50">

     

       113
       113
       +
       </div>

     

       83
       114
        
       {{ end }}

+6 -5

appview/pages/templates/strings/dashboard.html

···

       1
       1
       -
       {{ define "title" }}strings by {{ or .Card.UserHandle .Card.UserDid  }}{{ end }}

     

       1
       1
       +
       {{ define "title" }}strings by {{ resolve .Card.UserDid  }}{{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "extrameta" }}

     

       4
       4
       -
           <meta property="og:title" content="{{ or .Card.UserHandle .Card.UserDid  }}" />

     

       4
       4
       +
           {{ $handle := resolve .Card.UserDid }}

     

       5
       5
       +
           <meta property="og:title" content="{{ $handle }}" />

     

       5
       6
        
           <meta property="og:type" content="profile" />

     

       6
       6
       -
           <meta property="og:url" content="https://tangled.org/{{ or .Card.UserHandle .Card.UserDid  }}" />

     

       7
       7
       -
           <meta property="og:description" content="{{ or .Card.Profile.Description .Card.UserHandle .Card.UserDid }}" />

     

       7
       7
       +
           <meta property="og:url" content="https://tangled.org/{{ $handle }}" />

     

       8
       8
       +
           <meta property="og:description" content="{{ or .Card.Profile.Description $handle }}" />

     

       8
       9
        
       {{ end }}

     

       9
       10
        
       

     

       10
       11
        
       

     
···

       35
       36
        
         {{ $s := index . 1 }}

     

       36
       37
        
         <div class="py-4 px-6 drop-shadow-sm rounded bg-white dark:bg-gray-800">

     

       37
       38
        
           <div class="font-medium dark:text-white flex gap-2 items-center">

     

       38
       38
       -
               <a href="/strings/{{ or $root.Card.UserHandle $root.Card.UserDid  }}/{{ $s.Rkey }}">{{ $s.Filename }}</a>

     

       39
       39
       +
               <a href="/strings/{{ resolve $root.Card.UserDid }}/{{ $s.Rkey }}">{{ $s.Filename }}</a>

     

       39
       40
        
           </div>

     

       40
       41
        
           {{ with $s.Description }}

     

       41
       42
        
             <div class="text-gray-600 dark:text-gray-300 text-sm">

+13 -9

appview/pages/templates/strings/string.html

···

       1
       1
       -
       {{ define "title" }}{{ .String.Filename }} · by {{ didOrHandle .Owner.DID.String .Owner.Handle.String }}{{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ .String.Filename }} · by {{ resolve .Owner.DID.String }}{{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "extrameta" }}

     

       4
       4
       -
         {{ $ownerId := didOrHandle .Owner.DID.String .Owner.Handle.String }}

     

       4
       4
       +
         {{ $ownerId := resolve .Owner.DID.String }}

     

       5
       5
        
         <meta property="og:title" content="{{ .String.Filename }} · by {{ $ownerId }}" />

     

       6
       6
        
         <meta property="og:type" content="object" />

     

       7
       7
        
         <meta property="og:url" content="https://tangled.org/strings/{{ $ownerId }}/{{ .String.Rkey }}" />

     
···

       9
       9
        
       {{ end }}

     

       10
       10
        
       

     

       11
       11
        
       {{ define "content" }}

     

       12
       12
       -
       {{ $ownerId := didOrHandle .Owner.DID.String .Owner.Handle.String }}

     

       12
       12
       +
       {{ $ownerId := resolve .Owner.DID.String }}

     

       13
       13
        
         <section id="string-header" class="mb-4 py-2 px-6 dark:text-white">

     

       14
       14
        
           <div class="text-lg flex items-center justify-between">

     

       15
       15
        
             <div>

     
···

       17
       17
        
               <span class="select-none">/</span>

     

       18
       18
        
               <a href="/strings/{{ $ownerId }}/{{ .String.Rkey }}" class="font-bold">{{ .String.Filename }}</a>

     

       19
       19
        
             </div>

     

       20
       20
       -
             {{ if and .LoggedInUser (eq .LoggedInUser.Did .String.Did) }}

     

       21
       21
       -
               <div class="flex gap-2 text-base">

     

       20
       20
       +
             <div class="flex gap-2 text-base">

     

       21
       21
       +
               {{ if and .LoggedInUser (eq .LoggedInUser.Did .String.Did) }}

     

       22
       22
        
                 <a class="btn flex items-center gap-2 no-underline hover:no-underline p-2 group"

     

       23
       23
        
                    hx-boost="true"

     

       24
       24
        
                    href="/strings/{{ .String.Did }}/{{ .String.Rkey }}/edit">

     
···

       37
       37
        
                   <span class="hidden md:inline">delete</span>

     

       38
       38
        
                   {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       39
       39
        
                 </button>

     

       40
       40
       -
               </div>

     

       41
       41
       -
             {{ end }}

     

       40
       40
       +
               {{ end }}

     

       41
       41
       +
               {{ template "fragments/starBtn"

     

       42
       42
       +
                 (dict "SubjectAt" .String.AtUri

     

       43
       43
       +
                       "IsStarred" .IsStarred

     

       44
       44
       +
                       "StarCount" .StarCount) }}

     

       45
       45
       +
             </div>

     

       42
       46
        
           </div>

     

       43
       47
        
           <span>

     

       44
       48
        
             {{ with .String.Description }}

     
···

       75
       79
        
           </div>

     

       76
       80
        
           <div class="overflow-x-auto overflow-y-hidden relative">

     

       77
       81
        
             {{ if .ShowRendered }}

     

       78
       78
       -
             <div id="blob-contents" class="prose dark:prose-invert">{{ .RenderedContents }}</div>

     

       82
       82
       +
               <div id="blob-contents" class="prose dark:prose-invert">{{ .String.Contents | readme }}</div>

     

       79
       83
        
             {{ else }}

     

       80
       80
       -
             <div id="blob-contents" class="whitespace-pre peer-target:bg-yellow-200 dark:peer-target:bg-yellow-900">{{ .String.Contents | escapeHtml }}</div>

     

       84
       84
       +
               <div id="blob-contents" class="whitespace-pre peer-target:bg-yellow-200 dark:peer-target:bg-yellow-900">{{ code .String.Contents .String.Filename | escapeHtml }}</div>

     

       81
       85
        
             {{ end }}

     

       82
       86
        
           </div>

     

       83
       87
        
           {{ template "fragments/multiline-select" }}

+1 -2

appview/pages/templates/timeline/fragments/goodfirstissues.html

···

       3
       3
        
           <a href="/goodfirstissues" class="no-underline hover:no-underline">

     

       4
       4
        
             <div class="flex items-center justify-between gap-2 bg-purple-200 dark:bg-purple-900 border border-purple-400 dark:border-purple-500 rounded mb-4 py-4 px-6 ">

     

       5
       5
        
               <div class="flex-1 flex flex-col gap-2">

     

       6
       6
       -
                 <div class="text-purple-500 dark:text-purple-400">Oct 2025</div>

     

       7
       6
        
                 <p>

     

       8
       8
       -
                   Make your first contribution to an open-source project this October.

     

       7
       7
       +
                   Make your first contribution to an open-source project.

     

       9
       8
        
                   <em>good-first-issue</em> helps new contributors find easy ways to

     

       10
       9
        
                   start contributing to open-source projects.

     

       11
       10
        
                 </p>

+5 -5

appview/pages/templates/timeline/fragments/timeline.html

···

       14
       14
        
                       <div class="flex flex-col divide-y divide-gray-200 dark:divide-gray-700 border border-gray-200 dark:border-gray-700 rounded-sm">

     

       15
       15
        
                         {{ if .Repo }}

     

       16
       16
        
                           {{ template "timeline/fragments/repoEvent" (list $ .) }}

     

       17
       17
       -
                         {{ else if .Star }}

     

       17
       17
       +
                         {{ else if .RepoStar }}

     

       18
       18
        
                           {{ template "timeline/fragments/starEvent" (list $ .) }}

     

       19
       19
        
                         {{ else if .Follow }}

     

       20
       20
        
                           {{ template "timeline/fragments/followEvent" (list $ .) }}

     
···

       52
       52
        
             <span class="text-gray-700 dark:text-gray-400 text-xs">{{ template "repo/fragments/time" $repo.Created }}</span>

     

       53
       53
        
           </div>

     

       54
       54
        
         {{ with $repo }}

     

       55
       55
       -
           {{ template "user/fragments/repoCard" (list $root . true true (dict "IsStarred" $event.IsStarred "RepoAt" .RepoAt "Stats" (dict "StarCount" $event.StarCount))) }}

     

       55
       55
       +
           {{ template "user/fragments/repoCard" (list $root . true true (dict "IsStarred" $event.IsStarred "SubjectAt" .RepoAt "StarCount" $event.StarCount)) }}

     

       56
       56
        
         {{ end }}

     

       57
       57
        
       {{ end }}

     

       58
       58
        
       

     

       59
       59
        
       {{ define "timeline/fragments/starEvent" }}

     

       60
       60
        
         {{ $root := index . 0 }}

     

       61
       61
        
         {{ $event := index . 1 }}

     

       62
       62
       -
         {{ $star := $event.Star }}

     

       62
       62
       +
         {{ $star := $event.RepoStar }}

     

       63
       63
        
         {{ with $star }}

     

       64
       64
       -
           {{ $starrerHandle :=  resolve .StarredByDid }}

     

       64
       64
       +
           {{ $starrerHandle := resolve .Did }}

     

       65
       65
        
           {{ $repoOwnerHandle :=  resolve .Repo.Did }}

     

       66
       66
        
           <div class="pl-6 py-2 bg-white dark:bg-gray-800 text-gray-600 dark:text-gray-300 flex flex-wrap items-center gap-2 text-sm">

     

       67
       67
        
               {{ template "user/fragments/picHandleLink" $starrerHandle }}

     
···

       72
       72
        
               <span class="text-gray-700 dark:text-gray-400 text-xs">{{ template "repo/fragments/time" .Created }}</span>

     

       73
       73
        
           </div>

     

       74
       74
        
           {{ with .Repo }}

     

       75
       75
       -
             {{ template "user/fragments/repoCard" (list $root . true true (dict "IsStarred" $event.IsStarred "RepoAt" .RepoAt "Stats" (dict "StarCount" $event.StarCount))) }}

     

       75
       75
       +
             {{ template "user/fragments/repoCard" (list $root . true true (dict "IsStarred" $event.IsStarred "SubjectAt" .RepoAt "StarCount" $event.StarCount)) }}

     

       76
       76
        
           {{ end }}

     

       77
       77
        
         {{ end }}

     

       78
       78
        
       {{ end }}

+4 -2

appview/pages/templates/user/followers.html

···

       1
       1
       -
       {{ define "title" }}{{ or .Card.UserHandle .Card.UserDid }} · followers {{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ resolve .Card.UserDid }} · followers {{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "profileContent" }}

     

       4
       4
        
         <div id="all-followers" class="md:col-span-8 order-2 md:order-2">

     
···

       19
       19
        
                     "FollowersCount" .FollowersCount

     

       20
       20
        
                     "FollowingCount" .FollowingCount) }}

     

       21
       21
        
           {{ else }}

     

       22
       22
       -
               <p class="px-6 dark:text-white">This user does not have any followers yet.</p>

     

       22
       22
       +
               <div class="text-base text-gray-500 flex items-center justify-center italic p-12 border border-gray-200 dark:border-gray-700 rounded">

     

       23
       23
       +
                 <span>This user does not have any followers yet.</span>

     

       24
       24
       +
               </div>

     

       23
       25
        
           {{ end }}

     

       24
       26
        
         </div>

     

       25
       27
        
       {{ end }}

+4 -2

appview/pages/templates/user/following.html

···

       1
       1
       -
       {{ define "title" }}{{ or .Card.UserHandle .Card.UserDid }} · following {{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ resolve .Card.UserDid }} · following {{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "profileContent" }}

     

       4
       4
        
         <div id="all-following" class="md:col-span-8 order-2 md:order-2">

     
···

       19
       19
        
                     "FollowersCount" .FollowersCount

     

       20
       20
        
                     "FollowingCount" .FollowingCount) }}

     

       21
       21
        
           {{ else }}

     

       22
       22
       -
               <p class="px-6 dark:text-white">This user does not follow anyone yet.</p>

     

       22
       22
       +
               <div class="text-base text-gray-500 flex items-center justify-center italic p-12 border border-gray-200 dark:border-gray-700 rounded">

     

       23
       23
       +
                 <span>This user does not follow anyone yet.</span>

     

       24
       24
       +
               </div>

     

       23
       25
        
           {{ end }}

     

       24
       26
        
         </div>

     

       25
       27
        
       {{ end }}

+7 -1

appview/pages/templates/user/fragments/editBio.html

···

       26
       26
        
               {{ if and .Profile .Profile.Pronouns }}

     

       27
       27
        
                 {{ $pronouns = .Profile.Pronouns }}

     

       28
       28
        
               {{ end }}

     

       29
       29
       -
               <input type="text" class="py-1 px-1 w-full" name="pronouns" value="{{ $pronouns }}">

     

       29
       29
       +
               <input

     

       30
       30
       +
                 type="text"

     

       31
       31
       +
                 class="py-1 px-1 w-full"

     

       32
       32
       +
                 name="pronouns"

     

       33
       33
       +
                 placeholder="they/them"

     

       34
       34
       +
                 value="{{ $pronouns }}"

     

       35
       35
       +
               >

     

       30
       36
        
             </div>

     

       31
       37
        
           </div>

     

       32
       38

+1 -1

appview/pages/templates/user/fragments/profileCard.html

···

       1
       1
        
       {{ define "user/fragments/profileCard" }}

     

       2
       2
       -
         {{ $userIdent := didOrHandle .UserDid .UserHandle }}

     

       2
       2
       +
         {{ $userIdent := resolve .UserDid }}

     

       3
       3
        
           <div class="grid grid-cols-3 md:grid-cols-1 gap-1 items-center">

     

       4
       4
        
             <div id="avatar" class="col-span-1 flex justify-center items-center">

     

       5
       5
        
               <div class="w-3/4 aspect-square relative">

+2 -1

appview/pages/templates/user/fragments/repoCard.html

···

       1
       1
        
       {{ define "user/fragments/repoCard" }}

     

       2
       2
       +
         {{/* root, repo, fullName [,starButton [,starData]] */}}

     

       2
       3
        
         {{ $root := index . 0 }}

     

       3
       4
        
         {{ $repo := index . 1 }}

     

       4
       5
        
         {{ $fullName := index . 2 }}

     
···

       29
       30
        
               </div>

     

       30
       31
        
               {{ if and $starButton $root.LoggedInUser }}

     

       31
       32
        
               <div class="shrink-0">

     

       32
       32
       -
                 {{ template "repo/fragments/repoStar" $starData }}

     

       33
       33
       +
                 {{ template "fragments/starBtn" $starData }}

     

       33
       34
        
               </div>

     

       34
       35
        
               {{ end }}

     

       35
       36
        
             </div>

+22 -4

appview/pages/templates/user/overview.html

···

       1
       1
       -
       {{ define "title" }}{{ or .Card.UserHandle .Card.UserDid }}{{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ resolve .Card.UserDid }}{{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "profileContent" }}

     

       4
       4
        
         <div id="all-repos" class="md:col-span-4 order-2 md:order-2">

     
···

       16
       16
        
         <p class="text-sm font-bold px-2 pb-4 dark:text-white">ACTIVITY</p>

     

       17
       17
        
         <div class="flex flex-col gap-4 relative">

     

       18
       18
        
           {{ if .ProfileTimeline.IsEmpty }}

     

       19
       19
       -
             <p class="dark:text-white">This user does not have any activity yet.</p>

     

       19
       19
       +
             <div class="text-base text-gray-500 flex items-center justify-center italic p-12 border border-gray-200 dark:border-gray-700 rounded">

     

       20
       20
       +
               <span class="flex items-center gap-2">

     

       21
       21
       +
                 This user does not have any activity yet.

     

       22
       22
       +
               </span>

     

       23
       23
       +
             </div>

     

       20
       24
        
           {{ end }}

     

       21
       25
        
       

     

       22
       26
        
           {{ with .ProfileTimeline }}

     
···

       33
       37
        
                   </p>

     

       34
       38
        
       

     

       35
       39
        
                     <div class="flex flex-col gap-1">

     

       40
       40
       +
                       {{ block "commits"  .Commits }} {{ end }}

     

       36
       41
        
                       {{ block "repoEvents"  .RepoEvents }} {{ end }}

     

       37
       42
        
                       {{ block "issueEvents" .IssueEvents }} {{ end }}

     

       38
       43
        
                       {{ block "pullEvents"  .PullEvents }} {{ end }}

     
···

       43
       48
        
             {{ end }}

     

       44
       49
        
           {{ end }}

     

       45
       50
        
         </div>

     

       51
       51
       +
       {{ end }}

     

       52
       52
       +
       

     

       53
       53
       +
       {{ define "commits" }}

     

       54
       54
       +
         {{ if . }}

     

       55
       55
       +
           <div class="flex flex-wrap items-center gap-1">

     

       56
       56
       +
             {{ i "git-commit-horizontal" "size-5" }}

     

       57
       57
       +
             created {{ . }} commits

     

       58
       58
       +
           </div>

     

       59
       59
       +
         {{ end }}

     

       46
       60
        
       {{ end }}

     

       47
       61
        
       

     

       48
       62
        
       {{ define "repoEvents" }}

     
···

       224
       238
        
       {{ define "ownRepos" }}

     

       225
       239
        
         <div>

     

       226
       240
        
           <div class="text-sm font-bold px-2 pb-4 dark:text-white flex items-center gap-2">

     

       227
       227
       -
             <a href="/@{{ or $.Card.UserHandle $.Card.UserDid }}?tab=repos"

     

       241
       241
       +
             <a href="/{{ resolve $.Card.UserDid }}?tab=repos"

     

       228
       242
        
               class="flex text-black dark:text-white items-center gap-2 no-underline hover:no-underline group">

     

       229
       243
        
               <span>PINNED REPOS</span>

     

       230
       244
        
             </a>

     
···

       244
       258
        
               {{ template "user/fragments/repoCard" (list $ . false) }}

     

       245
       259
        
             </div>

     

       246
       260
        
             {{ else }}

     

       247
       247
       -
               <p class="dark:text-white">This user does not have any pinned repos.</p>

     

       261
       261
       +
               <div class="text-base text-gray-500 flex items-center justify-center italic p-12 border border-gray-200 dark:border-gray-700 rounded">

     

       262
       262
       +
                 <span class="flex items-center gap-2">

     

       263
       263
       +
                   This user does not have any pinned repos.

     

       264
       264
       +
                 </span>

     

       265
       265
       +
               </div>

     

       248
       266
        
             {{ end }}

     

       249
       267
        
           </div>

     

       250
       268
        
         </div>

+4 -2

appview/pages/templates/user/repos.html

···

       1
       1
       -
       {{ define "title" }}{{ or .Card.UserHandle .Card.UserDid }} · repos {{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ resolve .Card.UserDid }} · repos {{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "profileContent" }}

     

       4
       4
        
         <div id="all-repos" class="md:col-span-8 order-2 md:order-2">

     
···

       13
       13
        
                {{ template "user/fragments/repoCard" (list $ . false) }}

     

       14
       14
        
             </div>

     

       15
       15
        
           {{ else }}

     

       16
       16
       -
               <p class="px-6 dark:text-white">This user does not have any repos yet.</p>

     

       16
       16
       +
               <div class="text-base text-gray-500 flex items-center justify-center italic p-12 border border-gray-200 dark:border-gray-700 rounded">

     

       17
       17
       +
                 <span>This user does not have any repos yet.</span>

     

       18
       18
       +
               </div>

     

       17
       19
        
           {{ end }}

     

       18
       20
        
         </div>

     

       19
       21
        
       {{ end }}

+1 -1

appview/pages/templates/user/settings/notifications.html

···

       151
       151
        
                 </div>

     

       152
       152
        
               </div>

     

       153
       153
        
               <label class="flex items-center gap-2">

     

       154
       154
       -
                 <input type="checkbox" name="mentioned" {{if .Preferences.UserMentioned}}checked{{end}}>

     

       154
       154
       +
                 <input type="checkbox" name="user_mentioned" {{if .Preferences.UserMentioned}}checked{{end}}>

     

       155
       155
        
               </label>

     

       156
       156
        
             </div>

     

       157
       157

+9 -6

appview/pages/templates/user/signup.html

···

       43
       43
        
                           page to complete your registration.

     

       44
       44
        
                           </span>

     

       45
       45
        
                           <div class="w-full mt-4 text-center">

     

       46
       46
       -
                             <div class="cf-turnstile" data-sitekey="{{ .CloudflareSiteKey }}"></div>

     

       46
       46
       +
                             <div class="cf-turnstile" data-sitekey="{{ .CloudflareSiteKey }}" data-size="flexible"></div>

     

       47
       47
        
                           </div>

     

       48
       48
        
                           <button class="btn text-base w-full my-2 mt-6" type="submit" id="signup-button" tabindex="7" >

     

       49
       49
        
                             <span>join now</span>

     

       50
       50
        
                           </button>

     

       51
       51
       +
                           <p class="text-sm text-gray-500">

     

       52
       52
       +
                             Already have an AT Protocol account? <a href="/login" class="underline">Login to Tangled</a>.

     

       53
       53
       +
                           </p>

     

       54
       54
       +
       

     

       55
       55
       +
                           <p id="signup-msg" class="error w-full"></p>

     

       56
       56
       +
                           <p class="text-sm text-gray-500 pt-4">

     

       57
       57
       +
                             By signing up, you agree to our <a href="/terms" class="underline">Terms of Service</a> and <a href="/privacy" class="underline">Privacy Policy</a>.

     

       58
       58
       +
                           </p>

     

       51
       59
        
                       </form>

     

       52
       52
       -
                       <p class="text-sm text-gray-500">

     

       53
       53
       -
                         Already have an AT Protocol account? <a href="/login" class="underline">Login to Tangled</a>.

     

       54
       54
       -
                       </p>

     

       55
       55
       -
       

     

       56
       56
       -
                       <p id="signup-msg" class="error w-full"></p>

     

       57
       60
        
                   </main>

     

       58
       61
        
               </body>

     

       59
       62
        
           </html>

+4 -2

appview/pages/templates/user/starred.html

···

       1
       1
       -
       {{ define "title" }}{{ or .Card.UserHandle .Card.UserDid }} · repos {{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ resolve .Card.UserDid }} · repos {{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "profileContent" }}

     

       4
       4
        
         <div id="all-repos" class="md:col-span-8 order-2 md:order-2">

     
···

       13
       13
        
                {{ template "user/fragments/repoCard" (list $ . true) }}

     

       14
       14
        
             </div>

     

       15
       15
        
           {{ else }}

     

       16
       16
       -
               <p class="px-6 dark:text-white">This user does not have any starred repos yet.</p>

     

       16
       16
       +
               <div class="text-base text-gray-500 flex items-center justify-center italic p-12 border border-gray-200 dark:border-gray-700 rounded">

     

       17
       17
       +
                 <span>This user does not have any starred repos yet.</span>

     

       18
       18
       +
               </div>

     

       17
       19
        
           {{ end }}

     

       18
       20
        
         </div>

     

       19
       21
        
       {{ end }}

+5 -3

appview/pages/templates/user/strings.html

···

       1
       1
       -
       {{ define "title" }}{{ or .Card.UserHandle .Card.UserDid }} · strings {{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ resolve .Card.UserDid }} · strings {{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "profileContent" }}

     

       4
       4
        
         <div id="all-strings" class="md:col-span-8 order-2 md:order-2">

     
···

       13
       13
        
               {{ template "singleString" (list $ .) }}

     

       14
       14
        
             </div>

     

       15
       15
        
           {{ else }}

     

       16
       16
       -
             <p class="px-6 dark:text-white">This user does not have any strings yet.</p>

     

       16
       16
       +
             <div class="text-base text-gray-500 flex items-center justify-center italic p-12 border border-gray-200 dark:border-gray-700 rounded">

     

       17
       17
       +
               <span>This user does not have any strings yet.</span>

     

       18
       18
       +
             </div>

     

       17
       19
        
           {{ end }}

     

       18
       20
        
         </div>

     

       19
       21
        
       {{ end }}

     
···

       23
       25
        
         {{ $s := index . 1 }}

     

       24
       26
        
         <div class="py-4 px-6 rounded bg-white dark:bg-gray-800">

     

       25
       27
        
           <div class="font-medium dark:text-white flex gap-2 items-center">

     

       26
       26
       -
               <a href="/strings/{{ or $root.Card.UserHandle $root.Card.UserDid  }}/{{ $s.Rkey }}">{{ $s.Filename }}</a>

     

       28
       28
       +
               <a href="/strings/{{ resolve $root.Card.UserDid  }}/{{ $s.Rkey }}">{{ $s.Filename }}</a>

     

       27
       29
        
           </div>

     

       28
       30
        
           {{ with $s.Description }}

     

       29
       31
        
             <div class="text-gray-600 dark:text-gray-300 text-sm">

+19 -22

appview/pipelines/pipelines.go

···

       16
       16
        
       	"tangled.org/core/appview/reporesolver"

     

       17
       17
        
       	"tangled.org/core/eventconsumer"

     

       18
       18
        
       	"tangled.org/core/idresolver"

     

       19
       19
       +
       	"tangled.org/core/orm"

     

       19
       20
        
       	"tangled.org/core/rbac"

     

       20
       21
        
       	spindlemodel "tangled.org/core/spindle/models"

     

       21
       22
        
       

     
···

       78
       79
        
       		return

     

       79
       80
        
       	}

     

       80
       81
        
       

     

       81
       81
       -
       	repoInfo := f.RepoInfo(user)

     

       82
       82
       -
       

     

       83
       82
        
       	ps, err := db.GetPipelineStatuses(

     

       84
       83
        
       		p.db,

     

       85
       85
       -
       		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       86
       86
       -
       		db.FilterEq("repo_name", repoInfo.Name),

     

       87
       87
       -
       		db.FilterEq("knot", repoInfo.Knot),

     

       84
       84
       +
       		30,

     

       85
       85
       +
       		orm.FilterEq("repo_owner", f.Did),

     

       86
       86
       +
       		orm.FilterEq("repo_name", f.Name),

     

       87
       87
       +
       		orm.FilterEq("knot", f.Knot),

     

       88
       88
        
       	)

     

       89
       89
        
       	if err != nil {

     

       90
       90
        
       		l.Error("failed to query db", "err", err)

     
···

       93
       93
        
       

     

       94
       94
        
       	p.pages.Pipelines(w, pages.PipelinesParams{

     

       95
       95
        
       		LoggedInUser: user,

     

       96
       96
       -
       		RepoInfo:     repoInfo,

     

       96
       96
       +
       		RepoInfo:     p.repoResolver.GetRepoInfo(r, user),

     

       97
       97
        
       		Pipelines:    ps,

     

       98
       98
        
       	})

     

       99
       99
        
       }

     
···

       107
       107
        
       		l.Error("failed to get repo and knot", "err", err)

     

       108
       108
        
       		return

     

       109
       109
        
       	}

     

       110
       110
       -
       

     

       111
       111
       -
       	repoInfo := f.RepoInfo(user)

     

       112
       110
        
       

     

       113
       111
        
       	pipelineId := chi.URLParam(r, "pipeline")

     

       114
       112
        
       	if pipelineId == "" {

     
···

       124
       122
        
       

     

       125
       123
        
       	ps, err := db.GetPipelineStatuses(

     

       126
       124
        
       		p.db,

     

       127
       127
       -
       		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       128
       128
       -
       		db.FilterEq("repo_name", repoInfo.Name),

     

       129
       129
       -
       		db.FilterEq("knot", repoInfo.Knot),

     

       130
       130
       -
       		db.FilterEq("id", pipelineId),

     

       125
       125
       +
       		1,

     

       126
       126
       +
       		orm.FilterEq("repo_owner", f.Did),

     

       127
       127
       +
       		orm.FilterEq("repo_name", f.Name),

     

       128
       128
       +
       		orm.FilterEq("knot", f.Knot),

     

       129
       129
       +
       		orm.FilterEq("id", pipelineId),

     

       131
       130
        
       	)

     

       132
       131
        
       	if err != nil {

     

       133
       132
        
       		l.Error("failed to query db", "err", err)

     
···

       143
       142
        
       

     

       144
       143
        
       	p.pages.Workflow(w, pages.WorkflowParams{

     

       145
       144
        
       		LoggedInUser: user,

     

       146
       146
       -
       		RepoInfo:     repoInfo,

     

       145
       145
       +
       		RepoInfo:     p.repoResolver.GetRepoInfo(r, user),

     

       147
       146
        
       		Pipeline:     singlePipeline,

     

       148
       147
        
       		Workflow:     workflow,

     

       149
       148
        
       	})

     
···

       174
       173
        
       	ctx, cancel := context.WithCancel(r.Context())

     

       175
       174
        
       	defer cancel()

     

       176
       175
        
       

     

       177
       177
       -
       	user := p.oauth.GetUser(r)

     

       178
       176
        
       	f, err := p.repoResolver.Resolve(r)

     

       179
       177
        
       	if err != nil {

     

       180
       178
        
       		l.Error("failed to get repo and knot", "err", err)

     
···

       182
       180
        
       		return

     

       183
       181
        
       	}

     

       184
       182
        
       

     

       185
       185
       -
       	repoInfo := f.RepoInfo(user)

     

       186
       186
       -
       

     

       187
       183
        
       	pipelineId := chi.URLParam(r, "pipeline")

     

       188
       184
        
       	workflow := chi.URLParam(r, "workflow")

     

       189
       185
        
       	if pipelineId == "" || workflow == "" {

     
···

       193
       189
        
       

     

       194
       190
        
       	ps, err := db.GetPipelineStatuses(

     

       195
       191
        
       		p.db,

     

       196
       196
       -
       		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       197
       197
       -
       		db.FilterEq("repo_name", repoInfo.Name),

     

       198
       198
       -
       		db.FilterEq("knot", repoInfo.Knot),

     

       199
       199
       -
       		db.FilterEq("id", pipelineId),

     

       192
       192
       +
       		1,

     

       193
       193
       +
       		orm.FilterEq("repo_owner", f.Did),

     

       194
       194
       +
       		orm.FilterEq("repo_name", f.Name),

     

       195
       195
       +
       		orm.FilterEq("knot", f.Knot),

     

       196
       196
       +
       		orm.FilterEq("id", pipelineId),

     

       200
       197
        
       	)

     

       201
       198
        
       	if err != nil || len(ps) != 1 {

     

       202
       199
        
       		l.Error("pipeline query failed", "err", err, "count", len(ps))

     
···

       205
       202
        
       	}

     

       206
       203
        
       

     

       207
       204
        
       	singlePipeline := ps[0]

     

       208
       208
       -
       	spindle := repoInfo.Spindle

     

       209
       209
       -
       	knot := repoInfo.Knot

     

       205
       205
       +
       	spindle := f.Spindle

     

       206
       206
       +
       	knot := f.Knot

     

       210
       207
        
       	rkey := singlePipeline.Rkey

     

       211
       208
        
       

     

       212
       209
        
       	if spindle == "" || knot == "" || rkey == "" {

+3 -2

appview/pulls/opengraph.go

···

       13
       13
        
       	"tangled.org/core/appview/db"

     

       14
       14
        
       	"tangled.org/core/appview/models"

     

       15
       15
        
       	"tangled.org/core/appview/ogcard"

     

       16
       16
       +
       	"tangled.org/core/orm"

     

       16
       17
        
       	"tangled.org/core/patchutil"

     

       17
       18
        
       	"tangled.org/core/types"

     

       18
       19
        
       )

     
···

       276
       277
        
       	}

     

       277
       278
        
       

     

       278
       279
        
       	// Get comment count from database

     

       279
       279
       -
       	comments, err := db.GetPullComments(s.db, db.FilterEq("pull_id", pull.ID))

     

       280
       280
       +
       	comments, err := db.GetPullComments(s.db, orm.FilterEq("pull_id", pull.ID))

     

       280
       281
        
       	if err != nil {

     

       281
       282
        
       		log.Printf("failed to get pull comments: %v", err)

     

       282
       283
        
       	}

     
···

       293
       294
        
       		filesChanged = niceDiff.Stat.FilesChanged

     

       294
       295
        
       	}

     

       295
       296
        
       

     

       296
       296
       -
       	card, err := s.drawPullSummaryCard(pull, &f.Repo, commentCount, diffStats, filesChanged)

     

       297
       297
       +
       	card, err := s.drawPullSummaryCard(pull, f, commentCount, diffStats, filesChanged)

     

       297
       298
        
       	if err != nil {

     

       298
       299
        
       		log.Println("failed to draw pull summary card", err)

     

       299
       300
        
       		http.Error(w, "failed to draw pull summary card", http.StatusInternalServerError)

+122 -139

appview/pulls/pulls.go

···

       19
       19
        
       	"tangled.org/core/appview/config"

     

       20
       20
        
       	"tangled.org/core/appview/db"

     

       21
       21
        
       	pulls_indexer "tangled.org/core/appview/indexer/pulls"

     

       22
       22
       +
       	"tangled.org/core/appview/mentions"

     

       22
       23
        
       	"tangled.org/core/appview/models"

     

       23
       24
        
       	"tangled.org/core/appview/notify"

     

       24
       25
        
       	"tangled.org/core/appview/oauth"

     

       25
       26
        
       	"tangled.org/core/appview/pages"

     

       26
       27
        
       	"tangled.org/core/appview/pages/markup"

     

       27
       27
       -
       	"tangled.org/core/appview/refresolver"

     

       28
       28
       +
       	"tangled.org/core/appview/pages/repoinfo"

     

       28
       29
        
       	"tangled.org/core/appview/reporesolver"

     

       29
       30
        
       	"tangled.org/core/appview/validator"

     

       30
       31
        
       	"tangled.org/core/appview/xrpcclient"

     

       31
       32
        
       	"tangled.org/core/idresolver"

     

       33
       33
       +
       	"tangled.org/core/orm"

     

       32
       34
        
       	"tangled.org/core/patchutil"

     

       33
       35
        
       	"tangled.org/core/rbac"

     

       34
       36
        
       	"tangled.org/core/tid"

     
···

       43
       45
        
       )

     

       44
       46
        
       

     

       45
       47
        
       type Pulls struct {

     

       46
       46
       -
       	oauth        *oauth.OAuth

     

       47
       47
       -
       	repoResolver *reporesolver.RepoResolver

     

       48
       48
       -
       	pages        *pages.Pages

     

       49
       49
       -
       	idResolver   *idresolver.Resolver

     

       50
       50
       -
       	refResolver  *refresolver.Resolver

     

       51
       51
       -
       	db           *db.DB

     

       52
       52
       -
       	config       *config.Config

     

       53
       53
       -
       	notifier     notify.Notifier

     

       54
       54
       -
       	enforcer     *rbac.Enforcer

     

       55
       55
       -
       	logger       *slog.Logger

     

       56
       56
       -
       	validator    *validator.Validator

     

       57
       57
       -
       	indexer      *pulls_indexer.Indexer

     

       48
       48
       +
       	oauth            *oauth.OAuth

     

       49
       49
       +
       	repoResolver     *reporesolver.RepoResolver

     

       50
       50
       +
       	pages            *pages.Pages

     

       51
       51
       +
       	idResolver       *idresolver.Resolver

     

       52
       52
       +
       	mentionsResolver *mentions.Resolver

     

       53
       53
       +
       	db               *db.DB

     

       54
       54
       +
       	config           *config.Config

     

       55
       55
       +
       	notifier         notify.Notifier

     

       56
       56
       +
       	enforcer         *rbac.Enforcer

     

       57
       57
       +
       	logger           *slog.Logger

     

       58
       58
       +
       	validator        *validator.Validator

     

       59
       59
       +
       	indexer          *pulls_indexer.Indexer

     

       58
       60
        
       }

     

       59
       61
        
       

     

       60
       62
        
       func New(

     
···

       62
       64
        
       	repoResolver *reporesolver.RepoResolver,

     

       63
       65
        
       	pages *pages.Pages,

     

       64
       66
        
       	resolver *idresolver.Resolver,

     

       65
       65
       -
       	refResolver *refresolver.Resolver,

     

       67
       67
       +
       	mentionsResolver *mentions.Resolver,

     

       66
       68
        
       	db *db.DB,

     

       67
       69
        
       	config *config.Config,

     

       68
       70
        
       	notifier notify.Notifier,

     
···

       72
       74
        
       	logger *slog.Logger,

     

       73
       75
        
       ) *Pulls {

     

       74
       76
        
       	return &Pulls{

     

       75
       75
       -
       		oauth:        oauth,

     

       76
       76
       -
       		repoResolver: repoResolver,

     

       77
       77
       -
       		pages:        pages,

     

       78
       78
       -
       		idResolver:   resolver,

     

       79
       79
       -
       		refResolver:  refResolver,

     

       80
       80
       -
       		db:           db,

     

       81
       81
       -
       		config:       config,

     

       82
       82
       -
       		notifier:     notifier,

     

       83
       83
       -
       		enforcer:     enforcer,

     

       84
       84
       -
       		logger:       logger,

     

       85
       85
       -
       		validator:    validator,

     

       86
       86
       -
       		indexer:      indexer,

     

       77
       77
       +
       		oauth:            oauth,

     

       78
       78
       +
       		repoResolver:     repoResolver,

     

       79
       79
       +
       		pages:            pages,

     

       80
       80
       +
       		idResolver:       resolver,

     

       81
       81
       +
       		mentionsResolver: mentionsResolver,

     

       82
       82
       +
       		db:               db,

     

       83
       83
       +
       		config:           config,

     

       84
       84
       +
       		notifier:         notifier,

     

       85
       85
       +
       		enforcer:         enforcer,

     

       86
       86
       +
       		logger:           logger,

     

       87
       87
       +
       		validator:        validator,

     

       88
       88
       +
       		indexer:          indexer,

     

       87
       89
        
       	}

     

       88
       90
        
       }

     

       89
       91
        
       

     
···

       128
       130
        
       

     

       129
       131
        
       		s.pages.PullActionsFragment(w, pages.PullActionsParams{

     

       130
       132
        
       			LoggedInUser:       user,

     

       131
       131
       -
       			RepoInfo:           f.RepoInfo(user),

     

       133
       133
       +
       			RepoInfo:           s.repoResolver.GetRepoInfo(r, user),

     

       132
       134
        
       			Pull:               pull,

     

       133
       135
        
       			RoundNumber:        roundNumber,

     

       134
       136
        
       			MergeCheck:         mergeCheckResponse,

     
···

       172
       174
        
       	if user != nil && user.Did == pull.OwnerDid {

     

       173
       175
        
       		resubmitResult = s.resubmitCheck(r, f, pull, stack)

     

       174
       176
        
       	}

     

       175
       175
       -
       

     

       176
       176
       -
       	repoInfo := f.RepoInfo(user)

     

       177
       177
        
       

     

       178
       178
        
       	m := make(map[string]models.Pipeline)

     

       179
       179
        
       

     
···

       190
       190
        
       

     

       191
       191
        
       	ps, err := db.GetPipelineStatuses(

     

       192
       192
        
       		s.db,

     

       193
       193
       -
       		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       194
       194
       -
       		db.FilterEq("repo_name", repoInfo.Name),

     

       195
       195
       -
       		db.FilterEq("knot", repoInfo.Knot),

     

       196
       196
       -
       		db.FilterIn("sha", shas),

     

       193
       193
       +
       		len(shas),

     

       194
       194
       +
       		orm.FilterEq("repo_owner", f.Did),

     

       195
       195
       +
       		orm.FilterEq("repo_name", f.Name),

     

       196
       196
       +
       		orm.FilterEq("knot", f.Knot),

     

       197
       197
       +
       		orm.FilterIn("sha", shas),

     

       197
       198
        
       	)

     

       198
       199
        
       	if err != nil {

     

       199
       200
        
       		log.Printf("failed to fetch pipeline statuses: %s", err)

     
···

       217
       218
        
       

     

       218
       219
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       219
       220
        
       		s.db,

     

       220
       220
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       221
       221
       -
       		db.FilterContains("scope", tangled.RepoPullNSID),

     

       221
       221
       +
       		orm.FilterIn("at_uri", f.Labels),

     

       222
       222
       +
       		orm.FilterContains("scope", tangled.RepoPullNSID),

     

       222
       223
        
       	)

     

       223
       224
        
       	if err != nil {

     

       224
       225
        
       		log.Println("failed to fetch labels", err)

     
···

       233
       234
        
       

     

       234
       235
        
       	s.pages.RepoSinglePull(w, pages.RepoSinglePullParams{

     

       235
       236
        
       		LoggedInUser:       user,

     

       236
       236
       -
       		RepoInfo:           repoInfo,

     

       237
       237
       +
       		RepoInfo:           s.repoResolver.GetRepoInfo(r, user),

     

       237
       238
        
       		Pull:               pull,

     

       238
       239
        
       		Stack:              stack,

     

       239
       240
        
       		AbandonedPulls:     abandonedPulls,

     
···

       251
       252
        
       	})

     

       252
       253
        
       }

     

       253
       254
        
       

     

       254
       254
       -
       func (s *Pulls) mergeCheck(r *http.Request, f *reporesolver.ResolvedRepo, pull *models.Pull, stack models.Stack) types.MergeCheckResponse {

     

       255
       255
       +
       func (s *Pulls) mergeCheck(r *http.Request, f *models.Repo, pull *models.Pull, stack models.Stack) types.MergeCheckResponse {

     

       255
       256
        
       	if pull.State == models.PullMerged {

     

       256
       257
        
       		return types.MergeCheckResponse{}

     

       257
       258
        
       	}

     
···

       280
       281
        
       		r.Context(),

     

       281
       282
        
       		&xrpcc,

     

       282
       283
        
       		&tangled.RepoMergeCheck_Input{

     

       283
       283
       -
       			Did:    f.OwnerDid(),

     

       284
       284
       +
       			Did:    f.Did,

     

       284
       285
        
       			Name:   f.Name,

     

       285
       286
        
       			Branch: pull.TargetBranch,

     

       286
       287
        
       			Patch:  patch,

     
···

       318
       319
        
       	return result

     

       319
       320
        
       }

     

       320
       321
        
       

     

       321
       321
       -
       func (s *Pulls) branchDeleteStatus(r *http.Request, f *reporesolver.ResolvedRepo, pull *models.Pull) *models.BranchDeleteStatus {

     

       322
       322
       +
       func (s *Pulls) branchDeleteStatus(r *http.Request, repo *models.Repo, pull *models.Pull) *models.BranchDeleteStatus {

     

       322
       323
        
       	if pull.State != models.PullMerged {

     

       323
       324
        
       		return nil

     

       324
       325
        
       	}

     
···

       329
       330
        
       	}

     

       330
       331
        
       

     

       331
       332
        
       	var branch string

     

       332
       332
       -
       	var repo *models.Repo

     

       333
       333
        
       	// check if the branch exists

     

       334
       334
        
       	// NOTE: appview could cache branches/tags etc. for every repo by listening for gitRefUpdates

     

       335
       335
        
       	if pull.IsBranchBased() {

     

       336
       336
        
       		branch = pull.PullSource.Branch

     

       337
       337
       -
       		repo = &f.Repo

     

       338
       337
        
       	} else if pull.IsForkBased() {

     

       339
       338
        
       		branch = pull.PullSource.Branch

     

       340
       339
        
       		repo = pull.PullSource.Repo

     
···

       373
       372
        
       	}

     

       374
       373
        
       }

     

       375
       374
        
       

     

       376
       376
       -
       func (s *Pulls) resubmitCheck(r *http.Request, f *reporesolver.ResolvedRepo, pull *models.Pull, stack models.Stack) pages.ResubmitResult {

     

       375
       375
       +
       func (s *Pulls) resubmitCheck(r *http.Request, repo *models.Repo, pull *models.Pull, stack models.Stack) pages.ResubmitResult {

     

       377
       376
        
       	if pull.State == models.PullMerged || pull.State == models.PullDeleted || pull.PullSource == nil {

     

       378
       377
        
       		return pages.Unknown

     

       379
       378
        
       	}

     
···

       393
       392
        
       		repoName = sourceRepo.Name

     

       394
       393
        
       	} else {

     

       395
       394
        
       		// pulls within the same repo

     

       396
       396
       -
       		knot = f.Knot

     

       397
       397
       -
       		ownerDid = f.OwnerDid()

     

       398
       398
       -
       		repoName = f.Name

     

       395
       395
       +
       		knot = repo.Knot

     

       396
       396
       +
       		ownerDid = repo.Did

     

       397
       397
       +
       		repoName = repo.Name

     

       399
       398
        
       	}

     

       400
       399
        
       

     

       401
       400
        
       	scheme := "http"

     
···

       407
       406
        
       		Host: host,

     

       408
       407
        
       	}

     

       409
       408
        
       

     

       410
       410
       -
       	repo := fmt.Sprintf("%s/%s", ownerDid, repoName)

     

       411
       411
       -
       	branchResp, err := tangled.RepoBranch(r.Context(), xrpcc, pull.PullSource.Branch, repo)

     

       409
       409
       +
       	didSlashName := fmt.Sprintf("%s/%s", ownerDid, repoName)

     

       410
       410
       +
       	branchResp, err := tangled.RepoBranch(r.Context(), xrpcc, pull.PullSource.Branch, didSlashName)

     

       412
       411
        
       	if err != nil {

     

       413
       412
        
       		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       414
       413
        
       			log.Println("failed to call XRPC repo.branches", xrpcerr)

     
···

       436
       435
        
       

     

       437
       436
        
       func (s *Pulls) RepoPullPatch(w http.ResponseWriter, r *http.Request) {

     

       438
       437
        
       	user := s.oauth.GetUser(r)

     

       439
       439
       -
       	f, err := s.repoResolver.Resolve(r)

     

       440
       440
       -
       	if err != nil {

     

       441
       441
       -
       		log.Println("failed to get repo and knot", err)

     

       442
       442
       -
       		return

     

       443
       443
       -
       	}

     

       444
       438
        
       

     

       445
       439
        
       	var diffOpts types.DiffOpts

     

       446
       440
        
       	if d := r.URL.Query().Get("diff"); d == "split" {

     
···

       469
       463
        
       

     

       470
       464
        
       	s.pages.RepoPullPatchPage(w, pages.RepoPullPatchParams{

     

       471
       465
        
       		LoggedInUser: user,

     

       472
       472
       -
       		RepoInfo:     f.RepoInfo(user),

     

       466
       466
       +
       		RepoInfo:     s.repoResolver.GetRepoInfo(r, user),

     

       473
       467
        
       		Pull:         pull,

     

       474
       468
        
       		Stack:        stack,

     

       475
       469
        
       		Round:        roundIdInt,

     
···

       482
       476
        
       

     

       483
       477
        
       func (s *Pulls) RepoPullInterdiff(w http.ResponseWriter, r *http.Request) {

     

       484
       478
        
       	user := s.oauth.GetUser(r)

     

       485
       485
       -
       

     

       486
       486
       -
       	f, err := s.repoResolver.Resolve(r)

     

       487
       487
       -
       	if err != nil {

     

       488
       488
       -
       		log.Println("failed to get repo and knot", err)

     

       489
       489
       -
       		return

     

       490
       490
       -
       	}

     

       491
       479
        
       

     

       492
       480
        
       	var diffOpts types.DiffOpts

     

       493
       481
        
       	if d := r.URL.Query().Get("diff"); d == "split" {

     
···

       533
       521
        
       

     

       534
       522
        
       	s.pages.RepoPullInterdiffPage(w, pages.RepoPullInterdiffParams{

     

       535
       523
        
       		LoggedInUser: s.oauth.GetUser(r),

     

       536
       536
       -
       		RepoInfo:     f.RepoInfo(user),

     

       524
       524
       +
       		RepoInfo:     s.repoResolver.GetRepoInfo(r, user),

     

       537
       525
        
       		Pull:         pull,

     

       538
       526
        
       		Round:        roundIdInt,

     

       539
       527
        
       		Interdiff:    interdiff,

     
···

       610
       598
        
       

     

       611
       599
        
       	pulls, err := db.GetPulls(

     

       612
       600
        
       		s.db,

     

       613
       613
       -
       		db.FilterIn("id", ids),

     

       601
       601
       +
       		orm.FilterIn("id", ids),

     

       614
       602
        
       	)

     

       615
       603
        
       	if err != nil {

     

       616
       604
        
       		log.Println("failed to get pulls", err)

     
···

       658
       646
        
       	}

     

       659
       647
        
       	pulls = pulls[:n]

     

       660
       648
        
       

     

       661
       661
       -
       	repoInfo := f.RepoInfo(user)

     

       662
       649
        
       	ps, err := db.GetPipelineStatuses(

     

       663
       650
        
       		s.db,

     

       664
       664
       -
       		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       665
       665
       -
       		db.FilterEq("repo_name", repoInfo.Name),

     

       666
       666
       -
       		db.FilterEq("knot", repoInfo.Knot),

     

       667
       667
       -
       		db.FilterIn("sha", shas),

     

       651
       651
       +
       		len(shas),

     

       652
       652
       +
       		orm.FilterEq("repo_owner", f.Did),

     

       653
       653
       +
       		orm.FilterEq("repo_name", f.Name),

     

       654
       654
       +
       		orm.FilterEq("knot", f.Knot),

     

       655
       655
       +
       		orm.FilterIn("sha", shas),

     

       668
       656
        
       	)

     

       669
       657
        
       	if err != nil {

     

       670
       658
        
       		log.Printf("failed to fetch pipeline statuses: %s", err)

     
···

       677
       665
        
       

     

       678
       666
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       679
       667
        
       		s.db,

     

       680
       680
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       681
       681
       -
       		db.FilterContains("scope", tangled.RepoPullNSID),

     

       668
       668
       +
       		orm.FilterIn("at_uri", f.Labels),

     

       669
       669
       +
       		orm.FilterContains("scope", tangled.RepoPullNSID),

     

       682
       670
        
       	)

     

       683
       671
        
       	if err != nil {

     

       684
       672
        
       		log.Println("failed to fetch labels", err)

     
···

       693
       681
        
       

     

       694
       682
        
       	s.pages.RepoPulls(w, pages.RepoPullsParams{

     

       695
       683
        
       		LoggedInUser: s.oauth.GetUser(r),

     

       696
       696
       -
       		RepoInfo:     f.RepoInfo(user),

     

       684
       684
       +
       		RepoInfo:     s.repoResolver.GetRepoInfo(r, user),

     

       697
       685
        
       		Pulls:        pulls,

     

       698
       686
        
       		LabelDefs:    defs,

     

       699
       687
        
       		FilteringBy:  state,

     
···

       730
       718
        
       	case http.MethodGet:

     

       731
       719
        
       		s.pages.PullNewCommentFragment(w, pages.PullNewCommentParams{

     

       732
       720
        
       			LoggedInUser: user,

     

       733
       733
       -
       			RepoInfo:     f.RepoInfo(user),

     

       721
       721
       +
       			RepoInfo:     s.repoResolver.GetRepoInfo(r, user),

     

       734
       722
        
       			Pull:         pull,

     

       735
       723
        
       			RoundNumber:  roundNumber,

     

       736
       724
        
       		})

     
···

       742
       730
        
       			return

     

       743
       731
        
       		}

     

       744
       732
        
       

     

       745
       745
       -
       		mentions, references := s.refResolver.Resolve(r.Context(), body)

     

       733
       733
       +
       		mentions, references := s.mentionsResolver.Resolve(r.Context(), body)

     

       746
       734
        
       

     

       747
       735
        
       		// Start a transaction

     

       748
       736
        
       		tx, err := s.db.BeginTx(r.Context(), nil)

     
···

       807
       795
        
       

     

       808
       796
        
       		s.notifier.NewPullComment(r.Context(), comment, mentions)

     

       809
       797
        
       

     

       810
       810
       -
       		s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", f.OwnerSlashRepo(), pull.PullId, commentId))

     

       798
       798
       +
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       799
       799
       +
       		s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", ownerSlashRepo, pull.PullId, commentId))

     

       811
       800
        
       		return

     

       812
       801
        
       	}

     

       813
       802
        
       }

     
···

       831
       820
        
       			Host: host,

     

       832
       821
        
       		}

     

       833
       822
        
       

     

       834
       834
       -
       		repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       823
       823
       +
       		repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       835
       824
        
       		xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       836
       825
        
       		if err != nil {

     

       837
       826
        
       			if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     
···

       858
       847
        
       

     

       859
       848
        
       		s.pages.RepoNewPull(w, pages.RepoNewPullParams{

     

       860
       849
        
       			LoggedInUser: user,

     

       861
       861
       -
       			RepoInfo:     f.RepoInfo(user),

     

       850
       850
       +
       			RepoInfo:     s.repoResolver.GetRepoInfo(r, user),

     

       862
       851
        
       			Branches:     result.Branches,

     

       863
       852
        
       			Strategy:     strategy,

     

       864
       853
        
       			SourceBranch: sourceBranch,

     
···

       881
       870
        
       		}

     

       882
       871
        
       

     

       883
       872
        
       		// Determine PR type based on input parameters

     

       884
       884
       -
       		isPushAllowed := f.RepoInfo(user).Roles.IsPushAllowed()

     

       873
       873
       +
       		roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}

     

       874
       874
       +
       		isPushAllowed := roles.IsPushAllowed()

     

       885
       875
        
       		isBranchBased := isPushAllowed && sourceBranch != "" && fromFork == ""

     

       886
       876
        
       		isForkBased := fromFork != "" && sourceBranch != ""

     

       887
       877
        
       		isPatchBased := patch != "" && !isBranchBased && !isForkBased

     
···

       979
       969
        
       func (s *Pulls) handleBranchBasedPull(

     

       980
       970
        
       	w http.ResponseWriter,

     

       981
       971
        
       	r *http.Request,

     

       982
       982
       -
       	f *reporesolver.ResolvedRepo,

     

       972
       972
       +
       	repo *models.Repo,

     

       983
       973
        
       	user *oauth.User,

     

       984
       974
        
       	title,

     

       985
       975
        
       	body,

     
···

       991
       981
        
       	if !s.config.Core.Dev {

     

       992
       982
        
       		scheme = "https"

     

       993
       983
        
       	}

     

       994
       994
       -
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       984
       984
       +
       	host := fmt.Sprintf("%s://%s", scheme, repo.Knot)

     

       995
       985
        
       	xrpcc := &indigoxrpc.Client{

     

       996
       986
        
       		Host: host,

     

       997
       987
        
       	}

     

       998
       988
        
       

     

       999
       999
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       1000
       1000
       -
       	xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, targetBranch, sourceBranch)

     

       989
       989
       +
       	didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name)

     

       990
       990
       +
       	xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, didSlashRepo, targetBranch, sourceBranch)

     

       1001
       991
        
       	if err != nil {

     

       1002
       992
        
       		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       1003
       993
        
       			log.Println("failed to call XRPC repo.compare", xrpcerr)

     
···

       1034
       1024
        
       		Sha:    comparison.Rev2,

     

       1035
       1025
        
       	}

     

       1036
       1026
        
       

     

       1037
       1037
       -
       	s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)

     

       1027
       1027
       +
       	s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)

     

       1038
       1028
        
       }

     

       1039
       1029
        
       

     

       1040
       1040
       -
       func (s *Pulls) handlePatchBasedPull(w http.ResponseWriter, r *http.Request, f *reporesolver.ResolvedRepo, user *oauth.User, title, body, targetBranch, patch string, isStacked bool) {

     

       1030
       1030
       +
       func (s *Pulls) handlePatchBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, user *oauth.User, title, body, targetBranch, patch string, isStacked bool) {

     

       1041
       1031
        
       	if err := s.validator.ValidatePatch(&patch); err != nil {

     

       1042
       1032
        
       		s.logger.Error("patch validation failed", "err", err)

     

       1043
       1033
        
       		s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.")

     

       1044
       1034
        
       		return

     

       1045
       1035
        
       	}

     

       1046
       1036
        
       

     

       1047
       1047
       -
       	s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, "", "", nil, nil, isStacked)

     

       1037
       1037
       +
       	s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, "", "", nil, nil, isStacked)

     

       1048
       1038
        
       }

     

       1049
       1039
        
       

     

       1050
       1050
       -
       func (s *Pulls) handleForkBasedPull(w http.ResponseWriter, r *http.Request, f *reporesolver.ResolvedRepo, user *oauth.User, forkRepo string, title, body, targetBranch, sourceBranch string, isStacked bool) {

     

       1040
       1040
       +
       func (s *Pulls) handleForkBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, user *oauth.User, forkRepo string, title, body, targetBranch, sourceBranch string, isStacked bool) {

     

       1051
       1041
        
       	repoString := strings.SplitN(forkRepo, "/", 2)

     

       1052
       1042
        
       	forkOwnerDid := repoString[0]

     

       1053
       1043
        
       	repoName := repoString[1]

     
···

       1149
       1139
        
       		Sha:    sourceRev,

     

       1150
       1140
        
       	}

     

       1151
       1141
        
       

     

       1152
       1152
       -
       	s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)

     

       1142
       1142
       +
       	s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)

     

       1153
       1143
        
       }

     

       1154
       1144
        
       

     

       1155
       1145
        
       func (s *Pulls) createPullRequest(

     

       1156
       1146
        
       	w http.ResponseWriter,

     

       1157
       1147
        
       	r *http.Request,

     

       1158
       1158
       -
       	f *reporesolver.ResolvedRepo,

     

       1148
       1148
       +
       	repo *models.Repo,

     

       1159
       1149
        
       	user *oauth.User,

     

       1160
       1150
        
       	title, body, targetBranch string,

     

       1161
       1151
        
       	patch string,

     
···

       1170
       1160
        
       		s.createStackedPullRequest(

     

       1171
       1161
        
       			w,

     

       1172
       1162
        
       			r,

     

       1173
       1173
       -
       			f,

     

       1163
       1163
       +
       			repo,

     

       1174
       1164
        
       			user,

     

       1175
       1165
        
       			targetBranch,

     

       1176
       1166
        
       			patch,

     
···

       1216
       1206
        
       		}

     

       1217
       1207
        
       	}

     

       1218
       1208
        
       

     

       1219
       1219
       -
       	mentions, references := s.refResolver.Resolve(r.Context(), body)

     

       1209
       1209
       +
       	mentions, references := s.mentionsResolver.Resolve(r.Context(), body)

     

       1220
       1210
        
       

     

       1221
       1211
        
       	rkey := tid.TID()

     

       1222
       1212
        
       	initialSubmission := models.PullSubmission{

     
···

       1229
       1219
        
       		Body:         body,

     

       1230
       1220
        
       		TargetBranch: targetBranch,

     

       1231
       1221
        
       		OwnerDid:     user.Did,

     

       1232
       1232
       -
       		RepoAt:       f.RepoAt(),

     

       1222
       1222
       +
       		RepoAt:       repo.RepoAt(),

     

       1233
       1223
        
       		Rkey:         rkey,

     

       1234
       1224
        
       		Mentions:     mentions,

     

       1235
       1225
        
       		References:   references,

     
···

       1244
       1234
        
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       1245
       1235
        
       		return

     

       1246
       1236
        
       	}

     

       1247
       1247
       -
       	pullId, err := db.NextPullId(tx, f.RepoAt())

     

       1237
       1237
       +
       	pullId, err := db.NextPullId(tx, repo.RepoAt())

     

       1248
       1238
        
       	if err != nil {

     

       1249
       1239
        
       		log.Println("failed to get pull id", err)

     

       1250
       1240
        
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     
···

       1259
       1249
        
       			Val: &tangled.RepoPull{

     

       1260
       1250
        
       				Title: title,

     

       1261
       1251
        
       				Target: &tangled.RepoPull_Target{

     

       1262
       1262
       -
       					Repo:   string(f.RepoAt()),

     

       1252
       1252
       +
       					Repo:   string(repo.RepoAt()),

     

       1263
       1253
        
       					Branch: targetBranch,

     

       1264
       1254
        
       				},

     

       1265
       1255
        
       				Patch:     patch,

     
···

       1282
       1272
        
       

     

       1283
       1273
        
       	s.notifier.NewPull(r.Context(), pull)

     

       1284
       1274
        
       

     

       1285
       1285
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pullId))

     

       1275
       1275
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)

     

       1276
       1276
       +
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pullId))

     

       1286
       1277
        
       }

     

       1287
       1278
        
       

     

       1288
       1279
        
       func (s *Pulls) createStackedPullRequest(

     

       1289
       1280
        
       	w http.ResponseWriter,

     

       1290
       1281
        
       	r *http.Request,

     

       1291
       1291
       -
       	f *reporesolver.ResolvedRepo,

     

       1282
       1282
       +
       	repo *models.Repo,

     

       1292
       1283
        
       	user *oauth.User,

     

       1293
       1284
        
       	targetBranch string,

     

       1294
       1285
        
       	patch string,

     
···

       1320
       1311
        
       

     

       1321
       1312
        
       	// build a stack out of this patch

     

       1322
       1313
        
       	stackId := uuid.New()

     

       1323
       1323
       -
       	stack, err := s.newStack(r.Context(), f, user, targetBranch, patch, pullSource, stackId.String())

     

       1314
       1314
       +
       	stack, err := s.newStack(r.Context(), repo, user, targetBranch, patch, pullSource, stackId.String())

     

       1324
       1315
        
       	if err != nil {

     

       1325
       1316
        
       		log.Println("failed to create stack", err)

     

       1326
       1317
        
       		s.pages.Notice(w, "pull", fmt.Sprintf("Failed to create stack: %v", err))

     
···

       1383
       1374
        
       		return

     

       1384
       1375
        
       	}

     

       1385
       1376
        
       

     

       1386
       1386
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls", f.OwnerSlashRepo()))

     

       1377
       1377
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)

     

       1378
       1378
       +
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls", ownerSlashRepo))

     

       1387
       1379
        
       }

     

       1388
       1380
        
       

     

       1389
       1381
        
       func (s *Pulls) ValidatePatch(w http.ResponseWriter, r *http.Request) {

     
···

       1414
       1406
        
       

     

       1415
       1407
        
       func (s *Pulls) PatchUploadFragment(w http.ResponseWriter, r *http.Request) {

     

       1416
       1408
        
       	user := s.oauth.GetUser(r)

     

       1417
       1417
       -
       	f, err := s.repoResolver.Resolve(r)

     

       1418
       1418
       -
       	if err != nil {

     

       1419
       1419
       -
       		log.Println("failed to get repo and knot", err)

     

       1420
       1420
       -
       		return

     

       1421
       1421
       -
       	}

     

       1422
       1409
        
       

     

       1423
       1410
        
       	s.pages.PullPatchUploadFragment(w, pages.PullPatchUploadParams{

     

       1424
       1424
       -
       		RepoInfo: f.RepoInfo(user),

     

       1411
       1411
       +
       		RepoInfo: s.repoResolver.GetRepoInfo(r, user),

     

       1425
       1412
        
       	})

     

       1426
       1413
        
       }

     

       1427
       1414
        
       

     
···

       1442
       1429
        
       		Host: host,

     

       1443
       1430
        
       	}

     

       1444
       1431
        
       

     

       1445
       1445
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       1432
       1432
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       1446
       1433
        
       	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       1447
       1434
        
       	if err != nil {

     

       1448
       1435
        
       		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     
···

       1475
       1462
        
       	}

     

       1476
       1463
        
       

     

       1477
       1464
        
       	s.pages.PullCompareBranchesFragment(w, pages.PullCompareBranchesParams{

     

       1478
       1478
       -
       		RepoInfo: f.RepoInfo(user),

     

       1465
       1465
       +
       		RepoInfo: s.repoResolver.GetRepoInfo(r, user),

     

       1479
       1466
        
       		Branches: withoutDefault,

     

       1480
       1467
        
       	})

     

       1481
       1468
        
       }

     

       1482
       1469
        
       

     

       1483
       1470
        
       func (s *Pulls) CompareForksFragment(w http.ResponseWriter, r *http.Request) {

     

       1484
       1471
        
       	user := s.oauth.GetUser(r)

     

       1485
       1485
       -
       	f, err := s.repoResolver.Resolve(r)

     

       1486
       1486
       -
       	if err != nil {

     

       1487
       1487
       -
       		log.Println("failed to get repo and knot", err)

     

       1488
       1488
       -
       		return

     

       1489
       1489
       -
       	}

     

       1490
       1472
        
       

     

       1491
       1473
        
       	forks, err := db.GetForksByDid(s.db, user.Did)

     

       1492
       1474
        
       	if err != nil {

     
···

       1495
       1477
        
       	}

     

       1496
       1478
        
       

     

       1497
       1479
        
       	s.pages.PullCompareForkFragment(w, pages.PullCompareForkParams{

     

       1498
       1498
       -
       		RepoInfo: f.RepoInfo(user),

     

       1480
       1480
       +
       		RepoInfo: s.repoResolver.GetRepoInfo(r, user),

     

       1499
       1481
        
       		Forks:    forks,

     

       1500
       1482
        
       		Selected: r.URL.Query().Get("fork"),

     

       1501
       1483
        
       	})

     
···

       1517
       1499
        
       	// fork repo

     

       1518
       1500
        
       	repo, err := db.GetRepo(

     

       1519
       1501
        
       		s.db,

     

       1520
       1520
       -
       		db.FilterEq("did", forkOwnerDid),

     

       1521
       1521
       -
       		db.FilterEq("name", forkName),

     

       1502
       1502
       +
       		orm.FilterEq("did", forkOwnerDid),

     

       1503
       1503
       +
       		orm.FilterEq("name", forkName),

     

       1522
       1504
        
       	)

     

       1523
       1505
        
       	if err != nil {

     

       1524
       1506
        
       		log.Println("failed to get repo", "did", forkOwnerDid, "name", forkName, "err", err)

     
···

       1563
       1545
        
       		Host: targetHost,

     

       1564
       1546
        
       	}

     

       1565
       1547
        
       

     

       1566
       1566
       -
       	targetRepo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       1548
       1548
       +
       	targetRepo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       1567
       1549
        
       	targetXrpcBytes, err := tangled.RepoBranches(r.Context(), targetXrpcc, "", 0, targetRepo)

     

       1568
       1550
        
       	if err != nil {

     

       1569
       1551
        
       		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     
···

       1588
       1570
        
       	})

     

       1589
       1571
        
       

     

       1590
       1572
        
       	s.pages.PullCompareForkBranchesFragment(w, pages.PullCompareForkBranchesParams{

     

       1591
       1591
       -
       		RepoInfo:       f.RepoInfo(user),

     

       1573
       1573
       +
       		RepoInfo:       s.repoResolver.GetRepoInfo(r, user),

     

       1592
       1574
        
       		SourceBranches: sourceBranches.Branches,

     

       1593
       1575
        
       		TargetBranches: targetBranches.Branches,

     

       1594
       1576
        
       	})

     
···

       1596
       1578
        
       

     

       1597
       1579
        
       func (s *Pulls) ResubmitPull(w http.ResponseWriter, r *http.Request) {

     

       1598
       1580
        
       	user := s.oauth.GetUser(r)

     

       1599
       1599
       -
       	f, err := s.repoResolver.Resolve(r)

     

       1600
       1600
       -
       	if err != nil {

     

       1601
       1601
       -
       		log.Println("failed to get repo and knot", err)

     

       1602
       1602
       -
       		return

     

       1603
       1603
       -
       	}

     

       1604
       1581
        
       

     

       1605
       1582
        
       	pull, ok := r.Context().Value("pull").(*models.Pull)

     

       1606
       1583
        
       	if !ok {

     
···

       1612
       1589
        
       	switch r.Method {

     

       1613
       1590
        
       	case http.MethodGet:

     

       1614
       1591
        
       		s.pages.PullResubmitFragment(w, pages.PullResubmitParams{

     

       1615
       1615
       -
       			RepoInfo: f.RepoInfo(user),

     

       1592
       1592
       +
       			RepoInfo: s.repoResolver.GetRepoInfo(r, user),

     

       1616
       1593
        
       			Pull:     pull,

     

       1617
       1594
        
       		})

     

       1618
       1595
        
       		return

     
···

       1679
       1656
        
       		return

     

       1680
       1657
        
       	}

     

       1681
       1658
        
       

     

       1682
       1682
       -
       	if !f.RepoInfo(user).Roles.IsPushAllowed() {

     

       1659
       1659
       +
       	roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}

     

       1660
       1660
       +
       	if !roles.IsPushAllowed() {

     

       1683
       1661
        
       		log.Println("unauthorized user")

     

       1684
       1662
        
       		w.WriteHeader(http.StatusUnauthorized)

     

       1685
       1663
        
       		return

     
···

       1694
       1672
        
       		Host: host,

     

       1695
       1673
        
       	}

     

       1696
       1674
        
       

     

       1697
       1697
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       1675
       1675
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       1698
       1676
        
       	xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, pull.TargetBranch, pull.PullSource.Branch)

     

       1699
       1677
        
       	if err != nil {

     

       1700
       1678
        
       		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     
···

       1821
       1799
        
       func (s *Pulls) resubmitPullHelper(

     

       1822
       1800
        
       	w http.ResponseWriter,

     

       1823
       1801
        
       	r *http.Request,

     

       1824
       1824
       -
       	f *reporesolver.ResolvedRepo,

     

       1802
       1802
       +
       	repo *models.Repo,

     

       1825
       1803
        
       	user *oauth.User,

     

       1826
       1804
        
       	pull *models.Pull,

     

       1827
       1805
        
       	patch string,

     
···

       1830
       1808
        
       ) {

     

       1831
       1809
        
       	if pull.IsStacked() {

     

       1832
       1810
        
       		log.Println("resubmitting stacked PR")

     

       1833
       1833
       -
       		s.resubmitStackedPullHelper(w, r, f, user, pull, patch, pull.StackId)

     

       1811
       1811
       +
       		s.resubmitStackedPullHelper(w, r, repo, user, pull, patch, pull.StackId)

     

       1834
       1812
        
       		return

     

       1835
       1813
        
       	}

     

       1836
       1814
        
       

     
···

       1910
       1888
        
       			Val: &tangled.RepoPull{

     

       1911
       1889
        
       				Title: pull.Title,

     

       1912
       1890
        
       				Target: &tangled.RepoPull_Target{

     

       1913
       1913
       -
       					Repo:   string(f.RepoAt()),

     

       1891
       1891
       +
       					Repo:   string(repo.RepoAt()),

     

       1914
       1892
        
       					Branch: pull.TargetBranch,

     

       1915
       1893
        
       				},

     

       1916
       1894
        
       				Patch:     patch, // new patch

     
···

       1931
       1909
        
       		return

     

       1932
       1910
        
       	}

     

       1933
       1911
        
       

     

       1934
       1934
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))

     

       1912
       1912
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)

     

       1913
       1913
       +
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       1935
       1914
        
       }

     

       1936
       1915
        
       

     

       1937
       1916
        
       func (s *Pulls) resubmitStackedPullHelper(

     

       1938
       1917
        
       	w http.ResponseWriter,

     

       1939
       1918
        
       	r *http.Request,

     

       1940
       1940
       -
       	f *reporesolver.ResolvedRepo,

     

       1919
       1919
       +
       	repo *models.Repo,

     

       1941
       1920
        
       	user *oauth.User,

     

       1942
       1921
        
       	pull *models.Pull,

     

       1943
       1922
        
       	patch string,

     
···

       1946
       1925
        
       	targetBranch := pull.TargetBranch

     

       1947
       1926
        
       

     

       1948
       1927
        
       	origStack, _ := r.Context().Value("stack").(models.Stack)

     

       1949
       1949
       -
       	newStack, err := s.newStack(r.Context(), f, user, targetBranch, patch, pull.PullSource, stackId)

     

       1928
       1928
       +
       	newStack, err := s.newStack(r.Context(), repo, user, targetBranch, patch, pull.PullSource, stackId)

     

       1950
       1929
        
       	if err != nil {

     

       1951
       1930
        
       		log.Println("failed to create resubmitted stack", err)

     

       1952
       1931
        
       		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")

     
···

       2088
       2067
        
       			tx,

     

       2089
       2068
        
       			p.ParentChangeId,

     

       2090
       2069
        
       			// these should be enough filters to be unique per-stack

     

       2091
       2091
       -
       			db.FilterEq("repo_at", p.RepoAt.String()),

     

       2092
       2092
       -
       			db.FilterEq("owner_did", p.OwnerDid),

     

       2093
       2093
       -
       			db.FilterEq("change_id", p.ChangeId),

     

       2070
       2070
       +
       			orm.FilterEq("repo_at", p.RepoAt.String()),

     

       2071
       2071
       +
       			orm.FilterEq("owner_did", p.OwnerDid),

     

       2072
       2072
       +
       			orm.FilterEq("change_id", p.ChangeId),

     

       2094
       2073
        
       		)

     

       2095
       2074
        
       

     

       2096
       2075
        
       		if err != nil {

     
···

       2124
       2103
        
       		return

     

       2125
       2104
        
       	}

     

       2126
       2105
        
       

     

       2127
       2127
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))

     

       2106
       2106
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)

     

       2107
       2107
       +
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       2128
       2108
        
       }

     

       2129
       2109
        
       

     

       2130
       2110
        
       func (s *Pulls) MergePull(w http.ResponseWriter, r *http.Request) {

     
···

       2177
       2157
        
       

     

       2178
       2158
        
       	authorName := ident.Handle.String()

     

       2179
       2159
        
       	mergeInput := &tangled.RepoMerge_Input{

     

       2180
       2180
       -
       		Did:           f.OwnerDid(),

     

       2160
       2160
       +
       		Did:           f.Did,

     

       2181
       2161
        
       		Name:          f.Name,

     

       2182
       2162
        
       		Branch:        pull.TargetBranch,

     

       2183
       2163
        
       		Patch:         patch,

     
···

       2242
       2222
        
       		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)

     

       2243
       2223
        
       	}

     

       2244
       2224
        
       

     

       2245
       2245
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/@%s/%s/pulls/%d", f.OwnerHandle(), f.Name, pull.PullId))

     

       2225
       2225
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       2226
       2226
       +
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       2246
       2227
        
       }

     

       2247
       2228
        
       

     

       2248
       2229
        
       func (s *Pulls) ClosePull(w http.ResponseWriter, r *http.Request) {

     
···

       2262
       2243
        
       	}

     

       2263
       2244
        
       

     

       2264
       2245
        
       	// auth filter: only owner or collaborators can close

     

       2265
       2265
       -
       	roles := f.RolesInRepo(user)

     

       2246
       2246
       +
       	roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}

     

       2266
       2247
        
       	isOwner := roles.IsOwner()

     

       2267
       2248
        
       	isCollaborator := roles.IsCollaborator()

     

       2268
       2249
        
       	isPullAuthor := user.Did == pull.OwnerDid

     
···

       2314
       2295
        
       		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)

     

       2315
       2296
        
       	}

     

       2316
       2297
        
       

     

       2317
       2317
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))

     

       2298
       2298
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       2299
       2299
       +
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       2318
       2300
        
       }

     

       2319
       2301
        
       

     

       2320
       2302
        
       func (s *Pulls) ReopenPull(w http.ResponseWriter, r *http.Request) {

     
···

       2335
       2317
        
       	}

     

       2336
       2318
        
       

     

       2337
       2319
        
       	// auth filter: only owner or collaborators can close

     

       2338
       2338
       -
       	roles := f.RolesInRepo(user)

     

       2320
       2320
       +
       	roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}

     

       2339
       2321
        
       	isOwner := roles.IsOwner()

     

       2340
       2322
        
       	isCollaborator := roles.IsCollaborator()

     

       2341
       2323
        
       	isPullAuthor := user.Did == pull.OwnerDid

     
···

       2387
       2369
        
       		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)

     

       2388
       2370
        
       	}

     

       2389
       2371
        
       

     

       2390
       2390
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))

     

       2372
       2372
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       2373
       2373
       +
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       2391
       2374
        
       }

     

       2392
       2375
        
       

     

       2393
       2393
       -
       func (s *Pulls) newStack(ctx context.Context, f *reporesolver.ResolvedRepo, user *oauth.User, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) {

     

       2376
       2376
       +
       func (s *Pulls) newStack(ctx context.Context, repo *models.Repo, user *oauth.User, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) {

     

       2394
       2377
        
       	formatPatches, err := patchutil.ExtractPatches(patch)

     

       2395
       2378
        
       	if err != nil {

     

       2396
       2379
        
       		return nil, fmt.Errorf("Failed to extract patches: %v", err)

     
···

       2415
       2398
        
       		body := fp.Body

     

       2416
       2399
        
       		rkey := tid.TID()

     

       2417
       2400
        
       

     

       2418
       2418
       -
       		mentions, references := s.refResolver.Resolve(ctx, body)

     

       2401
       2401
       +
       		mentions, references := s.mentionsResolver.Resolve(ctx, body)

     

       2419
       2402
        
       

     

       2420
       2403
        
       		initialSubmission := models.PullSubmission{

     

       2421
       2404
        
       			Patch:     fp.Raw,

     
···

       2427
       2410
        
       			Body:         body,

     

       2428
       2411
        
       			TargetBranch: targetBranch,

     

       2429
       2412
        
       			OwnerDid:     user.Did,

     

       2430
       2430
       -
       			RepoAt:       f.RepoAt(),

     

       2413
       2413
       +
       			RepoAt:       repo.RepoAt(),

     

       2431
       2414
        
       			Rkey:         rkey,

     

       2432
       2415
        
       			Mentions:     mentions,

     

       2433
       2416
        
       			References:   references,

-65

appview/refresolver/resolver.go

···

       1
       1
       -
       package refresolver

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"context"

     

       5
       5
       -
       	"log/slog"

     

       6
       6
       -
       

     

       7
       7
       -
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       8
       8
       -
       	"tangled.org/core/appview/config"

     

       9
       9
       -
       	"tangled.org/core/appview/db"

     

       10
       10
       -
       	"tangled.org/core/appview/models"

     

       11
       11
       -
       	"tangled.org/core/appview/pages/markup"

     

       12
       12
       -
       	"tangled.org/core/idresolver"

     

       13
       13
       -
       )

     

       14
       14
       -
       

     

       15
       15
       -
       type Resolver struct {

     

       16
       16
       -
       	config     *config.Config

     

       17
       17
       -
       	idResolver *idresolver.Resolver

     

       18
       18
       -
       	execer     db.Execer

     

       19
       19
       -
       	logger     *slog.Logger

     

       20
       20
       -
       }

     

       21
       21
       -
       

     

       22
       22
       -
       func New(

     

       23
       23
       -
       	config *config.Config,

     

       24
       24
       -
       	idResolver *idresolver.Resolver,

     

       25
       25
       -
       	execer db.Execer,

     

       26
       26
       -
       	logger *slog.Logger,

     

       27
       27
       -
       ) *Resolver {

     

       28
       28
       -
       	return &Resolver{

     

       29
       29
       -
       		config,

     

       30
       30
       -
       		idResolver,

     

       31
       31
       -
       		execer,

     

       32
       32
       -
       		logger,

     

       33
       33
       -
       	}

     

       34
       34
       -
       }

     

       35
       35
       -
       

     

       36
       36
       -
       func (r *Resolver) Resolve(ctx context.Context, source string) ([]syntax.DID, []syntax.ATURI) {

     

       37
       37
       -
       	l := r.logger.With("method", "Resolve")

     

       38
       38
       -
       	rawMentions, rawRefs := markup.FindReferences(r.config.Core.AppviewHost, source)

     

       39
       39
       -
       	l.Debug("found possible references", "mentions", rawMentions, "refs", rawRefs)

     

       40
       40
       -
       	idents := r.idResolver.ResolveIdents(ctx, rawMentions)

     

       41
       41
       -
       	var mentions []syntax.DID

     

       42
       42
       -
       	for _, ident := range idents {

     

       43
       43
       -
       		if ident != nil && !ident.Handle.IsInvalidHandle() {

     

       44
       44
       -
       			mentions = append(mentions, ident.DID)

     

       45
       45
       -
       		}

     

       46
       46
       -
       	}

     

       47
       47
       -
       	l.Debug("found mentions", "mentions", mentions)

     

       48
       48
       -
       

     

       49
       49
       -
       	var resolvedRefs []models.ReferenceLink

     

       50
       50
       -
       	for _, rawRef := range rawRefs {

     

       51
       51
       -
       		ident, err := r.idResolver.ResolveIdent(ctx, rawRef.Handle)

     

       52
       52
       -
       		if err != nil || ident == nil || ident.Handle.IsInvalidHandle() {

     

       53
       53
       -
       			continue

     

       54
       54
       -
       		}

     

       55
       55
       -
       		rawRef.Handle = string(ident.DID)

     

       56
       56
       -
       		resolvedRefs = append(resolvedRefs, rawRef)

     

       57
       57
       -
       	}

     

       58
       58
       -
       	aturiRefs, err := db.ValidateReferenceLinks(r.execer, resolvedRefs)

     

       59
       59
       -
       	if err != nil {

     

       60
       60
       -
       		l.Error("failed running query", "err", err)

     

       61
       61
       -
       	}

     

       62
       62
       -
       	l.Debug("found references", "refs", aturiRefs)

     

       63
       63
       -
       

     

       64
       64
       -
       	return mentions, aturiRefs

     

       65
       65
       -
       }

+2 -2

appview/repo/archive.go

···

       31
       31
        
       	xrpcc := &indigoxrpc.Client{

     

       32
       32
        
       		Host: host,

     

       33
       33
        
       	}

     

       34
       34
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       35
       35
       -
       	archiveBytes, err := tangled.RepoArchive(r.Context(), xrpcc, "tar.gz", "", ref, repo)

     

       34
       34
       +
       	didSlashRepo := f.DidSlashRepo()

     

       35
       35
       +
       	archiveBytes, err := tangled.RepoArchive(r.Context(), xrpcc, "tar.gz", "", ref, didSlashRepo)

     

       36
       36
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       37
       37
        
       		l.Error("failed to call XRPC repo.archive", "err", xrpcerr)

     

       38
       38
        
       		rp.pages.Error503(w)

+21 -14

appview/repo/artifact.go

···

       14
       14
        
       	"tangled.org/core/appview/db"

     

       15
       15
        
       	"tangled.org/core/appview/models"

     

       16
       16
        
       	"tangled.org/core/appview/pages"

     

       17
       17
       -
       	"tangled.org/core/appview/reporesolver"

     

       18
       17
        
       	"tangled.org/core/appview/xrpcclient"

     

       18
       18
       +
       	"tangled.org/core/orm"

     

       19
       19
        
       	"tangled.org/core/tid"

     

       20
       20
        
       	"tangled.org/core/types"

     

       21
       21
        
       

     
···

       131
       131
        
       

     

       132
       132
        
       	rp.pages.RepoArtifactFragment(w, pages.RepoArtifactParams{

     

       133
       133
        
       		LoggedInUser: user,

     

       134
       134
       -
       		RepoInfo:     f.RepoInfo(user),

     

       134
       134
       +
       		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       135
       135
        
       		Artifact:     artifact,

     

       136
       136
        
       	})

     

       137
       137
        
       }

     
···

       156
       156
        
       

     

       157
       157
        
       	artifacts, err := db.GetArtifact(

     

       158
       158
        
       		rp.db,

     

       159
       159
       -
       		db.FilterEq("repo_at", f.RepoAt()),

     

       160
       160
       -
       		db.FilterEq("tag", tag.Tag.Hash[:]),

     

       161
       161
       -
       		db.FilterEq("name", filename),

     

       159
       159
       +
       		orm.FilterEq("repo_at", f.RepoAt()),

     

       160
       160
       +
       		orm.FilterEq("tag", tag.Tag.Hash[:]),

     

       161
       161
       +
       		orm.FilterEq("name", filename),

     

       162
       162
        
       	)

     

       163
       163
        
       	if err != nil {

     

       164
       164
        
       		log.Println("failed to get artifacts", err)

     
···

       174
       174
        
       

     

       175
       175
        
       	artifact := artifacts[0]

     

       176
       176
        
       

     

       177
       177
       -
       	ownerPds := f.OwnerId.PDSEndpoint()

     

       177
       177
       +
       	ownerId, err := rp.idResolver.ResolveIdent(r.Context(), f.Did)

     

       178
       178
       +
       	if err != nil {

     

       179
       179
       +
       		log.Println("failed to resolve repo owner did", f.Did, err)

     

       180
       180
       +
       		http.Error(w, "repository owner not found", http.StatusNotFound)

     

       181
       181
       +
       		return

     

       182
       182
       +
       	}

     

       183
       183
       +
       

     

       184
       184
       +
       	ownerPds := ownerId.PDSEndpoint()

     

       178
       185
        
       	url, _ := url.Parse(fmt.Sprintf("%s/xrpc/com.atproto.sync.getBlob", ownerPds))

     

       179
       186
        
       	q := url.Query()

     

       180
       187
        
       	q.Set("cid", artifact.BlobCid.String())

     
···

       228
       235
        
       

     

       229
       236
        
       	artifacts, err := db.GetArtifact(

     

       230
       237
        
       		rp.db,

     

       231
       231
       -
       		db.FilterEq("repo_at", f.RepoAt()),

     

       232
       232
       -
       		db.FilterEq("tag", tag[:]),

     

       233
       233
       -
       		db.FilterEq("name", filename),

     

       238
       238
       +
       		orm.FilterEq("repo_at", f.RepoAt()),

     

       239
       239
       +
       		orm.FilterEq("tag", tag[:]),

     

       240
       240
       +
       		orm.FilterEq("name", filename),

     

       234
       241
        
       	)

     

       235
       242
        
       	if err != nil {

     

       236
       243
        
       		log.Println("failed to get artifacts", err)

     
···

       270
       277
        
       	defer tx.Rollback()

     

       271
       278
        
       

     

       272
       279
        
       	err = db.DeleteArtifact(tx,

     

       273
       273
       -
       		db.FilterEq("repo_at", f.RepoAt()),

     

       274
       274
       -
       		db.FilterEq("tag", artifact.Tag[:]),

     

       275
       275
       -
       		db.FilterEq("name", filename),

     

       280
       280
       +
       		orm.FilterEq("repo_at", f.RepoAt()),

     

       281
       281
       +
       		orm.FilterEq("tag", artifact.Tag[:]),

     

       282
       282
       +
       		orm.FilterEq("name", filename),

     

       276
       283
        
       	)

     

       277
       284
        
       	if err != nil {

     

       278
       285
        
       		log.Println("failed to remove artifact record from db", err)

     
···

       290
       297
        
       	w.Write([]byte{})

     

       291
       298
        
       }

     

       292
       299
        
       

     

       293
       293
       -
       func (rp *Repo) resolveTag(ctx context.Context, f *reporesolver.ResolvedRepo, tagParam string) (*types.TagReference, error) {

     

       300
       300
       +
       func (rp *Repo) resolveTag(ctx context.Context, f *models.Repo, tagParam string) (*types.TagReference, error) {

     

       294
       301
        
       	tagParam, err := url.QueryUnescape(tagParam)

     

       295
       302
        
       	if err != nil {

     

       296
       303
        
       		return nil, err

     
···

       305
       312
        
       		Host: host,

     

       306
       313
        
       	}

     

       307
       314
        
       

     

       308
       308
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       315
       315
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       309
       316
        
       	xrpcBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, repo)

     

       310
       317
        
       	if err != nil {

     

       311
       318
        
       		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

+142 -68

appview/repo/blob.go

···

       1
       1
        
       package repo

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"encoding/base64"

     

       4
       5
        
       	"fmt"

     

       5
       6
        
       	"io"

     

       6
       7
        
       	"net/http"

     
···

       10
       11
        
       	"strings"

     

       11
       12
        
       

     

       12
       13
        
       	"tangled.org/core/api/tangled"

     

       14
       14
       +
       	"tangled.org/core/appview/config"

     

       15
       15
       +
       	"tangled.org/core/appview/models"

     

       13
       16
        
       	"tangled.org/core/appview/pages"

     

       14
       17
        
       	"tangled.org/core/appview/pages/markup"

     

       18
       18
       +
       	"tangled.org/core/appview/reporesolver"

     

       15
       19
        
       	xrpcclient "tangled.org/core/appview/xrpcclient"

     

       16
       20
        
       

     

       17
       21
        
       	indigoxrpc "github.com/bluesky-social/indigo/xrpc"

     

       18
       22
        
       	"github.com/go-chi/chi/v5"

     

       19
       23
        
       )

     

       20
       24
        
       

     

       25
       25
       +
       // the content can be one of the following:

     

       26
       26
       +
       //

     

       27
       27
       +
       // - code      : text |          | raw

     

       28
       28
       +
       // - markup    : text | rendered | raw

     

       29
       29
       +
       // - svg       : text | rendered | raw

     

       30
       30
       +
       // - png       :      | rendered | raw

     

       31
       31
       +
       // - video     :      | rendered | raw

     

       32
       32
       +
       // - submodule :      | rendered |

     

       33
       33
       +
       // - rest      :      |          |

     

       21
       34
        
       func (rp *Repo) Blob(w http.ResponseWriter, r *http.Request) {

     

       22
       35
        
       	l := rp.logger.With("handler", "RepoBlob")

     

       36
       36
       +
       

     

       23
       37
        
       	f, err := rp.repoResolver.Resolve(r)

     

       24
       38
        
       	if err != nil {

     

       25
       39
        
       		l.Error("failed to get repo and knot", "err", err)

     

       26
       40
        
       		return

     

       27
       41
        
       	}

     

       42
       42
       +
       

     

       28
       43
        
       	ref := chi.URLParam(r, "ref")

     

       29
       44
        
       	ref, _ = url.PathUnescape(ref)

     

       45
       45
       +
       

     

       30
       46
        
       	filePath := chi.URLParam(r, "*")

     

       31
       47
        
       	filePath, _ = url.PathUnescape(filePath)

     

       48
       48
       +
       

     

       32
       49
        
       	scheme := "http"

     

       33
       50
        
       	if !rp.config.Core.Dev {

     

       34
       51
        
       		scheme = "https"

     
···

       37
       54
        
       	xrpcc := &indigoxrpc.Client{

     

       38
       55
        
       		Host: host,

     

       39
       56
        
       	}

     

       40
       40
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Repo.Name)

     

       57
       57
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       41
       58
        
       	resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo)

     

       42
       59
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       43
       60
        
       		l.Error("failed to call XRPC repo.blob", "err", xrpcerr)

     

       44
       61
        
       		rp.pages.Error503(w)

     

       45
       62
        
       		return

     

       46
       63
        
       	}

     

       64
       64
       +
       

     

       65
       65
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       66
       66
       +
       

     

       47
       67
        
       	// Use XRPC response directly instead of converting to internal types

     

       48
       68
        
       	var breadcrumbs [][]string

     

       49
       49
       -
       	breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))})

     

       69
       69
       +
       	breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", ownerSlashRepo, url.PathEscape(ref))})

     

       50
       70
        
       	if filePath != "" {

     

       51
       71
        
       		for idx, elem := range strings.Split(filePath, "/") {

     

       52
       72
        
       			breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], url.PathEscape(elem))})

     

       53
       73
        
       		}

     

       54
       74
        
       	}

     

       55
       55
       -
       	showRendered := false

     

       56
       56
       -
       	renderToggle := false

     

       57
       57
       -
       	if markup.GetFormat(resp.Path) == markup.FormatMarkdown {

     

       58
       58
       -
       		renderToggle = true

     

       59
       59
       -
       		showRendered = r.URL.Query().Get("code") != "true"

     

       60
       60
       -
       	}

     

       61
       61
       -
       	var unsupported bool

     

       62
       62
       -
       	var isImage bool

     

       63
       63
       -
       	var isVideo bool

     

       64
       64
       -
       	var contentSrc string

     

       65
       65
       -
       	if resp.IsBinary != nil && *resp.IsBinary {

     

       66
       66
       -
       		ext := strings.ToLower(filepath.Ext(resp.Path))

     

       67
       67
       -
       		switch ext {

     

       68
       68
       -
       		case ".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp":

     

       69
       69
       -
       			isImage = true

     

       70
       70
       -
       		case ".mp4", ".webm", ".ogg", ".mov", ".avi":

     

       71
       71
       -
       			isVideo = true

     

       72
       72
       -
       		default:

     

       73
       73
       -
       			unsupported = true

     

       74
       74
       -
       		}

     

       75
       75
       -
       		// fetch the raw binary content using sh.tangled.repo.blob xrpc

     

       76
       76
       -
       		repoName := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       77
       77
       -
       		baseURL := &url.URL{

     

       78
       78
       -
       			Scheme: scheme,

     

       79
       79
       -
       			Host:   f.Knot,

     

       80
       80
       -
       			Path:   "/xrpc/sh.tangled.repo.blob",

     

       81
       81
       -
       		}

     

       82
       82
       -
       		query := baseURL.Query()

     

       83
       83
       -
       		query.Set("repo", repoName)

     

       84
       84
       -
       		query.Set("ref", ref)

     

       85
       85
       -
       		query.Set("path", filePath)

     

       86
       86
       -
       		query.Set("raw", "true")

     

       87
       87
       -
       		baseURL.RawQuery = query.Encode()

     

       88
       88
       -
       		blobURL := baseURL.String()

     

       89
       89
       -
       		contentSrc = blobURL

     

       90
       90
       -
       		if !rp.config.Core.Dev {

     

       91
       91
       -
       			contentSrc = markup.GenerateCamoURL(rp.config.Camo.Host, rp.config.Camo.SharedSecret, blobURL)

     

       92
       92
       -
       		}

     

       93
       93
       -
       	}

     

       94
       94
       -
       	lines := 0

     

       95
       95
       -
       	if resp.IsBinary == nil || !*resp.IsBinary {

     

       96
       96
       -
       		lines = strings.Count(resp.Content, "\n") + 1

     

       97
       97
       -
       	}

     

       98
       98
       -
       	var sizeHint uint64

     

       99
       99
       -
       	if resp.Size != nil {

     

       100
       100
       -
       		sizeHint = uint64(*resp.Size)

     

       101
       101
       -
       	} else {

     

       102
       102
       -
       		sizeHint = uint64(len(resp.Content))

     

       103
       103
       -
       	}

     

       75
       75
       +
       

     

       76
       76
       +
       	// Create the blob view

     

       77
       77
       +
       	blobView := NewBlobView(resp, rp.config, f, ref, filePath, r.URL.Query())

     

       78
       78
       +
       

     

       104
       79
        
       	user := rp.oauth.GetUser(r)

     

       105
       105
       -
       	// Determine if content is binary (dereference pointer)

     

       106
       106
       -
       	isBinary := false

     

       107
       107
       -
       	if resp.IsBinary != nil {

     

       108
       108
       -
       		isBinary = *resp.IsBinary

     

       109
       109
       -
       	}

     

       80
       80
       +
       

     

       110
       81
        
       	rp.pages.RepoBlob(w, pages.RepoBlobParams{

     

       111
       82
        
       		LoggedInUser:    user,

     

       112
       112
       -
       		RepoInfo:        f.RepoInfo(user),

     

       83
       83
       +
       		RepoInfo:        rp.repoResolver.GetRepoInfo(r, user),

     

       113
       84
        
       		BreadCrumbs:     breadcrumbs,

     

       114
       114
       -
       		ShowRendered:    showRendered,

     

       115
       115
       -
       		RenderToggle:    renderToggle,

     

       116
       116
       -
       		Unsupported:     unsupported,

     

       117
       117
       -
       		IsImage:         isImage,

     

       118
       118
       -
       		IsVideo:         isVideo,

     

       119
       119
       -
       		ContentSrc:      contentSrc,

     

       85
       85
       +
       		BlobView:        blobView,

     

       120
       86
        
       		RepoBlob_Output: resp,

     

       121
       121
       -
       		Contents:        resp.Content,

     

       122
       122
       -
       		Lines:           lines,

     

       123
       123
       -
       		SizeHint:        sizeHint,

     

       124
       124
       -
       		IsBinary:        isBinary,

     

       125
       87
        
       	})

     

       126
       88
        
       }

     

       127
       89
        
       

     

       128
       90
        
       func (rp *Repo) RepoBlobRaw(w http.ResponseWriter, r *http.Request) {

     

       129
       91
        
       	l := rp.logger.With("handler", "RepoBlobRaw")

     

       92
       92
       +
       

     

       130
       93
        
       	f, err := rp.repoResolver.Resolve(r)

     

       131
       94
        
       	if err != nil {

     

       132
       95
        
       		l.Error("failed to get repo and knot", "err", err)

     

       133
       96
        
       		w.WriteHeader(http.StatusBadRequest)

     

       134
       97
        
       		return

     

       135
       98
        
       	}

     

       99
       99
       +
       

     

       136
       100
        
       	ref := chi.URLParam(r, "ref")

     

       137
       101
        
       	ref, _ = url.PathUnescape(ref)

     

       102
       102
       +
       

     

       138
       103
        
       	filePath := chi.URLParam(r, "*")

     

       139
       104
        
       	filePath, _ = url.PathUnescape(filePath)

     

       105
       105
       +
       

     

       140
       106
        
       	scheme := "http"

     

       141
       107
        
       	if !rp.config.Core.Dev {

     

       142
       108
        
       		scheme = "https"

     

       143
       109
        
       	}

     

       144
       144
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Repo.Name)

     

       110
       110
       +
       	repo := f.DidSlashRepo()

     

       145
       111
        
       	baseURL := &url.URL{

     

       146
       112
        
       		Scheme: scheme,

     

       147
       113
        
       		Host:   f.Knot,

     
···

       159
       125
        
       		l.Error("failed to create request", "err", err)

     

       160
       126
        
       		return

     

       161
       127
        
       	}

     

       128
       128
       +
       

     

       162
       129
        
       	// forward the If-None-Match header

     

       163
       130
        
       	if clientETag := r.Header.Get("If-None-Match"); clientETag != "" {

     

       164
       131
        
       		req.Header.Set("If-None-Match", clientETag)

     

       165
       132
        
       	}

     

       166
       133
        
       	client := &http.Client{}

     

       134
       134
       +
       

     

       167
       135
        
       	resp, err := client.Do(req)

     

       168
       136
        
       	if err != nil {

     

       169
       137
        
       		l.Error("failed to reach knotserver", "err", err)

     

       170
       138
        
       		rp.pages.Error503(w)

     

       171
       139
        
       		return

     

       172
       140
        
       	}

     

       141
       141
       +
       

     

       173
       142
        
       	defer resp.Body.Close()

     

       143
       143
       +
       

     

       174
       144
        
       	// forward 304 not modified

     

       175
       145
        
       	if resp.StatusCode == http.StatusNotModified {

     

       176
       146
        
       		w.WriteHeader(http.StatusNotModified)

     

       177
       147
        
       		return

     

       178
       148
        
       	}

     

       149
       149
       +
       

     

       179
       150
        
       	if resp.StatusCode != http.StatusOK {

     

       180
       151
        
       		l.Error("knotserver returned non-OK status for raw blob", "url", blobURL, "statuscode", resp.StatusCode)

     

       181
       152
        
       		w.WriteHeader(resp.StatusCode)

     

       182
       153
        
       		_, _ = io.Copy(w, resp.Body)

     

       183
       154
        
       		return

     

       184
       155
        
       	}

     

       156
       156
       +
       

     

       185
       157
        
       	contentType := resp.Header.Get("Content-Type")

     

       186
       158
        
       	body, err := io.ReadAll(resp.Body)

     

       187
       159
        
       	if err != nil {

     
···

       189
       161
        
       		w.WriteHeader(http.StatusInternalServerError)

     

       190
       162
        
       		return

     

       191
       163
        
       	}

     

       164
       164
       +
       

     

       192
       165
        
       	if strings.HasPrefix(contentType, "text/") || isTextualMimeType(contentType) {

     

       193
       166
        
       		// serve all textual content as text/plain

     

       194
       167
        
       		w.Header().Set("Content-Type", "text/plain; charset=utf-8")

     
···

       202
       175
        
       		w.Write([]byte("unsupported content type"))

     

       203
       176
        
       		return

     

       204
       177
        
       	}

     

       178
       178
       +
       }

     

       179
       179
       +
       

     

       180
       180
       +
       // NewBlobView creates a BlobView from the XRPC response

     

       181
       181
       +
       func NewBlobView(resp *tangled.RepoBlob_Output, config *config.Config, repo *models.Repo, ref, filePath string, queryParams url.Values) models.BlobView {

     

       182
       182
       +
       	view := models.BlobView{

     

       183
       183
       +
       		Contents: "",

     

       184
       184
       +
       		Lines:    0,

     

       185
       185
       +
       	}

     

       186
       186
       +
       

     

       187
       187
       +
       	// Set size

     

       188
       188
       +
       	if resp.Size != nil {

     

       189
       189
       +
       		view.SizeHint = uint64(*resp.Size)

     

       190
       190
       +
       	} else if resp.Content != nil {

     

       191
       191
       +
       		view.SizeHint = uint64(len(*resp.Content))

     

       192
       192
       +
       	}

     

       193
       193
       +
       

     

       194
       194
       +
       	if resp.Submodule != nil {

     

       195
       195
       +
       		view.ContentType = models.BlobContentTypeSubmodule

     

       196
       196
       +
       		view.HasRenderedView = true

     

       197
       197
       +
       		view.ContentSrc = resp.Submodule.Url

     

       198
       198
       +
       		return view

     

       199
       199
       +
       	}

     

       200
       200
       +
       

     

       201
       201
       +
       	// Determine if binary

     

       202
       202
       +
       	if resp.IsBinary != nil && *resp.IsBinary {

     

       203
       203
       +
       		view.ContentSrc = generateBlobURL(config, repo, ref, filePath)

     

       204
       204
       +
       		ext := strings.ToLower(filepath.Ext(resp.Path))

     

       205
       205
       +
       

     

       206
       206
       +
       		switch ext {

     

       207
       207
       +
       		case ".jpg", ".jpeg", ".png", ".gif", ".webp":

     

       208
       208
       +
       			view.ContentType = models.BlobContentTypeImage

     

       209
       209
       +
       			view.HasRawView = true

     

       210
       210
       +
       			view.HasRenderedView = true

     

       211
       211
       +
       			view.ShowingRendered = true

     

       212
       212
       +
       

     

       213
       213
       +
       		case ".svg":

     

       214
       214
       +
       			view.ContentType = models.BlobContentTypeSvg

     

       215
       215
       +
       			view.HasRawView = true

     

       216
       216
       +
       			view.HasTextView = true

     

       217
       217
       +
       			view.HasRenderedView = true

     

       218
       218
       +
       			view.ShowingRendered = queryParams.Get("code") != "true"

     

       219
       219
       +
       			if resp.Content != nil {

     

       220
       220
       +
       				bytes, _ := base64.StdEncoding.DecodeString(*resp.Content)

     

       221
       221
       +
       				view.Contents = string(bytes)

     

       222
       222
       +
       				view.Lines = strings.Count(view.Contents, "\n") + 1

     

       223
       223
       +
       			}

     

       224
       224
       +
       

     

       225
       225
       +
       		case ".mp4", ".webm", ".ogg", ".mov", ".avi":

     

       226
       226
       +
       			view.ContentType = models.BlobContentTypeVideo

     

       227
       227
       +
       			view.HasRawView = true

     

       228
       228
       +
       			view.HasRenderedView = true

     

       229
       229
       +
       			view.ShowingRendered = true

     

       230
       230
       +
       		}

     

       231
       231
       +
       

     

       232
       232
       +
       		return view

     

       233
       233
       +
       	}

     

       234
       234
       +
       

     

       235
       235
       +
       	// otherwise, we are dealing with text content

     

       236
       236
       +
       	view.HasRawView = true

     

       237
       237
       +
       	view.HasTextView = true

     

       238
       238
       +
       

     

       239
       239
       +
       	if resp.Content != nil {

     

       240
       240
       +
       		view.Contents = *resp.Content

     

       241
       241
       +
       		view.Lines = strings.Count(view.Contents, "\n") + 1

     

       242
       242
       +
       	}

     

       243
       243
       +
       

     

       244
       244
       +
       	// with text, we may be dealing with markdown

     

       245
       245
       +
       	format := markup.GetFormat(resp.Path)

     

       246
       246
       +
       	if format == markup.FormatMarkdown {

     

       247
       247
       +
       		view.ContentType = models.BlobContentTypeMarkup

     

       248
       248
       +
       		view.HasRenderedView = true

     

       249
       249
       +
       		view.ShowingRendered = queryParams.Get("code") != "true"

     

       250
       250
       +
       	}

     

       251
       251
       +
       

     

       252
       252
       +
       	return view

     

       253
       253
       +
       }

     

       254
       254
       +
       

     

       255
       255
       +
       func generateBlobURL(config *config.Config, repo *models.Repo, ref, filePath string) string {

     

       256
       256
       +
       	scheme := "http"

     

       257
       257
       +
       	if !config.Core.Dev {

     

       258
       258
       +
       		scheme = "https"

     

       259
       259
       +
       	}

     

       260
       260
       +
       

     

       261
       261
       +
       	repoName := fmt.Sprintf("%s/%s", repo.Did, repo.Name)

     

       262
       262
       +
       	baseURL := &url.URL{

     

       263
       263
       +
       		Scheme: scheme,

     

       264
       264
       +
       		Host:   repo.Knot,

     

       265
       265
       +
       		Path:   "/xrpc/sh.tangled.repo.blob",

     

       266
       266
       +
       	}

     

       267
       267
       +
       	query := baseURL.Query()

     

       268
       268
       +
       	query.Set("repo", repoName)

     

       269
       269
       +
       	query.Set("ref", ref)

     

       270
       270
       +
       	query.Set("path", filePath)

     

       271
       271
       +
       	query.Set("raw", "true")

     

       272
       272
       +
       	baseURL.RawQuery = query.Encode()

     

       273
       273
       +
       	blobURL := baseURL.String()

     

       274
       274
       +
       

     

       275
       275
       +
       	if !config.Core.Dev {

     

       276
       276
       +
       		return markup.GenerateCamoURL(config.Camo.Host, config.Camo.SharedSecret, blobURL)

     

       277
       277
       +
       	}

     

       278
       278
       +
       	return blobURL

     

       205
       279
        
       }

     

       206
       280
        
       

     

       207
       281
        
       func isTextualMimeType(mimeType string) bool {

+2 -2

appview/repo/branches.go

···

       29
       29
        
       	xrpcc := &indigoxrpc.Client{

     

       30
       30
        
       		Host: host,

     

       31
       31
        
       	}

     

       32
       32
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       32
       32
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       33
       33
        
       	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       34
       34
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       35
       35
        
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     
···

       46
       46
        
       	user := rp.oauth.GetUser(r)

     

       47
       47
        
       	rp.pages.RepoBranches(w, pages.RepoBranchesParams{

     

       48
       48
        
       		LoggedInUser:         user,

     

       49
       49
       -
       		RepoInfo:             f.RepoInfo(user),

     

       49
       49
       +
       		RepoInfo:             rp.repoResolver.GetRepoInfo(r, user),

     

       50
       50
        
       		RepoBranchesResponse: result,

     

       51
       51
        
       	})

     

       52
       52
        
       }

+18 -18

appview/repo/compare.go

···

       36
       36
        
       		Host: host,

     

       37
       37
        
       	}

     

       38
       38
        
       

     

       39
       39
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       39
       39
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       40
       40
        
       	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       41
       41
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       42
       42
        
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     
···

       88
       88
        
       		return

     

       89
       89
        
       	}

     

       90
       90
        
       

     

       91
       91
       -
       	repoinfo := f.RepoInfo(user)

     

       92
       92
       -
       

     

       93
       91
        
       	rp.pages.RepoCompareNew(w, pages.RepoCompareNewParams{

     

       94
       92
        
       		LoggedInUser: user,

     

       95
       95
       -
       		RepoInfo:     repoinfo,

     

       93
       93
       +
       		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       96
       94
        
       		Branches:     branches,

     

       97
       95
        
       		Tags:         tags.Tags,

     

       98
       96
        
       		Base:         base,

     
···

       116
       114
        
       	}

     

       117
       115
        
       

     

       118
       116
        
       	// if user is navigating to one of

     

       119
       119
       -
       	//   /compare/{base}/{head}

     

       120
       117
        
       	//   /compare/{base}...{head}

     

       121
       121
       -
       	base := chi.URLParam(r, "base")

     

       122
       122
       -
       	head := chi.URLParam(r, "head")

     

       123
       123
       -
       	if base == "" && head == "" {

     

       124
       124
       -
       		rest := chi.URLParam(r, "*") // master...feature/xyz

     

       125
       125
       -
       		parts := strings.SplitN(rest, "...", 2)

     

       126
       126
       -
       		if len(parts) == 2 {

     

       127
       127
       -
       			base = parts[0]

     

       128
       128
       -
       			head = parts[1]

     

       129
       129
       -
       		}

     

       118
       118
       +
       	//   /compare/{base}/{head}

     

       119
       119
       +
       	var base, head string

     

       120
       120
       +
       	rest := chi.URLParam(r, "*")

     

       121
       121
       +
       

     

       122
       122
       +
       	var parts []string

     

       123
       123
       +
       	if strings.Contains(rest, "...") {

     

       124
       124
       +
       		parts = strings.SplitN(rest, "...", 2)

     

       125
       125
       +
       	} else if strings.Contains(rest, "/") {

     

       126
       126
       +
       		parts = strings.SplitN(rest, "/", 2)

     

       127
       127
       +
       	}

     

       128
       128
       +
       

     

       129
       129
       +
       	if len(parts) == 2 {

     

       130
       130
       +
       		base = parts[0]

     

       131
       131
       +
       		head = parts[1]

     

       130
       132
        
       	}

     

       131
       133
        
       

     

       132
       134
        
       	base, _ = url.PathUnescape(base)

     
···

       147
       149
        
       		Host: host,

     

       148
       150
        
       	}

     

       149
       151
        
       

     

       150
       150
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       152
       152
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       151
       153
        
       

     

       152
       154
        
       	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       153
       155
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     
···

       198
       200
        
       		diff = patchutil.AsNiceDiff(formatPatch.FormatPatchRaw, base)

     

       199
       201
        
       	}

     

       200
       202
        
       

     

       201
       201
       -
       	repoinfo := f.RepoInfo(user)

     

       202
       202
       -
       

     

       203
       203
        
       	rp.pages.RepoCompare(w, pages.RepoCompareParams{

     

       204
       204
        
       		LoggedInUser: user,

     

       205
       205
       -
       		RepoInfo:     repoinfo,

     

       205
       205
       +
       		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       206
       206
        
       		Branches:     branches.Branches,

     

       207
       207
        
       		Tags:         tags.Tags,

     

       208
       208
        
       		Base:         base,

+24 -17

appview/repo/feed.go

···

       11
       11
        
       	"tangled.org/core/appview/db"

     

       12
       12
        
       	"tangled.org/core/appview/models"

     

       13
       13
        
       	"tangled.org/core/appview/pagination"

     

       14
       14
       -
       	"tangled.org/core/appview/reporesolver"

     

       14
       14
       +
       	"tangled.org/core/orm"

     

       15
       15
        
       

     

       16
       16
       +
       	"github.com/bluesky-social/indigo/atproto/identity"

     

       16
       17
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       17
       18
        
       	"github.com/gorilla/feeds"

     

       18
       19
        
       )

     

       19
       20
        
       

     

       20
       20
       -
       func (rp *Repo) getRepoFeed(ctx context.Context, f *reporesolver.ResolvedRepo) (*feeds.Feed, error) {

     

       21
       21
       +
       func (rp *Repo) getRepoFeed(ctx context.Context, repo *models.Repo, ownerSlashRepo string) (*feeds.Feed, error) {

     

       21
       22
        
       	const feedLimitPerType = 100

     

       22
       23
        
       

     

       23
       23
       -
       	pulls, err := db.GetPullsWithLimit(rp.db, feedLimitPerType, db.FilterEq("repo_at", f.RepoAt()))

     

       24
       24
       +
       	pulls, err := db.GetPullsWithLimit(rp.db, feedLimitPerType, orm.FilterEq("repo_at", repo.RepoAt()))

     

       24
       25
        
       	if err != nil {

     

       25
       26
        
       		return nil, err

     

       26
       27
        
       	}

     
···

       28
       29
        
       	issues, err := db.GetIssuesPaginated(

     

       29
       30
        
       		rp.db,

     

       30
       31
        
       		pagination.Page{Limit: feedLimitPerType},

     

       31
       31
       -
       		db.FilterEq("repo_at", f.RepoAt()),

     

       32
       32
       +
       		orm.FilterEq("repo_at", repo.RepoAt()),

     

       32
       33
        
       	)

     

       33
       34
        
       	if err != nil {

     

       34
       35
        
       		return nil, err

     

       35
       36
        
       	}

     

       36
       37
        
       

     

       37
       38
        
       	feed := &feeds.Feed{

     

       38
       38
       -
       		Title:   fmt.Sprintf("activity feed for %s", f.OwnerSlashRepo()),

     

       39
       39
       -
       		Link:    &feeds.Link{Href: fmt.Sprintf("%s/%s", rp.config.Core.AppviewHost, f.OwnerSlashRepo()), Type: "text/html", Rel: "alternate"},

     

       39
       39
       +
       		Title:   fmt.Sprintf("activity feed for @%s", ownerSlashRepo),

     

       40
       40
       +
       		Link:    &feeds.Link{Href: fmt.Sprintf("%s/%s", rp.config.Core.AppviewHost, ownerSlashRepo), Type: "text/html", Rel: "alternate"},

     

       40
       41
        
       		Items:   make([]*feeds.Item, 0),

     

       41
       42
        
       		Updated: time.UnixMilli(0),

     

       42
       43
        
       	}

     

       43
       44
        
       

     

       44
       45
        
       	for _, pull := range pulls {

     

       45
       45
       -
       		items, err := rp.createPullItems(ctx, pull, f)

     

       46
       46
       +
       		items, err := rp.createPullItems(ctx, pull, repo, ownerSlashRepo)

     

       46
       47
        
       		if err != nil {

     

       47
       48
        
       			return nil, err

     

       48
       49
        
       		}

     
···

       50
       51
        
       	}

     

       51
       52
        
       

     

       52
       53
        
       	for _, issue := range issues {

     

       53
       53
       -
       		item, err := rp.createIssueItem(ctx, issue, f)

     

       54
       54
       +
       		item, err := rp.createIssueItem(ctx, issue, repo, ownerSlashRepo)

     

       54
       55
        
       		if err != nil {

     

       55
       56
        
       			return nil, err

     

       56
       57
        
       		}

     
···

       71
       72
        
       	return feed, nil

     

       72
       73
        
       }

     

       73
       74
        
       

     

       74
       74
       -
       func (rp *Repo) createPullItems(ctx context.Context, pull *models.Pull, f *reporesolver.ResolvedRepo) ([]*feeds.Item, error) {

     

       75
       75
       +
       func (rp *Repo) createPullItems(ctx context.Context, pull *models.Pull, repo *models.Repo, ownerSlashRepo string) ([]*feeds.Item, error) {

     

       75
       76
        
       	owner, err := rp.idResolver.ResolveIdent(ctx, pull.OwnerDid)

     

       76
       77
        
       	if err != nil {

     

       77
       78
        
       		return nil, err

     
···

       80
       81
        
       	var items []*feeds.Item

     

       81
       82
        
       

     

       82
       83
        
       	state := rp.getPullState(pull)

     

       83
       83
       -
       	description := rp.buildPullDescription(owner.Handle, state, pull, f.OwnerSlashRepo())

     

       84
       84
       +
       	description := rp.buildPullDescription(owner.Handle, state, pull, ownerSlashRepo)

     

       84
       85
        
       

     

       85
       86
        
       	mainItem := &feeds.Item{

     

       86
       87
        
       		Title:       fmt.Sprintf("[PR #%d] %s", pull.PullId, pull.Title),

     

       87
       88
        
       		Description: description,

     

       88
       88
       -
       		Link:        &feeds.Link{Href: fmt.Sprintf("%s/%s/pulls/%d", rp.config.Core.AppviewHost, f.OwnerSlashRepo(), pull.PullId)},

     

       89
       89
       +
       		Link:        &feeds.Link{Href: fmt.Sprintf("%s/%s/pulls/%d", rp.config.Core.AppviewHost, ownerSlashRepo, pull.PullId)},

     

       89
       90
        
       		Created:     pull.Created,

     

       90
       91
        
       		Author:      &feeds.Author{Name: fmt.Sprintf("@%s", owner.Handle)},

     

       91
       92
        
       	}

     
···

       98
       99
        
       

     

       99
       100
        
       		roundItem := &feeds.Item{

     

       100
       101
        
       			Title:       fmt.Sprintf("[PR #%d] %s (round #%d)", pull.PullId, pull.Title, round.RoundNumber),

     

       101
       101
       -
       			Description: fmt.Sprintf("@%s submitted changes (at round #%d) on PR #%d in %s", owner.Handle, round.RoundNumber, pull.PullId, f.OwnerSlashRepo()),

     

       102
       102
       -
       			Link:        &feeds.Link{Href: fmt.Sprintf("%s/%s/pulls/%d/round/%d/", rp.config.Core.AppviewHost, f.OwnerSlashRepo(), pull.PullId, round.RoundNumber)},

     

       102
       102
       +
       			Description: fmt.Sprintf("@%s submitted changes (at round #%d) on PR #%d in @%s", owner.Handle, round.RoundNumber, pull.PullId, ownerSlashRepo),

     

       103
       103
       +
       			Link:        &feeds.Link{Href: fmt.Sprintf("%s/%s/pulls/%d/round/%d/", rp.config.Core.AppviewHost, ownerSlashRepo, pull.PullId, round.RoundNumber)},

     

       103
       104
        
       			Created:     round.Created,

     

       104
       105
        
       			Author:      &feeds.Author{Name: fmt.Sprintf("@%s", owner.Handle)},

     

       105
       106
        
       		}

     
···

       109
       110
        
       	return items, nil

     

       110
       111
        
       }

     

       111
       112
        
       

     

       112
       112
       -
       func (rp *Repo) createIssueItem(ctx context.Context, issue models.Issue, f *reporesolver.ResolvedRepo) (*feeds.Item, error) {

     

       113
       113
       +
       func (rp *Repo) createIssueItem(ctx context.Context, issue models.Issue, repo *models.Repo, ownerSlashRepo string) (*feeds.Item, error) {

     

       113
       114
        
       	owner, err := rp.idResolver.ResolveIdent(ctx, issue.Did)

     

       114
       115
        
       	if err != nil {

     

       115
       116
        
       		return nil, err

     
···

       122
       123
        
       

     

       123
       124
        
       	return &feeds.Item{

     

       124
       125
        
       		Title:       fmt.Sprintf("[Issue #%d] %s", issue.IssueId, issue.Title),

     

       125
       125
       -
       		Description: fmt.Sprintf("@%s %s issue #%d in %s", owner.Handle, state, issue.IssueId, f.OwnerSlashRepo()),

     

       126
       126
       -
       		Link:        &feeds.Link{Href: fmt.Sprintf("%s/%s/issues/%d", rp.config.Core.AppviewHost, f.OwnerSlashRepo(), issue.IssueId)},

     

       126
       126
       +
       		Description: fmt.Sprintf("@%s %s issue #%d in @%s", owner.Handle, state, issue.IssueId, ownerSlashRepo),

     

       127
       127
       +
       		Link:        &feeds.Link{Href: fmt.Sprintf("%s/%s/issues/%d", rp.config.Core.AppviewHost, ownerSlashRepo, issue.IssueId)},

     

       127
       128
        
       		Created:     issue.Created,

     

       128
       129
        
       		Author:      &feeds.Author{Name: fmt.Sprintf("@%s", owner.Handle)},

     

       129
       130
        
       	}, nil

     
···

       152
       153
        
       		log.Println("failed to fully resolve repo:", err)

     

       153
       154
        
       		return

     

       154
       155
        
       	}

     

       156
       156
       +
       	repoOwnerId, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       157
       157
       +
       	if !ok || repoOwnerId.Handle.IsInvalidHandle() {

     

       158
       158
       +
       		log.Println("failed to get resolved repo owner id")

     

       159
       159
       +
       		return

     

       160
       160
       +
       	}

     

       161
       161
       +
       	ownerSlashRepo := repoOwnerId.Handle.String() + "/" + f.Name

     

       155
       162
        
       

     

       156
       156
       -
       	feed, err := rp.getRepoFeed(r.Context(), f)

     

       163
       163
       +
       	feed, err := rp.getRepoFeed(r.Context(), f, ownerSlashRepo)

     

       157
       164
        
       	if err != nil {

     

       158
       165
        
       		log.Println("failed to get repo feed:", err)

     

       159
       166
        
       		rp.pages.Error500(w)

+22 -24

appview/repo/index.go

···

       22
       22
        
       	"tangled.org/core/appview/db"

     

       23
       23
        
       	"tangled.org/core/appview/models"

     

       24
       24
        
       	"tangled.org/core/appview/pages"

     

       25
       25
       -
       	"tangled.org/core/appview/reporesolver"

     

       26
       25
        
       	"tangled.org/core/appview/xrpcclient"

     

       26
       26
       +
       	"tangled.org/core/orm"

     

       27
       27
        
       	"tangled.org/core/types"

     

       28
       28
        
       

     

       29
       29
        
       	"github.com/go-chi/chi/v5"

     
···

       52
       52
        
       	}

     

       53
       53
        
       

     

       54
       54
        
       	user := rp.oauth.GetUser(r)

     

       55
       55
       -
       	repoInfo := f.RepoInfo(user)

     

       56
       55
        
       

     

       57
       56
        
       	// Build index response from multiple XRPC calls

     

       58
       57
        
       	result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref)

     
···

       62
       61
        
       			rp.pages.RepoIndexPage(w, pages.RepoIndexParams{

     

       63
       62
        
       				LoggedInUser:     user,

     

       64
       63
        
       				NeedsKnotUpgrade: true,

     

       65
       65
       -
       				RepoInfo:         repoInfo,

     

       64
       64
       +
       				RepoInfo:         rp.repoResolver.GetRepoInfo(r, user),

     

       66
       65
        
       			})

     

       67
       66
        
       			return

     

       68
       67
        
       		}

     
···

       124
       123
        
       		l.Error("failed to get email to did map", "err", err)

     

       125
       124
        
       	}

     

       126
       125
        
       

     

       127
       127
       -
       	vc, err := commitverify.GetVerifiedObjectCommits(rp.db, emailToDidMap, commitsTrunc)

     

       126
       126
       +
       	vc, err := commitverify.GetVerifiedCommits(rp.db, emailToDidMap, commitsTrunc)

     

       128
       127
        
       	if err != nil {

     

       129
       128
        
       		l.Error("failed to GetVerifiedObjectCommits", "err", err)

     

       130
       129
        
       	}

     
···

       140
       139
        
       	for _, c := range commitsTrunc {

     

       141
       140
        
       		shas = append(shas, c.Hash.String())

     

       142
       141
        
       	}

     

       143
       143
       -
       	pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas)

     

       142
       142
       +
       	pipelines, err := getPipelineStatuses(rp.db, f, shas)

     

       144
       143
        
       	if err != nil {

     

       145
       144
        
       		l.Error("failed to fetch pipeline statuses", "err", err)

     

       146
       145
        
       		// non-fatal

     
···

       148
       147
        
       

     

       149
       148
        
       	rp.pages.RepoIndexPage(w, pages.RepoIndexParams{

     

       150
       149
        
       		LoggedInUser:      user,

     

       151
       151
       -
       		RepoInfo:          repoInfo,

     

       150
       150
       +
       		RepoInfo:          rp.repoResolver.GetRepoInfo(r, user),

     

       152
       151
        
       		TagMap:            tagMap,

     

       153
       152
        
       		RepoIndexResponse: *result,

     

       154
       153
        
       		CommitsTrunc:      commitsTrunc,

     
···

       165
       164
        
       func (rp *Repo) getLanguageInfo(

     

       166
       165
        
       	ctx context.Context,

     

       167
       166
        
       	l *slog.Logger,

     

       168
       168
       -
       	f *reporesolver.ResolvedRepo,

     

       167
       167
       +
       	repo *models.Repo,

     

       169
       168
        
       	xrpcc *indigoxrpc.Client,

     

       170
       169
        
       	currentRef string,

     

       171
       170
        
       	isDefaultRef bool,

     
···

       173
       172
        
       	// first attempt to fetch from db

     

       174
       173
        
       	langs, err := db.GetRepoLanguages(

     

       175
       174
        
       		rp.db,

     

       176
       176
       -
       		db.FilterEq("repo_at", f.RepoAt()),

     

       177
       177
       -
       		db.FilterEq("ref", currentRef),

     

       175
       175
       +
       		orm.FilterEq("repo_at", repo.RepoAt()),

     

       176
       176
       +
       		orm.FilterEq("ref", currentRef),

     

       178
       177
        
       	)

     

       179
       178
        
       

     

       180
       179
        
       	if err != nil || langs == nil {

     

       181
       180
        
       		// non-fatal, fetch langs from ks via XRPC

     

       182
       182
       -
       		repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       183
       183
       -
       		ls, err := tangled.RepoLanguages(ctx, xrpcc, currentRef, repo)

     

       181
       181
       +
       		didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name)

     

       182
       182
       +
       		ls, err := tangled.RepoLanguages(ctx, xrpcc, currentRef, didSlashRepo)

     

       184
       183
        
       		if err != nil {

     

       185
       184
        
       			if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       186
       185
        
       				l.Error("failed to call XRPC repo.languages", "err", xrpcerr)

     
···

       195
       194
        
       

     

       196
       195
        
       		for _, lang := range ls.Languages {

     

       197
       196
        
       			langs = append(langs, models.RepoLanguage{

     

       198
       198
       -
       				RepoAt:       f.RepoAt(),

     

       197
       197
       +
       				RepoAt:       repo.RepoAt(),

     

       199
       198
        
       				Ref:          currentRef,

     

       200
       199
        
       				IsDefaultRef: isDefaultRef,

     

       201
       200
        
       				Language:     lang.Name,

     
···

       210
       209
        
       		defer tx.Rollback()

     

       211
       210
        
       

     

       212
       211
        
       		// update appview's cache

     

       213
       213
       -
       		err = db.UpdateRepoLanguages(tx, f.RepoAt(), currentRef, langs)

     

       212
       212
       +
       		err = db.UpdateRepoLanguages(tx, repo.RepoAt(), currentRef, langs)

     

       214
       213
        
       		if err != nil {

     

       215
       214
        
       			// non-fatal

     

       216
       215
        
       			l.Error("failed to cache lang results", "err", err)

     
···

       255
       254
        
       }

     

       256
       255
        
       

     

       257
       256
        
       // buildIndexResponse creates a RepoIndexResponse by combining multiple xrpc calls in parallel

     

       258
       258
       -
       func (rp *Repo) buildIndexResponse(ctx context.Context, xrpcc *indigoxrpc.Client, f *reporesolver.ResolvedRepo, ref string) (*types.RepoIndexResponse, error) {

     

       259
       259
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       257
       257
       +
       func (rp *Repo) buildIndexResponse(ctx context.Context, xrpcc *indigoxrpc.Client, repo *models.Repo, ref string) (*types.RepoIndexResponse, error) {

     

       258
       258
       +
       	didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name)

     

       260
       259
        
       

     

       261
       260
        
       	// first get branches to determine the ref if not specified

     

       262
       262
       -
       	branchesBytes, err := tangled.RepoBranches(ctx, xrpcc, "", 0, repo)

     

       261
       261
       +
       	branchesBytes, err := tangled.RepoBranches(ctx, xrpcc, "", 0, didSlashRepo)

     

       263
       262
        
       	if err != nil {

     

       264
       263
        
       		return nil, fmt.Errorf("failed to call repoBranches: %w", err)

     

       265
       264
        
       	}

     
···

       303
       302
        
       	wg.Add(1)

     

       304
       303
        
       	go func() {

     

       305
       304
        
       		defer wg.Done()

     

       306
       306
       -
       		tagsBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, repo)

     

       305
       305
       +
       		tagsBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, didSlashRepo)

     

       307
       306
        
       		if err != nil {

     

       308
       307
        
       			errs = errors.Join(errs, fmt.Errorf("failed to call repoTags: %w", err))

     

       309
       308
        
       			return

     
···

       318
       317
        
       	wg.Add(1)

     

       319
       318
        
       	go func() {

     

       320
       319
        
       		defer wg.Done()

     

       321
       321
       -
       		resp, err := tangled.RepoTree(ctx, xrpcc, "", ref, repo)

     

       320
       320
       +
       		resp, err := tangled.RepoTree(ctx, xrpcc, "", ref, didSlashRepo)

     

       322
       321
        
       		if err != nil {

     

       323
       322
        
       			errs = errors.Join(errs, fmt.Errorf("failed to call repoTree: %w", err))

     

       324
       323
        
       			return

     
···

       330
       329
        
       	wg.Add(1)

     

       331
       330
        
       	go func() {

     

       332
       331
        
       		defer wg.Done()

     

       333
       333
       -
       		logBytes, err := tangled.RepoLog(ctx, xrpcc, "", 50, "", ref, repo)

     

       332
       332
       +
       		logBytes, err := tangled.RepoLog(ctx, xrpcc, "", 50, "", ref, didSlashRepo)

     

       334
       333
        
       		if err != nil {

     

       335
       334
        
       			errs = errors.Join(errs, fmt.Errorf("failed to call repoLog: %w", err))

     

       336
       335
        
       			return

     
···

       351
       350
        
       	if treeResp != nil && treeResp.Files != nil {

     

       352
       351
        
       		for _, file := range treeResp.Files {

     

       353
       352
        
       			niceFile := types.NiceTree{

     

       354
       354
       -
       				IsFile:    file.Is_file,

     

       355
       355
       -
       				IsSubtree: file.Is_subtree,

     

       356
       356
       -
       				Name:      file.Name,

     

       357
       357
       -
       				Mode:      file.Mode,

     

       358
       358
       -
       				Size:      file.Size,

     

       353
       353
       +
       				Name: file.Name,

     

       354
       354
       +
       				Mode: file.Mode,

     

       355
       355
       +
       				Size: file.Size,

     

       359
       356
        
       			}

     

       357
       357
       +
       

     

       360
       358
        
       			if file.Last_commit != nil {

     

       361
       359
        
       				when, _ := time.Parse(time.RFC3339, file.Last_commit.When)

     

       362
       360
        
       				niceFile.LastCommit = &types.LastCommitInfo{

+8 -11

appview/repo/log.go

···

       57
       57
        
       		cursor = strconv.Itoa(offset)

     

       58
       58
        
       	}

     

       59
       59
        
       

     

       60
       60
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       60
       60
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       61
       61
        
       	xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo)

     

       62
       62
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       63
       63
        
       		l.Error("failed to call XRPC repo.log", "err", xrpcerr)

     
···

       116
       116
        
       		l.Error("failed to fetch email to did mapping", "err", err)

     

       117
       117
        
       	}

     

       118
       118
        
       

     

       119
       119
       -
       	vc, err := commitverify.GetVerifiedObjectCommits(rp.db, emailToDidMap, xrpcResp.Commits)

     

       119
       119
       +
       	vc, err := commitverify.GetVerifiedCommits(rp.db, emailToDidMap, xrpcResp.Commits)

     

       120
       120
        
       	if err != nil {

     

       121
       121
        
       		l.Error("failed to GetVerifiedObjectCommits", "err", err)

     

       122
       122
        
       	}

     

       123
       123
       -
       

     

       124
       124
       -
       	repoInfo := f.RepoInfo(user)

     

       125
       123
        
       

     

       126
       124
        
       	var shas []string

     

       127
       125
        
       	for _, c := range xrpcResp.Commits {

     

       128
       126
        
       		shas = append(shas, c.Hash.String())

     

       129
       127
        
       	}

     

       130
       130
       -
       	pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas)

     

       128
       128
       +
       	pipelines, err := getPipelineStatuses(rp.db, f, shas)

     

       131
       129
        
       	if err != nil {

     

       132
       130
        
       		l.Error("failed to getPipelineStatuses", "err", err)

     

       133
       131
        
       		// non-fatal

     
···

       136
       134
        
       	rp.pages.RepoLog(w, pages.RepoLogParams{

     

       137
       135
        
       		LoggedInUser:    user,

     

       138
       136
        
       		TagMap:          tagMap,

     

       139
       139
       -
       		RepoInfo:        repoInfo,

     

       137
       137
       +
       		RepoInfo:        rp.repoResolver.GetRepoInfo(r, user),

     

       140
       138
        
       		RepoLogResponse: xrpcResp,

     

       141
       139
        
       		EmailToDid:      emailToDidMap,

     

       142
       140
        
       		VerifiedCommits: vc,

     
···

       174
       172
        
       		Host: host,

     

       175
       173
        
       	}

     

       176
       174
        
       

     

       177
       177
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       175
       175
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       178
       176
        
       	xrpcBytes, err := tangled.RepoDiff(r.Context(), xrpcc, ref, repo)

     

       179
       177
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       180
       178
        
       		l.Error("failed to call XRPC repo.diff", "err", xrpcerr)

     
···

       194
       192
        
       		l.Error("failed to get email to did mapping", "err", err)

     

       195
       193
        
       	}

     

       196
       194
        
       

     

       197
       197
       -
       	vc, err := commitverify.GetVerifiedCommits(rp.db, emailToDidMap, []types.NiceDiff{*result.Diff})

     

       195
       195
       +
       	vc, err := commitverify.GetVerifiedCommits(rp.db, emailToDidMap, []types.Commit{result.Diff.Commit})

     

       198
       196
        
       	if err != nil {

     

       199
       197
        
       		l.Error("failed to GetVerifiedCommits", "err", err)

     

       200
       198
        
       	}

     

       201
       199
        
       

     

       202
       200
        
       	user := rp.oauth.GetUser(r)

     

       203
       203
       -
       	repoInfo := f.RepoInfo(user)

     

       204
       204
       -
       	pipelines, err := getPipelineStatuses(rp.db, repoInfo, []string{result.Diff.Commit.This})

     

       201
       201
       +
       	pipelines, err := getPipelineStatuses(rp.db, f, []string{result.Diff.Commit.This})

     

       205
       202
        
       	if err != nil {

     

       206
       203
        
       		l.Error("failed to getPipelineStatuses", "err", err)

     

       207
       204
        
       		// non-fatal

     
···

       213
       210
        
       

     

       214
       211
        
       	rp.pages.RepoCommit(w, pages.RepoCommitParams{

     

       215
       212
        
       		LoggedInUser:       user,

     

       216
       216
       -
       		RepoInfo:           f.RepoInfo(user),

     

       213
       213
       +
       		RepoInfo:           rp.repoResolver.GetRepoInfo(r, user),

     

       217
       214
        
       		RepoCommitResponse: result,

     

       218
       215
        
       		EmailToDid:         emailToDidMap,

     

       219
       216
        
       		VerifiedCommit:     vc,

+4 -3

appview/repo/opengraph.go

···

       16
       16
        
       	"tangled.org/core/appview/db"

     

       17
       17
        
       	"tangled.org/core/appview/models"

     

       18
       18
        
       	"tangled.org/core/appview/ogcard"

     

       19
       19
       +
       	"tangled.org/core/orm"

     

       19
       20
        
       	"tangled.org/core/types"

     

       20
       21
        
       )

     

       21
       22
        
       

     
···

       338
       339
        
       	var languageStats []types.RepoLanguageDetails

     

       339
       340
        
       	langs, err := db.GetRepoLanguages(

     

       340
       341
        
       		rp.db,

     

       341
       341
       -
       		db.FilterEq("repo_at", f.RepoAt()),

     

       342
       342
       -
       		db.FilterEq("is_default_ref", 1),

     

       342
       342
       +
       		orm.FilterEq("repo_at", f.RepoAt()),

     

       343
       343
       +
       		orm.FilterEq("is_default_ref", 1),

     

       343
       344
        
       	)

     

       344
       345
        
       	if err != nil {

     

       345
       346
        
       		log.Printf("failed to get language stats from db: %v", err)

     
···

       374
       375
        
       		})

     

       375
       376
        
       	}

     

       376
       377
        
       

     

       377
       377
       -
       	card, err := rp.drawRepoSummaryCard(&f.Repo, languageStats)

     

       378
       378
       +
       	card, err := rp.drawRepoSummaryCard(f, languageStats)

     

       378
       379
        
       	if err != nil {

     

       379
       380
        
       		log.Println("failed to draw repo summary card", err)

     

       380
       381
        
       		http.Error(w, "failed to draw repo summary card", http.StatusInternalServerError)

+37 -37

appview/repo/repo.go

···

       24
       24
        
       	xrpcclient "tangled.org/core/appview/xrpcclient"

     

       25
       25
        
       	"tangled.org/core/eventconsumer"

     

       26
       26
        
       	"tangled.org/core/idresolver"

     

       27
       27
       +
       	"tangled.org/core/orm"

     

       27
       28
        
       	"tangled.org/core/rbac"

     

       28
       29
        
       	"tangled.org/core/tid"

     

       29
       30
        
       	"tangled.org/core/xrpc/serviceauth"

     
···

       78
       79
        
       	}

     

       79
       80
        
       }

     

       80
       81
        
       

     

       81
       81
       -
       // isTextualMimeType returns true if the MIME type represents textual content

     

       82
       82
       -
       

     

       83
       82
        
       // modify the spindle configured for this repo

     

       84
       83
        
       func (rp *Repo) EditSpindle(w http.ResponseWriter, r *http.Request) {

     

       85
       84
        
       	user := rp.oauth.GetUser(r)

     
···

       120
       119
        
       		}

     

       121
       120
        
       	}

     

       122
       121
        
       

     

       123
       123
       -
       	newRepo := f.Repo

     

       122
       122
       +
       	newRepo := *f

     

       124
       123
        
       	newRepo.Spindle = newSpindle

     

       125
       124
        
       	record := newRepo.AsRecord()

     

       126
       125
        
       

     
···

       259
       258
        
       	l.Info("wrote label record to PDS")

     

       260
       259
        
       

     

       261
       260
        
       	// update the repo to subscribe to this label

     

       262
       262
       -
       	newRepo := f.Repo

     

       261
       261
       +
       	newRepo := *f

     

       263
       262
        
       	newRepo.Labels = append(newRepo.Labels, aturi)

     

       264
       263
        
       	repoRecord := newRepo.AsRecord()

     

       265
       264
        
       

     
···

       347
       346
        
       	// get form values

     

       348
       347
        
       	labelId := r.FormValue("label-id")

     

       349
       348
        
       

     

       350
       350
       -
       	label, err := db.GetLabelDefinition(rp.db, db.FilterEq("id", labelId))

     

       349
       349
       +
       	label, err := db.GetLabelDefinition(rp.db, orm.FilterEq("id", labelId))

     

       351
       350
        
       	if err != nil {

     

       352
       351
        
       		fail("Failed to find label definition.", err)

     

       353
       352
        
       		return

     
···

       371
       370
        
       	}

     

       372
       371
        
       

     

       373
       372
        
       	// update repo record to remove the label reference

     

       374
       374
       -
       	newRepo := f.Repo

     

       373
       373
       +
       	newRepo := *f

     

       375
       374
        
       	var updated []string

     

       376
       375
        
       	removedAt := label.AtUri().String()

     

       377
       376
        
       	for _, l := range newRepo.Labels {

     
···

       411
       410
        
       

     

       412
       411
        
       	err = db.UnsubscribeLabel(

     

       413
       412
        
       		tx,

     

       414
       414
       -
       		db.FilterEq("repo_at", f.RepoAt()),

     

       415
       415
       -
       		db.FilterEq("label_at", removedAt),

     

       413
       413
       +
       		orm.FilterEq("repo_at", f.RepoAt()),

     

       414
       414
       +
       		orm.FilterEq("label_at", removedAt),

     

       416
       415
        
       	)

     

       417
       416
        
       	if err != nil {

     

       418
       417
        
       		fail("Failed to unsubscribe label.", err)

     

       419
       418
        
       		return

     

       420
       419
        
       	}

     

       421
       420
        
       

     

       422
       422
       -
       	err = db.DeleteLabelDefinition(tx, db.FilterEq("id", label.Id))

     

       421
       421
       +
       	err = db.DeleteLabelDefinition(tx, orm.FilterEq("id", label.Id))

     

       423
       422
        
       	if err != nil {

     

       424
       423
        
       		fail("Failed to delete label definition.", err)

     

       425
       424
        
       		return

     
···

       458
       457
        
       	}

     

       459
       458
        
       

     

       460
       459
        
       	labelAts := r.Form["label"]

     

       461
       461
       -
       	_, err = db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", labelAts))

     

       460
       460
       +
       	_, err = db.GetLabelDefinitions(rp.db, orm.FilterIn("at_uri", labelAts))

     

       462
       461
        
       	if err != nil {

     

       463
       462
        
       		fail("Failed to subscribe to label.", err)

     

       464
       463
        
       		return

     

       465
       464
        
       	}

     

       466
       465
        
       

     

       467
       467
       -
       	newRepo := f.Repo

     

       466
       466
       +
       	newRepo := *f

     

       468
       467
        
       	newRepo.Labels = append(newRepo.Labels, labelAts...)

     

       469
       468
        
       

     

       470
       469
        
       	// dedup

     
···

       479
       478
        
       		return

     

       480
       479
        
       	}

     

       481
       480
        
       

     

       482
       482
       -
       	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Repo.Did, f.Repo.Rkey)

     

       481
       481
       +
       	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Did, f.Rkey)

     

       483
       482
        
       	if err != nil {

     

       484
       483
        
       		fail("Failed to update labels, no record found on PDS.", err)

     

       485
       484
        
       		return

     
···

       544
       543
        
       	}

     

       545
       544
        
       

     

       546
       545
        
       	labelAts := r.Form["label"]

     

       547
       547
       -
       	_, err = db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", labelAts))

     

       546
       546
       +
       	_, err = db.GetLabelDefinitions(rp.db, orm.FilterIn("at_uri", labelAts))

     

       548
       547
        
       	if err != nil {

     

       549
       548
        
       		fail("Failed to unsubscribe to label.", err)

     

       550
       549
        
       		return

     

       551
       550
        
       	}

     

       552
       551
        
       

     

       553
       552
        
       	// update repo record to remove the label reference

     

       554
       554
       -
       	newRepo := f.Repo

     

       553
       553
       +
       	newRepo := *f

     

       555
       554
        
       	var updated []string

     

       556
       555
        
       	for _, l := range newRepo.Labels {

     

       557
       556
        
       		if !slices.Contains(labelAts, l) {

     
···

       567
       566
        
       		return

     

       568
       567
        
       	}

     

       569
       568
        
       

     

       570
       570
       -
       	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Repo.Did, f.Repo.Rkey)

     

       569
       569
       +
       	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Did, f.Rkey)

     

       571
       570
        
       	if err != nil {

     

       572
       571
        
       		fail("Failed to update labels, no record found on PDS.", err)

     

       573
       572
        
       		return

     
···

       584
       583
        
       

     

       585
       584
        
       	err = db.UnsubscribeLabel(

     

       586
       585
        
       		rp.db,

     

       587
       587
       -
       		db.FilterEq("repo_at", f.RepoAt()),

     

       588
       588
       -
       		db.FilterIn("label_at", labelAts),

     

       586
       586
       +
       		orm.FilterEq("repo_at", f.RepoAt()),

     

       587
       587
       +
       		orm.FilterIn("label_at", labelAts),

     

       589
       588
        
       	)

     

       590
       589
        
       	if err != nil {

     

       591
       590
        
       		fail("Failed to unsubscribe label.", err)

     
···

       614
       613
        
       

     

       615
       614
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       616
       615
        
       		rp.db,

     

       617
       617
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       618
       618
       -
       		db.FilterContains("scope", subject.Collection().String()),

     

       616
       616
       +
       		orm.FilterIn("at_uri", f.Labels),

     

       617
       617
       +
       		orm.FilterContains("scope", subject.Collection().String()),

     

       619
       618
        
       	)

     

       620
       619
        
       	if err != nil {

     

       621
       620
        
       		l.Error("failed to fetch label defs", "err", err)

     
···

       627
       626
        
       		defs[l.AtUri().String()] = &l

     

       628
       627
        
       	}

     

       629
       628
        
       

     

       630
       630
       -
       	states, err := db.GetLabels(rp.db, db.FilterEq("subject", subject))

     

       629
       629
       +
       	states, err := db.GetLabels(rp.db, orm.FilterEq("subject", subject))

     

       631
       630
        
       	if err != nil {

     

       632
       631
        
       		l.Error("failed to build label state", "err", err)

     

       633
       632
        
       		return

     
···

       637
       636
        
       	user := rp.oauth.GetUser(r)

     

       638
       637
        
       	rp.pages.LabelPanel(w, pages.LabelPanelParams{

     

       639
       638
        
       		LoggedInUser: user,

     

       640
       640
       -
       		RepoInfo:     f.RepoInfo(user),

     

       639
       639
       +
       		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       641
       640
        
       		Defs:         defs,

     

       642
       641
        
       		Subject:      subject.String(),

     

       643
       642
        
       		State:        state,

     
···

       662
       661
        
       

     

       663
       662
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       664
       663
        
       		rp.db,

     

       665
       665
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       666
       666
       -
       		db.FilterContains("scope", subject.Collection().String()),

     

       664
       664
       +
       		orm.FilterIn("at_uri", f.Labels),

     

       665
       665
       +
       		orm.FilterContains("scope", subject.Collection().String()),

     

       667
       666
        
       	)

     

       668
       667
        
       	if err != nil {

     

       669
       668
        
       		l.Error("failed to fetch labels", "err", err)

     
···

       675
       674
        
       		defs[l.AtUri().String()] = &l

     

       676
       675
        
       	}

     

       677
       676
        
       

     

       678
       678
       -
       	states, err := db.GetLabels(rp.db, db.FilterEq("subject", subject))

     

       677
       677
       +
       	states, err := db.GetLabels(rp.db, orm.FilterEq("subject", subject))

     

       679
       678
        
       	if err != nil {

     

       680
       679
        
       		l.Error("failed to build label state", "err", err)

     

       681
       680
        
       		return

     
···

       685
       684
        
       	user := rp.oauth.GetUser(r)

     

       686
       685
        
       	rp.pages.EditLabelPanel(w, pages.EditLabelPanelParams{

     

       687
       686
        
       		LoggedInUser: user,

     

       688
       688
       -
       		RepoInfo:     f.RepoInfo(user),

     

       687
       687
       +
       		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       689
       688
        
       		Defs:         defs,

     

       690
       689
        
       		Subject:      subject.String(),

     

       691
       690
        
       		State:        state,

     
···

       866
       865
        
       		r.Context(),

     

       867
       866
        
       		client,

     

       868
       867
        
       		&tangled.RepoDelete_Input{

     

       869
       869
       -
       			Did:  f.OwnerDid(),

     

       868
       868
       +
       			Did:  f.Did,

     

       870
       869
        
       			Name: f.Name,

     

       871
       870
        
       			Rkey: f.Rkey,

     

       872
       871
        
       		},

     
···

       904
       903
        
       	l.Info("removed collaborators")

     

       905
       904
        
       

     

       906
       905
        
       	// remove repo RBAC

     

       907
       907
       -
       	err = rp.enforcer.RemoveRepo(f.OwnerDid(), f.Knot, f.DidSlashRepo())

     

       906
       906
       +
       	err = rp.enforcer.RemoveRepo(f.Did, f.Knot, f.DidSlashRepo())

     

       908
       907
        
       	if err != nil {

     

       909
       908
        
       		rp.pages.Notice(w, noticeId, "Failed to update RBAC rules")

     

       910
       909
        
       		return

     

       911
       910
        
       	}

     

       912
       911
        
       

     

       913
       912
        
       	// remove repo from db

     

       914
       914
       -
       	err = db.RemoveRepo(tx, f.OwnerDid(), f.Name)

     

       913
       913
       +
       	err = db.RemoveRepo(tx, f.Did, f.Name)

     

       915
       914
        
       	if err != nil {

     

       916
       915
        
       		rp.pages.Notice(w, noticeId, "Failed to update appview")

     

       917
       916
        
       		return

     
···

       932
       931
        
       		return

     

       933
       932
        
       	}

     

       934
       933
        
       

     

       935
       935
       -
       	rp.pages.HxRedirect(w, fmt.Sprintf("/%s", f.OwnerDid()))

     

       934
       934
       +
       	rp.pages.HxRedirect(w, fmt.Sprintf("/%s", f.Did))

     

       936
       935
        
       }

     

       937
       936
        
       

     

       938
       937
        
       func (rp *Repo) SyncRepoFork(w http.ResponseWriter, r *http.Request) {

     
···

       961
       960
        
       			return

     

       962
       961
        
       		}

     

       963
       962
        
       

     

       964
       964
       -
       		repoInfo := f.RepoInfo(user)

     

       965
       965
       -
       		if repoInfo.Source == nil {

     

       963
       963
       +
       		if f.Source == "" {

     

       966
       964
        
       			rp.pages.Notice(w, "repo", "This repository is not a fork.")

     

       967
       965
        
       			return

     

       968
       966
        
       		}

     
···

       973
       971
        
       			&tangled.RepoForkSync_Input{

     

       974
       972
        
       				Did:    user.Did,

     

       975
       973
        
       				Name:   f.Name,

     

       976
       976
       -
       				Source: repoInfo.Source.RepoAt().String(),

     

       974
       974
       +
       				Source: f.Source,

     

       977
       975
        
       				Branch: ref,

     

       978
       976
        
       			},

     

       979
       977
        
       		)

     
···

       1009
       1007
        
       		rp.pages.ForkRepo(w, pages.ForkRepoParams{

     

       1010
       1008
        
       			LoggedInUser: user,

     

       1011
       1009
        
       			Knots:        knots,

     

       1012
       1012
       -
       			RepoInfo:     f.RepoInfo(user),

     

       1010
       1010
       +
       			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       1013
       1011
        
       		})

     

       1014
       1012
        
       

     

       1015
       1013
        
       	case http.MethodPost:

     
···

       1039
       1037
        
       		// in the user's account.

     

       1040
       1038
        
       		existingRepo, err := db.GetRepo(

     

       1041
       1039
        
       			rp.db,

     

       1042
       1042
       -
       			db.FilterEq("did", user.Did),

     

       1043
       1043
       -
       			db.FilterEq("name", forkName),

     

       1040
       1040
       +
       			orm.FilterEq("did", user.Did),

     

       1041
       1041
       +
       			orm.FilterEq("name", forkName),

     

       1044
       1042
        
       		)

     

       1045
       1043
        
       		if err != nil {

     

       1046
       1044
        
       			if !errors.Is(err, sql.ErrNoRows) {

     
···

       1060
       1058
        
       			uri = "http"

     

       1061
       1059
        
       		}

     

       1062
       1060
        
       

     

       1063
       1063
       -
       		forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.Repo.Name)

     

       1061
       1061
       +
       		forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.Did, f.Name)

     

       1064
       1062
        
       		l = l.With("cloneUrl", forkSourceUrl)

     

       1065
       1063
        
       

     

       1066
       1064
        
       		sourceAt := f.RepoAt().String()

     
···

       1073
       1071
        
       			Knot:        targetKnot,

     

       1074
       1072
        
       			Rkey:        rkey,

     

       1075
       1073
        
       			Source:      sourceAt,

     

       1076
       1076
       -
       			Description: f.Repo.Description,

     

       1074
       1074
       +
       			Description: f.Description,

     

       1077
       1075
        
       			Created:     time.Now(),

     

       1078
       1076
        
       			Labels:      rp.config.Label.DefaultLabelDefs,

     

       1079
       1077
        
       		}

     
···

       1132
       1130
        
       		}

     

       1133
       1131
        
       		defer rollback()

     

       1134
       1132
        
       

     

       1133
       1133
       +
       		// TODO: this could coordinate better with the knot to recieve a clone status

     

       1135
       1134
        
       		client, err := rp.oauth.ServiceClient(

     

       1136
       1135
        
       			r,

     

       1137
       1136
        
       			oauth.WithService(targetKnot),

     

       1138
       1137
        
       			oauth.WithLxm(tangled.RepoCreateNSID),

     

       1139
       1138
        
       			oauth.WithDev(rp.config.Core.Dev),

     

       1139
       1139
       +
       			oauth.WithTimeout(time.Second*20), // big repos take time to clone

     

       1140
       1140
        
       		)

     

       1141
       1141
        
       		if err != nil {

     

       1142
       1142
        
       			l.Error("could not create service client", "err", err)

+20 -35

appview/repo/repo_util.go

···

       1
       1
        
       package repo

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"crypto/rand"

     

       5
       5
       -
       	"math/big"

     

       4
       4
       +
       	"maps"

     

       6
       5
        
       	"slices"

     

       7
       6
        
       	"sort"

     

       8
       7
        
       	"strings"

     

       9
       8
        
       

     

       10
       9
        
       	"tangled.org/core/appview/db"

     

       11
       10
        
       	"tangled.org/core/appview/models"

     

       12
       12
       -
       	"tangled.org/core/appview/pages/repoinfo"

     

       11
       11
       +
       	"tangled.org/core/orm"

     

       13
       12
        
       	"tangled.org/core/types"

     

       14
       14
       -
       

     

       15
       15
       -
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       16
       13
        
       )

     

       17
       14
        
       

     

       18
       15
        
       func sortFiles(files []types.NiceTree) {

     

       19
       16
        
       	sort.Slice(files, func(i, j int) bool {

     

       20
       20
       -
       		iIsFile := files[i].IsFile

     

       21
       21
       -
       		jIsFile := files[j].IsFile

     

       17
       17
       +
       		iIsFile := files[i].IsFile()

     

       18
       18
       +
       		jIsFile := files[j].IsFile()

     

       22
       19
        
       		if iIsFile != jIsFile {

     

       23
       20
        
       			return !iIsFile

     

       24
       21
        
       		}

     
···

       45
       42
        
       	})

     

       46
       43
        
       }

     

       47
       44
        
       

     

       48
       48
       -
       func uniqueEmails(commits []*object.Commit) []string {

     

       45
       45
       +
       func uniqueEmails(commits []types.Commit) []string {

     

       49
       46
        
       	emails := make(map[string]struct{})

     

       50
       47
        
       	for _, commit := range commits {

     

       51
       51
       -
       		if commit.Author.Email != "" {

     

       52
       52
       -
       			emails[commit.Author.Email] = struct{}{}

     

       53
       53
       -
       		}

     

       54
       54
       -
       		if commit.Committer.Email != "" {

     

       55
       55
       -
       			emails[commit.Committer.Email] = struct{}{}

     

       48
       48
       +
       		emails[commit.Author.Email] = struct{}{}

     

       49
       49
       +
       		emails[commit.Committer.Email] = struct{}{}

     

       50
       50
       +
       		for _, c := range commit.CoAuthors() {

     

       51
       51
       +
       			emails[c.Email] = struct{}{}

     

       56
       52
        
       		}

     

       57
       53
        
       	}

     

       58
       58
       -
       	var uniqueEmails []string

     

       59
       59
       -
       	for email := range emails {

     

       60
       60
       -
       		uniqueEmails = append(uniqueEmails, email)

     

       61
       61
       -
       	}

     

       62
       62
       -
       	return uniqueEmails

     

       54
       54
       +
       

     

       55
       55
       +
       	// delete empty emails if any, from the set

     

       56
       56
       +
       	delete(emails, "")

     

       57
       57
       +
       

     

       58
       58
       +
       	return slices.Collect(maps.Keys(emails))

     

       63
       59
        
       }

     

       64
       60
        
       

     

       65
       61
        
       func balanceIndexItems(commitCount, branchCount, tagCount, fileCount int) (commitsTrunc int, branchesTrunc int, tagsTrunc int) {

     
···

       90
       86
        
       	return

     

       91
       87
        
       }

     

       92
       88
        
       

     

       93
       93
       -
       func randomString(n int) string {

     

       94
       94
       -
       	const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

     

       95
       95
       -
       	result := make([]byte, n)

     

       96
       96
       -
       

     

       97
       97
       -
       	for i := 0; i < n; i++ {

     

       98
       98
       -
       		n, _ := rand.Int(rand.Reader, big.NewInt(int64(len(letters))))

     

       99
       99
       -
       		result[i] = letters[n.Int64()]

     

       100
       100
       -
       	}

     

       101
       101
       -
       

     

       102
       102
       -
       	return string(result)

     

       103
       103
       -
       }

     

       104
       104
       -
       

     

       105
       89
        
       // grab pipelines from DB and munge that into a hashmap with commit sha as key

     

       106
       90
        
       //

     

       107
       91
        
       // golang is so blessed that it requires 35 lines of imperative code for this

     

       108
       92
        
       func getPipelineStatuses(

     

       109
       93
        
       	d *db.DB,

     

       110
       110
       -
       	repoInfo repoinfo.RepoInfo,

     

       94
       94
       +
       	repo *models.Repo,

     

       111
       95
        
       	shas []string,

     

       112
       96
        
       ) (map[string]models.Pipeline, error) {

     

       113
       97
        
       	m := make(map[string]models.Pipeline)

     
···

       118
       102
        
       

     

       119
       103
        
       	ps, err := db.GetPipelineStatuses(

     

       120
       104
        
       		d,

     

       121
       121
       -
       		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       122
       122
       -
       		db.FilterEq("repo_name", repoInfo.Name),

     

       123
       123
       -
       		db.FilterEq("knot", repoInfo.Knot),

     

       124
       124
       -
       		db.FilterIn("sha", shas),

     

       105
       105
       +
       		len(shas),

     

       106
       106
       +
       		orm.FilterEq("repo_owner", repo.Did),

     

       107
       107
       +
       		orm.FilterEq("repo_name", repo.Name),

     

       108
       108
       +
       		orm.FilterEq("knot", repo.Knot),

     

       109
       109
       +
       		orm.FilterIn("sha", shas),

     

       125
       110
        
       	)

     

       126
       111
        
       	if err != nil {

     

       127
       112
        
       		return nil, err

-1

appview/repo/router.go

···

       61
       61
        
       		// for example:

     

       62
       62
        
       		//   /compare/master...some/feature

     

       63
       63
        
       		//   /compare/master...example.com:another/feature <- this is a fork

     

       64
       64
       -
       		r.Get("/{base}/{head}", rp.Compare)

     

       65
       64
        
       		r.Get("/*", rp.Compare)

     

       66
       65
        
       	})

     

       67
       66

+41 -12

appview/repo/settings.go

···

       10
       10
        
       

     

       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/oauth"

     

       14
       15
        
       	"tangled.org/core/appview/pages"

     

       15
       16
        
       	xrpcclient "tangled.org/core/appview/xrpcclient"

     

       17
       17
       +
       	"tangled.org/core/orm"

     

       16
       18
        
       	"tangled.org/core/types"

     

       17
       19
        
       

     

       18
       20
        
       	comatproto "github.com/bluesky-social/indigo/api/atproto"

     
···

       194
       196
        
       		Host: host,

     

       195
       197
        
       	}

     

       196
       198
        
       

     

       197
       197
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       199
       199
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       198
       200
        
       	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       199
       201
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       200
       202
        
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     
···

       209
       211
        
       		return

     

       210
       212
        
       	}

     

       211
       213
        
       

     

       212
       212
       -
       	defaultLabels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", rp.config.Label.DefaultLabelDefs))

     

       214
       214
       +
       	defaultLabels, err := db.GetLabelDefinitions(rp.db, orm.FilterIn("at_uri", rp.config.Label.DefaultLabelDefs))

     

       213
       215
        
       	if err != nil {

     

       214
       216
        
       		l.Error("failed to fetch labels", "err", err)

     

       215
       217
        
       		rp.pages.Error503(w)

     

       216
       218
        
       		return

     

       217
       219
        
       	}

     

       218
       220
        
       

     

       219
       219
       -
       	labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Repo.Labels))

     

       221
       221
       +
       	labels, err := db.GetLabelDefinitions(rp.db, orm.FilterIn("at_uri", f.Labels))

     

       220
       222
        
       	if err != nil {

     

       221
       223
        
       		l.Error("failed to fetch labels", "err", err)

     

       222
       224
        
       		rp.pages.Error503(w)

     
···

       237
       239
        
       	labels = labels[:n]

     

       238
       240
        
       

     

       239
       241
        
       	subscribedLabels := make(map[string]struct{})

     

       240
       240
       -
       	for _, l := range f.Repo.Labels {

     

       242
       242
       +
       	for _, l := range f.Labels {

     

       241
       243
        
       		subscribedLabels[l] = struct{}{}

     

       242
       244
        
       	}

     

       243
       245
        
       

     
···

       254
       256
        
       

     

       255
       257
        
       	rp.pages.RepoGeneralSettings(w, pages.RepoGeneralSettingsParams{

     

       256
       258
        
       		LoggedInUser:       user,

     

       257
       257
       -
       		RepoInfo:           f.RepoInfo(user),

     

       259
       259
       +
       		RepoInfo:           rp.repoResolver.GetRepoInfo(r, user),

     

       258
       260
        
       		Branches:           result.Branches,

     

       259
       261
        
       		Labels:             labels,

     

       260
       262
        
       		DefaultLabels:      defaultLabels,

     
···

       271
       273
        
       	f, err := rp.repoResolver.Resolve(r)

     

       272
       274
        
       	user := rp.oauth.GetUser(r)

     

       273
       275
        
       

     

       274
       274
       -
       	repoCollaborators, err := f.Collaborators(r.Context())

     

       276
       276
       +
       	collaborators, err := func(repo *models.Repo) ([]pages.Collaborator, error) {

     

       277
       277
       +
       		repoCollaborators, err := rp.enforcer.E.GetImplicitUsersForResourceByDomain(repo.DidSlashRepo(), repo.Knot)

     

       278
       278
       +
       		if err != nil {

     

       279
       279
       +
       			return nil, err

     

       280
       280
       +
       		}

     

       281
       281
       +
       		var collaborators []pages.Collaborator

     

       282
       282
       +
       		for _, item := range repoCollaborators {

     

       283
       283
       +
       			// currently only two roles: owner and member

     

       284
       284
       +
       			var role string

     

       285
       285
       +
       			switch item[3] {

     

       286
       286
       +
       			case "repo:owner":

     

       287
       287
       +
       				role = "owner"

     

       288
       288
       +
       			case "repo:collaborator":

     

       289
       289
       +
       				role = "collaborator"

     

       290
       290
       +
       			default:

     

       291
       291
       +
       				continue

     

       292
       292
       +
       			}

     

       293
       293
       +
       

     

       294
       294
       +
       			did := item[0]

     

       295
       295
       +
       

     

       296
       296
       +
       			c := pages.Collaborator{

     

       297
       297
       +
       				Did:  did,

     

       298
       298
       +
       				Role: role,

     

       299
       299
       +
       			}

     

       300
       300
       +
       			collaborators = append(collaborators, c)

     

       301
       301
       +
       		}

     

       302
       302
       +
       		return collaborators, nil

     

       303
       303
       +
       	}(f)

     

       275
       304
        
       	if err != nil {

     

       276
       305
        
       		l.Error("failed to get collaborators", "err", err)

     

       277
       306
        
       	}

     

       278
       307
        
       

     

       279
       308
        
       	rp.pages.RepoAccessSettings(w, pages.RepoAccessSettingsParams{

     

       280
       309
        
       		LoggedInUser:  user,

     

       281
       281
       -
       		RepoInfo:      f.RepoInfo(user),

     

       310
       310
       +
       		RepoInfo:      rp.repoResolver.GetRepoInfo(r, user),

     

       282
       311
        
       		Tabs:          settingsTabs,

     

       283
       312
        
       		Tab:           "access",

     

       284
       284
       -
       		Collaborators: repoCollaborators,

     

       313
       313
       +
       		Collaborators: collaborators,

     

       285
       314
        
       	})

     

       286
       315
        
       }

     

       287
       316
        
       

     
···

       292
       321
        
       	user := rp.oauth.GetUser(r)

     

       293
       322
        
       

     

       294
       323
        
       	// all spindles that the repo owner is a member of

     

       295
       295
       -
       	spindles, err := rp.enforcer.GetSpindlesForUser(f.OwnerDid())

     

       324
       324
       +
       	spindles, err := rp.enforcer.GetSpindlesForUser(f.Did)

     

       296
       325
        
       	if err != nil {

     

       297
       326
        
       		l.Error("failed to fetch spindles", "err", err)

     

       298
       327
        
       		return

     
···

       339
       368
        
       

     

       340
       369
        
       	rp.pages.RepoPipelineSettings(w, pages.RepoPipelineSettingsParams{

     

       341
       370
        
       		LoggedInUser:   user,

     

       342
       342
       -
       		RepoInfo:       f.RepoInfo(user),

     

       371
       371
       +
       		RepoInfo:       rp.repoResolver.GetRepoInfo(r, user),

     

       343
       372
        
       		Tabs:           settingsTabs,

     

       344
       373
        
       		Tab:            "pipelines",

     

       345
       374
        
       		Spindles:       spindles,

     
···

       374
       403
        
       	)

     

       375
       404
        
       

     

       376
       405
        
       	err = rp.validator.ValidateURI(website)

     

       377
       377
       -
       	if err != nil {

     

       406
       406
       +
       	if website != "" && err != nil {

     

       378
       407
        
       		l.Error("invalid uri", "err", err)

     

       379
       408
        
       		rp.pages.Notice(w, noticeId, err.Error())

     

       380
       409
        
       		return

     
···

       388
       417
        
       	}

     

       389
       418
        
       	l.Debug("got", "topicsStr", topicStr, "topics", topics)

     

       390
       419
        
       

     

       391
       391
       -
       	newRepo := f.Repo

     

       420
       420
       +
       	newRepo := *f

     

       392
       421
        
       	newRepo.Description = description

     

       393
       422
        
       	newRepo.Website = website

     

       394
       423
        
       	newRepo.Topics = topics

+4 -3

appview/repo/tags.go

···

       10
       10
        
       	"tangled.org/core/appview/models"

     

       11
       11
        
       	"tangled.org/core/appview/pages"

     

       12
       12
        
       	xrpcclient "tangled.org/core/appview/xrpcclient"

     

       13
       13
       +
       	"tangled.org/core/orm"

     

       13
       14
        
       	"tangled.org/core/types"

     

       14
       15
        
       

     

       15
       16
        
       	indigoxrpc "github.com/bluesky-social/indigo/xrpc"

     
···

       31
       32
        
       	xrpcc := &indigoxrpc.Client{

     

       32
       33
        
       		Host: host,

     

       33
       34
        
       	}

     

       34
       34
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       35
       35
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       35
       36
        
       	xrpcBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       36
       37
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       37
       38
        
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     
···

       44
       45
        
       		rp.pages.Error503(w)

     

       45
       46
        
       		return

     

       46
       47
        
       	}

     

       47
       47
       -
       	artifacts, err := db.GetArtifact(rp.db, db.FilterEq("repo_at", f.RepoAt()))

     

       48
       48
       +
       	artifacts, err := db.GetArtifact(rp.db, orm.FilterEq("repo_at", f.RepoAt()))

     

       48
       49
        
       	if err != nil {

     

       49
       50
        
       		l.Error("failed grab artifacts", "err", err)

     

       50
       51
        
       		return

     
···

       71
       72
        
       	user := rp.oauth.GetUser(r)

     

       72
       73
        
       	rp.pages.RepoTags(w, pages.RepoTagsParams{

     

       73
       74
        
       		LoggedInUser:      user,

     

       74
       74
       -
       		RepoInfo:          f.RepoInfo(user),

     

       75
       75
       +
       		RepoInfo:          rp.repoResolver.GetRepoInfo(r, user),

     

       75
       76
        
       		RepoTagsResponse:  result,

     

       76
       77
        
       		ArtifactMap:       artifactMap,

     

       77
       78
        
       		DanglingArtifacts: danglingArtifacts,

+10 -9

appview/repo/tree.go

···

       9
       9
        
       

     

       10
       10
        
       	"tangled.org/core/api/tangled"

     

       11
       11
        
       	"tangled.org/core/appview/pages"

     

       12
       12
       +
       	"tangled.org/core/appview/reporesolver"

     

       12
       13
        
       	xrpcclient "tangled.org/core/appview/xrpcclient"

     

       13
       14
        
       	"tangled.org/core/types"

     

       14
       15
        
       

     
···

       39
       40
        
       	xrpcc := &indigoxrpc.Client{

     

       40
       41
        
       		Host: host,

     

       41
       42
        
       	}

     

       42
       42
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       43
       43
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       43
       44
        
       	xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo)

     

       44
       45
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       45
       46
        
       		l.Error("failed to call XRPC repo.tree", "err", xrpcerr)

     
···

       50
       51
        
       	files := make([]types.NiceTree, len(xrpcResp.Files))

     

       51
       52
        
       	for i, xrpcFile := range xrpcResp.Files {

     

       52
       53
        
       		file := types.NiceTree{

     

       53
       53
       -
       			Name:      xrpcFile.Name,

     

       54
       54
       -
       			Mode:      xrpcFile.Mode,

     

       55
       55
       -
       			Size:      int64(xrpcFile.Size),

     

       56
       56
       -
       			IsFile:    xrpcFile.Is_file,

     

       57
       57
       -
       			IsSubtree: xrpcFile.Is_subtree,

     

       54
       54
       +
       			Name: xrpcFile.Name,

     

       55
       55
       +
       			Mode: xrpcFile.Mode,

     

       56
       56
       +
       			Size: int64(xrpcFile.Size),

     

       58
       57
        
       		}

     

       59
       58
        
       		// Convert last commit info if present

     

       60
       59
        
       		if xrpcFile.Last_commit != nil {

     
···

       81
       80
        
       		result.ReadmeFileName = xrpcResp.Readme.Filename

     

       82
       81
        
       		result.Readme = xrpcResp.Readme.Contents

     

       83
       82
        
       	}

     

       83
       83
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       84
       84
        
       	// redirects tree paths trying to access a blob; in this case the result.Files is unpopulated,

     

       85
       85
        
       	// so we can safely redirect to the "parent" (which is the same file).

     

       86
       86
        
       	if len(result.Files) == 0 && result.Parent == treePath {

     

       87
       87
       -
       		redirectTo := fmt.Sprintf("/%s/blob/%s/%s", f.OwnerSlashRepo(), url.PathEscape(ref), result.Parent)

     

       87
       87
       +
       		redirectTo := fmt.Sprintf("/%s/blob/%s/%s", ownerSlashRepo, url.PathEscape(ref), result.Parent)

     

       88
       88
        
       		http.Redirect(w, r, redirectTo, http.StatusFound)

     

       89
       89
        
       		return

     

       90
       90
        
       	}

     

       91
       91
        
       	user := rp.oauth.GetUser(r)

     

       92
       92
        
       	var breadcrumbs [][]string

     

       93
       93
       -
       	breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))})

     

       93
       93
       +
       	breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", ownerSlashRepo, url.PathEscape(ref))})

     

       94
       94
        
       	if treePath != "" {

     

       95
       95
        
       		for idx, elem := range strings.Split(treePath, "/") {

     

       96
       96
        
       			breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], url.PathEscape(elem))})

     

       97
       97
        
       		}

     

       98
       98
        
       	}

     

       99
       99
        
       	sortFiles(result.Files)

     

       100
       100
       +
       

     

       100
       101
        
       	rp.pages.RepoTree(w, pages.RepoTreeParams{

     

       101
       102
        
       		LoggedInUser:     user,

     

       102
       103
        
       		BreadCrumbs:      breadcrumbs,

     

       103
       104
        
       		TreePath:         treePath,

     

       104
       104
       -
       		RepoInfo:         f.RepoInfo(user),

     

       105
       105
       +
       		RepoInfo:         rp.repoResolver.GetRepoInfo(r, user),

     

       105
       106
        
       		RepoTreeResponse: result,

     

       106
       107
        
       	})

     

       107
       108
        
       }

+76 -164

appview/reporesolver/resolver.go

···

       1
       1
        
       package reporesolver

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"context"

     

       5
       5
       -
       	"database/sql"

     

       6
       6
       -
       	"errors"

     

       7
       4
        
       	"fmt"

     

       8
       5
        
       	"log"

     

       9
       6
        
       	"net/http"

     
···

       12
       9
        
       	"strings"

     

       13
       10
        
       

     

       14
       11
        
       	"github.com/bluesky-social/indigo/atproto/identity"

     

       15
       15
       -
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       16
       12
        
       	"github.com/go-chi/chi/v5"

     

       17
       13
        
       	"tangled.org/core/appview/config"

     

       18
       14
        
       	"tangled.org/core/appview/db"

     

       19
       15
        
       	"tangled.org/core/appview/models"

     

       20
       16
        
       	"tangled.org/core/appview/oauth"

     

       21
       21
       -
       	"tangled.org/core/appview/pages"

     

       22
       17
        
       	"tangled.org/core/appview/pages/repoinfo"

     

       23
       23
       -
       	"tangled.org/core/idresolver"

     

       24
       18
        
       	"tangled.org/core/rbac"

     

       25
       19
        
       )

     

       26
       20
        
       

     

       27
       27
       -
       type ResolvedRepo struct {

     

       28
       28
       -
       	models.Repo

     

       29
       29
       -
       	OwnerId    identity.Identity

     

       30
       30
       -
       	CurrentDir string

     

       31
       31
       -
       	Ref        string

     

       32
       32
       -
       

     

       33
       33
       -
       	rr *RepoResolver

     

       21
       21
       +
       type RepoResolver struct {

     

       22
       22
       +
       	config   *config.Config

     

       23
       23
       +
       	enforcer *rbac.Enforcer

     

       24
       24
       +
       	execer   db.Execer

     

       34
       25
        
       }

     

       35
       26
        
       

     

       36
       36
       -
       type RepoResolver struct {

     

       37
       37
       -
       	config     *config.Config

     

       38
       38
       -
       	enforcer   *rbac.Enforcer

     

       39
       39
       -
       	idResolver *idresolver.Resolver

     

       40
       40
       -
       	execer     db.Execer

     

       27
       27
       +
       func New(config *config.Config, enforcer *rbac.Enforcer, execer db.Execer) *RepoResolver {

     

       28
       28
       +
       	return &RepoResolver{config: config, enforcer: enforcer, execer: execer}

     

       41
       29
        
       }

     

       42
       30
        
       

     

       43
       43
       -
       func New(config *config.Config, enforcer *rbac.Enforcer, resolver *idresolver.Resolver, execer db.Execer) *RepoResolver {

     

       44
       44
       -
       	return &RepoResolver{config: config, enforcer: enforcer, idResolver: resolver, execer: execer}

     

       31
       31
       +
       // NOTE: this... should not even be here. the entire package will be removed in future refactor

     

       32
       32
       +
       func GetBaseRepoPath(r *http.Request, repo *models.Repo) string {

     

       33
       33
       +
       	var (

     

       34
       34
       +
       		user = chi.URLParam(r, "user")

     

       35
       35
       +
       		name = chi.URLParam(r, "repo")

     

       36
       36
       +
       	)

     

       37
       37
       +
       	if user == "" || name == "" {

     

       38
       38
       +
       		return repo.DidSlashRepo()

     

       39
       39
       +
       	}

     

       40
       40
       +
       	return path.Join(user, name)

     

       45
       41
        
       }

     

       46
       42
        
       

     

       47
       47
       -
       func (rr *RepoResolver) Resolve(r *http.Request) (*ResolvedRepo, error) {

     

       43
       43
       +
       // TODO: move this out of `RepoResolver` struct

     

       44
       44
       +
       func (rr *RepoResolver) Resolve(r *http.Request) (*models.Repo, error) {

     

       48
       45
        
       	repo, ok := r.Context().Value("repo").(*models.Repo)

     

       49
       46
        
       	if !ok {

     

       50
       47
        
       		log.Println("malformed middleware: `repo` not exist in context")

     

       51
       48
        
       		return nil, fmt.Errorf("malformed middleware")

     

       52
       49
        
       	}

     

       53
       53
       -
       	id, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       54
       54
       -
       	if !ok {

     

       55
       55
       -
       		log.Println("malformed middleware")

     

       56
       56
       -
       		return nil, fmt.Errorf("malformed middleware")

     

       57
       57
       -
       	}

     

       58
       50
        
       

     

       59
       59
       -
       	currentDir := path.Dir(extractPathAfterRef(r.URL.EscapedPath()))

     

       60
       60
       -
       	ref := chi.URLParam(r, "ref")

     

       61
       61
       -
       

     

       62
       62
       -
       	return &ResolvedRepo{

     

       63
       63
       -
       		Repo:       *repo,

     

       64
       64
       -
       		OwnerId:    id,

     

       65
       65
       -
       		CurrentDir: currentDir,

     

       66
       66
       -
       		Ref:        ref,

     

       67
       67
       -
       

     

       68
       68
       -
       		rr: rr,

     

       69
       69
       -
       	}, nil

     

       70
       70
       -
       }

     

       71
       71
       -
       

     

       72
       72
       -
       func (f *ResolvedRepo) OwnerDid() string {

     

       73
       73
       -
       	return f.OwnerId.DID.String()

     

       74
       74
       -
       }

     

       75
       75
       -
       

     

       76
       76
       -
       func (f *ResolvedRepo) OwnerHandle() string {

     

       77
       77
       -
       	return f.OwnerId.Handle.String()

     

       51
       51
       +
       	return repo, nil

     

       78
       52
        
       }

     

       79
       53
        
       

     

       80
       80
       -
       func (f *ResolvedRepo) OwnerSlashRepo() string {

     

       81
       81
       -
       	handle := f.OwnerId.Handle

     

       82
       82
       -
       

     

       83
       83
       -
       	var p string

     

       84
       84
       -
       	if handle != "" && !handle.IsInvalidHandle() {

     

       85
       85
       -
       		p, _ = securejoin.SecureJoin(fmt.Sprintf("@%s", handle), f.Name)

     

       86
       86
       -
       	} else {

     

       87
       87
       -
       		p, _ = securejoin.SecureJoin(f.OwnerDid(), f.Name)

     

       54
       54
       +
       // 1. [x] replace `RepoInfo` to `reporesolver.GetRepoInfo(r *http.Request, repo, user)`

     

       55
       55
       +
       // 2. [x] remove `rr`, `CurrentDir`, `Ref` fields from `ResolvedRepo`

     

       56
       56
       +
       // 3. [x] remove `ResolvedRepo`

     

       57
       57
       +
       // 4. [ ] replace reporesolver to reposervice

     

       58
       58
       +
       func (rr *RepoResolver) GetRepoInfo(r *http.Request, user *oauth.User) repoinfo.RepoInfo {

     

       59
       59
       +
       	ownerId, ook := r.Context().Value("resolvedId").(identity.Identity)

     

       60
       60
       +
       	repo, rok := r.Context().Value("repo").(*models.Repo)

     

       61
       61
       +
       	if !ook || !rok {

     

       62
       62
       +
       		log.Println("malformed request, failed to get repo from context")

     

       88
       63
        
       	}

     

       89
       64
        
       

     

       90
       90
       -
       	return p

     

       91
       91
       -
       }

     

       65
       65
       +
       	// get dir/ref

     

       66
       66
       +
       	currentDir := path.Dir(extractPathAfterRef(r.URL.EscapedPath()))

     

       67
       67
       +
       	ref := chi.URLParam(r, "ref")

     

       92
       68
        
       

     

       93
       93
       -
       func (f *ResolvedRepo) Collaborators(ctx context.Context) ([]pages.Collaborator, error) {

     

       94
       94
       -
       	repoCollaborators, err := f.rr.enforcer.E.GetImplicitUsersForResourceByDomain(f.DidSlashRepo(), f.Knot)

     

       95
       95
       -
       	if err != nil {

     

       96
       96
       -
       		return nil, err

     

       69
       69
       +
       	repoAt := repo.RepoAt()

     

       70
       70
       +
       	isStarred := false

     

       71
       71
       +
       	roles := repoinfo.RolesInRepo{}

     

       72
       72
       +
       	if user != nil {

     

       73
       73
       +
       		isStarred = db.GetStarStatus(rr.execer, user.Did, repoAt)

     

       74
       74
       +
       		roles.Roles = rr.enforcer.GetPermissionsInRepo(user.Did, repo.Knot, repo.DidSlashRepo())

     

       97
       75
        
       	}

     

       98
       76
        
       

     

       99
       99
       -
       	var collaborators []pages.Collaborator

     

       100
       100
       -
       	for _, item := range repoCollaborators {

     

       101
       101
       -
       		// currently only two roles: owner and member

     

       102
       102
       -
       		var role string

     

       103
       103
       -
       		switch item[3] {

     

       104
       104
       -
       		case "repo:owner":

     

       105
       105
       -
       			role = "owner"

     

       106
       106
       -
       		case "repo:collaborator":

     

       107
       107
       -
       			role = "collaborator"

     

       108
       108
       -
       		default:

     

       109
       109
       -
       			continue

     

       77
       77
       +
       	stats := repo.RepoStats

     

       78
       78
       +
       	if stats == nil {

     

       79
       79
       +
       		starCount, err := db.GetStarCount(rr.execer, repoAt)

     

       80
       80
       +
       		if err != nil {

     

       81
       81
       +
       			log.Println("failed to get star count for ", repoAt)

     

       110
       82
        
       		}

     

       111
       111
       -
       

     

       112
       112
       -
       		did := item[0]

     

       113
       113
       -
       

     

       114
       114
       -
       		c := pages.Collaborator{

     

       115
       115
       -
       			Did:    did,

     

       116
       116
       -
       			Handle: "",

     

       117
       117
       -
       			Role:   role,

     

       83
       83
       +
       		issueCount, err := db.GetIssueCount(rr.execer, repoAt)

     

       84
       84
       +
       		if err != nil {

     

       85
       85
       +
       			log.Println("failed to get issue count for ", repoAt)

     

       118
       86
        
       		}

     

       119
       119
       -
       		collaborators = append(collaborators, c)

     

       120
       120
       -
       	}

     

       121
       121
       -
       

     

       122
       122
       -
       	// populate all collborators with handles

     

       123
       123
       -
       	identsToResolve := make([]string, len(collaborators))

     

       124
       124
       -
       	for i, collab := range collaborators {

     

       125
       125
       -
       		identsToResolve[i] = collab.Did

     

       126
       126
       -
       	}

     

       127
       127
       -
       

     

       128
       128
       -
       	resolvedIdents := f.rr.idResolver.ResolveIdents(ctx, identsToResolve)

     

       129
       129
       -
       	for i, resolved := range resolvedIdents {

     

       130
       130
       -
       		if resolved != nil {

     

       131
       131
       -
       			collaborators[i].Handle = resolved.Handle.String()

     

       87
       87
       +
       		pullCount, err := db.GetPullCount(rr.execer, repoAt)

     

       88
       88
       +
       		if err != nil {

     

       89
       89
       +
       			log.Println("failed to get pull count for ", repoAt)

     

       132
       90
        
       		}

     

       133
       133
       -
       	}

     

       134
       134
       -
       

     

       135
       135
       -
       	return collaborators, nil

     

       136
       136
       -
       }

     

       137
       137
       -
       

     

       138
       138
       -
       // this function is a bit weird since it now returns RepoInfo from an entirely different

     

       139
       139
       -
       // package. we should refactor this or get rid of RepoInfo entirely.

     

       140
       140
       -
       func (f *ResolvedRepo) RepoInfo(user *oauth.User) repoinfo.RepoInfo {

     

       141
       141
       -
       	repoAt := f.RepoAt()

     

       142
       142
       -
       	isStarred := false

     

       143
       143
       -
       	if user != nil {

     

       144
       144
       -
       		isStarred = db.GetStarStatus(f.rr.execer, user.Did, repoAt)

     

       145
       145
       -
       	}

     

       146
       146
       -
       

     

       147
       147
       -
       	starCount, err := db.GetStarCount(f.rr.execer, repoAt)

     

       148
       148
       -
       	if err != nil {

     

       149
       149
       -
       		log.Println("failed to get star count for ", repoAt)

     

       150
       150
       -
       	}

     

       151
       151
       -
       	issueCount, err := db.GetIssueCount(f.rr.execer, repoAt)

     

       152
       152
       -
       	if err != nil {

     

       153
       153
       -
       		log.Println("failed to get issue count for ", repoAt)

     

       154
       154
       -
       	}

     

       155
       155
       -
       	pullCount, err := db.GetPullCount(f.rr.execer, repoAt)

     

       156
       156
       -
       	if err != nil {

     

       157
       157
       -
       		log.Println("failed to get issue count for ", repoAt)

     

       158
       158
       -
       	}

     

       159
       159
       -
       	source, err := db.GetRepoSource(f.rr.execer, repoAt)

     

       160
       160
       -
       	if errors.Is(err, sql.ErrNoRows) {

     

       161
       161
       -
       		source = ""

     

       162
       162
       -
       	} else if err != nil {

     

       163
       163
       -
       		log.Println("failed to get repo source for ", repoAt, err)

     

       91
       91
       +
       		stats = &models.RepoStats{

     

       92
       92
       +
       			StarCount:  starCount,

     

       93
       93
       +
       			IssueCount: issueCount,

     

       94
       94
       +
       			PullCount:  pullCount,

     

       95
       95
       +
       		}

     

       164
       96
        
       	}

     

       165
       97
        
       

     

       166
       98
        
       	var sourceRepo *models.Repo

     

       167
       167
       -
       	if source != "" {

     

       168
       168
       -
       		sourceRepo, err = db.GetRepoByAtUri(f.rr.execer, source)

     

       99
       99
       +
       	var err error

     

       100
       100
       +
       	if repo.Source != "" {

     

       101
       101
       +
       		sourceRepo, err = db.GetRepoByAtUri(rr.execer, repo.Source)

     

       169
       102
        
       		if err != nil {

     

       170
       103
        
       			log.Println("failed to get repo by at uri", err)

     

       171
       104
        
       		}

     

       172
       105
        
       	}

     

       173
       106
        
       

     

       174
       174
       -
       	var sourceHandle *identity.Identity

     

       175
       175
       -
       	if sourceRepo != nil {

     

       176
       176
       -
       		sourceHandle, err = f.rr.idResolver.ResolveIdent(context.Background(), sourceRepo.Did)

     

       177
       177
       -
       		if err != nil {

     

       178
       178
       -
       			log.Println("failed to resolve source repo", err)

     

       179
       179
       -
       		}

     

       180
       180
       -
       	}

     

       107
       107
       +
       	repoInfo := repoinfo.RepoInfo{

     

       108
       108
       +
       		// this is basically a models.Repo

     

       109
       109
       +
       		OwnerDid:    ownerId.DID.String(),

     

       110
       110
       +
       		OwnerHandle: ownerId.Handle.String(),

     

       111
       111
       +
       		Name:        repo.Name,

     

       112
       112
       +
       		Rkey:        repo.Rkey,

     

       113
       113
       +
       		Description: repo.Description,

     

       114
       114
       +
       		Website:     repo.Website,

     

       115
       115
       +
       		Topics:      repo.Topics,

     

       116
       116
       +
       		Knot:        repo.Knot,

     

       117
       117
       +
       		Spindle:     repo.Spindle,

     

       118
       118
       +
       		Stats:       *stats,

     

       181
       119
        
       

     

       182
       182
       -
       	knot := f.Knot

     

       120
       120
       +
       		// fork repo upstream

     

       121
       121
       +
       		Source: sourceRepo,

     

       183
       122
        
       

     

       184
       184
       -
       	repoInfo := repoinfo.RepoInfo{

     

       185
       185
       -
       		OwnerDid:    f.OwnerDid(),

     

       186
       186
       -
       		OwnerHandle: f.OwnerHandle(),

     

       187
       187
       -
       		Name:        f.Name,

     

       188
       188
       -
       		Rkey:        f.Repo.Rkey,

     

       189
       189
       -
       		RepoAt:      repoAt,

     

       190
       190
       -
       		Description: f.Description,

     

       191
       191
       -
       		Website:     f.Website,

     

       192
       192
       -
       		Topics:      f.Topics,

     

       193
       193
       -
       		IsStarred:   isStarred,

     

       194
       194
       -
       		Knot:        knot,

     

       195
       195
       -
       		Spindle:     f.Spindle,

     

       196
       196
       -
       		Roles:       f.RolesInRepo(user),

     

       197
       197
       -
       		Stats: models.RepoStats{

     

       198
       198
       -
       			StarCount:  starCount,

     

       199
       199
       -
       			IssueCount: issueCount,

     

       200
       200
       -
       			PullCount:  pullCount,

     

       201
       201
       -
       		},

     

       202
       202
       -
       		CurrentDir: f.CurrentDir,

     

       203
       203
       -
       		Ref:        f.Ref,

     

       204
       204
       -
       	}

     

       123
       123
       +
       		// page context

     

       124
       124
       +
       		CurrentDir: currentDir,

     

       125
       125
       +
       		Ref:        ref,

     

       205
       126
        
       

     

       206
       206
       -
       	if sourceRepo != nil {

     

       207
       207
       -
       		repoInfo.Source = sourceRepo

     

       208
       208
       -
       		repoInfo.SourceHandle = sourceHandle.Handle.String()

     

       127
       127
       +
       		// info related to the session

     

       128
       128
       +
       		IsStarred: isStarred,

     

       129
       129
       +
       		Roles:     roles,

     

       209
       130
        
       	}

     

       210
       131
        
       

     

       211
       132
        
       	return repoInfo

     

       212
       212
       -
       }

     

       213
       213
       -
       

     

       214
       214
       -
       func (f *ResolvedRepo) RolesInRepo(u *oauth.User) repoinfo.RolesInRepo {

     

       215
       215
       -
       	if u != nil {

     

       216
       216
       -
       		r := f.rr.enforcer.GetPermissionsInRepo(u.Did, f.Knot, f.DidSlashRepo())

     

       217
       217
       -
       		return repoinfo.RolesInRepo{Roles: r}

     

       218
       218
       -
       	} else {

     

       219
       219
       -
       		return repoinfo.RolesInRepo{}

     

       220
       220
       -
       	}

     

       221
       133
        
       }

     

       222
       134
        
       

     

       223
       135
        
       // extractPathAfterRef gets the actual repository path

+5 -4

appview/serververify/verify.go

···

       9
       9
        
       	"tangled.org/core/api/tangled"

     

       10
       10
        
       	"tangled.org/core/appview/db"

     

       11
       11
        
       	"tangled.org/core/appview/xrpcclient"

     

       12
       12
       +
       	"tangled.org/core/orm"

     

       12
       13
        
       	"tangled.org/core/rbac"

     

       13
       14
        
       )

     

       14
       15
        
       

     
···

       76
       77
        
       	// mark this spindle as verified in the db

     

       77
       78
        
       	rowId, err := db.VerifySpindle(

     

       78
       79
        
       		tx,

     

       79
       79
       -
       		db.FilterEq("owner", owner),

     

       80
       80
       -
       		db.FilterEq("instance", instance),

     

       80
       80
       +
       		orm.FilterEq("owner", owner),

     

       81
       81
       +
       		orm.FilterEq("instance", instance),

     

       81
       82
        
       	)

     

       82
       83
        
       	if err != nil {

     

       83
       84
        
       		return 0, fmt.Errorf("failed to write to DB: %w", err)

     
···

       115
       116
        
       	// mark as registered

     

       116
       117
        
       	err = db.MarkRegistered(

     

       117
       118
        
       		tx,

     

       118
       118
       -
       		db.FilterEq("did", owner),

     

       119
       119
       -
       		db.FilterEq("domain", domain),

     

       119
       119
       +
       		orm.FilterEq("did", owner),

     

       120
       120
       +
       		orm.FilterEq("domain", domain),

     

       120
       121
        
       	)

     

       121
       122
        
       	if err != nil {

     

       122
       123
        
       		return fmt.Errorf("failed to register domain: %w", err)

appview/settings/settings.go

···

       43
       43
        
       		{"Name": "keys", "Icon": "key"},

     

       44
       44
        
       		{"Name": "emails", "Icon": "mail"},

     

       45
       45
        
       		{"Name": "notifications", "Icon": "bell"},

     

       46
       46
       +
       		{"Name": "knots", "Icon": "volleyball"},

     

       47
       47
       +
       		{"Name": "spindles", "Icon": "spool"},

     

       46
       48
        
       	}

     

       47
       49
        
       )

     

       48
       50

+44 -26

appview/spindles/spindles.go

···

       20
       20
        
       	"tangled.org/core/appview/serververify"

     

       21
       21
        
       	"tangled.org/core/appview/xrpcclient"

     

       22
       22
        
       	"tangled.org/core/idresolver"

     

       23
       23
       +
       	"tangled.org/core/orm"

     

       23
       24
        
       	"tangled.org/core/rbac"

     

       24
       25
        
       	"tangled.org/core/tid"

     

       25
       26
        
       

     
···

       38
       39
        
       	Logger     *slog.Logger

     

       39
       40
        
       }

     

       40
       41
        
       

     

       42
       42
       +
       type tab = map[string]any

     

       43
       43
       +
       

     

       44
       44
       +
       var (

     

       45
       45
       +
       	spindlesTabs []tab = []tab{

     

       46
       46
       +
       		{"Name": "profile", "Icon": "user"},

     

       47
       47
       +
       		{"Name": "keys", "Icon": "key"},

     

       48
       48
       +
       		{"Name": "emails", "Icon": "mail"},

     

       49
       49
       +
       		{"Name": "notifications", "Icon": "bell"},

     

       50
       50
       +
       		{"Name": "knots", "Icon": "volleyball"},

     

       51
       51
       +
       		{"Name": "spindles", "Icon": "spool"},

     

       52
       52
       +
       	}

     

       53
       53
       +
       )

     

       54
       54
       +
       

     

       41
       55
        
       func (s *Spindles) Router() http.Handler {

     

       42
       56
        
       	r := chi.NewRouter()

     

       43
       57
        
       

     
···

       58
       72
        
       	user := s.OAuth.GetUser(r)

     

       59
       73
        
       	all, err := db.GetSpindles(

     

       60
       74
        
       		s.Db,

     

       61
       61
       -
       		db.FilterEq("owner", user.Did),

     

       75
       75
       +
       		orm.FilterEq("owner", user.Did),

     

       62
       76
        
       	)

     

       63
       77
        
       	if err != nil {

     

       64
       78
        
       		s.Logger.Error("failed to fetch spindles", "err", err)

     
···

       69
       83
        
       	s.Pages.Spindles(w, pages.SpindlesParams{

     

       70
       84
        
       		LoggedInUser: user,

     

       71
       85
        
       		Spindles:     all,

     

       86
       86
       +
       		Tabs:         spindlesTabs,

     

       87
       87
       +
       		Tab:          "spindles",

     

       72
       88
        
       	})

     

       73
       89
        
       }

     

       74
       90
        
       

     
···

       86
       102
        
       

     

       87
       103
        
       	spindles, err := db.GetSpindles(

     

       88
       104
        
       		s.Db,

     

       89
       89
       -
       		db.FilterEq("instance", instance),

     

       90
       90
       -
       		db.FilterEq("owner", user.Did),

     

       91
       91
       -
       		db.FilterIsNot("verified", "null"),

     

       105
       105
       +
       		orm.FilterEq("instance", instance),

     

       106
       106
       +
       		orm.FilterEq("owner", user.Did),

     

       107
       107
       +
       		orm.FilterIsNot("verified", "null"),

     

       92
       108
        
       	)

     

       93
       109
        
       	if err != nil || len(spindles) != 1 {

     

       94
       110
        
       		l.Error("failed to get spindle", "err", err, "len(spindles)", len(spindles))

     
···

       108
       124
        
       	repos, err := db.GetRepos(

     

       109
       125
        
       		s.Db,

     

       110
       126
        
       		0,

     

       111
       111
       -
       		db.FilterEq("spindle", instance),

     

       127
       127
       +
       		orm.FilterEq("spindle", instance),

     

       112
       128
        
       	)

     

       113
       129
        
       	if err != nil {

     

       114
       130
        
       		l.Error("failed to get spindle repos", "err", err)

     
···

       127
       143
        
       		Spindle:      spindle,

     

       128
       144
        
       		Members:      members,

     

       129
       145
        
       		Repos:        repoMap,

     

       146
       146
       +
       		Tabs:         spindlesTabs,

     

       147
       147
       +
       		Tab:          "spindles",

     

       130
       148
        
       	})

     

       131
       149
        
       }

     

       132
       150
        
       

     
···

       273
       291
        
       

     

       274
       292
        
       	spindles, err := db.GetSpindles(

     

       275
       293
        
       		s.Db,

     

       276
       276
       -
       		db.FilterEq("owner", user.Did),

     

       277
       277
       -
       		db.FilterEq("instance", instance),

     

       294
       294
       +
       		orm.FilterEq("owner", user.Did),

     

       295
       295
       +
       		orm.FilterEq("instance", instance),

     

       278
       296
        
       	)

     

       279
       297
        
       	if err != nil || len(spindles) != 1 {

     

       280
       298
        
       		l.Error("failed to retrieve instance", "err", err, "len(spindles)", len(spindles))

     
···

       302
       320
        
       	// remove spindle members first

     

       303
       321
        
       	err = db.RemoveSpindleMember(

     

       304
       322
        
       		tx,

     

       305
       305
       -
       		db.FilterEq("did", user.Did),

     

       306
       306
       -
       		db.FilterEq("instance", instance),

     

       323
       323
       +
       		orm.FilterEq("did", user.Did),

     

       324
       324
       +
       		orm.FilterEq("instance", instance),

     

       307
       325
        
       	)

     

       308
       326
        
       	if err != nil {

     

       309
       327
        
       		l.Error("failed to remove spindle members", "err", err)

     
···

       313
       331
        
       

     

       314
       332
        
       	err = db.DeleteSpindle(

     

       315
       333
        
       		tx,

     

       316
       316
       -
       		db.FilterEq("owner", user.Did),

     

       317
       317
       -
       		db.FilterEq("instance", instance),

     

       334
       334
       +
       		orm.FilterEq("owner", user.Did),

     

       335
       335
       +
       		orm.FilterEq("instance", instance),

     

       318
       336
        
       	)

     

       319
       337
        
       	if err != nil {

     

       320
       338
        
       		l.Error("failed to delete spindle", "err", err)

     
···

       365
       383
        
       

     

       366
       384
        
       	shouldRedirect := r.Header.Get("shouldRedirect")

     

       367
       385
        
       	if shouldRedirect == "true" {

     

       368
       368
       -
       		s.Pages.HxRedirect(w, "/spindles")

     

       386
       386
       +
       		s.Pages.HxRedirect(w, "/settings/spindles")

     

       369
       387
        
       		return

     

       370
       388
        
       	}

     

       371
       389
        
       

     
···

       393
       411
        
       

     

       394
       412
        
       	spindles, err := db.GetSpindles(

     

       395
       413
        
       		s.Db,

     

       396
       396
       -
       		db.FilterEq("owner", user.Did),

     

       397
       397
       -
       		db.FilterEq("instance", instance),

     

       414
       414
       +
       		orm.FilterEq("owner", user.Did),

     

       415
       415
       +
       		orm.FilterEq("instance", instance),

     

       398
       416
        
       	)

     

       399
       417
        
       	if err != nil || len(spindles) != 1 {

     

       400
       418
        
       		l.Error("failed to retrieve instance", "err", err, "len(spindles)", len(spindles))

     
···

       436
       454
        
       

     

       437
       455
        
       	verifiedSpindle, err := db.GetSpindles(

     

       438
       456
        
       		s.Db,

     

       439
       439
       -
       		db.FilterEq("id", rowId),

     

       457
       457
       +
       		orm.FilterEq("id", rowId),

     

       440
       458
        
       	)

     

       441
       459
        
       	if err != nil || len(verifiedSpindle) != 1 {

     

       442
       460
        
       		l.Error("failed get new spindle", "err", err)

     
···

       469
       487
        
       

     

       470
       488
        
       	spindles, err := db.GetSpindles(

     

       471
       489
        
       		s.Db,

     

       472
       472
       -
       		db.FilterEq("owner", user.Did),

     

       473
       473
       -
       		db.FilterEq("instance", instance),

     

       490
       490
       +
       		orm.FilterEq("owner", user.Did),

     

       491
       491
       +
       		orm.FilterEq("instance", instance),

     

       474
       492
        
       	)

     

       475
       493
        
       	if err != nil || len(spindles) != 1 {

     

       476
       494
        
       		l.Error("failed to retrieve instance", "err", err, "len(spindles)", len(spindles))

     
···

       581
       599
        
       	}

     

       582
       600
        
       

     

       583
       601
        
       	// success

     

       584
       584
       -
       	s.Pages.HxRedirect(w, fmt.Sprintf("/spindles/%s", instance))

     

       602
       602
       +
       	s.Pages.HxRedirect(w, fmt.Sprintf("/settings/spindles/%s", instance))

     

       585
       603
        
       }

     

       586
       604
        
       

     

       587
       605
        
       func (s *Spindles) removeMember(w http.ResponseWriter, r *http.Request) {

     
···

       605
       623
        
       

     

       606
       624
        
       	spindles, err := db.GetSpindles(

     

       607
       625
        
       		s.Db,

     

       608
       608
       -
       		db.FilterEq("owner", user.Did),

     

       609
       609
       -
       		db.FilterEq("instance", instance),

     

       626
       626
       +
       		orm.FilterEq("owner", user.Did),

     

       627
       627
       +
       		orm.FilterEq("instance", instance),

     

       610
       628
        
       	)

     

       611
       629
        
       	if err != nil || len(spindles) != 1 {

     

       612
       630
        
       		l.Error("failed to retrieve instance", "err", err, "len(spindles)", len(spindles))

     
···

       655
       673
        
       	// get the record from the DB first:

     

       656
       674
        
       	members, err := db.GetSpindleMembers(

     

       657
       675
        
       		s.Db,

     

       658
       658
       -
       		db.FilterEq("did", user.Did),

     

       659
       659
       -
       		db.FilterEq("instance", instance),

     

       660
       660
       -
       		db.FilterEq("subject", memberId.DID),

     

       676
       676
       +
       		orm.FilterEq("did", user.Did),

     

       677
       677
       +
       		orm.FilterEq("instance", instance),

     

       678
       678
       +
       		orm.FilterEq("subject", memberId.DID),

     

       661
       679
        
       	)

     

       662
       680
        
       	if err != nil || len(members) != 1 {

     

       663
       681
        
       		l.Error("failed to get member", "err", err)

     
···

       668
       686
        
       	// remove from db

     

       669
       687
        
       	if err = db.RemoveSpindleMember(

     

       670
       688
        
       		tx,

     

       671
       671
       -
       		db.FilterEq("did", user.Did),

     

       672
       672
       -
       		db.FilterEq("instance", instance),

     

       673
       673
       -
       		db.FilterEq("subject", memberId.DID),

     

       689
       689
       +
       		orm.FilterEq("did", user.Did),

     

       690
       690
       +
       		orm.FilterEq("instance", instance),

     

       691
       691
       +
       		orm.FilterEq("subject", memberId.DID),

     

       674
       692
        
       	); err != nil {

     

       675
       693
        
       		l.Error("failed to remove spindle member", "err", err)

     

       676
       694
        
       		fail()

+6 -5

appview/state/gfi.go

···

       11
       11
        
       	"tangled.org/core/appview/pages"

     

       12
       12
        
       	"tangled.org/core/appview/pagination"

     

       13
       13
        
       	"tangled.org/core/consts"

     

       14
       14
       +
       	"tangled.org/core/orm"

     

       14
       15
        
       )

     

       15
       16
        
       

     

       16
       17
        
       func (s *State) GoodFirstIssues(w http.ResponseWriter, r *http.Request) {

     
···

       20
       21
        
       

     

       21
       22
        
       	goodFirstIssueLabel := s.config.Label.GoodFirstIssue

     

       22
       23
        
       

     

       23
       23
       -
       	gfiLabelDef, err := db.GetLabelDefinition(s.db, db.FilterEq("at_uri", goodFirstIssueLabel))

     

       24
       24
       +
       	gfiLabelDef, err := db.GetLabelDefinition(s.db, orm.FilterEq("at_uri", goodFirstIssueLabel))

     

       24
       25
        
       	if err != nil {

     

       25
       26
        
       		log.Println("failed to get gfi label def", err)

     

       26
       27
        
       		s.pages.Error500(w)

     

       27
       28
        
       		return

     

       28
       29
        
       	}

     

       29
       30
        
       

     

       30
       30
       -
       	repoLabels, err := db.GetRepoLabels(s.db, db.FilterEq("label_at", goodFirstIssueLabel))

     

       31
       31
       +
       	repoLabels, err := db.GetRepoLabels(s.db, orm.FilterEq("label_at", goodFirstIssueLabel))

     

       31
       32
        
       	if err != nil {

     

       32
       33
        
       		log.Println("failed to get repo labels", err)

     

       33
       34
        
       		s.pages.Error503(w)

     
···

       55
       56
        
       		pagination.Page{

     

       56
       57
        
       			Limit: 500,

     

       57
       58
        
       		},

     

       58
       58
       -
       		db.FilterIn("repo_at", repoUris),

     

       59
       59
       -
       		db.FilterEq("open", 1),

     

       59
       59
       +
       		orm.FilterIn("repo_at", repoUris),

     

       60
       60
       +
       		orm.FilterEq("open", 1),

     

       60
       61
        
       	)

     

       61
       62
        
       	if err != nil {

     

       62
       63
        
       		log.Println("failed to get issues", err)

     
···

       132
       133
        
       		}

     

       133
       134
        
       

     

       134
       135
        
       		if len(uriList) > 0 {

     

       135
       135
       -
       			allLabelDefs, err = db.GetLabelDefinitions(s.db, db.FilterIn("at_uri", uriList))

     

       136
       136
       +
       			allLabelDefs, err = db.GetLabelDefinitions(s.db, orm.FilterIn("at_uri", uriList))

     

       136
       137
        
       			if err != nil {

     

       137
       138
        
       				log.Println("failed to fetch labels", err)

     

       138
       139
        
       			}

+6 -5

appview/state/knotstream.go

···

       16
       16
        
       	ec "tangled.org/core/eventconsumer"

     

       17
       17
        
       	"tangled.org/core/eventconsumer/cursor"

     

       18
       18
        
       	"tangled.org/core/log"

     

       19
       19
       +
       	"tangled.org/core/orm"

     

       19
       20
        
       	"tangled.org/core/rbac"

     

       20
       21
        
       	"tangled.org/core/workflow"

     

       21
       22
        
       

     
···

       30
       31
        
       

     

       31
       32
        
       	knots, err := db.GetRegistrations(

     

       32
       33
        
       		d,

     

       33
       33
       -
       		db.FilterIsNot("registered", "null"),

     

       34
       34
       +
       		orm.FilterIsNot("registered", "null"),

     

       34
       35
        
       	)

     

       35
       36
        
       	if err != nil {

     

       36
       37
        
       		return nil, err

     
···

       143
       144
        
       	repos, err := db.GetRepos(

     

       144
       145
        
       		d,

     

       145
       146
        
       		0,

     

       146
       146
       -
       		db.FilterEq("did", record.RepoDid),

     

       147
       147
       -
       		db.FilterEq("name", record.RepoName),

     

       147
       147
       +
       		orm.FilterEq("did", record.RepoDid),

     

       148
       148
       +
       		orm.FilterEq("name", record.RepoName),

     

       148
       149
        
       	)

     

       149
       150
        
       	if err != nil {

     

       150
       151
        
       		return fmt.Errorf("failed to look for repo in DB (%s/%s): %w", record.RepoDid, record.RepoName, err)

     
···

       209
       210
        
       	repos, err := db.GetRepos(

     

       210
       211
        
       		d,

     

       211
       212
        
       		0,

     

       212
       212
       -
       		db.FilterEq("did", record.TriggerMetadata.Repo.Did),

     

       213
       213
       -
       		db.FilterEq("name", record.TriggerMetadata.Repo.Repo),

     

       213
       213
       +
       		orm.FilterEq("did", record.TriggerMetadata.Repo.Did),

     

       214
       214
       +
       		orm.FilterEq("name", record.TriggerMetadata.Repo.Repo),

     

       214
       215
        
       	)

     

       215
       216
        
       	if err != nil {

     

       216
       217
        
       		return fmt.Errorf("failed to look for repo in DB: nsid %s, rkey %s, %w", msg.Nsid, msg.Rkey, err)

+28 -21

appview/state/profile.go

···

       19
       19
        
       	"tangled.org/core/appview/db"

     

       20
       20
        
       	"tangled.org/core/appview/models"

     

       21
       21
        
       	"tangled.org/core/appview/pages"

     

       22
       22
       +
       	"tangled.org/core/orm"

     

       22
       23
        
       )

     

       23
       24
        
       

     

       24
       25
        
       func (s *State) Profile(w http.ResponseWriter, r *http.Request) {

     
···

       56
       57
        
       		return nil, fmt.Errorf("failed to get profile: %w", err)

     

       57
       58
        
       	}

     

       58
       59
        
       

     

       59
       59
       -
       	repoCount, err := db.CountRepos(s.db, db.FilterEq("did", did))

     

       60
       60
       +
       	repoCount, err := db.CountRepos(s.db, orm.FilterEq("did", did))

     

       60
       61
        
       	if err != nil {

     

       61
       62
        
       		return nil, fmt.Errorf("failed to get repo count: %w", err)

     

       62
       63
        
       	}

     

       63
       64
        
       

     

       64
       64
       -
       	stringCount, err := db.CountStrings(s.db, db.FilterEq("did", did))

     

       65
       65
       +
       	stringCount, err := db.CountStrings(s.db, orm.FilterEq("did", did))

     

       65
       66
        
       	if err != nil {

     

       66
       67
        
       		return nil, fmt.Errorf("failed to get string count: %w", err)

     

       67
       68
        
       	}

     

       68
       69
        
       

     

       69
       69
       -
       	starredCount, err := db.CountStars(s.db, db.FilterEq("starred_by_did", did))

     

       70
       70
       +
       	starredCount, err := db.CountStars(s.db, orm.FilterEq("did", did))

     

       70
       71
        
       	if err != nil {

     

       71
       72
        
       		return nil, fmt.Errorf("failed to get starred repo count: %w", err)

     

       72
       73
        
       	}

     
···

       86
       87
        
       	startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC)

     

       87
       88
        
       	punchcard, err := db.MakePunchcard(

     

       88
       89
        
       		s.db,

     

       89
       89
       -
       		db.FilterEq("did", did),

     

       90
       90
       -
       		db.FilterGte("date", startOfYear.Format(time.DateOnly)),

     

       91
       91
       -
       		db.FilterLte("date", now.Format(time.DateOnly)),

     

       90
       90
       +
       		orm.FilterEq("did", did),

     

       91
       91
       +
       		orm.FilterGte("date", startOfYear.Format(time.DateOnly)),

     

       92
       92
       +
       		orm.FilterLte("date", now.Format(time.DateOnly)),

     

       92
       93
        
       	)

     

       93
       94
        
       	if err != nil {

     

       94
       95
        
       		return nil, fmt.Errorf("failed to get punchcard for %s: %w", did, err)

     
···

       96
       97
        
       

     

       97
       98
        
       	return &pages.ProfileCard{

     

       98
       99
        
       		UserDid:      did,

     

       99
       99
       -
       		UserHandle:   ident.Handle.String(),

     

       100
       100
        
       		Profile:      profile,

     

       101
       101
        
       		FollowStatus: followStatus,

     

       102
       102
        
       		Stats: pages.ProfileStats{

     
···

       119
       119
        
       		s.pages.Error500(w)

     

       120
       120
        
       		return

     

       121
       121
        
       	}

     

       122
       122
       -
       	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     

       122
       122
       +
       	l = l.With("profileDid", profile.UserDid)

     

       123
       123
        
       

     

       124
       124
        
       	repos, err := db.GetRepos(

     

       125
       125
        
       		s.db,

     

       126
       126
        
       		0,

     

       127
       127
       -
       		db.FilterEq("did", profile.UserDid),

     

       127
       127
       +
       		orm.FilterEq("did", profile.UserDid),

     

       128
       128
        
       	)

     

       129
       129
        
       	if err != nil {

     

       130
       130
        
       		l.Error("failed to fetch repos", "err", err)

     
···

       162
       162
        
       		l.Error("failed to create timeline", "err", err)

     

       163
       163
        
       	}

     

       164
       164
        
       

     

       165
       165
       +
       	// populate commit counts in the timeline, using the punchcard

     

       166
       166
       +
       	currentMonth := time.Now().Month()

     

       167
       167
       +
       	for _, p := range profile.Punchcard.Punches {

     

       168
       168
       +
       		idx := currentMonth - p.Date.Month()

     

       169
       169
       +
       		if int(idx) < len(timeline.ByMonth) {

     

       170
       170
       +
       			timeline.ByMonth[idx].Commits += p.Count

     

       171
       171
       +
       		}

     

       172
       172
       +
       	}

     

       173
       173
       +
       

     

       165
       174
        
       	s.pages.ProfileOverview(w, pages.ProfileOverviewParams{

     

       166
       175
        
       		LoggedInUser:       s.oauth.GetUser(r),

     

       167
       176
        
       		Card:               profile,

     
···

       180
       189
        
       		s.pages.Error500(w)

     

       181
       190
        
       		return

     

       182
       191
        
       	}

     

       183
       183
       -
       	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     

       192
       192
       +
       	l = l.With("profileDid", profile.UserDid)

     

       184
       193
        
       

     

       185
       194
        
       	repos, err := db.GetRepos(

     

       186
       195
        
       		s.db,

     

       187
       196
        
       		0,

     

       188
       188
       -
       		db.FilterEq("did", profile.UserDid),

     

       197
       197
       +
       		orm.FilterEq("did", profile.UserDid),

     

       189
       198
        
       	)

     

       190
       199
        
       	if err != nil {

     

       191
       200
        
       		l.Error("failed to get repos", "err", err)

     
···

       209
       218
        
       		s.pages.Error500(w)

     

       210
       219
        
       		return

     

       211
       220
        
       	}

     

       212
       212
       -
       	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     

       221
       221
       +
       	l = l.With("profileDid", profile.UserDid)

     

       213
       222
        
       

     

       214
       214
       -
       	stars, err := db.GetStars(s.db, 0, db.FilterEq("starred_by_did", profile.UserDid))

     

       223
       223
       +
       	stars, err := db.GetRepoStars(s.db, 0, orm.FilterEq("did", profile.UserDid))

     

       215
       224
        
       	if err != nil {

     

       216
       225
        
       		l.Error("failed to get stars", "err", err)

     

       217
       226
        
       		s.pages.Error500(w)

     
···

       219
       228
        
       	}

     

       220
       229
        
       	var repos []models.Repo

     

       221
       230
        
       	for _, s := range stars {

     

       222
       222
       -
       		if s.Repo != nil {

     

       223
       223
       -
       			repos = append(repos, *s.Repo)

     

       224
       224
       -
       		}

     

       231
       231
       +
       		repos = append(repos, *s.Repo)

     

       225
       232
        
       	}

     

       226
       233
        
       

     

       227
       234
        
       	err = s.pages.ProfileStarred(w, pages.ProfileStarredParams{

     
···

       240
       247
        
       		s.pages.Error500(w)

     

       241
       248
        
       		return

     

       242
       249
        
       	}

     

       243
       243
       -
       	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     

       250
       250
       +
       	l = l.With("profileDid", profile.UserDid)

     

       244
       251
        
       

     

       245
       245
       -
       	strings, err := db.GetStrings(s.db, 0, db.FilterEq("did", profile.UserDid))

     

       252
       252
       +
       	strings, err := db.GetStrings(s.db, 0, orm.FilterEq("did", profile.UserDid))

     

       246
       253
        
       	if err != nil {

     

       247
       254
        
       		l.Error("failed to get strings", "err", err)

     

       248
       255
        
       		s.pages.Error500(w)

     
···

       272
       279
        
       	if err != nil {

     

       273
       280
        
       		return nil, err

     

       274
       281
        
       	}

     

       275
       275
       -
       	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     

       282
       282
       +
       	l = l.With("profileDid", profile.UserDid)

     

       276
       283
        
       

     

       277
       284
        
       	loggedInUser := s.oauth.GetUser(r)

     

       278
       285
        
       	params := FollowsPageParams{

     
···

       294
       301
        
       		followDids = append(followDids, extractDid(follow))

     

       295
       302
        
       	}

     

       296
       303
        
       

     

       297
       297
       -
       	profiles, err := db.GetProfiles(s.db, db.FilterIn("did", followDids))

     

       304
       304
       +
       	profiles, err := db.GetProfiles(s.db, orm.FilterIn("did", followDids))

     

       298
       305
        
       	if err != nil {

     

       299
       306
        
       		l.Error("failed to get profiles", "followDids", followDids, "err", err)

     

       300
       307
        
       		return &params, err

     
···

       697
       704
        
       		log.Printf("getting profile data for %s: %s", user.Did, err)

     

       698
       705
        
       	}

     

       699
       706
        
       

     

       700
       700
       -
       	repos, err := db.GetRepos(s.db, 0, db.FilterEq("did", user.Did))

     

       707
       707
       +
       	repos, err := db.GetRepos(s.db, 0, orm.FilterEq("did", user.Did))

     

       701
       708
        
       	if err != nil {

     

       702
       709
        
       		log.Printf("getting repos for %s: %s", user.Did, err)

     

       703
       710
        
       	}

+19 -13

appview/state/router.go

···

       57
       57
        
       			if userutil.IsFlattenedDid(firstPart) {

     

       58
       58
        
       				unflattenedDid := userutil.UnflattenDid(firstPart)

     

       59
       59
        
       				redirectPath := strings.Join(append([]string{unflattenedDid}, pathParts[1:]...), "/")

     

       60
       60
       -
       				http.Redirect(w, r, "/"+redirectPath, http.StatusFound)

     

       60
       60
       +
       

     

       61
       61
       +
       				redirectURL := *r.URL

     

       62
       62
       +
       				redirectURL.Path = "/" + redirectPath

     

       63
       63
       +
       

     

       64
       64
       +
       				http.Redirect(w, r, redirectURL.String(), http.StatusFound)

     

       61
       65
        
       				return

     

       62
       66
        
       			}

     

       63
       67
        
       

     

       64
       68
        
       			// if using a handle with @, rewrite to work without @

     

       65
       69
        
       			if normalized := strings.TrimPrefix(firstPart, "@"); userutil.IsHandle(normalized) {

     

       66
       70
        
       				redirectPath := strings.Join(append([]string{normalized}, pathParts[1:]...), "/")

     

       67
       67
       -
       				http.Redirect(w, r, "/"+redirectPath, http.StatusFound)

     

       71
       71
       +
       

     

       72
       72
       +
       				redirectURL := *r.URL

     

       73
       73
       +
       				redirectURL.Path = "/" + redirectPath

     

       74
       74
       +
       

     

       75
       75
       +
       				http.Redirect(w, r, redirectURL.String(), http.StatusFound)

     

       68
       76
        
       				return

     

       69
       77
        
       			}

     

       78
       78
       +
       

     

       70
       79
        
       		}

     

       71
       80
        
       

     

       72
       81
        
       		standardRouter.ServeHTTP(w, r)

     
···

       82
       91
        
       		r.Get("/", s.Profile)

     

       83
       92
        
       		r.Get("/feed.atom", s.AtomFeedPage)

     

       84
       93
        
       

     

       85
       85
       -
       		// redirect /@handle/repo.git -> /@handle/repo

     

       86
       86
       -
       		r.Get("/{repo}.git", func(w http.ResponseWriter, r *http.Request) {

     

       87
       87
       -
       			nonDotGitPath := strings.TrimSuffix(r.URL.Path, ".git")

     

       88
       88
       -
       			http.Redirect(w, r, nonDotGitPath, http.StatusMovedPermanently)

     

       89
       89
       -
       		})

     

       90
       90
       -
       

     

       91
       94
        
       		r.With(mw.ResolveRepo()).Route("/{repo}", func(r chi.Router) {

     

       92
       95
        
       			r.Use(mw.GoImport())

     

       93
       96
        
       			r.Mount("/", s.RepoRouter(mw))

     
···

       136
       139
        
       		// r.Post("/import", s.ImportRepo)

     

       137
       140
        
       	})

     

       138
       141
        
       

     

       139
       139
       -
       	r.Get("/goodfirstissues", s.GoodFirstIssues)

     

       142
       142
       +
       	r.With(middleware.Paginate).Get("/goodfirstissues", s.GoodFirstIssues)

     

       140
       143
        
       

     

       141
       144
        
       	r.With(middleware.AuthMiddleware(s.oauth)).Route("/follow", func(r chi.Router) {

     

       142
       145
        
       		r.Post("/", s.Follow)

     
···

       163
       166
        
       

     

       164
       167
        
       	r.Mount("/settings", s.SettingsRouter())

     

       165
       168
        
       	r.Mount("/strings", s.StringsRouter(mw))

     

       166
       166
       -
       	r.Mount("/knots", s.KnotsRouter())

     

       167
       167
       -
       	r.Mount("/spindles", s.SpindlesRouter())

     

       169
       169
       +
       

     

       170
       170
       +
       	r.Mount("/settings/knots", s.KnotsRouter())

     

       171
       171
       +
       	r.Mount("/settings/spindles", s.SpindlesRouter())

     

       172
       172
       +
       

     

       168
       173
        
       	r.Mount("/notifications", s.NotificationsRouter(mw))

     

       169
       174
        
       

     

       170
       175
        
       	r.Mount("/signup", s.SignupRouter())

     
···

       258
       263
        
       	issues := issues.New(

     

       259
       264
        
       		s.oauth,

     

       260
       265
        
       		s.repoResolver,

     

       266
       266
       +
       		s.enforcer,

     

       261
       267
        
       		s.pages,

     

       262
       268
        
       		s.idResolver,

     

       263
       263
       -
       		s.refResolver,

     

       269
       269
       +
       		s.mentionsResolver,

     

       264
       270
        
       		s.db,

     

       265
       271
        
       		s.config,

     

       266
       272
        
       		s.notifier,

     
···

       277
       283
        
       		s.repoResolver,

     

       278
       284
        
       		s.pages,

     

       279
       285
        
       		s.idResolver,

     

       280
       280
       -
       		s.refResolver,

     

       286
       286
       +
       		s.mentionsResolver,

     

       281
       287
        
       		s.db,

     

       282
       288
        
       		s.config,

     

       283
       289
        
       		s.notifier,

+2 -1

appview/state/spindlestream.go

···

       17
       17
        
       	ec "tangled.org/core/eventconsumer"

     

       18
       18
        
       	"tangled.org/core/eventconsumer/cursor"

     

       19
       19
        
       	"tangled.org/core/log"

     

       20
       20
       +
       	"tangled.org/core/orm"

     

       20
       21
        
       	"tangled.org/core/rbac"

     

       21
       22
        
       	spindle "tangled.org/core/spindle/models"

     

       22
       23
        
       )

     
···

       27
       28
        
       

     

       28
       29
        
       	spindles, err := db.GetSpindles(

     

       29
       30
        
       		d,

     

       30
       30
       -
       		db.FilterIsNot("verified", "null"),

     

       31
       31
       +
       		orm.FilterIsNot("verified", "null"),

     

       31
       32
        
       	)

     

       32
       33
        
       	if err != nil {

     

       33
       34
        
       		return nil, err

+9 -13

appview/state/star.go

···

       57
       57
        
       		log.Println("created atproto record: ", resp.Uri)

     

       58
       58
        
       

     

       59
       59
        
       		star := &models.Star{

     

       60
       60
       -
       			StarredByDid: currentUser.Did,

     

       61
       61
       -
       			RepoAt:       subjectUri,

     

       62
       62
       -
       			Rkey:         rkey,

     

       60
       60
       +
       			Did:    currentUser.Did,

     

       61
       61
       +
       			RepoAt: subjectUri,

     

       62
       62
       +
       			Rkey:   rkey,

     

       63
       63
        
       		}

     

       64
       64
        
       

     

       65
       65
        
       		err = db.AddStar(s.db, star)

     
···

       75
       75
        
       

     

       76
       76
        
       		s.notifier.NewStar(r.Context(), star)

     

       77
       77
        
       

     

       78
       78
       -
       		s.pages.RepoStarFragment(w, pages.RepoStarFragmentParams{

     

       78
       78
       +
       		s.pages.StarBtnFragment(w, pages.StarBtnFragmentParams{

     

       79
       79
        
       			IsStarred: true,

     

       80
       80
       -
       			RepoAt:    subjectUri,

     

       81
       81
       -
       			Stats: models.RepoStats{

     

       82
       82
       -
       				StarCount: starCount,

     

       83
       83
       -
       			},

     

       80
       80
       +
       			SubjectAt: subjectUri,

     

       81
       81
       +
       			StarCount: starCount,

     

       84
       82
        
       		})

     

       85
       83
        
       

     

       86
       84
        
       		return

     
···

       117
       115
        
       

     

       118
       116
        
       		s.notifier.DeleteStar(r.Context(), star)

     

       119
       117
        
       

     

       120
       120
       -
       		s.pages.RepoStarFragment(w, pages.RepoStarFragmentParams{

     

       118
       118
       +
       		s.pages.StarBtnFragment(w, pages.StarBtnFragmentParams{

     

       121
       119
        
       			IsStarred: false,

     

       122
       122
       -
       			RepoAt:    subjectUri,

     

       123
       123
       -
       			Stats: models.RepoStats{

     

       124
       124
       -
       				StarCount: starCount,

     

       125
       125
       -
       			},

     

       120
       120
       +
       			SubjectAt: subjectUri,

     

       121
       121
       +
       			StarCount: starCount,

     

       126
       122
        
       		})

     

       127
       123
        
       

     

       128
       124
        
       		return

+29 -28

appview/state/state.go

···

       15
       15
        
       	"tangled.org/core/appview/config"

     

       16
       16
        
       	"tangled.org/core/appview/db"

     

       17
       17
        
       	"tangled.org/core/appview/indexer"

     

       18
       18
       +
       	"tangled.org/core/appview/mentions"

     

       18
       19
        
       	"tangled.org/core/appview/models"

     

       19
       20
        
       	"tangled.org/core/appview/notify"

     

       20
       21
        
       	dbnotify "tangled.org/core/appview/notify/db"

     

       21
       22
        
       	phnotify "tangled.org/core/appview/notify/posthog"

     

       22
       23
        
       	"tangled.org/core/appview/oauth"

     

       23
       24
        
       	"tangled.org/core/appview/pages"

     

       24
       24
       -
       	"tangled.org/core/appview/refresolver"

     

       25
       25
        
       	"tangled.org/core/appview/reporesolver"

     

       26
       26
        
       	"tangled.org/core/appview/validator"

     

       27
       27
        
       	xrpcclient "tangled.org/core/appview/xrpcclient"

     
···

       30
       30
        
       	"tangled.org/core/jetstream"

     

       31
       31
        
       	"tangled.org/core/log"

     

       32
       32
        
       	tlog "tangled.org/core/log"

     

       33
       33
       +
       	"tangled.org/core/orm"

     

       33
       34
        
       	"tangled.org/core/rbac"

     

       34
       35
        
       	"tangled.org/core/tid"

     

       35
       36
        
       

     
···

       43
       44
        
       )

     

       44
       45
        
       

     

       45
       46
        
       type State struct {

     

       46
       46
       -
       	db            *db.DB

     

       47
       47
       -
       	notifier      notify.Notifier

     

       48
       48
       -
       	indexer       *indexer.Indexer

     

       49
       49
       -
       	oauth         *oauth.OAuth

     

       50
       50
       -
       	enforcer      *rbac.Enforcer

     

       51
       51
       -
       	pages         *pages.Pages

     

       52
       52
       -
       	idResolver    *idresolver.Resolver

     

       53
       53
       -
       	refResolver   *refresolver.Resolver

     

       54
       54
       -
       	posthog       posthog.Client

     

       55
       55
       -
       	jc            *jetstream.JetstreamClient

     

       56
       56
       -
       	config        *config.Config

     

       57
       57
       -
       	repoResolver  *reporesolver.RepoResolver

     

       58
       58
       -
       	knotstream    *eventconsumer.Consumer

     

       59
       59
       -
       	spindlestream *eventconsumer.Consumer

     

       60
       60
       -
       	logger        *slog.Logger

     

       61
       61
       -
       	validator     *validator.Validator

     

       47
       47
       +
       	db               *db.DB

     

       48
       48
       +
       	notifier         notify.Notifier

     

       49
       49
       +
       	indexer          *indexer.Indexer

     

       50
       50
       +
       	oauth            *oauth.OAuth

     

       51
       51
       +
       	enforcer         *rbac.Enforcer

     

       52
       52
       +
       	pages            *pages.Pages

     

       53
       53
       +
       	idResolver       *idresolver.Resolver

     

       54
       54
       +
       	mentionsResolver *mentions.Resolver

     

       55
       55
       +
       	posthog          posthog.Client

     

       56
       56
       +
       	jc               *jetstream.JetstreamClient

     

       57
       57
       +
       	config           *config.Config

     

       58
       58
       +
       	repoResolver     *reporesolver.RepoResolver

     

       59
       59
       +
       	knotstream       *eventconsumer.Consumer

     

       60
       60
       +
       	spindlestream    *eventconsumer.Consumer

     

       61
       61
       +
       	logger           *slog.Logger

     

       62
       62
       +
       	validator        *validator.Validator

     

       62
       63
        
       }

     

       63
       64
        
       

     

       64
       65
        
       func Make(ctx context.Context, config *config.Config) (*State, error) {

     
···

       98
       99
        
       	}

     

       99
       100
        
       	validator := validator.New(d, res, enforcer)

     

       100
       101
        
       

     

       101
       101
       -
       	repoResolver := reporesolver.New(config, enforcer, res, d)

     

       102
       102
       +
       	repoResolver := reporesolver.New(config, enforcer, d)

     

       102
       103
        
       

     

       103
       103
       -
       	refResolver := refresolver.New(config, res, d, log.SubLogger(logger, "refResolver"))

     

       104
       104
       +
       	mentionsResolver := mentions.New(config, res, d, log.SubLogger(logger, "mentionsResolver"))

     

       104
       105
        
       

     

       105
       106
        
       	wrapper := db.DbWrapper{Execer: d}

     

       106
       107
        
       	jc, err := jetstream.NewJetstreamClient(

     
···

       182
       183
        
       		enforcer,

     

       183
       184
        
       		pages,

     

       184
       185
        
       		res,

     

       185
       185
       -
       		refResolver,

     

       186
       186
       +
       		mentionsResolver,

     

       186
       187
        
       		posthog,

     

       187
       188
        
       		jc,

     

       188
       189
        
       		config,

     
···

       299
       300
        
       		return

     

       300
       301
        
       	}

     

       301
       302
        
       

     

       302
       302
       -
       	gfiLabel, err := db.GetLabelDefinition(s.db, db.FilterEq("at_uri", s.config.Label.GoodFirstIssue))

     

       303
       303
       +
       	gfiLabel, err := db.GetLabelDefinition(s.db, orm.FilterEq("at_uri", s.config.Label.GoodFirstIssue))

     

       303
       304
        
       	if err != nil {

     

       304
       305
        
       		// non-fatal

     

       305
       306
        
       	}

     
···

       323
       324
        
       

     

       324
       325
        
       	regs, err := db.GetRegistrations(

     

       325
       326
        
       		s.db,

     

       326
       326
       -
       		db.FilterEq("did", user.Did),

     

       327
       327
       -
       		db.FilterEq("needs_upgrade", 1),

     

       327
       327
       +
       		orm.FilterEq("did", user.Did),

     

       328
       328
       +
       		orm.FilterEq("needs_upgrade", 1),

     

       328
       329
        
       	)

     

       329
       330
        
       	if err != nil {

     

       330
       331
        
       		l.Error("non-fatal: failed to get registrations", "err", err)

     
···

       332
       333
        
       

     

       333
       334
        
       	spindles, err := db.GetSpindles(

     

       334
       335
        
       		s.db,

     

       335
       335
       -
       		db.FilterEq("owner", user.Did),

     

       336
       336
       -
       		db.FilterEq("needs_upgrade", 1),

     

       336
       336
       +
       		orm.FilterEq("owner", user.Did),

     

       337
       337
       +
       		orm.FilterEq("needs_upgrade", 1),

     

       337
       338
        
       	)

     

       338
       339
        
       	if err != nil {

     

       339
       340
        
       		l.Error("non-fatal: failed to get spindles", "err", err)

     
···

       504
       505
        
       		// Check for existing repos

     

       505
       506
        
       		existingRepo, err := db.GetRepo(

     

       506
       507
        
       			s.db,

     

       507
       507
       -
       			db.FilterEq("did", user.Did),

     

       508
       508
       -
       			db.FilterEq("name", repoName),

     

       508
       508
       +
       			orm.FilterEq("did", user.Did),

     

       509
       509
       +
       			orm.FilterEq("name", repoName),

     

       509
       510
        
       		)

     

       510
       511
        
       		if err == nil && existingRepo != nil {

     

       511
       512
        
       			l.Info("repo exists")

     
···

       665
       666
        
       }

     

       666
       667
        
       

     

       667
       668
        
       func BackfillDefaultDefs(e db.Execer, r *idresolver.Resolver, defaults []string) error {

     

       668
       668
       -
       	defaultLabels, err := db.GetLabelDefinitions(e, db.FilterIn("at_uri", defaults))

     

       669
       669
       +
       	defaultLabels, err := db.GetLabelDefinitions(e, orm.FilterIn("at_uri", defaults))

     

       669
       670
        
       	if err != nil {

     

       670
       671
        
       		return err

     

       671
       672
        
       	}

+21 -8

appview/strings/strings.go

···

       17
       17
        
       	"tangled.org/core/appview/pages"

     

       18
       18
        
       	"tangled.org/core/appview/pages/markup"

     

       19
       19
        
       	"tangled.org/core/idresolver"

     

       20
       20
       +
       	"tangled.org/core/orm"

     

       20
       21
        
       	"tangled.org/core/tid"

     

       21
       22
        
       

     

       22
       23
        
       	"github.com/bluesky-social/indigo/api/atproto"

     
···

       108
       109
        
       	strings, err := db.GetStrings(

     

       109
       110
        
       		s.Db,

     

       110
       111
        
       		0,

     

       111
       111
       -
       		db.FilterEq("did", id.DID),

     

       112
       112
       -
       		db.FilterEq("rkey", rkey),

     

       112
       112
       +
       		orm.FilterEq("did", id.DID),

     

       113
       113
       +
       		orm.FilterEq("rkey", rkey),

     

       113
       114
        
       	)

     

       114
       115
        
       	if err != nil {

     

       115
       116
        
       		l.Error("failed to fetch string", "err", err)

     
···

       148
       149
        
       		showRendered = r.URL.Query().Get("code") != "true"

     

       149
       150
        
       	}

     

       150
       151
        
       

     

       152
       152
       +
       	starCount, err := db.GetStarCount(s.Db, string.AtUri())

     

       153
       153
       +
       	if err != nil {

     

       154
       154
       +
       		l.Error("failed to get star count", "err", err)

     

       155
       155
       +
       	}

     

       156
       156
       +
       	user := s.OAuth.GetUser(r)

     

       157
       157
       +
       	isStarred := false

     

       158
       158
       +
       	if user != nil {

     

       159
       159
       +
       		isStarred = db.GetStarStatus(s.Db, user.Did, string.AtUri())

     

       160
       160
       +
       	}

     

       161
       161
       +
       

     

       151
       162
        
       	s.Pages.SingleString(w, pages.SingleStringParams{

     

       152
       152
       -
       		LoggedInUser: s.OAuth.GetUser(r),

     

       163
       163
       +
       		LoggedInUser: user,

     

       153
       164
        
       		RenderToggle: renderToggle,

     

       154
       165
        
       		ShowRendered: showRendered,

     

       155
       155
       -
       		String:       string,

     

       166
       166
       +
       		String:       &string,

     

       156
       167
        
       		Stats:        string.Stats(),

     

       168
       168
       +
       		IsStarred:    isStarred,

     

       169
       169
       +
       		StarCount:    starCount,

     

       157
       170
        
       		Owner:        id,

     

       158
       171
        
       	})

     

       159
       172
        
       }

     
···

       187
       200
        
       	all, err := db.GetStrings(

     

       188
       201
        
       		s.Db,

     

       189
       202
        
       		0,

     

       190
       190
       -
       		db.FilterEq("did", id.DID),

     

       191
       191
       -
       		db.FilterEq("rkey", rkey),

     

       203
       203
       +
       		orm.FilterEq("did", id.DID),

     

       204
       204
       +
       		orm.FilterEq("rkey", rkey),

     

       192
       205
        
       	)

     

       193
       206
        
       	if err != nil {

     

       194
       207
        
       		l.Error("failed to fetch string", "err", err)

     
···

       396
       409
        
       

     

       397
       410
        
       	if err := db.DeleteString(

     

       398
       411
        
       		s.Db,

     

       399
       399
       -
       		db.FilterEq("did", user.Did),

     

       400
       400
       -
       		db.FilterEq("rkey", rkey),

     

       412
       412
       +
       		orm.FilterEq("did", user.Did),

     

       413
       413
       +
       		orm.FilterEq("rkey", rkey),

     

       401
       414
        
       	); err != nil {

     

       402
       415
        
       		fail("Failed to delete string.", err)

     

       403
       416
        
       		return

+2 -1

appview/validator/issue.go

···

       6
       6
        
       

     

       7
       7
        
       	"tangled.org/core/appview/db"

     

       8
       8
        
       	"tangled.org/core/appview/models"

     

       9
       9
       +
       	"tangled.org/core/orm"

     

       9
       10
        
       )

     

       10
       11
        
       

     

       11
       12
        
       func (v *Validator) ValidateIssueComment(comment *models.IssueComment) error {

     

       12
       13
        
       	// if comments have parents, only ingest ones that are 1 level deep

     

       13
       14
        
       	if comment.ReplyTo != nil {

     

       14
       14
       -
       		parents, err := db.GetIssueComments(v.db, db.FilterEq("at_uri", *comment.ReplyTo))

     

       15
       15
       +
       		parents, err := db.GetIssueComments(v.db, orm.FilterEq("at_uri", *comment.ReplyTo))

     

       15
       16
        
       		if err != nil {

     

       16
       17
        
       			return fmt.Errorf("failed to fetch parent comment: %w", err)

     

       17
       18
        
       		}

+1 -34

crypto/verify.go

···

       5
       5
        
       	"crypto/sha256"

     

       6
       6
        
       	"encoding/base64"

     

       7
       7
        
       	"fmt"

     

       8
       8
       -
       	"strings"

     

       9
       8
        
       

     

       10
       9
        
       	"github.com/hiddeco/sshsig"

     

       11
       10
        
       	"golang.org/x/crypto/ssh"

     

       12
       12
       -
       	"tangled.org/core/types"

     

       13
       11
        
       )

     

       14
       12
        
       

     

       15
       13
        
       func VerifySignature(pubKey, signature, payload []byte) (error, bool) {

     
···

       28
       26
        
       	// multiple algorithms but sha-512 is most secure, and git's ssh signing defaults

     

       29
       27
        
       	// to sha-512 for all key types anyway.

     

       30
       28
        
       	err = sshsig.Verify(buf, sig, pub, sshsig.HashSHA512, "git")

     

       31
       31
       -
       	return err, err == nil

     

       32
       32
       -
       }

     

       33
       29
        
       

     

       34
       34
       -
       // VerifyCommitSignature reconstructs the payload used to sign a commit. This is

     

       35
       35
       -
       // essentially the git cat-file output but without the gpgsig header.

     

       36
       36
       -
       //

     

       37
       37
       -
       // Caveats: signature verification will fail on commits with more than one parent,

     

       38
       38
       -
       // i.e. merge commits, because types.NiceDiff doesn't carry more than one Parent field

     

       39
       39
       -
       // and we are unable to reconstruct the payload correctly.

     

       40
       40
       -
       //

     

       41
       41
       -
       // Ideally this should directly operate on an *object.Commit.

     

       42
       42
       -
       func VerifyCommitSignature(pubKey string, commit types.NiceDiff) (error, bool) {

     

       43
       43
       -
       	signature := commit.Commit.PGPSignature

     

       44
       44
       -
       

     

       45
       45
       -
       	author := bytes.NewBuffer([]byte{})

     

       46
       46
       -
       	committer := bytes.NewBuffer([]byte{})

     

       47
       47
       -
       	commit.Commit.Author.Encode(author)

     

       48
       48
       -
       	commit.Commit.Committer.Encode(committer)

     

       49
       49
       -
       

     

       50
       50
       -
       	payload := strings.Builder{}

     

       51
       51
       -
       

     

       52
       52
       -
       	fmt.Fprintf(&payload, "tree %s\n", commit.Commit.Tree)

     

       53
       53
       -
       	if commit.Commit.Parent != "" {

     

       54
       54
       -
       		fmt.Fprintf(&payload, "parent %s\n", commit.Commit.Parent)

     

       55
       55
       -
       	}

     

       56
       56
       -
       	fmt.Fprintf(&payload, "author %s\n", author.String())

     

       57
       57
       -
       	fmt.Fprintf(&payload, "committer %s\n", committer.String())

     

       58
       58
       -
       	if commit.Commit.ChangedId != "" {

     

       59
       59
       -
       		fmt.Fprintf(&payload, "change-id %s\n", commit.Commit.ChangedId)

     

       60
       60
       -
       	}

     

       61
       61
       -
       	fmt.Fprintf(&payload, "\n%s", commit.Commit.Message)

     

       62
       62
       -
       

     

       63
       63
       -
       	return VerifySignature([]byte(pubKey), []byte(signature), []byte(payload.String()))

     

       30
       30
       +
       	return err, err == nil

     

       64
       31
        
       }

     

       65
       32
        
       

     

       66
       33
        
       // SSHFingerprint computes the fingerprint of the supplied ssh pubkey.

+3 -3

docs/hacking.md

···

       117
       117
        
       # type `poweroff` at the shell to exit the VM

     

       118
       118
        
       ```

     

       119
       119
        
       

     

       120
       120
       -
       This starts a knot on port 6000, a spindle on port 6555

     

       120
       120
       +
       This starts a knot on port 6444, a spindle on port 6555

     

       121
       121
        
       with `ssh` exposed on port 2222.

     

       122
       122
        
       

     

       123
       123
        
       Once the services are running, head to

     

       124
       124
       -
       http://localhost:3000/knots and hit verify. It should

     

       124
       124
       +
       http://localhost:3000/settings/knots and hit verify. It should

     

       125
       125
        
       verify the ownership of the services instantly if everything

     

       126
       126
        
       went smoothly.

     

       127
       127
        
       

     
···

       146
       146
        
       ### running a spindle

     

       147
       147
        
       

     

       148
       148
        
       The above VM should already be running a spindle on

     

       149
       149
       -
       `localhost:6555`. Head to http://localhost:3000/spindles and

     

       149
       149
       +
       `localhost:6555`. Head to http://localhost:3000/settings/spindles and

     

       150
       150
        
       hit verify. You can then configure each repository to use

     

       151
       151
        
       this spindle and run CI jobs.

     

       152
       152

+1 -1

docs/knot-hosting.md

···

       131
       131
        
       

     

       132
       132
        
       You should now have a running knot server! You can finalize

     

       133
       133
        
       your registration by hitting the `verify` button on the

     

       134
       134
       -
       [/knots](https://tangled.org/knots) page. This simply creates

     

       134
       134
       +
       [/settings/knots](https://tangled.org/settings/knots) page. This simply creates

     

       135
       135
        
       a record on your PDS to announce the existence of the knot.

     

       136
       136
        
       

     

       137
       137
        
       ### custom paths

+3 -3

docs/migrations.md

···

       14
       14
        
       For knots:

     

       15
       15
        
       

     

       16
       16
        
       - Upgrade to latest tag (v1.9.0 or above)

     

       17
       17
       -
       - Head to the [knot dashboard](https://tangled.org/knots) and

     

       17
       17
       +
       - Head to the [knot dashboard](https://tangled.org/settings/knots) and

     

       18
       18
        
         hit the "retry" button to verify your knot

     

       19
       19
        
       

     

       20
       20
        
       For spindles:

     

       21
       21
        
       

     

       22
       22
        
       - Upgrade to latest tag (v1.9.0 or above)

     

       23
       23
        
       - Head to the [spindle

     

       24
       24
       -
         dashboard](https://tangled.org/spindles) and hit the

     

       24
       24
       +
         dashboard](https://tangled.org/settings/spindles) and hit the

     

       25
       25
        
         "retry" button to verify your spindle

     

       26
       26
        
       

     

       27
       27
        
       ## Upgrading from v1.7.x

     
···

       41
       41
        
         [settings](https://tangled.org/settings) page.

     

       42
       42
        
       - Restart your knot once you have replaced the environment

     

       43
       43
        
         variable

     

       44
       44
       -
       - Head to the [knot dashboard](https://tangled.org/knots) and

     

       44
       44
       +
       - Head to the [knot dashboard](https://tangled.org/settings/knots) and

     

       45
       45
        
         hit the "retry" button to verify your knot. This simply

     

       46
       46
        
         writes a `sh.tangled.knot` record to your PDS.

     

       47
       47

+20 -3

flake.lock

···

       1
       1
        
       {

     

       2
       2
        
         "nodes": {

     

       3
       3
       +
           "actor-typeahead-src": {

     

       4
       4
       +
             "flake": false,

     

       5
       5
       +
             "locked": {

     

       6
       6
       +
               "lastModified": 1762835797,

     

       7
       7
       +
               "narHash": "sha256-heizoWUKDdar6ymfZTnj3ytcEv/L4d4fzSmtr0HlXsQ=",

     

       8
       8
       +
               "ref": "refs/heads/main",

     

       9
       9
       +
               "rev": "677fe7f743050a4e7f09d4a6f87bbf1325a06f6b",

     

       10
       10
       +
               "revCount": 6,

     

       11
       11
       +
               "type": "git",

     

       12
       12
       +
               "url": "https://tangled.org/@jakelazaroff.com/actor-typeahead"

     

       13
       13
       +
             },

     

       14
       14
       +
             "original": {

     

       15
       15
       +
               "type": "git",

     

       16
       16
       +
               "url": "https://tangled.org/@jakelazaroff.com/actor-typeahead"

     

       17
       17
       +
             }

     

       18
       18
       +
           },

     

       3
       19
        
           "flake-compat": {

     

       4
       20
        
             "flake": false,

     

       5
       21
        
             "locked": {

     
···

       134
       150
        
           },

     

       135
       151
        
           "nixpkgs": {

     

       136
       152
        
             "locked": {

     

       137
       137
       -
               "lastModified": 1751984180,

     

       138
       138
       -
               "narHash": "sha256-LwWRsENAZJKUdD3SpLluwDmdXY9F45ZEgCb0X+xgOL0=",

     

       153
       153
       +
               "lastModified": 1765186076,

     

       154
       154
       +
               "narHash": "sha256-hM20uyap1a0M9d344I692r+ik4gTMyj60cQWO+hAYP8=",

     

       139
       155
        
               "owner": "nixos",

     

       140
       156
        
               "repo": "nixpkgs",

     

       141
       141
       -
               "rev": "9807714d6944a957c2e036f84b0ff8caf9930bc0",

     

       157
       157
       +
               "rev": "addf7cf5f383a3101ecfba091b98d0a1263dc9b8",

     

       142
       158
        
               "type": "github"

     

       143
       159
        
             },

     

       144
       160
        
             "original": {

     
···

       150
       166
        
           },

     

       151
       167
        
           "root": {

     

       152
       168
        
             "inputs": {

     

       169
       169
       +
               "actor-typeahead-src": "actor-typeahead-src",

     

       153
       170
        
               "flake-compat": "flake-compat",

     

       154
       171
        
               "gomod2nix": "gomod2nix",

     

       155
       172
        
               "htmx-src": "htmx-src",

+12 -12

flake.nix

···

       33
       33
        
             url = "https://github.com/rsms/inter/releases/download/v4.1/Inter-4.1.zip";

     

       34
       34
        
             flake = false;

     

       35
       35
        
           };

     

       36
       36
       +
           actor-typeahead-src = {

     

       37
       37
       +
             url = "git+https://tangled.org/@jakelazaroff.com/actor-typeahead";

     

       38
       38
       +
             flake = false;

     

       39
       39
       +
           };

     

       36
       40
        
           ibm-plex-mono-src = {

     

       37
       41
        
             url = "https://github.com/IBM/plex/releases/download/%40ibm%2Fplex-mono%401.1.0/ibm-plex-mono.zip";

     

       38
       42
        
             flake = false;

     
···

       54
       58
        
           inter-fonts-src,

     

       55
       59
        
           sqlite-lib-src,

     

       56
       60
        
           ibm-plex-mono-src,

     

       61
       61
       +
           actor-typeahead-src,

     

       57
       62
        
           ...

     

       58
       63
        
         }: let

     

       59
       64
        
           supportedSystems = ["x86_64-linux" "x86_64-darwin" "aarch64-linux" "aarch64-darwin"];

     
···

       75
       80
        
                 }).buildGoApplication;

     

       76
       81
        
               modules = ./nix/gomod2nix.toml;

     

       77
       82
        
               sqlite-lib = self.callPackage ./nix/pkgs/sqlite-lib.nix {

     

       78
       78
       -
                 inherit (pkgs) gcc;

     

       79
       83
        
                 inherit sqlite-lib-src;

     

       80
       84
        
               };

     

       81
       85
        
               lexgen = self.callPackage ./nix/pkgs/lexgen.nix {inherit indigo;};

     

       82
       86
        
               goat = self.callPackage ./nix/pkgs/goat.nix {inherit indigo;};

     

       83
       87
        
               appview-static-files = self.callPackage ./nix/pkgs/appview-static-files.nix {

     

       84
       84
       -
                 inherit htmx-src htmx-ws-src lucide-src inter-fonts-src ibm-plex-mono-src;

     

       88
       88
       +
                 inherit htmx-src htmx-ws-src lucide-src inter-fonts-src ibm-plex-mono-src actor-typeahead-src;

     

       85
       89
        
               };

     

       86
       90
        
               appview = self.callPackage ./nix/pkgs/appview.nix {};

     

       87
       91
        
               spindle = self.callPackage ./nix/pkgs/spindle.nix {};

     
···

       151
       155
        
               nativeBuildInputs = [

     

       152
       156
        
                 pkgs.go

     

       153
       157
        
                 pkgs.air

     

       154
       154
       -
                 pkgs.tilt

     

       155
       158
        
                 pkgs.gopls

     

       156
       159
        
                 pkgs.httpie

     

       157
       160
        
                 pkgs.litecli

     
···

       179
       182
        
             air-watcher = name: arg:

     

       180
       183
        
               pkgs.writeShellScriptBin "run"

     

       181
       184
        
               ''

     

       182
       182
       -
                 ${pkgs.air}/bin/air -c /dev/null \

     

       183
       183
       -
                 -build.cmd "${pkgs.go}/bin/go build -o ./out/${name}.out ./cmd/${name}/main.go" \

     

       184
       184
       -
                 -build.bin "./out/${name}.out" \

     

       185
       185
       -
                 -build.args_bin "${arg}" \

     

       186
       186
       -
                 -build.stop_on_error "true" \

     

       187
       187
       -
                 -build.include_ext "go"

     

       185
       185
       +
                 export PATH=${pkgs.go}/bin:$PATH

     

       186
       186
       +
                 ${pkgs.air}/bin/air -c ./.air/${name}.toml \

     

       187
       187
       +
                   -build.args_bin "${arg}"

     

       188
       188
        
               '';

     

       189
       189
        
             tailwind-watcher =

     

       190
       190
        
               pkgs.writeShellScriptBin "run"

     
···

       283
       283
        
           }: {

     

       284
       284
        
             imports = [./nix/modules/appview.nix];

     

       285
       285
        
       

     

       286
       286
       -
             services.tangled.appview.package = lib.mkDefault self.packages.${pkgs.system}.appview;

     

       286
       286
       +
             services.tangled.appview.package = lib.mkDefault self.packages.${pkgs.stdenv.hostPlatform.system}.appview;

     

       287
       287
        
           };

     

       288
       288
        
           nixosModules.knot = {

     

       289
       289
        
             lib,

     
···

       292
       292
        
           }: {

     

       293
       293
        
             imports = [./nix/modules/knot.nix];

     

       294
       294
        
       

     

       295
       295
       -
             services.tangled.knot.package = lib.mkDefault self.packages.${pkgs.system}.knot;

     

       295
       295
       +
             services.tangled.knot.package = lib.mkDefault self.packages.${pkgs.stdenv.hostPlatform.system}.knot;

     

       296
       296
        
           };

     

       297
       297
        
           nixosModules.spindle = {

     

       298
       298
        
             lib,

     
···

       301
       301
        
           }: {

     

       302
       302
        
             imports = [./nix/modules/spindle.nix];

     

       303
       303
        
       

     

       304
       304
       -
             services.tangled.spindle.package = lib.mkDefault self.packages.${pkgs.system}.spindle;

     

       304
       304
       +
             services.tangled.spindle.package = lib.mkDefault self.packages.${pkgs.stdenv.hostPlatform.system}.spindle;

     

       305
       305
        
           };

     

       306
       306
        
         };

     

       307
       307
        
       }

+5 -15

go.mod

···

       1
       1
        
       module tangled.org/core

     

       2
       2
        
       

     

       3
       3
       -
       go 1.24.4

     

       3
       3
       +
       go 1.25.0

     

       4
       4
        
       

     

       5
       5
        
       require (

     

       6
       6
        
       	github.com/Blank-Xu/sql-adapter v1.1.1

     

       7
       7
        
       	github.com/alecthomas/assert/v2 v2.11.0

     

       8
       8
        
       	github.com/alecthomas/chroma/v2 v2.15.0

     

       9
       9
        
       	github.com/avast/retry-go/v4 v4.6.1

     

       10
       10
       +
       	github.com/blevesearch/bleve/v2 v2.5.3

     

       10
       11
        
       	github.com/bluekeyes/go-gitdiff v0.8.1

     

       11
       12
        
       	github.com/bluesky-social/indigo v0.0.0-20251003000214-3259b215110e

     

       12
       13
        
       	github.com/bluesky-social/jetstream v0.0.0-20241210005130-ea96859b93d1

     

       14
       14
       +
       	github.com/bmatcuk/doublestar/v4 v4.9.1

     

       13
       15
        
       	github.com/carlmjohnson/versioninfo v0.22.5

     

       14
       16
        
       	github.com/casbin/casbin/v2 v2.103.0

     

       17
       17
       +
       	github.com/charmbracelet/log v0.4.2

     

       15
       18
        
       	github.com/cloudflare/cloudflare-go v0.115.0

     

       16
       19
        
       	github.com/cyphar/filepath-securejoin v0.4.1

     

       17
       20
        
       	github.com/dgraph-io/ristretto v0.2.0

     
···

       29
       32
        
       	github.com/hiddeco/sshsig v0.2.0

     

       30
       33
        
       	github.com/hpcloud/tail v1.0.0

     

       31
       34
        
       	github.com/ipfs/go-cid v0.5.0

     

       32
       32
       -
       	github.com/lestrrat-go/jwx/v2 v2.1.6

     

       33
       35
        
       	github.com/mattn/go-sqlite3 v1.14.24

     

       34
       36
        
       	github.com/microcosm-cc/bluemonday v1.0.27

     

       35
       37
        
       	github.com/openbao/openbao/api/v2 v2.3.0

     
···

       42
       44
        
       	github.com/stretchr/testify v1.10.0

     

       43
       45
        
       	github.com/urfave/cli/v3 v3.3.3

     

       44
       46
        
       	github.com/whyrusleeping/cbor-gen v0.3.1

     

       45
       45
       -
       	github.com/wyatt915/goldmark-treeblood v0.0.1

     

       46
       47
        
       	github.com/yuin/goldmark v1.7.13

     

       47
       48
        
       	github.com/yuin/goldmark-highlighting/v2 v2.0.0-20230729083705-37449abec8cc

     

       49
       49
       +
       	gitlab.com/staticnoise/goldmark-callout v0.0.0-20240609120641-6366b799e4ab

     

       48
       50
        
       	golang.org/x/crypto v0.40.0

     

       49
       51
        
       	golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b

     

       50
       52
        
       	golang.org/x/image v0.31.0

     
···

       65
       67
        
       	github.com/aymerick/douceur v0.2.0 // indirect

     

       66
       68
        
       	github.com/beorn7/perks v1.0.1 // indirect

     

       67
       69
        
       	github.com/bits-and-blooms/bitset v1.22.0 // indirect

     

       68
       68
       -
       	github.com/blevesearch/bleve/v2 v2.5.3 // indirect

     

       69
       70
        
       	github.com/blevesearch/bleve_index_api v1.2.8 // indirect

     

       70
       71
        
       	github.com/blevesearch/geo v0.2.4 // indirect

     

       71
       72
        
       	github.com/blevesearch/go-faiss v1.0.25 // indirect

     
···

       83
       84
        
       	github.com/blevesearch/zapx/v14 v14.4.2 // indirect

     

       84
       85
        
       	github.com/blevesearch/zapx/v15 v15.4.2 // indirect

     

       85
       86
        
       	github.com/blevesearch/zapx/v16 v16.2.4 // indirect

     

       86
       86
       -
       	github.com/bmatcuk/doublestar/v4 v4.9.1 // indirect

     

       87
       87
        
       	github.com/casbin/govaluate v1.3.0 // indirect

     

       88
       88
        
       	github.com/cenkalti/backoff/v4 v4.3.0 // indirect

     

       89
       89
        
       	github.com/cespare/xxhash/v2 v2.3.0 // indirect

     

       90
       90
        
       	github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc // indirect

     

       91
       91
        
       	github.com/charmbracelet/lipgloss v1.1.0 // indirect

     

       92
       92
       -
       	github.com/charmbracelet/log v0.4.2 // indirect

     

       93
       92
        
       	github.com/charmbracelet/x/ansi v0.8.0 // indirect

     

       94
       93
        
       	github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd // indirect

     

       95
       94
        
       	github.com/charmbracelet/x/term v0.2.1 // indirect

     
···

       98
       97
        
       	github.com/containerd/errdefs/pkg v0.3.0 // indirect

     

       99
       98
        
       	github.com/containerd/log v0.1.0 // indirect

     

       100
       99
        
       	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect

     

       101
       101
       -
       	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 // indirect

     

       102
       100
        
       	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect

     

       103
       101
        
       	github.com/distribution/reference v0.6.0 // indirect

     

       104
       102
        
       	github.com/dlclark/regexp2 v1.11.5 // indirect

     
···

       152
       150
        
       	github.com/kevinburke/ssh_config v1.2.0 // indirect

     

       153
       151
        
       	github.com/klauspost/compress v1.18.0 // indirect

     

       154
       152
        
       	github.com/klauspost/cpuid/v2 v2.3.0 // indirect

     

       155
       155
       -
       	github.com/lestrrat-go/blackmagic v1.0.4 // indirect

     

       156
       156
       -
       	github.com/lestrrat-go/httpcc v1.0.1 // indirect

     

       157
       157
       -
       	github.com/lestrrat-go/httprc v1.0.6 // indirect

     

       158
       158
       -
       	github.com/lestrrat-go/iter v1.0.2 // indirect

     

       159
       159
       -
       	github.com/lestrrat-go/option v1.0.1 // indirect

     

       160
       153
        
       	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect

     

       161
       154
        
       	github.com/mattn/go-isatty v0.0.20 // indirect

     

       162
       155
        
       	github.com/mattn/go-runewidth v0.0.16 // indirect

     
···

       191
       184
        
       	github.com/prometheus/procfs v0.16.1 // indirect

     

       192
       185
        
       	github.com/rivo/uniseg v0.4.7 // indirect

     

       193
       186
        
       	github.com/ryanuber/go-glob v1.0.0 // indirect

     

       194
       194
       -
       	github.com/segmentio/asm v1.2.0 // indirect

     

       195
       187
        
       	github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect

     

       196
       188
        
       	github.com/spaolacci/murmur3 v1.1.0 // indirect

     

       197
       189
        
       	github.com/vmihailenco/go-tinylfu v0.2.2 // indirect

     

       198
       190
        
       	github.com/vmihailenco/msgpack/v5 v5.4.1 // indirect

     

       199
       191
        
       	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect

     

       200
       200
       -
       	github.com/wyatt915/treeblood v0.1.16 // indirect

     

       201
       192
        
       	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect

     

       202
       202
       -
       	gitlab.com/staticnoise/goldmark-callout v0.0.0-20240609120641-6366b799e4ab // indirect

     

       203
       193
        
       	gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b // indirect

     

       204
       194
        
       	gitlab.com/yawning/tuplehash v0.0.0-20230713102510-df83abbf9a02 // indirect

     

       205
       195
        
       	go.etcd.io/bbolt v1.4.0 // indirect

-21

go.sum

···

       71
       71
        
       github.com/bluesky-social/jetstream v0.0.0-20241210005130-ea96859b93d1 h1:CFvRtYNSnWRAi/98M3O466t9dYuwtesNbu6FVPymRrA=

     

       72
       72
        
       github.com/bluesky-social/jetstream v0.0.0-20241210005130-ea96859b93d1/go.mod h1:WiYEeyJSdUwqoaZ71KJSpTblemUCpwJfh5oVXplK6T4=

     

       73
       73
        
       github.com/bmatcuk/doublestar/v4 v4.6.1/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=

     

       74
       74
       -
       github.com/bmatcuk/doublestar/v4 v4.7.1 h1:fdDeAqgT47acgwd9bd9HxJRDmc9UAmPpc+2m0CXv75Q=

     

       75
       74
        
       github.com/bmatcuk/doublestar/v4 v4.7.1/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=

     

       76
       75
        
       github.com/bmatcuk/doublestar/v4 v4.9.1 h1:X8jg9rRZmJd4yRy7ZeNDRnM+T3ZfHv15JiBJ/avrEXE=

     

       77
       76
        
       github.com/bmatcuk/doublestar/v4 v4.9.1/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=

     
···

       126
       125
        
       github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

     

       127
       126
        
       github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=

     

       128
       127
        
       github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

     

       129
       129
       -
       github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 h1:NMZiJj8QnKe1LgsbDayM4UoHwbvwDRwnI3hwNaAHRnc=

     

       130
       130
       -
       github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0/go.mod h1:ZXNYxsqcloTdSy/rNShjYzMhyjf0LaoftYK0p+A3h40=

     

       131
       128
        
       github.com/dgraph-io/ristretto v0.2.0 h1:XAfl+7cmoUDWW/2Lx8TGZQjjxIQ2Ley9DSf52dru4WE=

     

       132
       129
        
       github.com/dgraph-io/ristretto v0.2.0/go.mod h1:8uBHCU/PBV4Ag0CJrP47b9Ofby5dqWNh4FicAdoqFNU=

     

       133
       130
        
       github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13 h1:fAjc9m62+UWV/WAFKLNi6ZS0675eEUC9y3AlwSbQu1Y=

     
···

       330
       327
        
       github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=

     

       331
       328
        
       github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=

     

       332
       329
        
       github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=

     

       333
       333
       -
       github.com/lestrrat-go/blackmagic v1.0.4 h1:IwQibdnf8l2KoO+qC3uT4OaTWsW7tuRQXy9TRN9QanA=

     

       334
       334
       -
       github.com/lestrrat-go/blackmagic v1.0.4/go.mod h1:6AWFyKNNj0zEXQYfTMPfZrAXUWUfTIZ5ECEUEJaijtw=

     

       335
       335
       -
       github.com/lestrrat-go/httpcc v1.0.1 h1:ydWCStUeJLkpYyjLDHihupbn2tYmZ7m22BGkcvZZrIE=

     

       336
       336
       -
       github.com/lestrrat-go/httpcc v1.0.1/go.mod h1:qiltp3Mt56+55GPVCbTdM9MlqhvzyuL6W/NMDA8vA5E=

     

       337
       337
       -
       github.com/lestrrat-go/httprc v1.0.6 h1:qgmgIRhpvBqexMJjA/PmwSvhNk679oqD1RbovdCGW8k=

     

       338
       338
       -
       github.com/lestrrat-go/httprc v1.0.6/go.mod h1:mwwz3JMTPBjHUkkDv/IGJ39aALInZLrhBp0X7KGUZlo=

     

       339
       339
       -
       github.com/lestrrat-go/iter v1.0.2 h1:gMXo1q4c2pHmC3dn8LzRhJfP1ceCbgSiT9lUydIzltI=

     

       340
       340
       -
       github.com/lestrrat-go/iter v1.0.2/go.mod h1:Momfcq3AnRlRjI5b5O8/G5/BvpzrhoFTZcn06fEOPt4=

     

       341
       341
       -
       github.com/lestrrat-go/jwx/v2 v2.1.6 h1:hxM1gfDILk/l5ylers6BX/Eq1m/pnxe9NBwW6lVfecA=

     

       342
       342
       -
       github.com/lestrrat-go/jwx/v2 v2.1.6/go.mod h1:Y722kU5r/8mV7fYDifjug0r8FK8mZdw0K0GpJw/l8pU=

     

       343
       343
       -
       github.com/lestrrat-go/option v1.0.1 h1:oAzP2fvZGQKWkvHa1/SAcFolBEca1oN+mQ7eooNBEYU=

     

       344
       344
       -
       github.com/lestrrat-go/option v1.0.1/go.mod h1:5ZHFbivi4xwXxhxY9XHDe2FHo6/Z7WWmtT7T5nBBp3I=

     

       345
       330
        
       github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=

     

       346
       331
        
       github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=

     

       347
       332
        
       github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=

     
···

       466
       451
        
       github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=

     

       467
       452
        
       github.com/ryanuber/go-glob v1.0.0 h1:iQh3xXAumdQ+4Ufa5b25cRpC5TYKlno6hsv6Cb3pkBk=

     

       468
       453
        
       github.com/ryanuber/go-glob v1.0.0/go.mod h1:807d1WSdnB0XRJzKNil9Om6lcp/3a0v4qIHxIXzX/Yc=

     

       469
       469
       -
       github.com/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys=

     

       470
       470
       -
       github.com/segmentio/asm v1.2.0/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs=

     

       471
       454
        
       github.com/sergi/go-diff v1.1.0 h1:we8PVUC3FE2uYfodKH/nBHMSetSfHDR6scGdBi+erh0=

     

       472
       455
        
       github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=

     

       473
       456
        
       github.com/sethvargo/go-envconfig v1.1.0 h1:cWZiJxeTm7AlCvzGXrEXaSTCNgip5oJepekh/BOQuog=

     
···

       512
       495
        
       github.com/warpfork/go-wish v0.0.0-20220906213052-39a1cc7a02d0/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw=

     

       513
       496
        
       github.com/whyrusleeping/cbor-gen v0.3.1 h1:82ioxmhEYut7LBVGhGq8xoRkXPLElVuh5mV67AFfdv0=

     

       514
       497
        
       github.com/whyrusleeping/cbor-gen v0.3.1/go.mod h1:pM99HXyEbSQHcosHc0iW7YFmwnscr+t9Te4ibko05so=

     

       515
       515
       -
       github.com/wyatt915/goldmark-treeblood v0.0.1 h1:6vLJcjFrHgE4ASu2ga4hqIQmbvQLU37v53jlHZ3pqDs=

     

       516
       516
       -
       github.com/wyatt915/goldmark-treeblood v0.0.1/go.mod h1:SmcJp5EBaV17rroNlgNQFydYwy0+fv85CUr/ZaCz208=

     

       517
       517
       -
       github.com/wyatt915/treeblood v0.1.16 h1:byxNbWZhnPDxdTp7W5kQhCeaY8RBVmojTFz1tEHgg8Y=

     

       518
       518
       -
       github.com/wyatt915/treeblood v0.1.16/go.mod h1:i7+yhhmzdDP17/97pIsOSffw74EK/xk+qJ0029cSXUY=

     

       519
       498
        
       github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=

     

       520
       499
        
       github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=

     

       521
       500
        
       github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=

+34

input.css

···

       245
       245
        
               details[data-callout] > summary::-webkit-details-marker {

     

       246
       246
        
                   display: none;

     

       247
       247
        
               }

     

       248
       248
       +
       

     

       248
       249
        
           }

     

       249
       250
        
           @layer utilities {

     

       250
       251
        
               .error {

     
···

       928
       929
        
               text-decoration: underline;

     

       929
       930
        
           }

     

       930
       931
        
       }

     

       932
       932
       +
       

     

       933
       933
       +
       actor-typeahead {

     

       934
       934
       +
         --color-background: #ffffff;

     

       935
       935
       +
         --color-border: #d1d5db;

     

       936
       936
       +
         --color-shadow: #000000;

     

       937
       937
       +
         --color-hover: #f9fafb;

     

       938
       938
       +
         --color-avatar-fallback: #e5e7eb;

     

       939
       939
       +
         --radius: 0.0;

     

       940
       940
       +
         --padding-menu: 0.0rem;

     

       941
       941
       +
         z-index: 1000;

     

       942
       942
       +
       }

     

       943
       943
       +
       

     

       944
       944
       +
       actor-typeahead::part(handle) {

     

       945
       945
       +
         color: #111827;

     

       946
       946
       +
       }

     

       947
       947
       +
       

     

       948
       948
       +
       actor-typeahead::part(menu) {

     

       949
       949
       +
         box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1);

     

       950
       950
       +
       }

     

       951
       951
       +
       

     

       952
       952
       +
       @media (prefers-color-scheme: dark) {

     

       953
       953
       +
         actor-typeahead {

     

       954
       954
       +
           --color-background: #1f2937;

     

       955
       955
       +
           --color-border: #4b5563;

     

       956
       956
       +
           --color-shadow: #000000;

     

       957
       957
       +
           --color-hover: #374151;

     

       958
       958
       +
           --color-avatar-fallback: #4b5563;

     

       959
       959
       +
         }

     

       960
       960
       +
       

     

       961
       961
       +
         actor-typeahead::part(handle) {

     

       962
       962
       +
           color: #f9fafb;

     

       963
       963
       +
         }

     

       964
       964
       +
       }

+15 -4

jetstream/jetstream.go

···

       72
       72
        
       	// existing instances of the closure when j.WantedDids is mutated

     

       73
       73
        
       	return func(ctx context.Context, evt *models.Event) error {

     

       74
       74
        
       

     

       75
       75
       +
       		j.mu.RLock()

     

       75
       76
        
       		// empty filter => all dids allowed

     

       76
       76
       -
       		if len(j.wantedDids) == 0 {

     

       77
       77
       -
       			return processFunc(ctx, evt)

     

       77
       77
       +
       		matches := len(j.wantedDids) == 0

     

       78
       78
       +
       		if !matches {

     

       79
       79
       +
       			if _, ok := j.wantedDids[evt.Did]; ok {

     

       80
       80
       +
       				matches = true

     

       81
       81
       +
       			}

     

       78
       82
        
       		}

     

       83
       83
       +
       		j.mu.RUnlock()

     

       79
       84
        
       

     

       80
       80
       -
       		if _, ok := j.wantedDids[evt.Did]; ok {

     

       85
       85
       +
       		if matches {

     

       81
       86
        
       			return processFunc(ctx, evt)

     

       82
       87
        
       		} else {

     

       83
       88
        
       			return nil

     
···

       122
       127
        
       

     

       123
       128
        
       	go func() {

     

       124
       129
        
       		if j.waitForDid {

     

       125
       125
       -
       			for len(j.wantedDids) == 0 {

     

       130
       130
       +
       			for {

     

       131
       131
       +
       				j.mu.RLock()

     

       132
       132
       +
       				hasDid := len(j.wantedDids) != 0

     

       133
       133
       +
       				j.mu.RUnlock()

     

       134
       134
       +
       				if hasDid {

     

       135
       135
       +
       					break

     

       136
       136
       +
       				}

     

       126
       137
        
       				time.Sleep(time.Second)

     

       127
       138
        
       			}

     

       128
       139
        
       		}

+81

knotserver/db/db.go

···

       1
       1
       +
       package db

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"database/sql"

     

       6
       6
       +
       	"log/slog"

     

       7
       7
       +
       	"strings"

     

       8
       8
       +
       

     

       9
       9
       +
       	_ "github.com/mattn/go-sqlite3"

     

       10
       10
       +
       	"tangled.org/core/log"

     

       11
       11
       +
       )

     

       12
       12
       +
       

     

       13
       13
       +
       type DB struct {

     

       14
       14
       +
       	db     *sql.DB

     

       15
       15
       +
       	logger *slog.Logger

     

       16
       16
       +
       }

     

       17
       17
       +
       

     

       18
       18
       +
       func Setup(ctx context.Context, dbPath string) (*DB, error) {

     

       19
       19
       +
       	// https://github.com/mattn/go-sqlite3#connection-string

     

       20
       20
       +
       	opts := []string{

     

       21
       21
       +
       		"_foreign_keys=1",

     

       22
       22
       +
       		"_journal_mode=WAL",

     

       23
       23
       +
       		"_synchronous=NORMAL",

     

       24
       24
       +
       		"_auto_vacuum=incremental",

     

       25
       25
       +
       	}

     

       26
       26
       +
       

     

       27
       27
       +
       	logger := log.FromContext(ctx)

     

       28
       28
       +
       	logger = log.SubLogger(logger, "db")

     

       29
       29
       +
       

     

       30
       30
       +
       	db, err := sql.Open("sqlite3", dbPath+"?"+strings.Join(opts, "&"))

     

       31
       31
       +
       	if err != nil {

     

       32
       32
       +
       		return nil, err

     

       33
       33
       +
       	}

     

       34
       34
       +
       

     

       35
       35
       +
       	conn, err := db.Conn(ctx)

     

       36
       36
       +
       	if err != nil {

     

       37
       37
       +
       		return nil, err

     

       38
       38
       +
       	}

     

       39
       39
       +
       	defer conn.Close()

     

       40
       40
       +
       

     

       41
       41
       +
       	_, err = conn.ExecContext(ctx, `

     

       42
       42
       +
       		create table if not exists known_dids (

     

       43
       43
       +
       			did text primary key

     

       44
       44
       +
       		);

     

       45
       45
       +
       

     

       46
       46
       +
       		create table if not exists public_keys (

     

       47
       47
       +
       			id integer primary key autoincrement,

     

       48
       48
       +
       			did text not null,

     

       49
       49
       +
       			key text not null,

     

       50
       50
       +
       			created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),

     

       51
       51
       +
       			unique(did, key),

     

       52
       52
       +
       			foreign key (did) references known_dids(did) on delete cascade

     

       53
       53
       +
       		);

     

       54
       54
       +
       

     

       55
       55
       +
       		create table if not exists _jetstream (

     

       56
       56
       +
       			id integer primary key autoincrement,

     

       57
       57
       +
       			last_time_us integer not null

     

       58
       58
       +
       		);

     

       59
       59
       +
       

     

       60
       60
       +
       		create table if not exists events (

     

       61
       61
       +
       			rkey text not null,

     

       62
       62
       +
       			nsid text not null,

     

       63
       63
       +
       			event text not null, -- json

     

       64
       64
       +
       			created integer not null default (strftime('%s', 'now')),

     

       65
       65
       +
       			primary key (rkey, nsid)

     

       66
       66
       +
       		);

     

       67
       67
       +
       

     

       68
       68
       +
       		create table if not exists migrations (

     

       69
       69
       +
       			id integer primary key autoincrement,

     

       70
       70
       +
       			name text unique

     

       71
       71
       +
       		);

     

       72
       72
       +
       	`)

     

       73
       73
       +
       	if err != nil {

     

       74
       74
       +
       		return nil, err

     

       75
       75
       +
       	}

     

       76
       76
       +
       

     

       77
       77
       +
       	return &DB{

     

       78
       78
       +
       		db:     db,

     

       79
       79
       +
       		logger: logger,

     

       80
       80
       +
       	}, nil

     

       81
       81
       +
       }

-64

knotserver/db/init.go

···

       1
       1
       -
       package db

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"database/sql"

     

       5
       5
       -
       	"strings"

     

       6
       6
       -
       

     

       7
       7
       -
       	_ "github.com/mattn/go-sqlite3"

     

       8
       8
       -
       )

     

       9
       9
       -
       

     

       10
       10
       -
       type DB struct {

     

       11
       11
       -
       	db *sql.DB

     

       12
       12
       -
       }

     

       13
       13
       -
       

     

       14
       14
       -
       func Setup(dbPath string) (*DB, error) {

     

       15
       15
       -
       	// https://github.com/mattn/go-sqlite3#connection-string

     

       16
       16
       -
       	opts := []string{

     

       17
       17
       -
       		"_foreign_keys=1",

     

       18
       18
       -
       		"_journal_mode=WAL",

     

       19
       19
       -
       		"_synchronous=NORMAL",

     

       20
       20
       -
       		"_auto_vacuum=incremental",

     

       21
       21
       -
       	}

     

       22
       22
       -
       

     

       23
       23
       -
       	db, err := sql.Open("sqlite3", dbPath+"?"+strings.Join(opts, "&"))

     

       24
       24
       -
       	if err != nil {

     

       25
       25
       -
       		return nil, err

     

       26
       26
       -
       	}

     

       27
       27
       -
       

     

       28
       28
       -
       	// NOTE: If any other migration is added here, you MUST

     

       29
       29
       -
       	// copy the pattern in appview: use a single sql.Conn

     

       30
       30
       -
       	// for every migration.

     

       31
       31
       -
       

     

       32
       32
       -
       	_, err = db.Exec(`

     

       33
       33
       -
       		create table if not exists known_dids (

     

       34
       34
       -
       			did text primary key

     

       35
       35
       -
       		);

     

       36
       36
       -
       

     

       37
       37
       -
       		create table if not exists public_keys (

     

       38
       38
       -
       			id integer primary key autoincrement,

     

       39
       39
       -
       			did text not null,

     

       40
       40
       -
       			key text not null,

     

       41
       41
       -
       			created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),

     

       42
       42
       -
       			unique(did, key),

     

       43
       43
       -
       			foreign key (did) references known_dids(did) on delete cascade

     

       44
       44
       -
       		);

     

       45
       45
       -
       

     

       46
       46
       -
       		create table if not exists _jetstream (

     

       47
       47
       -
       			id integer primary key autoincrement,

     

       48
       48
       -
       			last_time_us integer not null

     

       49
       49
       -
       		);

     

       50
       50
       -
       

     

       51
       51
       -
       		create table if not exists events (

     

       52
       52
       -
       			rkey text not null,

     

       53
       53
       -
       			nsid text not null,

     

       54
       54
       -
       			event text not null, -- json

     

       55
       55
       -
       			created integer not null default (strftime('%s', 'now')),

     

       56
       56
       -
       			primary key (rkey, nsid)

     

       57
       57
       -
       		);

     

       58
       58
       -
       	`)

     

       59
       59
       -
       	if err != nil {

     

       60
       60
       -
       		return nil, err

     

       61
       61
       -
       	}

     

       62
       62
       -
       

     

       63
       63
       -
       	return &DB{db: db}, nil

     

       64
       64
       -
       }

+1 -17

knotserver/git/diff.go

···

       77
       77
        
       		nd.Diff = append(nd.Diff, ndiff)

     

       78
       78
        
       	}

     

       79
       79
        
       

     

       80
       80
       -
       	nd.Stat.FilesChanged = len(diffs)

     

       81
       81
       -
       	nd.Commit.This = c.Hash.String()

     

       82
       82
       -
       	nd.Commit.PGPSignature = c.PGPSignature

     

       83
       83
       -
       	nd.Commit.Committer = c.Committer

     

       84
       84
       -
       	nd.Commit.Tree = c.TreeHash.String()

     

       85
       85
       -
       

     

       86
       86
       -
       	if parent.Hash.IsZero() {

     

       87
       87
       -
       		nd.Commit.Parent = ""

     

       88
       88
       -
       	} else {

     

       89
       89
       -
       		nd.Commit.Parent = parent.Hash.String()

     

       90
       90
       -
       	}

     

       91
       91
       -
       	nd.Commit.Author = c.Author

     

       92
       92
       -
       	nd.Commit.Message = c.Message

     

       93
       93
       -
       

     

       94
       94
       -
       	if v, ok := c.ExtraHeaders["change-id"]; ok {

     

       95
       95
       -
       		nd.Commit.ChangedId = string(v)

     

       96
       96
       -
       	}

     

       80
       80
       +
       	nd.Commit.FromGoGitCommit(c)

     

       97
       81
        
       

     

       98
       82
        
       	return &nd, nil

     

       99
       83
        
       }

+38 -2

knotserver/git/fork.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"errors"

     

       5
       5
        
       	"fmt"

     

       6
       6
       +
       	"log/slog"

     

       7
       7
       +
       	"net/url"

     

       6
       8
        
       	"os/exec"

     

       9
       9
       +
       	"path/filepath"

     

       7
       10
        
       

     

       8
       11
        
       	"github.com/go-git/go-git/v5"

     

       9
       12
        
       	"github.com/go-git/go-git/v5/config"

     

       13
       13
       +
       	knotconfig "tangled.org/core/knotserver/config"

     

       10
       14
        
       )

     

       11
       15
        
       

     

       12
       12
       -
       func Fork(repoPath, source string) error {

     

       13
       13
       -
       	cloneCmd := exec.Command("git", "clone", "--bare", source, repoPath)

     

       16
       16
       +
       func Fork(repoPath, source string, cfg *knotconfig.Config) error {

     

       17
       17
       +
       	u, err := url.Parse(source)

     

       18
       18
       +
       	if err != nil {

     

       19
       19
       +
       		return fmt.Errorf("failed to parse source URL: %w", err)

     

       20
       20
       +
       	}

     

       21
       21
       +
       

     

       22
       22
       +
       	if o := optimizeClone(u, cfg); o != nil {

     

       23
       23
       +
       		u = o

     

       24
       24
       +
       	}

     

       25
       25
       +
       

     

       26
       26
       +
       	cloneCmd := exec.Command("git", "clone", "--bare", u.String(), repoPath)

     

       14
       27
        
       	if err := cloneCmd.Run(); err != nil {

     

       15
       28
        
       		return fmt.Errorf("failed to bare clone repository: %w", err)

     

       16
       29
        
       	}

     
···

       21
       34
        
       	}

     

       22
       35
        
       

     

       23
       36
        
       	return nil

     

       37
       37
       +
       }

     

       38
       38
       +
       

     

       39
       39
       +
       func optimizeClone(u *url.URL, cfg *knotconfig.Config) *url.URL {

     

       40
       40
       +
       	// only optimize if it's the same host

     

       41
       41
       +
       	if u.Host != cfg.Server.Hostname {

     

       42
       42
       +
       		return nil

     

       43
       43
       +
       	}

     

       44
       44
       +
       

     

       45
       45
       +
       	local := filepath.Join(cfg.Repo.ScanPath, u.Path)

     

       46
       46
       +
       

     

       47
       47
       +
       	// sanity check: is there a git repo there?

     

       48
       48
       +
       	if _, err := PlainOpen(local); err != nil {

     

       49
       49
       +
       		return nil

     

       50
       50
       +
       	}

     

       51
       51
       +
       

     

       52
       52
       +
       	// create optimized file:// URL

     

       53
       53
       +
       	optimized := &url.URL{

     

       54
       54
       +
       		Scheme: "file",

     

       55
       55
       +
       		Path:   local,

     

       56
       56
       +
       	}

     

       57
       57
       +
       

     

       58
       58
       +
       	slog.Debug("performing local clone", "url", optimized.String())

     

       59
       59
       +
       	return optimized

     

       24
       60
        
       }

     

       25
       61
        
       

     

       26
       62
        
       func (g *GitRepo) Sync() error {

+60 -2

knotserver/git/git.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"archive/tar"

     

       5
       5
        
       	"bytes"

     

       6
       6
       +
       	"errors"

     

       6
       7
        
       	"fmt"

     

       7
       8
        
       	"io"

     

       8
       9
        
       	"io/fs"

     
···

       12
       13
        
       	"time"

     

       13
       14
        
       

     

       14
       15
        
       	"github.com/go-git/go-git/v5"

     

       16
       16
       +
       	"github.com/go-git/go-git/v5/config"

     

       15
       17
        
       	"github.com/go-git/go-git/v5/plumbing"

     

       16
       18
        
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       17
       19
        
       )

     

       18
       20
        
       

     

       19
       21
        
       var (

     

       20
       20
       -
       	ErrBinaryFile    = fmt.Errorf("binary file")

     

       21
       21
       -
       	ErrNotBinaryFile = fmt.Errorf("not binary file")

     

       22
       22
       +
       	ErrBinaryFile        = errors.New("binary file")

     

       23
       23
       +
       	ErrNotBinaryFile     = errors.New("not binary file")

     

       24
       24
       +
       	ErrMissingGitModules = errors.New("no .gitmodules file found")

     

       25
       25
       +
       	ErrInvalidGitModules = errors.New("invalid .gitmodules file")

     

       26
       26
       +
       	ErrNotSubmodule      = errors.New("path is not a submodule")

     

       22
       27
        
       )

     

       23
       28
        
       

     

       24
       29
        
       type GitRepo struct {

     
···

       188
       193
        
       	defer reader.Close()

     

       189
       194
        
       

     

       190
       195
        
       	return io.ReadAll(reader)

     

       196
       196
       +
       }

     

       197
       197
       +
       

     

       198
       198
       +
       // read and parse .gitmodules

     

       199
       199
       +
       func (g *GitRepo) Submodules() (*config.Modules, error) {

     

       200
       200
       +
       	c, err := g.r.CommitObject(g.h)

     

       201
       201
       +
       	if err != nil {

     

       202
       202
       +
       		return nil, fmt.Errorf("commit object: %w", err)

     

       203
       203
       +
       	}

     

       204
       204
       +
       

     

       205
       205
       +
       	tree, err := c.Tree()

     

       206
       206
       +
       	if err != nil {

     

       207
       207
       +
       		return nil, fmt.Errorf("tree: %w", err)

     

       208
       208
       +
       	}

     

       209
       209
       +
       

     

       210
       210
       +
       	// read .gitmodules file

     

       211
       211
       +
       	modulesEntry, err := tree.FindEntry(".gitmodules")

     

       212
       212
       +
       	if err != nil {

     

       213
       213
       +
       		return nil, fmt.Errorf("%w: %w", ErrMissingGitModules, err)

     

       214
       214
       +
       	}

     

       215
       215
       +
       

     

       216
       216
       +
       	modulesFile, err := tree.TreeEntryFile(modulesEntry)

     

       217
       217
       +
       	if err != nil {

     

       218
       218
       +
       		return nil, fmt.Errorf("%w: failed to read file: %w", ErrInvalidGitModules, err)

     

       219
       219
       +
       	}

     

       220
       220
       +
       

     

       221
       221
       +
       	content, err := modulesFile.Contents()

     

       222
       222
       +
       	if err != nil {

     

       223
       223
       +
       		return nil, fmt.Errorf("%w: failed to read contents: %w", ErrInvalidGitModules, err)

     

       224
       224
       +
       	}

     

       225
       225
       +
       

     

       226
       226
       +
       	// parse .gitmodules

     

       227
       227
       +
       	modules := config.NewModules()

     

       228
       228
       +
       	if err = modules.Unmarshal([]byte(content)); err != nil {

     

       229
       229
       +
       		return nil, fmt.Errorf("%w: failed to parse: %w", ErrInvalidGitModules, err)

     

       230
       230
       +
       	}

     

       231
       231
       +
       

     

       232
       232
       +
       	return modules, nil

     

       233
       233
       +
       }

     

       234
       234
       +
       

     

       235
       235
       +
       func (g *GitRepo) Submodule(path string) (*config.Submodule, error) {

     

       236
       236
       +
       	modules, err := g.Submodules()

     

       237
       237
       +
       	if err != nil {

     

       238
       238
       +
       		return nil, err

     

       239
       239
       +
       	}

     

       240
       240
       +
       

     

       241
       241
       +
       	for _, submodule := range modules.Submodules {

     

       242
       242
       +
       		if submodule.Path == path {

     

       243
       243
       +
       			return submodule, nil

     

       244
       244
       +
       		}

     

       245
       245
       +
       	}

     

       246
       246
       +
       

     

       247
       247
       +
       	// path is not a submodule

     

       248
       248
       +
       	return nil, ErrNotSubmodule

     

       191
       249
        
       }

     

       192
       250
        
       

     

       193
       251
        
       func (g *GitRepo) Branch(name string) (*plumbing.Reference, error) {

+4 -13

knotserver/git/tree.go

···

       7
       7
        
       	"path"

     

       8
       8
        
       	"time"

     

       9
       9
        
       

     

       10
       10
       +
       	"github.com/go-git/go-git/v5/plumbing/filemode"

     

       10
       11
        
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       11
       12
        
       	"tangled.org/core/types"

     

       12
       13
        
       )

     
···

       53
       54
        
       	}

     

       54
       55
        
       

     

       55
       56
        
       	for _, e := range subtree.Entries {

     

       56
       56
       -
       		mode, _ := e.Mode.ToOSFileMode()

     

       57
       57
        
       		sz, _ := subtree.Size(e.Name)

     

       58
       58
       -
       

     

       59
       58
        
       		fpath := path.Join(parent, e.Name)

     

       60
       59
        
       

     

       61
       60
        
       		var lastCommit *types.LastCommitInfo

     
···

       69
       68
        
       

     

       70
       69
        
       		nts = append(nts, types.NiceTree{

     

       71
       70
        
       			Name:       e.Name,

     

       72
       72
       -
       			Mode:       mode.String(),

     

       73
       73
       -
       			IsFile:     e.Mode.IsFile(),

     

       71
       71
       +
       			Mode:       e.Mode.String(),

     

       74
       72
        
       			Size:       sz,

     

       75
       73
        
       			LastCommit: lastCommit,

     

       76
       74
        
       		})

     
···

       126
       124
        
       		default:

     

       127
       125
        
       		}

     

       128
       126
        
       

     

       129
       129
       -
       		mode, err := e.Mode.ToOSFileMode()

     

       130
       130
       -
       		if err != nil {

     

       131
       131
       -
       			// TODO: log this

     

       132
       132
       -
       			continue

     

       133
       133
       -
       		}

     

       134
       134
       -
       

     

       135
       127
        
       		if e.Mode.IsFile() {

     

       136
       136
       -
       			err = cb(e, currentTree, root)

     

       137
       137
       -
       			if errors.Is(err, TerminateWalk) {

     

       128
       128
       +
       			if err := cb(e, currentTree, root); errors.Is(err, TerminateWalk) {

     

       138
       129
        
       				return err

     

       139
       130
        
       			}

     

       140
       131
        
       		}

     

       141
       132
        
       

     

       142
       133
        
       		// e is a directory

     

       143
       143
       -
       		if mode.IsDir() {

     

       134
       134
       +
       		if e.Mode == filemode.Dir {

     

       144
       135
        
       			subtree, err := currentTree.Tree(e.Name)

     

       145
       136
        
       			if err != nil {

     

       146
       137
        
       				return fmt.Errorf("sub tree %s: %w", e.Name, err)

+1 -1

knotserver/ingester.go

···

       161
       161
        
       

     

       162
       162
        
       	var pipeline workflow.RawPipeline

     

       163
       163
        
       	for _, e := range workflowDir {

     

       164
       164
       -
       		if !e.IsFile {

     

       164
       164
       +
       		if !e.IsFile() {

     

       165
       165
        
       			continue

     

       166
       166
        
       		}

     

       167
       167

+1 -1

knotserver/internal.go

···

       277
       277
        
       

     

       278
       278
        
       	var pipeline workflow.RawPipeline

     

       279
       279
        
       	for _, e := range workflowDir {

     

       280
       280
       -
       		if !e.IsFile {

     

       280
       280
       +
       		if !e.IsFile() {

     

       281
       281
        
       			continue

     

       282
       282
        
       		}

     

       283
       283

+1 -1

knotserver/server.go

···

       64
       64
        
       		logger.Info("running in dev mode, signature verification is disabled")

     

       65
       65
        
       	}

     

       66
       66
        
       

     

       67
       67
       -
       	db, err := db.Setup(c.Server.DBPath)

     

       67
       67
       +
       	db, err := db.Setup(ctx, c.Server.DBPath)

     

       68
       68
        
       	if err != nil {

     

       69
       69
        
       		return fmt.Errorf("failed to load db: %w", err)

     

       70
       70
        
       	}

+1 -1

knotserver/xrpc/create_repo.go

···

       84
       84
        
       	repoPath, _ := securejoin.SecureJoin(h.Config.Repo.ScanPath, relativeRepoPath)

     

       85
       85
        
       

     

       86
       86
        
       	if data.Source != nil && *data.Source != "" {

     

       87
       87
       -
       		err = git.Fork(repoPath, *data.Source)

     

       87
       87
       +
       		err = git.Fork(repoPath, *data.Source, h.Config)

     

       88
       88
        
       		if err != nil {

     

       89
       89
        
       			l.Error("forking repo", "error", err.Error())

     

       90
       90
        
       			writeError(w, xrpcerr.GenericError(err), http.StatusInternalServerError)

+21 -2

knotserver/xrpc/repo_blob.go

···

       42
       42
        
       		return

     

       43
       43
        
       	}

     

       44
       44
        
       

     

       45
       45
       +
       	// first check if this path is a submodule

     

       46
       46
       +
       	submodule, err := gr.Submodule(treePath)

     

       47
       47
       +
       	if err != nil {

     

       48
       48
       +
       		// this is okay, continue and try to treat it as a regular file

     

       49
       49
       +
       	} else {

     

       50
       50
       +
       		response := tangled.RepoBlob_Output{

     

       51
       51
       +
       			Ref:  ref,

     

       52
       52
       +
       			Path: treePath,

     

       53
       53
       +
       			Submodule: &tangled.RepoBlob_Submodule{

     

       54
       54
       +
       				Name:   submodule.Name,

     

       55
       55
       +
       				Url:    submodule.URL,

     

       56
       56
       +
       				Branch: &submodule.Branch,

     

       57
       57
       +
       			},

     

       58
       58
       +
       		}

     

       59
       59
       +
       		writeJson(w, response)

     

       60
       60
       +
       		return

     

       61
       61
       +
       	}

     

       62
       62
       +
       

     

       45
       63
        
       	contents, err := gr.RawContent(treePath)

     

       46
       64
        
       	if err != nil {

     

       47
       65
        
       		x.Logger.Error("file content", "error", err.Error(), "treePath", treePath)

     
···

       101
       119
        
       	var encoding string

     

       102
       120
        
       

     

       103
       121
        
       	isBinary := !isTextual(mimeType)

     

       122
       122
       +
       	size := int64(len(contents))

     

       104
       123
        
       

     

       105
       124
        
       	if isBinary {

     

       106
       125
        
       		content = base64.StdEncoding.EncodeToString(contents)

     
···

       113
       132
        
       	response := tangled.RepoBlob_Output{

     

       114
       133
        
       		Ref:      ref,

     

       115
       134
        
       		Path:     treePath,

     

       116
       116
       -
       		Content:  content,

     

       135
       135
       +
       		Content:  &content,

     

       117
       136
        
       		Encoding: &encoding,

     

       118
       118
       -
       		Size:     &[]int64{int64(len(contents))}[0],

     

       137
       137
       +
       		Size:     &size,

     

       119
       138
        
       		IsBinary: &isBinary,

     

       120
       139
        
       	}

     

       121
       140

+6 -1

knotserver/xrpc/repo_log.go

···

       62
       62
        
       		return

     

       63
       63
        
       	}

     

       64
       64
        
       

     

       65
       65
       +
       	tcommits := make([]types.Commit, len(commits))

     

       66
       66
       +
       	for i, c := range commits {

     

       67
       67
       +
       		tcommits[i].FromGoGitCommit(c)

     

       68
       68
       +
       	}

     

       69
       69
       +
       

     

       65
       70
        
       	// Create response using existing types.RepoLogResponse

     

       66
       71
        
       	response := types.RepoLogResponse{

     

       67
       67
       -
       		Commits: commits,

     

       72
       72
       +
       		Commits: tcommits,

     

       68
       73
        
       		Ref:     ref,

     

       69
       74
        
       		Page:    (offset / limit) + 1,

     

       70
       75
        
       		PerPage: limit,

+3 -5

knotserver/xrpc/repo_tree.go

···

       67
       67
        
       	treeEntries := make([]*tangled.RepoTree_TreeEntry, len(files))

     

       68
       68
        
       	for i, file := range files {

     

       69
       69
        
       		entry := &tangled.RepoTree_TreeEntry{

     

       70
       70
       -
       			Name:       file.Name,

     

       71
       71
       -
       			Mode:       file.Mode,

     

       72
       72
       -
       			Size:       file.Size,

     

       73
       73
       -
       			Is_file:    file.IsFile,

     

       74
       74
       -
       			Is_subtree: file.IsSubtree,

     

       70
       70
       +
       			Name: file.Name,

     

       71
       71
       +
       			Mode: file.Mode,

     

       72
       72
       +
       			Size: file.Size,

     

       75
       73
        
       		}

     

       76
       74
        
       

     

       77
       75
        
       		if file.LastCommit != nil {

+49 -5

lexicons/repo/blob.json

···

       6
       6
        
             "type": "query",

     

       7
       7
        
             "parameters": {

     

       8
       8
        
               "type": "params",

     

       9
       9
       -
               "required": ["repo", "ref", "path"],

     

       9
       9
       +
               "required": [

     

       10
       10
       +
                 "repo",

     

       11
       11
       +
                 "ref",

     

       12
       12
       +
                 "path"

     

       13
       13
       +
               ],

     

       10
       14
        
               "properties": {

     

       11
       15
        
                 "repo": {

     

       12
       16
        
                   "type": "string",

     
···

       31
       35
        
               "encoding": "application/json",

     

       32
       36
        
               "schema": {

     

       33
       37
        
                 "type": "object",

     

       34
       34
       -
                 "required": ["ref", "path", "content"],

     

       38
       38
       +
                 "required": [

     

       39
       39
       +
                   "ref",

     

       40
       40
       +
                   "path"

     

       41
       41
       +
                 ],

     

       35
       42
        
                 "properties": {

     

       36
       43
        
                   "ref": {

     

       37
       44
        
                     "type": "string",

     
···

       48
       55
        
                   "encoding": {

     

       49
       56
        
                     "type": "string",

     

       50
       57
        
                     "description": "Content encoding",

     

       51
       51
       -
                     "enum": ["utf-8", "base64"]

     

       58
       58
       +
                     "enum": [

     

       59
       59
       +
                       "utf-8",

     

       60
       60
       +
                       "base64"

     

       61
       61
       +
                     ]

     

       52
       62
        
                   },

     

       53
       63
        
                   "size": {

     

       54
       64
        
                     "type": "integer",

     
···

       61
       71
        
                   "mimeType": {

     

       62
       72
        
                     "type": "string",

     

       63
       73
        
                     "description": "MIME type of the file"

     

       74
       74
       +
                   },

     

       75
       75
       +
                   "submodule": {

     

       76
       76
       +
                     "type": "ref",

     

       77
       77
       +
                     "ref": "#submodule",

     

       78
       78
       +
                     "description": "Submodule information if path is a submodule"

     

       64
       79
        
                   },

     

       65
       80
        
                   "lastCommit": {

     

       66
       81
        
                     "type": "ref",

     
···

       90
       105
        
           },

     

       91
       106
        
           "lastCommit": {

     

       92
       107
        
             "type": "object",

     

       93
       93
       -
             "required": ["hash", "message", "when"],

     

       108
       108
       +
             "required": [

     

       109
       109
       +
               "hash",

     

       110
       110
       +
               "message",

     

       111
       111
       +
               "when"

     

       112
       112
       +
             ],

     

       94
       113
        
             "properties": {

     

       95
       114
        
               "hash": {

     

       96
       115
        
                 "type": "string",

     
···

       117
       136
        
           },

     

       118
       137
        
           "signature": {

     

       119
       138
        
             "type": "object",

     

       120
       120
       -
             "required": ["name", "email", "when"],

     

       139
       139
       +
             "required": [

     

       140
       140
       +
               "name",

     

       141
       141
       +
               "email",

     

       142
       142
       +
               "when"

     

       143
       143
       +
             ],

     

       121
       144
        
             "properties": {

     

       122
       145
        
               "name": {

     

       123
       146
        
                 "type": "string",

     
···

       131
       154
        
                 "type": "string",

     

       132
       155
        
                 "format": "datetime",

     

       133
       156
        
                 "description": "Author timestamp"

     

       157
       157
       +
               }

     

       158
       158
       +
             }

     

       159
       159
       +
           },

     

       160
       160
       +
           "submodule": {

     

       161
       161
       +
             "type": "object",

     

       162
       162
       +
             "required": [

     

       163
       163
       +
               "name",

     

       164
       164
       +
               "url"

     

       165
       165
       +
             ],

     

       166
       166
       +
             "properties": {

     

       167
       167
       +
               "name": {

     

       168
       168
       +
                 "type": "string",

     

       169
       169
       +
                 "description": "Submodule name"

     

       170
       170
       +
               },

     

       171
       171
       +
               "url": {

     

       172
       172
       +
                 "type": "string",

     

       173
       173
       +
                 "description": "Submodule repository URL"

     

       174
       174
       +
               },

     

       175
       175
       +
               "branch": {

     

       176
       176
       +
                 "type": "string",

     

       177
       177
       +
                 "description": "Branch to track in the submodule"

     

       134
       178
        
               }

     

       135
       179
        
             }

     

       136
       180
        
           }

+1 -9

lexicons/repo/tree.json

···

       91
       91
        
           },

     

       92
       92
        
           "treeEntry": {

     

       93
       93
        
             "type": "object",

     

       94
       94
       -
             "required": ["name", "mode", "size", "is_file", "is_subtree"],

     

       94
       94
       +
             "required": ["name", "mode", "size"],

     

       95
       95
        
             "properties": {

     

       96
       96
        
               "name": {

     

       97
       97
        
                 "type": "string",

     
···

       104
       104
        
               "size": {

     

       105
       105
        
                 "type": "integer",

     

       106
       106
        
                 "description": "File size in bytes"

     

       107
       107
       -
               },

     

       108
       108
       -
               "is_file": {

     

       109
       109
       -
                 "type": "boolean",

     

       110
       110
       -
                 "description": "Whether this entry is a file"

     

       111
       111
       -
               },

     

       112
       112
       -
               "is_subtree": {

     

       113
       113
       -
                 "type": "boolean",

     

       114
       114
       -
                 "description": "Whether this entry is a directory/subtree"

     

       115
       107
        
               },

     

       116
       108
        
               "last_commit": {

     

       117
       109
        
                 "type": "ref",

-30

nix/gomod2nix.toml

···

       165
       165
        
         [mod."github.com/davecgh/go-spew"]

     

       166
       166
        
           version = "v1.1.2-0.20180830191138-d8f796af33cc"

     

       167
       167
        
           hash = "sha256-fV9oI51xjHdOmEx6+dlq7Ku2Ag+m/bmbzPo6A4Y74qc="

     

       168
       168
       -
         [mod."github.com/decred/dcrd/dcrec/secp256k1/v4"]

     

       169
       169
       -
           version = "v4.4.0"

     

       170
       170
       -
           hash = "sha256-qrhEIwhDll3cxoVpMbm1NQ9/HTI42S7ms8Buzlo5HCg="

     

       171
       168
        
         [mod."github.com/dgraph-io/ristretto"]

     

       172
       169
        
           version = "v0.2.0"

     

       173
       170
        
           hash = "sha256-bnpxX+oO/Qf7IJevA0gsbloVoqRx+5bh7RQ9d9eLNYw="

     
···

       373
       370
        
         [mod."github.com/klauspost/cpuid/v2"]

     

       374
       371
        
           version = "v2.3.0"

     

       375
       372
        
           hash = "sha256-50JhbQyT67BK38HIdJihPtjV7orYp96HknI2VP7A9Yc="

     

       376
       376
       -
         [mod."github.com/lestrrat-go/blackmagic"]

     

       377
       377
       -
           version = "v1.0.4"

     

       378
       378
       -
           hash = "sha256-HmWOpwoPDNMwLdOi7onNn3Sb+ZsAa3Ai3gVBbXmQ0e8="

     

       379
       379
       -
         [mod."github.com/lestrrat-go/httpcc"]

     

       380
       380
       -
           version = "v1.0.1"

     

       381
       381
       -
           hash = "sha256-SMRSwJpqDIs/xL0l2e8vP0W65qtCHX2wigcOeqPJmos="

     

       382
       382
       -
         [mod."github.com/lestrrat-go/httprc"]

     

       383
       383
       -
           version = "v1.0.6"

     

       384
       384
       -
           hash = "sha256-mfZzePEhrmyyu/avEBd2MsDXyto8dq5+fyu5lA8GUWM="

     

       385
       385
       -
         [mod."github.com/lestrrat-go/iter"]

     

       386
       386
       -
           version = "v1.0.2"

     

       387
       387
       -
           hash = "sha256-30tErRf7Qu/NOAt1YURXY/XJSA6sCr6hYQfO8QqHrtw="

     

       388
       388
       -
         [mod."github.com/lestrrat-go/jwx/v2"]

     

       389
       389
       -
           version = "v2.1.6"

     

       390
       390
       -
           hash = "sha256-0LszXRZIba+X8AOrs3T4uanAUafBdlVB8/MpUNEFpbc="

     

       391
       391
       -
         [mod."github.com/lestrrat-go/option"]

     

       392
       392
       -
           version = "v1.0.1"

     

       393
       393
       -
           hash = "sha256-jVcIYYVsxElIS/l2akEw32vdEPR8+anR6oeT1FoYULI="

     

       394
       373
        
         [mod."github.com/lucasb-eyer/go-colorful"]

     

       395
       374
        
           version = "v1.2.0"

     

       396
       375
        
           hash = "sha256-Gg9dDJFCTaHrKHRR1SrJgZ8fWieJkybljybkI9x0gyE="

     
···

       511
       490
        
         [mod."github.com/ryanuber/go-glob"]

     

       512
       491
        
           version = "v1.0.0"

     

       513
       492
        
           hash = "sha256-YkMl1utwUhi3E0sHK23ISpAsPyj4+KeXyXKoFYGXGVY="

     

       514
       514
       -
         [mod."github.com/segmentio/asm"]

     

       515
       515
       -
           version = "v1.2.0"

     

       516
       516
       -
           hash = "sha256-zbNuKxNrUDUc6IlmRQNuJQzVe5Ol/mqp7srDg9IMMqs="

     

       517
       493
        
         [mod."github.com/sergi/go-diff"]

     

       518
       494
        
           version = "v1.1.0"

     

       519
       495
        
           hash = "sha256-8NJMabldpf40uwQN20T6QXx5KORDibCBJL02KD661xY="

     
···

       548
       524
        
         [mod."github.com/whyrusleeping/cbor-gen"]

     

       549
       525
        
           version = "v0.3.1"

     

       550
       526
        
           hash = "sha256-PAd8M2Z8t6rVRBII+Rg8Bz+QaJIwbW64bfyqsv31kgc="

     

       551
       551
       -
         [mod."github.com/wyatt915/goldmark-treeblood"]

     

       552
       552
       -
           version = "v0.0.1"

     

       553
       553
       -
           hash = "sha256-hAVFaktO02MiiqZFffr8ZlvFEfwxw4Y84OZ2t7e5G7g="

     

       554
       554
       -
         [mod."github.com/wyatt915/treeblood"]

     

       555
       555
       -
           version = "v0.1.16"

     

       556
       556
       -
           hash = "sha256-T68sa+iVx0qY7dDjXEAJvRWQEGXYIpUsf9tcWwO1tIw="

     

       557
       527
        
         [mod."github.com/xo/terminfo"]

     

       558
       528
        
           version = "v0.0.0-20220910002029-abceb7e1c41e"

     

       559
       529
        
           hash = "sha256-GyCDxxMQhXA3Pi/TsWXpA8cX5akEoZV7CFx4RO3rARU="

+278 -12

nix/modules/appview.nix

···

       13
       13
        
                 default = false;

     

       14
       14
        
                 description = "Enable tangled appview";

     

       15
       15
        
               };

     

       16
       16
       +
       

     

       16
       17
        
               package = mkOption {

     

       17
       18
        
                 type = types.package;

     

       18
       19
        
                 description = "Package to use for the appview";

     

       19
       20
        
               };

     

       21
       21
       +
       

     

       22
       22
       +
               # core configuration

     

       20
       23
        
               port = mkOption {

     

       21
       21
       -
                 type = types.int;

     

       24
       24
       +
                 type = types.port;

     

       22
       25
        
                 default = 3000;

     

       23
       26
        
                 description = "Port to run the appview on";

     

       24
       27
        
               };

     

       28
       28
       +
       

     

       29
       29
       +
               listenAddr = mkOption {

     

       30
       30
       +
                 type = types.str;

     

       31
       31
       +
                 default = "0.0.0.0:${toString cfg.port}";

     

       32
       32
       +
                 description = "Listen address for the appview service";

     

       33
       33
       +
               };

     

       34
       34
       +
       

     

       35
       35
       +
               dbPath = mkOption {

     

       36
       36
       +
                 type = types.str;

     

       37
       37
       +
                 default = "/var/lib/appview/appview.db";

     

       38
       38
       +
                 description = "Path to the SQLite database file";

     

       39
       39
       +
               };

     

       40
       40
       +
       

     

       41
       41
       +
               appviewHost = mkOption {

     

       42
       42
       +
                 type = types.str;

     

       43
       43
       +
                 default = "https://tangled.org";

     

       44
       44
       +
                 example = "https://example.com";

     

       45
       45
       +
                 description = "Public host URL for the appview instance";

     

       46
       46
       +
               };

     

       47
       47
       +
       

     

       48
       48
       +
               appviewName = mkOption {

     

       49
       49
       +
                 type = types.str;

     

       50
       50
       +
                 default = "Tangled";

     

       51
       51
       +
                 description = "Display name for the appview instance";

     

       52
       52
       +
               };

     

       53
       53
       +
       

     

       54
       54
       +
               dev = mkOption {

     

       55
       55
       +
                 type = types.bool;

     

       56
       56
       +
                 default = false;

     

       57
       57
       +
                 description = "Enable development mode";

     

       58
       58
       +
               };

     

       59
       59
       +
       

     

       60
       60
       +
               disallowedNicknamesFile = mkOption {

     

       61
       61
       +
                 type = types.nullOr types.path;

     

       62
       62
       +
                 default = null;

     

       63
       63
       +
                 description = "Path to file containing disallowed nicknames";

     

       64
       64
       +
               };

     

       65
       65
       +
       

     

       66
       66
       +
               # redis configuration

     

       67
       67
       +
               redis = {

     

       68
       68
       +
                 addr = mkOption {

     

       69
       69
       +
                   type = types.str;

     

       70
       70
       +
                   default = "localhost:6379";

     

       71
       71
       +
                   description = "Redis server address";

     

       72
       72
       +
                 };

     

       73
       73
       +
       

     

       74
       74
       +
                 db = mkOption {

     

       75
       75
       +
                   type = types.int;

     

       76
       76
       +
                   default = 0;

     

       77
       77
       +
                   description = "Redis database number";

     

       78
       78
       +
                 };

     

       79
       79
       +
               };

     

       80
       80
       +
       

     

       81
       81
       +
               # jetstream configuration

     

       82
       82
       +
               jetstream = {

     

       83
       83
       +
                 endpoint = mkOption {

     

       84
       84
       +
                   type = types.str;

     

       85
       85
       +
                   default = "wss://jetstream1.us-east.bsky.network/subscribe";

     

       86
       86
       +
                   description = "Jetstream WebSocket endpoint";

     

       87
       87
       +
                 };

     

       88
       88
       +
               };

     

       89
       89
       +
       

     

       90
       90
       +
               # knotstream consumer configuration

     

       91
       91
       +
               knotstream = {

     

       92
       92
       +
                 retryInterval = mkOption {

     

       93
       93
       +
                   type = types.str;

     

       94
       94
       +
                   default = "60s";

     

       95
       95
       +
                   description = "Initial retry interval for knotstream consumer";

     

       96
       96
       +
                 };

     

       97
       97
       +
       

     

       98
       98
       +
                 maxRetryInterval = mkOption {

     

       99
       99
       +
                   type = types.str;

     

       100
       100
       +
                   default = "120m";

     

       101
       101
       +
                   description = "Maximum retry interval for knotstream consumer";

     

       102
       102
       +
                 };

     

       103
       103
       +
       

     

       104
       104
       +
                 connectionTimeout = mkOption {

     

       105
       105
       +
                   type = types.str;

     

       106
       106
       +
                   default = "5s";

     

       107
       107
       +
                   description = "Connection timeout for knotstream consumer";

     

       108
       108
       +
                 };

     

       109
       109
       +
       

     

       110
       110
       +
                 workerCount = mkOption {

     

       111
       111
       +
                   type = types.int;

     

       112
       112
       +
                   default = 64;

     

       113
       113
       +
                   description = "Number of workers for knotstream consumer";

     

       114
       114
       +
                 };

     

       115
       115
       +
       

     

       116
       116
       +
                 queueSize = mkOption {

     

       117
       117
       +
                   type = types.int;

     

       118
       118
       +
                   default = 100;

     

       119
       119
       +
                   description = "Queue size for knotstream consumer";

     

       120
       120
       +
                 };

     

       121
       121
       +
               };

     

       122
       122
       +
       

     

       123
       123
       +
               # spindlestream consumer configuration

     

       124
       124
       +
               spindlestream = {

     

       125
       125
       +
                 retryInterval = mkOption {

     

       126
       126
       +
                   type = types.str;

     

       127
       127
       +
                   default = "60s";

     

       128
       128
       +
                   description = "Initial retry interval for spindlestream consumer";

     

       129
       129
       +
                 };

     

       130
       130
       +
       

     

       131
       131
       +
                 maxRetryInterval = mkOption {

     

       132
       132
       +
                   type = types.str;

     

       133
       133
       +
                   default = "120m";

     

       134
       134
       +
                   description = "Maximum retry interval for spindlestream consumer";

     

       135
       135
       +
                 };

     

       136
       136
       +
       

     

       137
       137
       +
                 connectionTimeout = mkOption {

     

       138
       138
       +
                   type = types.str;

     

       139
       139
       +
                   default = "5s";

     

       140
       140
       +
                   description = "Connection timeout for spindlestream consumer";

     

       141
       141
       +
                 };

     

       142
       142
       +
       

     

       143
       143
       +
                 workerCount = mkOption {

     

       144
       144
       +
                   type = types.int;

     

       145
       145
       +
                   default = 64;

     

       146
       146
       +
                   description = "Number of workers for spindlestream consumer";

     

       147
       147
       +
                 };

     

       148
       148
       +
       

     

       149
       149
       +
                 queueSize = mkOption {

     

       150
       150
       +
                   type = types.int;

     

       151
       151
       +
                   default = 100;

     

       152
       152
       +
                   description = "Queue size for spindlestream consumer";

     

       153
       153
       +
                 };

     

       154
       154
       +
               };

     

       155
       155
       +
       

     

       156
       156
       +
               # resend configuration

     

       157
       157
       +
               resend = {

     

       158
       158
       +
                 sentFrom = mkOption {

     

       159
       159
       +
                   type = types.str;

     

       160
       160
       +
                   default = "noreply@notifs.tangled.sh";

     

       161
       161
       +
                   description = "Email address to send notifications from";

     

       162
       162
       +
                 };

     

       163
       163
       +
               };

     

       164
       164
       +
       

     

       165
       165
       +
               # posthog configuration

     

       166
       166
       +
               posthog = {

     

       167
       167
       +
                 endpoint = mkOption {

     

       168
       168
       +
                   type = types.str;

     

       169
       169
       +
                   default = "https://eu.i.posthog.com";

     

       170
       170
       +
                   description = "PostHog API endpoint";

     

       171
       171
       +
                 };

     

       172
       172
       +
               };

     

       173
       173
       +
       

     

       174
       174
       +
               # camo configuration

     

       175
       175
       +
               camo = {

     

       176
       176
       +
                 host = mkOption {

     

       177
       177
       +
                   type = types.str;

     

       178
       178
       +
                   default = "https://camo.tangled.sh";

     

       179
       179
       +
                   description = "Camo proxy host URL";

     

       180
       180
       +
                 };

     

       181
       181
       +
               };

     

       182
       182
       +
       

     

       183
       183
       +
               # avatar configuration

     

       184
       184
       +
               avatar = {

     

       185
       185
       +
                 host = mkOption {

     

       186
       186
       +
                   type = types.str;

     

       187
       187
       +
                   default = "https://avatar.tangled.sh";

     

       188
       188
       +
                   description = "Avatar service host URL";

     

       189
       189
       +
                 };

     

       190
       190
       +
               };

     

       191
       191
       +
       

     

       192
       192
       +
               plc = {

     

       193
       193
       +
                 url = mkOption {

     

       194
       194
       +
                   type = types.str;

     

       195
       195
       +
                   default = "https://plc.directory";

     

       196
       196
       +
                   description = "PLC directory URL";

     

       197
       197
       +
                 };

     

       198
       198
       +
               };

     

       199
       199
       +
       

     

       200
       200
       +
               pds = {

     

       201
       201
       +
                 host = mkOption {

     

       202
       202
       +
                   type = types.str;

     

       203
       203
       +
                   default = "https://tngl.sh";

     

       204
       204
       +
                   description = "PDS host URL";

     

       205
       205
       +
                 };

     

       206
       206
       +
               };

     

       207
       207
       +
       

     

       208
       208
       +
               label = {

     

       209
       209
       +
                 defaults = mkOption {

     

       210
       210
       +
                   type = types.listOf types.str;

     

       211
       211
       +
                   default = [

     

       212
       212
       +
                     "at://did:plc:wshs7t2adsemcrrd4snkeqli/sh.tangled.label.definition/wontfix"

     

       213
       213
       +
                     "at://did:plc:wshs7t2adsemcrrd4snkeqli/sh.tangled.label.definition/good-first-issue"

     

       214
       214
       +
                     "at://did:plc:wshs7t2adsemcrrd4snkeqli/sh.tangled.label.definition/duplicate"

     

       215
       215
       +
                     "at://did:plc:wshs7t2adsemcrrd4snkeqli/sh.tangled.label.definition/documentation"

     

       216
       216
       +
                     "at://did:plc:wshs7t2adsemcrrd4snkeqli/sh.tangled.label.definition/assignee"

     

       217
       217
       +
                   ];

     

       218
       218
       +
                   description = "Default label definitions";

     

       219
       219
       +
                 };

     

       220
       220
       +
       

     

       221
       221
       +
                 goodFirstIssue = mkOption {

     

       222
       222
       +
                   type = types.str;

     

       223
       223
       +
                   default = "at://did:plc:wshs7t2adsemcrrd4snkeqli/sh.tangled.label.definition/good-first-issue";

     

       224
       224
       +
                   description = "Good first issue label definition";

     

       225
       225
       +
                 };

     

       226
       226
       +
               };

     

       227
       227
       +
       

     

       25
       228
        
               environmentFile = mkOption {

     

       26
       229
        
                 type = with types; nullOr path;

     

       27
       230
        
                 default = null;

     

       28
       28
       -
                 example = "/etc-/appview.env";

     

       231
       231
       +
                 example = "/etc/appview.env";

     

       29
       232
        
                 description = ''

     

       30
       233
        
                   Additional environment file as defined in {manpage}`systemd.exec(5)`.

     

       31
       234
        
       

     

       32
       32
       -
                   Sensitive secrets such as {env}`TANGLED_COOKIE_SECRET` may be

     

       33
       33
       -
                   passed to the service without makeing them world readable in the

     

       34
       34
       -
                   nix store.

     

       35
       35
       -
       

     

       235
       235
       +
                   Sensitive secrets such as {env}`TANGLED_COOKIE_SECRET`,

     

       236
       236
       +
                   {env}`TANGLED_OAUTH_CLIENT_SECRET`, {env}`TANGLED_RESEND_API_KEY`,

     

       237
       237
       +
                   {env}`TANGLED_CAMO_SHARED_SECRET`, {env}`TANGLED_AVATAR_SHARED_SECRET`,

     

       238
       238
       +
                   {env}`TANGLED_REDIS_PASS`, {env}`TANGLED_PDS_ADMIN_SECRET`,

     

       239
       239
       +
                   {env}`TANGLED_CLOUDFLARE_API_TOKEN`, {env}`TANGLED_CLOUDFLARE_ZONE_ID`,

     

       240
       240
       +
                   {env}`TANGLED_CLOUDFLARE_TURNSTILE_SITE_KEY`,

     

       241
       241
       +
                   {env}`TANGLED_CLOUDFLARE_TURNSTILE_SECRET_KEY`,

     

       242
       242
       +
                   {env}`TANGLED_POSTHOG_API_KEY`, {env}`TANGLED_APP_PASSWORD`,

     

       243
       243
       +
                   and {env}`TANGLED_ALT_APP_PASSWORD` may be passed to the service

     

       244
       244
       +
                   without making them world readable in the nix store.

     

       36
       245
        
                 '';

     

       37
       246
        
               };

     

       38
       247
        
             };

     
···

       47
       256
        
             systemd.services.appview = {

     

       48
       257
        
               description = "tangled appview service";

     

       49
       258
        
               wantedBy = ["multi-user.target"];

     

       50
       50
       -
               after = ["redis-appview.service"];

     

       259
       259
       +
               after = ["redis-appview.service" "network-online.target"];

     

       51
       260
        
               requires = ["redis-appview.service"];

     

       261
       261
       +
               wants = ["network-online.target"];

     

       52
       262
        
       

     

       53
       263
        
               serviceConfig = {

     

       54
       54
       -
                 ListenStream = "0.0.0.0:${toString cfg.port}";

     

       264
       264
       +
                 Type = "simple";

     

       55
       265
        
                 ExecStart = "${cfg.package}/bin/appview";

     

       56
       266
        
                 Restart = "always";

     

       57
       57
       -
                 EnvironmentFile = optional (cfg.environmentFile != null) cfg.environmentFile;

     

       58
       58
       -
               };

     

       267
       267
       +
                 RestartSec = "10s";

     

       268
       268
       +
                 EnvironmentFile = mkIf (cfg.environmentFile != null) cfg.environmentFile;

     

       269
       269
       +
       

     

       270
       270
       +
                 # state directory

     

       271
       271
       +
                 StateDirectory = "appview";

     

       272
       272
       +
                 WorkingDirectory = "/var/lib/appview";

     

       59
       273
        
       

     

       60
       60
       -
               environment = {

     

       61
       61
       -
                 TANGLED_DB_PATH = "appview.db";

     

       274
       274
       +
                 # security hardening

     

       275
       275
       +
                 NoNewPrivileges = true;

     

       276
       276
       +
                 PrivateTmp = true;

     

       277
       277
       +
                 ProtectSystem = "strict";

     

       278
       278
       +
                 ProtectHome = true;

     

       279
       279
       +
                 ReadWritePaths = ["/var/lib/appview"];

     

       62
       280
        
               };

     

       281
       281
       +
       

     

       282
       282
       +
               environment =

     

       283
       283
       +
                 {

     

       284
       284
       +
                   TANGLED_DB_PATH = cfg.dbPath;

     

       285
       285
       +
                   TANGLED_LISTEN_ADDR = cfg.listenAddr;

     

       286
       286
       +
                   TANGLED_APPVIEW_HOST = cfg.appviewHost;

     

       287
       287
       +
                   TANGLED_APPVIEW_NAME = cfg.appviewName;

     

       288
       288
       +
                   TANGLED_DEV =

     

       289
       289
       +
                     if cfg.dev

     

       290
       290
       +
                     then "true"

     

       291
       291
       +
                     else "false";

     

       292
       292
       +
                 }

     

       293
       293
       +
                 // optionalAttrs (cfg.disallowedNicknamesFile != null) {

     

       294
       294
       +
                   TANGLED_DISALLOWED_NICKNAMES_FILE = cfg.disallowedNicknamesFile;

     

       295
       295
       +
                 }

     

       296
       296
       +
                 // {

     

       297
       297
       +
                   TANGLED_REDIS_ADDR = cfg.redis.addr;

     

       298
       298
       +
                   TANGLED_REDIS_DB = toString cfg.redis.db;

     

       299
       299
       +
       

     

       300
       300
       +
                   TANGLED_JETSTREAM_ENDPOINT = cfg.jetstream.endpoint;

     

       301
       301
       +
       

     

       302
       302
       +
                   TANGLED_KNOTSTREAM_RETRY_INTERVAL = cfg.knotstream.retryInterval;

     

       303
       303
       +
                   TANGLED_KNOTSTREAM_MAX_RETRY_INTERVAL = cfg.knotstream.maxRetryInterval;

     

       304
       304
       +
                   TANGLED_KNOTSTREAM_CONNECTION_TIMEOUT = cfg.knotstream.connectionTimeout;

     

       305
       305
       +
                   TANGLED_KNOTSTREAM_WORKER_COUNT = toString cfg.knotstream.workerCount;

     

       306
       306
       +
                   TANGLED_KNOTSTREAM_QUEUE_SIZE = toString cfg.knotstream.queueSize;

     

       307
       307
       +
       

     

       308
       308
       +
                   TANGLED_SPINDLESTREAM_RETRY_INTERVAL = cfg.spindlestream.retryInterval;

     

       309
       309
       +
                   TANGLED_SPINDLESTREAM_MAX_RETRY_INTERVAL = cfg.spindlestream.maxRetryInterval;

     

       310
       310
       +
                   TANGLED_SPINDLESTREAM_CONNECTION_TIMEOUT = cfg.spindlestream.connectionTimeout;

     

       311
       311
       +
                   TANGLED_SPINDLESTREAM_WORKER_COUNT = toString cfg.spindlestream.workerCount;

     

       312
       312
       +
                   TANGLED_SPINDLESTREAM_QUEUE_SIZE = toString cfg.spindlestream.queueSize;

     

       313
       313
       +
       

     

       314
       314
       +
                   TANGLED_RESEND_SENT_FROM = cfg.resend.sentFrom;

     

       315
       315
       +
       

     

       316
       316
       +
                   TANGLED_POSTHOG_ENDPOINT = cfg.posthog.endpoint;

     

       317
       317
       +
       

     

       318
       318
       +
                   TANGLED_CAMO_HOST = cfg.camo.host;

     

       319
       319
       +
       

     

       320
       320
       +
                   TANGLED_AVATAR_HOST = cfg.avatar.host;

     

       321
       321
       +
       

     

       322
       322
       +
                   TANGLED_PLC_URL = cfg.plc.url;

     

       323
       323
       +
       

     

       324
       324
       +
                   TANGLED_PDS_HOST = cfg.pds.host;

     

       325
       325
       +
       

     

       326
       326
       +
                   TANGLED_LABEL_DEFAULTS = concatStringsSep "," cfg.label.defaults;

     

       327
       327
       +
                   TANGLED_LABEL_GFI = cfg.label.goodFirstIssue;

     

       328
       328
       +
                 };

     

       63
       329
        
             };

     

       64
       330
        
           };

     

       65
       331
        
         }

+60 -2

nix/modules/knot.nix

···

       51
       51
        
                   description = "Path where repositories are scanned from";

     

       52
       52
        
                 };

     

       53
       53
        
       

     

       54
       54
       +
                 readme = mkOption {

     

       55
       55
       +
                   type = types.listOf types.str;

     

       56
       56
       +
                   default = [

     

       57
       57
       +
                     "README.md"

     

       58
       58
       +
                     "readme.md"

     

       59
       59
       +
                     "README"

     

       60
       60
       +
                     "readme"

     

       61
       61
       +
                     "README.markdown"

     

       62
       62
       +
                     "readme.markdown"

     

       63
       63
       +
                     "README.txt"

     

       64
       64
       +
                     "readme.txt"

     

       65
       65
       +
                     "README.rst"

     

       66
       66
       +
                     "readme.rst"

     

       67
       67
       +
                     "README.org"

     

       68
       68
       +
                     "readme.org"

     

       69
       69
       +
                     "README.asciidoc"

     

       70
       70
       +
                     "readme.asciidoc"

     

       71
       71
       +
                   ];

     

       72
       72
       +
                   description = "List of README filenames to look for (in priority order)";

     

       73
       73
       +
                 };

     

       74
       74
       +
       

     

       54
       75
        
                 mainBranch = mkOption {

     

       55
       76
        
                   type = types.str;

     

       56
       77
        
                   default = "main";

     
···

       58
       79
        
                 };

     

       59
       80
        
               };

     

       60
       81
        
       

     

       82
       82
       +
               git = {

     

       83
       83
       +
                 userName = mkOption {

     

       84
       84
       +
                   type = types.str;

     

       85
       85
       +
                   default = "Tangled";

     

       86
       86
       +
                   description = "Git user name used as committer";

     

       87
       87
       +
                 };

     

       88
       88
       +
       

     

       89
       89
       +
                 userEmail = mkOption {

     

       90
       90
       +
                   type = types.str;

     

       91
       91
       +
                   default = "noreply@tangled.org";

     

       92
       92
       +
                   description = "Git user email used as committer";

     

       93
       93
       +
                 };

     

       94
       94
       +
               };

     

       95
       95
       +
       

     

       61
       96
        
               motd = mkOption {

     

       62
       97
        
                 type = types.nullOr types.str;

     

       63
       98
        
                 default = null;

     
···

       123
       158
        
                   description = "Jetstream endpoint to subscribe to";

     

       124
       159
        
                 };

     

       125
       160
        
       

     

       161
       161
       +
                 logDids = mkOption {

     

       162
       162
       +
                   type = types.bool;

     

       163
       163
       +
                   default = true;

     

       164
       164
       +
                   description = "Enable logging of DIDs";

     

       165
       165
       +
                 };

     

       166
       166
       +
       

     

       126
       167
        
                 dev = mkOption {

     

       127
       168
        
                   type = types.bool;

     

       128
       169
        
                   default = false;

     
···

       154
       195
        
                 Match User ${cfg.gitUser}

     

       155
       196
        
                     AuthorizedKeysCommand /etc/ssh/keyfetch_wrapper

     

       156
       197
        
                     AuthorizedKeysCommandUser nobody

     

       198
       198
       +
                     ChallengeResponseAuthentication no

     

       199
       199
       +
                     PasswordAuthentication no

     

       157
       200
        
               '';

     

       158
       201
        
             };

     

       159
       202
        
       

     
···

       190
       233
        
                 mkdir -p "${cfg.stateDir}/.config/git"

     

       191
       234
        
                 cat > "${cfg.stateDir}/.config/git/config" << EOF

     

       192
       235
        
                 [user]

     

       193
       193
       -
                     name = Git User

     

       194
       194
       -
                     email = git@example.com

     

       236
       236
       +
                     name = ${cfg.git.userName}

     

       237
       237
       +
                     email = ${cfg.git.userEmail}

     

       195
       238
        
                 [receive]

     

       196
       239
        
                     advertisePushOptions = true

     

       240
       240
       +
                 [uploadpack]

     

       241
       241
       +
                     allowFilter = true

     

       197
       242
        
                 EOF

     

       198
       243
        
                 ${setMotd}

     

       199
       244
        
                 chown -R ${cfg.gitUser}:${cfg.gitUser} "${cfg.stateDir}"

     
···

       205
       250
        
                 WorkingDirectory = cfg.stateDir;

     

       206
       251
        
                 Environment = [

     

       207
       252
        
                   "KNOT_REPO_SCAN_PATH=${cfg.repo.scanPath}"

     

       253
       253
       +
                   "KNOT_REPO_README=${concatStringsSep "," cfg.repo.readme}"

     

       208
       254
        
                   "KNOT_REPO_MAIN_BRANCH=${cfg.repo.mainBranch}"

     

       255
       255
       +
                   "KNOT_GIT_USER_NAME=${cfg.git.userName}"

     

       256
       256
       +
                   "KNOT_GIT_USER_EMAIL=${cfg.git.userEmail}"

     

       209
       257
        
                   "APPVIEW_ENDPOINT=${cfg.appviewEndpoint}"

     

       210
       258
        
                   "KNOT_SERVER_INTERNAL_LISTEN_ADDR=${cfg.server.internalListenAddr}"

     

       211
       259
        
                   "KNOT_SERVER_LISTEN_ADDR=${cfg.server.listenAddr}"

     
···

       214
       262
        
                   "KNOT_SERVER_PLC_URL=${cfg.server.plcUrl}"

     

       215
       263
        
                   "KNOT_SERVER_JETSTREAM_ENDPOINT=${cfg.server.jetstreamEndpoint}"

     

       216
       264
        
                   "KNOT_SERVER_OWNER=${cfg.server.owner}"

     

       265
       265
       +
                   "KNOT_SERVER_LOG_DIDS=${

     

       266
       266
       +
                     if cfg.server.logDids

     

       267
       267
       +
                     then "true"

     

       268
       268
       +
                     else "false"

     

       269
       269
       +
                   }"

     

       270
       270
       +
                   "KNOT_SERVER_DEV=${

     

       271
       271
       +
                     if cfg.server.dev

     

       272
       272
       +
                     then "true"

     

       273
       273
       +
                     else "false"

     

       274
       274
       +
                   }"

     

       217
       275
        
                 ];

     

       218
       276
        
                 ExecStart = "${cfg.package}/bin/knot server";

     

       219
       277
        
                 Restart = "always";

nix/pkgs/appview-static-files.nix

···

       5
       5
        
         lucide-src,

     

       6
       6
        
         inter-fonts-src,

     

       7
       7
        
         ibm-plex-mono-src,

     

       8
       8
       +
         actor-typeahead-src,

     

       8
       9
        
         sqlite-lib,

     

       9
       10
        
         tailwindcss,

     

       10
       11
        
         src,

     
···

       24
       25
        
         cp -f ${inter-fonts-src}/web/InterDisplay*.woff2 fonts/

     

       25
       26
        
         cp -f ${inter-fonts-src}/InterVariable*.ttf fonts/

     

       26
       27
        
         cp -f ${ibm-plex-mono-src}/fonts/complete/woff2/IBMPlexMono*.woff2 fonts/

     

       28
       28
       +
         cp -f ${actor-typeahead-src}/actor-typeahead.js .

     

       27
       29
        
         # tailwindcss -c $src/tailwind.config.js -i $src/input.css -o tw.css won't work

     

       28
       30
        
         # for whatever reason (produces broken css), so we are doing this instead

     

       29
       31
        
         cd ${src} && ${tailwindcss}/bin/tailwindcss -i input.css -o $out/tw.css

+1 -1

nix/pkgs/knot-unwrapped.nix

···

       4
       4
        
         sqlite-lib,

     

       5
       5
        
         src,

     

       6
       6
        
       }: let

     

       7
       7
       -
         version = "1.9.1-alpha";

     

       7
       7
       +
         version = "1.11.0-alpha";

     

       8
       8
        
       in

     

       9
       9
        
         buildGoApplication {

     

       10
       10
        
           pname = "knot";

+7 -5

nix/pkgs/sqlite-lib.nix

···

       1
       1
        
       {

     

       2
       2
       -
         gcc,

     

       3
       2
        
         stdenv,

     

       4
       3
        
         sqlite-lib-src,

     

       5
       4
        
       }:

     

       6
       5
        
       stdenv.mkDerivation {

     

       7
       6
        
         name = "sqlite-lib";

     

       8
       7
        
         src = sqlite-lib-src;

     

       9
       9
       -
         nativeBuildInputs = [gcc];

     

       8
       8
       +
       

     

       10
       9
        
         buildPhase = ''

     

       11
       11
       -
           gcc -c sqlite3.c

     

       12
       12
       -
           ar rcs libsqlite3.a sqlite3.o

     

       13
       13
       -
           ranlib libsqlite3.a

     

       10
       10
       +
           $CC -c sqlite3.c

     

       11
       11
       +
           $AR rcs libsqlite3.a sqlite3.o

     

       12
       12
       +
           $RANLIB libsqlite3.a

     

       13
       13
       +
         '';

     

       14
       14
       +
       

     

       15
       15
       +
         installPhase = ''

     

       14
       16
        
           mkdir -p $out/include $out/lib

     

       15
       17
        
           cp *.h $out/include

     

       16
       18
        
           cp libsqlite3.a $out/lib

+5 -5

nix/vm.nix

···

       48
       48
        
                   # knot

     

       49
       49
        
                   {

     

       50
       50
        
                     from = "host";

     

       51
       51
       -
                     host.port = 6000;

     

       52
       52
       -
                     guest.port = 6000;

     

       51
       51
       +
                     host.port = 6444;

     

       52
       52
       +
                     guest.port = 6444;

     

       53
       53
        
                   }

     

       54
       54
        
                   # spindle

     

       55
       55
        
                   {

     
···

       87
       87
        
                 motd = "Welcome to the development knot!\n";

     

       88
       88
        
                 server = {

     

       89
       89
        
                   owner = envVar "TANGLED_VM_KNOT_OWNER";

     

       90
       90
       -
                   hostname = envVarOr "TANGLED_VM_KNOT_HOST" "localhost:6000";

     

       90
       90
       +
                   hostname = envVarOr "TANGLED_VM_KNOT_HOST" "localhost:6444";

     

       91
       91
        
                   plcUrl = plcUrl;

     

       92
       92
        
                   jetstreamEndpoint = jetstream;

     

       93
       93
       -
                   listenAddr = "0.0.0.0:6000";

     

       93
       93
       +
                   listenAddr = "0.0.0.0:6444";

     

       94
       94
        
                 };

     

       95
       95
        
               };

     

       96
       96
        
               services.tangled.spindle = {

     

       97
       97
        
                 enable = true;

     

       98
       98
        
                 server = {

     

       99
       99
        
                   owner = envVar "TANGLED_VM_SPINDLE_OWNER";

     

       100
       100
       -
                   hostname = envVarOr "TANGLED_VM_SPINDLE_OWNER" "localhost:6555";

     

       100
       100
       +
                   hostname = envVarOr "TANGLED_VM_SPINDLE_HOST" "localhost:6555";

     

       101
       101
        
                   plcUrl = plcUrl;

     

       102
       102
        
                   jetstreamEndpoint = jetstream;

     

       103
       103
        
                   listenAddr = "0.0.0.0:6555";

+122

orm/orm.go

···

       1
       1
       +
       package orm

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"database/sql"

     

       6
       6
       +
       	"fmt"

     

       7
       7
       +
       	"log/slog"

     

       8
       8
       +
       	"reflect"

     

       9
       9
       +
       	"strings"

     

       10
       10
       +
       )

     

       11
       11
       +
       

     

       12
       12
       +
       type migrationFn = func(*sql.Tx) error

     

       13
       13
       +
       

     

       14
       14
       +
       func RunMigration(c *sql.Conn, logger *slog.Logger, name string, migrationFn migrationFn) error {

     

       15
       15
       +
       	logger = logger.With("migration", name)

     

       16
       16
       +
       

     

       17
       17
       +
       	tx, err := c.BeginTx(context.Background(), nil)

     

       18
       18
       +
       	if err != nil {

     

       19
       19
       +
       		return err

     

       20
       20
       +
       	}

     

       21
       21
       +
       	defer tx.Rollback()

     

       22
       22
       +
       

     

       23
       23
       +
       	var exists bool

     

       24
       24
       +
       	err = tx.QueryRow("select exists (select 1 from migrations where name = ?)", name).Scan(&exists)

     

       25
       25
       +
       	if err != nil {

     

       26
       26
       +
       		return err

     

       27
       27
       +
       	}

     

       28
       28
       +
       

     

       29
       29
       +
       	if !exists {

     

       30
       30
       +
       		// run migration

     

       31
       31
       +
       		err = migrationFn(tx)

     

       32
       32
       +
       		if err != nil {

     

       33
       33
       +
       			logger.Error("failed to run migration", "err", err)

     

       34
       34
       +
       			return err

     

       35
       35
       +
       		}

     

       36
       36
       +
       

     

       37
       37
       +
       		// mark migration as complete

     

       38
       38
       +
       		_, err = tx.Exec("insert into migrations (name) values (?)", name)

     

       39
       39
       +
       		if err != nil {

     

       40
       40
       +
       			logger.Error("failed to mark migration as complete", "err", err)

     

       41
       41
       +
       			return err

     

       42
       42
       +
       		}

     

       43
       43
       +
       

     

       44
       44
       +
       		// commit the transaction

     

       45
       45
       +
       		if err := tx.Commit(); err != nil {

     

       46
       46
       +
       			return err

     

       47
       47
       +
       		}

     

       48
       48
       +
       

     

       49
       49
       +
       		logger.Info("migration applied successfully")

     

       50
       50
       +
       	} else {

     

       51
       51
       +
       		logger.Warn("skipped migration, already applied")

     

       52
       52
       +
       	}

     

       53
       53
       +
       

     

       54
       54
       +
       	return nil

     

       55
       55
       +
       }

     

       56
       56
       +
       

     

       57
       57
       +
       type Filter struct {

     

       58
       58
       +
       	Key string

     

       59
       59
       +
       	arg any

     

       60
       60
       +
       	Cmp string

     

       61
       61
       +
       }

     

       62
       62
       +
       

     

       63
       63
       +
       func newFilter(key, cmp string, arg any) Filter {

     

       64
       64
       +
       	return Filter{

     

       65
       65
       +
       		Key: key,

     

       66
       66
       +
       		arg: arg,

     

       67
       67
       +
       		Cmp: cmp,

     

       68
       68
       +
       	}

     

       69
       69
       +
       }

     

       70
       70
       +
       

     

       71
       71
       +
       func FilterEq(key string, arg any) Filter      { return newFilter(key, "=", arg) }

     

       72
       72
       +
       func FilterNotEq(key string, arg any) Filter   { return newFilter(key, "<>", arg) }

     

       73
       73
       +
       func FilterGte(key string, arg any) Filter     { return newFilter(key, ">=", arg) }

     

       74
       74
       +
       func FilterLte(key string, arg any) Filter     { return newFilter(key, "<=", arg) }

     

       75
       75
       +
       func FilterIs(key string, arg any) Filter      { return newFilter(key, "is", arg) }

     

       76
       76
       +
       func FilterIsNot(key string, arg any) Filter   { return newFilter(key, "is not", arg) }

     

       77
       77
       +
       func FilterIn(key string, arg any) Filter      { return newFilter(key, "in", arg) }

     

       78
       78
       +
       func FilterLike(key string, arg any) Filter    { return newFilter(key, "like", arg) }

     

       79
       79
       +
       func FilterNotLike(key string, arg any) Filter { return newFilter(key, "not like", arg) }

     

       80
       80
       +
       func FilterContains(key string, arg any) Filter {

     

       81
       81
       +
       	return newFilter(key, "like", fmt.Sprintf("%%%v%%", arg))

     

       82
       82
       +
       }

     

       83
       83
       +
       

     

       84
       84
       +
       func (f Filter) Condition() string {

     

       85
       85
       +
       	rv := reflect.ValueOf(f.arg)

     

       86
       86
       +
       	kind := rv.Kind()

     

       87
       87
       +
       

     

       88
       88
       +
       	// if we have `FilterIn(k, [1, 2, 3])`, compile it down to `k in (?, ?, ?)`

     

       89
       89
       +
       	if (kind == reflect.Slice && rv.Type().Elem().Kind() != reflect.Uint8) || kind == reflect.Array {

     

       90
       90
       +
       		if rv.Len() == 0 {

     

       91
       91
       +
       			// always false

     

       92
       92
       +
       			return "1 = 0"

     

       93
       93
       +
       		}

     

       94
       94
       +
       

     

       95
       95
       +
       		placeholders := make([]string, rv.Len())

     

       96
       96
       +
       		for i := range placeholders {

     

       97
       97
       +
       			placeholders[i] = "?"

     

       98
       98
       +
       		}

     

       99
       99
       +
       

     

       100
       100
       +
       		return fmt.Sprintf("%s %s (%s)", f.Key, f.Cmp, strings.Join(placeholders, ", "))

     

       101
       101
       +
       	}

     

       102
       102
       +
       

     

       103
       103
       +
       	return fmt.Sprintf("%s %s ?", f.Key, f.Cmp)

     

       104
       104
       +
       }

     

       105
       105
       +
       

     

       106
       106
       +
       func (f Filter) Arg() []any {

     

       107
       107
       +
       	rv := reflect.ValueOf(f.arg)

     

       108
       108
       +
       	kind := rv.Kind()

     

       109
       109
       +
       	if (kind == reflect.Slice && rv.Type().Elem().Kind() != reflect.Uint8) || kind == reflect.Array {

     

       110
       110
       +
       		if rv.Len() == 0 {

     

       111
       111
       +
       			return nil

     

       112
       112
       +
       		}

     

       113
       113
       +
       

     

       114
       114
       +
       		out := make([]any, rv.Len())

     

       115
       115
       +
       		for i := range rv.Len() {

     

       116
       116
       +
       			out[i] = rv.Index(i).Interface()

     

       117
       117
       +
       		}

     

       118
       118
       +
       		return out

     

       119
       119
       +
       	}

     

       120
       120
       +
       

     

       121
       121
       +
       	return []any{f.arg}

     

       122
       122
       +
       }

-1

patchutil/patchutil.go

···

       296
       296
        
       	}

     

       297
       297
        
       

     

       298
       298
        
       	nd := types.NiceDiff{}

     

       299
       299
       -
       	nd.Commit.Parent = targetBranch

     

       300
       299
        
       

     

       301
       300
        
       	for _, d := range diffs {

     

       302
       301
        
       		ndiff := types.Diff{}

rbac/rbac.go

···

       285
       285
        
       	return e.E.Enforce(user, domain, repo, "repo:delete")

     

       286
       286
        
       }

     

       287
       287
        
       

     

       288
       288
       +
       func (e *Enforcer) IsRepoOwner(user, domain, repo string) (bool, error) {

     

       289
       289
       +
       	return e.E.Enforce(user, domain, repo, "repo:owner")

     

       290
       290
       +
       }

     

       291
       291
       +
       

     

       292
       292
       +
       func (e *Enforcer) IsRepoCollaborator(user, domain, repo string) (bool, error) {

     

       293
       293
       +
       	return e.E.Enforce(user, domain, repo, "repo:collaborator")

     

       294
       294
       +
       }

     

       295
       295
       +
       

     

       288
       296
        
       func (e *Enforcer) IsPushAllowed(user, domain, repo string) (bool, error) {

     

       289
       297
        
       	return e.E.Enforce(user, domain, repo, "repo:push")

     

       290
       298
        
       }

+31

sets/gen.go

···

       1
       1
       +
       package sets

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"math/rand"

     

       5
       5
       +
       	"reflect"

     

       6
       6
       +
       	"testing/quick"

     

       7
       7
       +
       )

     

       8
       8
       +
       

     

       9
       9
       +
       func (_ Set[T]) Generate(rand *rand.Rand, size int) reflect.Value {

     

       10
       10
       +
       	s := New[T]()

     

       11
       11
       +
       

     

       12
       12
       +
       	var zero T

     

       13
       13
       +
       	itemType := reflect.TypeOf(zero)

     

       14
       14
       +
       

     

       15
       15
       +
       	for {

     

       16
       16
       +
       		if s.Len() >= size {

     

       17
       17
       +
       			break

     

       18
       18
       +
       		}

     

       19
       19
       +
       

     

       20
       20
       +
       		item, ok := quick.Value(itemType, rand)

     

       21
       21
       +
       		if !ok {

     

       22
       22
       +
       			continue

     

       23
       23
       +
       		}

     

       24
       24
       +
       

     

       25
       25
       +
       		if val, ok := item.Interface().(T); ok {

     

       26
       26
       +
       			s.Insert(val)

     

       27
       27
       +
       		}

     

       28
       28
       +
       	}

     

       29
       29
       +
       

     

       30
       30
       +
       	return reflect.ValueOf(s)

     

       31
       31
       +
       }

+35

sets/readme.txt

···

       1
       1
       +
       sets

     

       2
       2
       +
       ----

     

       3
       3
       +
       set datastructure for go with generics and iterators. the

     

       4
       4
       +
       api is supposed to mimic rust's std::collections::HashSet api.

     

       5
       5
       +
       

     

       6
       6
       +
           s1 := sets.Collect(slices.Values([]int{1, 2, 3, 4}))

     

       7
       7
       +
           s2 := sets.Collect(slices.Values([]int{1, 2, 3, 4, 5, 6}))

     

       8
       8
       +
       

     

       9
       9
       +
           union     := sets.Collect(s1.Union(s2))

     

       10
       10
       +
           intersect := sets.Collect(s1.Intersection(s2))

     

       11
       11
       +
           diff      := sets.Collect(s1.Difference(s2))

     

       12
       12
       +
           symdiff   := sets.Collect(s1.SymmetricDifference(s2))

     

       13
       13
       +
       

     

       14
       14
       +
           s1.Len()          // 4

     

       15
       15
       +
           s1.Contains(1)    // true

     

       16
       16
       +
           s1.IsEmpty()      // false

     

       17
       17
       +
           s1.IsSubset(s2)   // true

     

       18
       18
       +
           s1.IsSuperset(s2) // false

     

       19
       19
       +
           s1.IsDisjoint(s2) // false

     

       20
       20
       +
       

     

       21
       21
       +
           if exists := s1.Insert(1); exists {

     

       22
       22
       +
               // already existed in set

     

       23
       23
       +
           }

     

       24
       24
       +
       

     

       25
       25
       +
           if existed := s1.Remove(1); existed {

     

       26
       26
       +
               // existed in set, now removed

     

       27
       27
       +
           }

     

       28
       28
       +
       

     

       29
       29
       +
       

     

       30
       30
       +
       testing

     

       31
       31
       +
       -------

     

       32
       32
       +
       includes property-based tests using the wonderful

     

       33
       33
       +
       testing/quick module!

     

       34
       34
       +
       

     

       35
       35
       +
           go test -v

+174

sets/set.go

···

       1
       1
       +
       package sets

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"iter"

     

       5
       5
       +
       	"maps"

     

       6
       6
       +
       )

     

       7
       7
       +
       

     

       8
       8
       +
       type Set[T comparable] struct {

     

       9
       9
       +
       	data map[T]struct{}

     

       10
       10
       +
       }

     

       11
       11
       +
       

     

       12
       12
       +
       func New[T comparable]() Set[T] {

     

       13
       13
       +
       	return Set[T]{

     

       14
       14
       +
       		data: make(map[T]struct{}),

     

       15
       15
       +
       	}

     

       16
       16
       +
       }

     

       17
       17
       +
       

     

       18
       18
       +
       func (s *Set[T]) Insert(item T) bool {

     

       19
       19
       +
       	_, exists := s.data[item]

     

       20
       20
       +
       	s.data[item] = struct{}{}

     

       21
       21
       +
       	return !exists

     

       22
       22
       +
       }

     

       23
       23
       +
       

     

       24
       24
       +
       func Singleton[T comparable](item T) Set[T] {

     

       25
       25
       +
       	n := New[T]()

     

       26
       26
       +
       	_ = n.Insert(item)

     

       27
       27
       +
       	return n

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       func (s *Set[T]) Remove(item T) bool {

     

       31
       31
       +
       	_, exists := s.data[item]

     

       32
       32
       +
       	if exists {

     

       33
       33
       +
       		delete(s.data, item)

     

       34
       34
       +
       	}

     

       35
       35
       +
       	return exists

     

       36
       36
       +
       }

     

       37
       37
       +
       

     

       38
       38
       +
       func (s Set[T]) Contains(item T) bool {

     

       39
       39
       +
       	_, exists := s.data[item]

     

       40
       40
       +
       	return exists

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       func (s Set[T]) Len() int {

     

       44
       44
       +
       	return len(s.data)

     

       45
       45
       +
       }

     

       46
       46
       +
       

     

       47
       47
       +
       func (s Set[T]) IsEmpty() bool {

     

       48
       48
       +
       	return len(s.data) == 0

     

       49
       49
       +
       }

     

       50
       50
       +
       

     

       51
       51
       +
       func (s *Set[T]) Clear() {

     

       52
       52
       +
       	s.data = make(map[T]struct{})

     

       53
       53
       +
       }

     

       54
       54
       +
       

     

       55
       55
       +
       func (s Set[T]) All() iter.Seq[T] {

     

       56
       56
       +
       	return func(yield func(T) bool) {

     

       57
       57
       +
       		for item := range s.data {

     

       58
       58
       +
       			if !yield(item) {

     

       59
       59
       +
       				return

     

       60
       60
       +
       			}

     

       61
       61
       +
       		}

     

       62
       62
       +
       	}

     

       63
       63
       +
       }

     

       64
       64
       +
       

     

       65
       65
       +
       func (s Set[T]) Clone() Set[T] {

     

       66
       66
       +
       	return Set[T]{

     

       67
       67
       +
       		data: maps.Clone(s.data),

     

       68
       68
       +
       	}

     

       69
       69
       +
       }

     

       70
       70
       +
       

     

       71
       71
       +
       func (s Set[T]) Union(other Set[T]) iter.Seq[T] {

     

       72
       72
       +
       	if s.Len() >= other.Len() {

     

       73
       73
       +
       		return chain(s.All(), other.Difference(s))

     

       74
       74
       +
       	} else {

     

       75
       75
       +
       		return chain(other.All(), s.Difference(other))

     

       76
       76
       +
       	}

     

       77
       77
       +
       }

     

       78
       78
       +
       

     

       79
       79
       +
       func chain[T any](seqs ...iter.Seq[T]) iter.Seq[T] {

     

       80
       80
       +
       	return func(yield func(T) bool) {

     

       81
       81
       +
       		for _, seq := range seqs {

     

       82
       82
       +
       			for item := range seq {

     

       83
       83
       +
       				if !yield(item) {

     

       84
       84
       +
       					return

     

       85
       85
       +
       				}

     

       86
       86
       +
       			}

     

       87
       87
       +
       		}

     

       88
       88
       +
       	}

     

       89
       89
       +
       }

     

       90
       90
       +
       

     

       91
       91
       +
       func (s Set[T]) Intersection(other Set[T]) iter.Seq[T] {

     

       92
       92
       +
       	return func(yield func(T) bool) {

     

       93
       93
       +
       		for item := range s.data {

     

       94
       94
       +
       			if other.Contains(item) {

     

       95
       95
       +
       				if !yield(item) {

     

       96
       96
       +
       					return

     

       97
       97
       +
       				}

     

       98
       98
       +
       			}

     

       99
       99
       +
       		}

     

       100
       100
       +
       	}

     

       101
       101
       +
       }

     

       102
       102
       +
       

     

       103
       103
       +
       func (s Set[T]) Difference(other Set[T]) iter.Seq[T] {

     

       104
       104
       +
       	return func(yield func(T) bool) {

     

       105
       105
       +
       		for item := range s.data {

     

       106
       106
       +
       			if !other.Contains(item) {

     

       107
       107
       +
       				if !yield(item) {

     

       108
       108
       +
       					return

     

       109
       109
       +
       				}

     

       110
       110
       +
       			}

     

       111
       111
       +
       		}

     

       112
       112
       +
       	}

     

       113
       113
       +
       }

     

       114
       114
       +
       

     

       115
       115
       +
       func (s Set[T]) SymmetricDifference(other Set[T]) iter.Seq[T] {

     

       116
       116
       +
       	return func(yield func(T) bool) {

     

       117
       117
       +
       		for item := range s.data {

     

       118
       118
       +
       			if !other.Contains(item) {

     

       119
       119
       +
       				if !yield(item) {

     

       120
       120
       +
       					return

     

       121
       121
       +
       				}

     

       122
       122
       +
       			}

     

       123
       123
       +
       		}

     

       124
       124
       +
       		for item := range other.data {

     

       125
       125
       +
       			if !s.Contains(item) {

     

       126
       126
       +
       				if !yield(item) {

     

       127
       127
       +
       					return

     

       128
       128
       +
       				}

     

       129
       129
       +
       			}

     

       130
       130
       +
       		}

     

       131
       131
       +
       	}

     

       132
       132
       +
       }

     

       133
       133
       +
       

     

       134
       134
       +
       func (s Set[T]) IsSubset(other Set[T]) bool {

     

       135
       135
       +
       	for item := range s.data {

     

       136
       136
       +
       		if !other.Contains(item) {

     

       137
       137
       +
       			return false

     

       138
       138
       +
       		}

     

       139
       139
       +
       	}

     

       140
       140
       +
       	return true

     

       141
       141
       +
       }

     

       142
       142
       +
       

     

       143
       143
       +
       func (s Set[T]) IsSuperset(other Set[T]) bool {

     

       144
       144
       +
       	return other.IsSubset(s)

     

       145
       145
       +
       }

     

       146
       146
       +
       

     

       147
       147
       +
       func (s Set[T]) IsDisjoint(other Set[T]) bool {

     

       148
       148
       +
       	for item := range s.data {

     

       149
       149
       +
       		if other.Contains(item) {

     

       150
       150
       +
       			return false

     

       151
       151
       +
       		}

     

       152
       152
       +
       	}

     

       153
       153
       +
       	return true

     

       154
       154
       +
       }

     

       155
       155
       +
       

     

       156
       156
       +
       func (s Set[T]) Equal(other Set[T]) bool {

     

       157
       157
       +
       	if s.Len() != other.Len() {

     

       158
       158
       +
       		return false

     

       159
       159
       +
       	}

     

       160
       160
       +
       	for item := range s.data {

     

       161
       161
       +
       		if !other.Contains(item) {

     

       162
       162
       +
       			return false

     

       163
       163
       +
       		}

     

       164
       164
       +
       	}

     

       165
       165
       +
       	return true

     

       166
       166
       +
       }

     

       167
       167
       +
       

     

       168
       168
       +
       func Collect[T comparable](seq iter.Seq[T]) Set[T] {

     

       169
       169
       +
       	result := New[T]()

     

       170
       170
       +
       	for item := range seq {

     

       171
       171
       +
       		result.Insert(item)

     

       172
       172
       +
       	}

     

       173
       173
       +
       	return result

     

       174
       174
       +
       }

+411

sets/set_test.go

···

       1
       1
       +
       package sets

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"slices"

     

       5
       5
       +
       	"testing"

     

       6
       6
       +
       	"testing/quick"

     

       7
       7
       +
       )

     

       8
       8
       +
       

     

       9
       9
       +
       func TestNew(t *testing.T) {

     

       10
       10
       +
       	s := New[int]()

     

       11
       11
       +
       	if s.Len() != 0 {

     

       12
       12
       +
       		t.Errorf("New set should be empty, got length %d", s.Len())

     

       13
       13
       +
       	}

     

       14
       14
       +
       	if !s.IsEmpty() {

     

       15
       15
       +
       		t.Error("New set should be empty")

     

       16
       16
       +
       	}

     

       17
       17
       +
       }

     

       18
       18
       +
       

     

       19
       19
       +
       func TestFromSlice(t *testing.T) {

     

       20
       20
       +
       	s := Collect(slices.Values([]int{1, 2, 3, 2, 1}))

     

       21
       21
       +
       	if s.Len() != 3 {

     

       22
       22
       +
       		t.Errorf("Expected length 3, got %d", s.Len())

     

       23
       23
       +
       	}

     

       24
       24
       +
       	if !s.Contains(1) || !s.Contains(2) || !s.Contains(3) {

     

       25
       25
       +
       		t.Error("Set should contain all unique elements from slice")

     

       26
       26
       +
       	}

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       29
       29
       +
       func TestInsert(t *testing.T) {

     

       30
       30
       +
       	s := New[string]()

     

       31
       31
       +
       

     

       32
       32
       +
       	if !s.Insert("hello") {

     

       33
       33
       +
       		t.Error("First insert should return true")

     

       34
       34
       +
       	}

     

       35
       35
       +
       	if s.Insert("hello") {

     

       36
       36
       +
       		t.Error("Duplicate insert should return false")

     

       37
       37
       +
       	}

     

       38
       38
       +
       	if s.Len() != 1 {

     

       39
       39
       +
       		t.Errorf("Expected length 1, got %d", s.Len())

     

       40
       40
       +
       	}

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       func TestRemove(t *testing.T) {

     

       44
       44
       +
       	s := Collect(slices.Values([]int{1, 2, 3}))

     

       45
       45
       +
       

     

       46
       46
       +
       	if !s.Remove(2) {

     

       47
       47
       +
       		t.Error("Remove existing element should return true")

     

       48
       48
       +
       	}

     

       49
       49
       +
       	if s.Remove(2) {

     

       50
       50
       +
       		t.Error("Remove non-existing element should return false")

     

       51
       51
       +
       	}

     

       52
       52
       +
       	if s.Contains(2) {

     

       53
       53
       +
       		t.Error("Element should be removed")

     

       54
       54
       +
       	}

     

       55
       55
       +
       	if s.Len() != 2 {

     

       56
       56
       +
       		t.Errorf("Expected length 2, got %d", s.Len())

     

       57
       57
       +
       	}

     

       58
       58
       +
       }

     

       59
       59
       +
       

     

       60
       60
       +
       func TestContains(t *testing.T) {

     

       61
       61
       +
       	s := Collect(slices.Values([]int{1, 2, 3}))

     

       62
       62
       +
       

     

       63
       63
       +
       	if !s.Contains(1) {

     

       64
       64
       +
       		t.Error("Should contain 1")

     

       65
       65
       +
       	}

     

       66
       66
       +
       	if s.Contains(4) {

     

       67
       67
       +
       		t.Error("Should not contain 4")

     

       68
       68
       +
       	}

     

       69
       69
       +
       }

     

       70
       70
       +
       

     

       71
       71
       +
       func TestClear(t *testing.T) {

     

       72
       72
       +
       	s := Collect(slices.Values([]int{1, 2, 3}))

     

       73
       73
       +
       	s.Clear()

     

       74
       74
       +
       

     

       75
       75
       +
       	if !s.IsEmpty() {

     

       76
       76
       +
       		t.Error("Set should be empty after clear")

     

       77
       77
       +
       	}

     

       78
       78
       +
       	if s.Len() != 0 {

     

       79
       79
       +
       		t.Errorf("Expected length 0, got %d", s.Len())

     

       80
       80
       +
       	}

     

       81
       81
       +
       }

     

       82
       82
       +
       

     

       83
       83
       +
       func TestIterator(t *testing.T) {

     

       84
       84
       +
       	s := Collect(slices.Values([]int{1, 2, 3}))

     

       85
       85
       +
       	var items []int

     

       86
       86
       +
       

     

       87
       87
       +
       	for item := range s.All() {

     

       88
       88
       +
       		items = append(items, item)

     

       89
       89
       +
       	}

     

       90
       90
       +
       

     

       91
       91
       +
       	slices.Sort(items)

     

       92
       92
       +
       	expected := []int{1, 2, 3}

     

       93
       93
       +
       	if !slices.Equal(items, expected) {

     

       94
       94
       +
       		t.Errorf("Expected %v, got %v", expected, items)

     

       95
       95
       +
       	}

     

       96
       96
       +
       }

     

       97
       97
       +
       

     

       98
       98
       +
       func TestClone(t *testing.T) {

     

       99
       99
       +
       	s1 := Collect(slices.Values([]int{1, 2, 3}))

     

       100
       100
       +
       	s2 := s1.Clone()

     

       101
       101
       +
       

     

       102
       102
       +
       	if !s1.Equal(s2) {

     

       103
       103
       +
       		t.Error("Cloned set should be equal to original")

     

       104
       104
       +
       	}

     

       105
       105
       +
       

     

       106
       106
       +
       	s2.Insert(4)

     

       107
       107
       +
       	if s1.Contains(4) {

     

       108
       108
       +
       		t.Error("Modifying clone should not affect original")

     

       109
       109
       +
       	}

     

       110
       110
       +
       }

     

       111
       111
       +
       

     

       112
       112
       +
       func TestUnion(t *testing.T) {

     

       113
       113
       +
       	s1 := Collect(slices.Values([]int{1, 2}))

     

       114
       114
       +
       	s2 := Collect(slices.Values([]int{2, 3}))

     

       115
       115
       +
       

     

       116
       116
       +
       	result := Collect(s1.Union(s2))

     

       117
       117
       +
       	expected := Collect(slices.Values([]int{1, 2, 3}))

     

       118
       118
       +
       

     

       119
       119
       +
       	if !result.Equal(expected) {

     

       120
       120
       +
       		t.Errorf("Expected %v, got %v", expected, result)

     

       121
       121
       +
       	}

     

       122
       122
       +
       }

     

       123
       123
       +
       

     

       124
       124
       +
       func TestIntersection(t *testing.T) {

     

       125
       125
       +
       	s1 := Collect(slices.Values([]int{1, 2, 3}))

     

       126
       126
       +
       	s2 := Collect(slices.Values([]int{2, 3, 4}))

     

       127
       127
       +
       

     

       128
       128
       +
       	expected := Collect(slices.Values([]int{2, 3}))

     

       129
       129
       +
       	result := Collect(s1.Intersection(s2))

     

       130
       130
       +
       

     

       131
       131
       +
       	if !result.Equal(expected) {

     

       132
       132
       +
       		t.Errorf("Expected %v, got %v", expected, result)

     

       133
       133
       +
       	}

     

       134
       134
       +
       }

     

       135
       135
       +
       

     

       136
       136
       +
       func TestDifference(t *testing.T) {

     

       137
       137
       +
       	s1 := Collect(slices.Values([]int{1, 2, 3}))

     

       138
       138
       +
       	s2 := Collect(slices.Values([]int{2, 3, 4}))

     

       139
       139
       +
       

     

       140
       140
       +
       	expected := Collect(slices.Values([]int{1}))

     

       141
       141
       +
       	result := Collect(s1.Difference(s2))

     

       142
       142
       +
       

     

       143
       143
       +
       	if !result.Equal(expected) {

     

       144
       144
       +
       		t.Errorf("Expected %v, got %v", expected, result)

     

       145
       145
       +
       	}

     

       146
       146
       +
       }

     

       147
       147
       +
       

     

       148
       148
       +
       func TestSymmetricDifference(t *testing.T) {

     

       149
       149
       +
       	s1 := Collect(slices.Values([]int{1, 2, 3}))

     

       150
       150
       +
       	s2 := Collect(slices.Values([]int{2, 3, 4}))

     

       151
       151
       +
       

     

       152
       152
       +
       	expected := Collect(slices.Values([]int{1, 4}))

     

       153
       153
       +
       	result := Collect(s1.SymmetricDifference(s2))

     

       154
       154
       +
       

     

       155
       155
       +
       	if !result.Equal(expected) {

     

       156
       156
       +
       		t.Errorf("Expected %v, got %v", expected, result)

     

       157
       157
       +
       	}

     

       158
       158
       +
       }

     

       159
       159
       +
       

     

       160
       160
       +
       func TestSymmetricDifferenceCommutativeProperty(t *testing.T) {

     

       161
       161
       +
       	s1 := Collect(slices.Values([]int{1, 2, 3}))

     

       162
       162
       +
       	s2 := Collect(slices.Values([]int{2, 3, 4}))

     

       163
       163
       +
       

     

       164
       164
       +
       	result1 := Collect(s1.SymmetricDifference(s2))

     

       165
       165
       +
       	result2 := Collect(s2.SymmetricDifference(s1))

     

       166
       166
       +
       

     

       167
       167
       +
       	if !result1.Equal(result2) {

     

       168
       168
       +
       		t.Errorf("Expected %v, got %v", result1, result2)

     

       169
       169
       +
       	}

     

       170
       170
       +
       }

     

       171
       171
       +
       

     

       172
       172
       +
       func TestIsSubset(t *testing.T) {

     

       173
       173
       +
       	s1 := Collect(slices.Values([]int{1, 2}))

     

       174
       174
       +
       	s2 := Collect(slices.Values([]int{1, 2, 3}))

     

       175
       175
       +
       

     

       176
       176
       +
       	if !s1.IsSubset(s2) {

     

       177
       177
       +
       		t.Error("s1 should be subset of s2")

     

       178
       178
       +
       	}

     

       179
       179
       +
       	if s2.IsSubset(s1) {

     

       180
       180
       +
       		t.Error("s2 should not be subset of s1")

     

       181
       181
       +
       	}

     

       182
       182
       +
       }

     

       183
       183
       +
       

     

       184
       184
       +
       func TestIsSuperset(t *testing.T) {

     

       185
       185
       +
       	s1 := Collect(slices.Values([]int{1, 2, 3}))

     

       186
       186
       +
       	s2 := Collect(slices.Values([]int{1, 2}))

     

       187
       187
       +
       

     

       188
       188
       +
       	if !s1.IsSuperset(s2) {

     

       189
       189
       +
       		t.Error("s1 should be superset of s2")

     

       190
       190
       +
       	}

     

       191
       191
       +
       	if s2.IsSuperset(s1) {

     

       192
       192
       +
       		t.Error("s2 should not be superset of s1")

     

       193
       193
       +
       	}

     

       194
       194
       +
       }

     

       195
       195
       +
       

     

       196
       196
       +
       func TestIsDisjoint(t *testing.T) {

     

       197
       197
       +
       	s1 := Collect(slices.Values([]int{1, 2}))

     

       198
       198
       +
       	s2 := Collect(slices.Values([]int{3, 4}))

     

       199
       199
       +
       	s3 := Collect(slices.Values([]int{2, 3}))

     

       200
       200
       +
       

     

       201
       201
       +
       	if !s1.IsDisjoint(s2) {

     

       202
       202
       +
       		t.Error("s1 and s2 should be disjoint")

     

       203
       203
       +
       	}

     

       204
       204
       +
       	if s1.IsDisjoint(s3) {

     

       205
       205
       +
       		t.Error("s1 and s3 should not be disjoint")

     

       206
       206
       +
       	}

     

       207
       207
       +
       }

     

       208
       208
       +
       

     

       209
       209
       +
       func TestEqual(t *testing.T) {

     

       210
       210
       +
       	s1 := Collect(slices.Values([]int{1, 2, 3}))

     

       211
       211
       +
       	s2 := Collect(slices.Values([]int{3, 2, 1}))

     

       212
       212
       +
       	s3 := Collect(slices.Values([]int{1, 2}))

     

       213
       213
       +
       

     

       214
       214
       +
       	if !s1.Equal(s2) {

     

       215
       215
       +
       		t.Error("s1 and s2 should be equal")

     

       216
       216
       +
       	}

     

       217
       217
       +
       	if s1.Equal(s3) {

     

       218
       218
       +
       		t.Error("s1 and s3 should not be equal")

     

       219
       219
       +
       	}

     

       220
       220
       +
       }

     

       221
       221
       +
       

     

       222
       222
       +
       func TestCollect(t *testing.T) {

     

       223
       223
       +
       	s1 := Collect(slices.Values([]int{1, 2}))

     

       224
       224
       +
       	s2 := Collect(slices.Values([]int{2, 3}))

     

       225
       225
       +
       

     

       226
       226
       +
       	unionSet := Collect(s1.Union(s2))

     

       227
       227
       +
       	if unionSet.Len() != 3 {

     

       228
       228
       +
       		t.Errorf("Expected union set length 3, got %d", unionSet.Len())

     

       229
       229
       +
       	}

     

       230
       230
       +
       	if !unionSet.Contains(1) || !unionSet.Contains(2) || !unionSet.Contains(3) {

     

       231
       231
       +
       		t.Error("Union set should contain 1, 2, and 3")

     

       232
       232
       +
       	}

     

       233
       233
       +
       

     

       234
       234
       +
       	diffSet := Collect(s1.Difference(s2))

     

       235
       235
       +
       	if diffSet.Len() != 1 {

     

       236
       236
       +
       		t.Errorf("Expected difference set length 1, got %d", diffSet.Len())

     

       237
       237
       +
       	}

     

       238
       238
       +
       	if !diffSet.Contains(1) {

     

       239
       239
       +
       		t.Error("Difference set should contain 1")

     

       240
       240
       +
       	}

     

       241
       241
       +
       }

     

       242
       242
       +
       

     

       243
       243
       +
       func TestPropertySingleonLen(t *testing.T) {

     

       244
       244
       +
       	f := func(item int) bool {

     

       245
       245
       +
       		single := Singleton(item)

     

       246
       246
       +
       		return single.Len() == 1

     

       247
       247
       +
       	}

     

       248
       248
       +
       

     

       249
       249
       +
       	if err := quick.Check(f, nil); err != nil {

     

       250
       250
       +
       		t.Error(err)

     

       251
       251
       +
       	}

     

       252
       252
       +
       }

     

       253
       253
       +
       

     

       254
       254
       +
       func TestPropertyInsertIdempotent(t *testing.T) {

     

       255
       255
       +
       	f := func(s Set[int], item int) bool {

     

       256
       256
       +
       		clone := s.Clone()

     

       257
       257
       +
       

     

       258
       258
       +
       		clone.Insert(item)

     

       259
       259
       +
       		firstLen := clone.Len()

     

       260
       260
       +
       

     

       261
       261
       +
       		clone.Insert(item)

     

       262
       262
       +
       		secondLen := clone.Len()

     

       263
       263
       +
       

     

       264
       264
       +
       		return firstLen == secondLen

     

       265
       265
       +
       	}

     

       266
       266
       +
       

     

       267
       267
       +
       	if err := quick.Check(f, nil); err != nil {

     

       268
       268
       +
       		t.Error(err)

     

       269
       269
       +
       	}

     

       270
       270
       +
       }

     

       271
       271
       +
       

     

       272
       272
       +
       func TestPropertyUnionCommutative(t *testing.T) {

     

       273
       273
       +
       	f := func(s1 Set[int], s2 Set[int]) bool {

     

       274
       274
       +
       		union1 := Collect(s1.Union(s2))

     

       275
       275
       +
       		union2 := Collect(s2.Union(s1))

     

       276
       276
       +
       		return union1.Equal(union2)

     

       277
       277
       +
       	}

     

       278
       278
       +
       

     

       279
       279
       +
       	if err := quick.Check(f, nil); err != nil {

     

       280
       280
       +
       		t.Error(err)

     

       281
       281
       +
       	}

     

       282
       282
       +
       }

     

       283
       283
       +
       

     

       284
       284
       +
       func TestPropertyIntersectionCommutative(t *testing.T) {

     

       285
       285
       +
       	f := func(s1 Set[int], s2 Set[int]) bool {

     

       286
       286
       +
       		inter1 := Collect(s1.Intersection(s2))

     

       287
       287
       +
       		inter2 := Collect(s2.Intersection(s1))

     

       288
       288
       +
       		return inter1.Equal(inter2)

     

       289
       289
       +
       	}

     

       290
       290
       +
       

     

       291
       291
       +
       	if err := quick.Check(f, nil); err != nil {

     

       292
       292
       +
       		t.Error(err)

     

       293
       293
       +
       	}

     

       294
       294
       +
       }

     

       295
       295
       +
       

     

       296
       296
       +
       func TestPropertyCloneEquals(t *testing.T) {

     

       297
       297
       +
       	f := func(s Set[int]) bool {

     

       298
       298
       +
       		clone := s.Clone()

     

       299
       299
       +
       		return s.Equal(clone)

     

       300
       300
       +
       	}

     

       301
       301
       +
       

     

       302
       302
       +
       	if err := quick.Check(f, nil); err != nil {

     

       303
       303
       +
       		t.Error(err)

     

       304
       304
       +
       	}

     

       305
       305
       +
       }

     

       306
       306
       +
       

     

       307
       307
       +
       func TestPropertyIntersectionIsSubset(t *testing.T) {

     

       308
       308
       +
       	f := func(s1 Set[int], s2 Set[int]) bool {

     

       309
       309
       +
       		inter := Collect(s1.Intersection(s2))

     

       310
       310
       +
       		return inter.IsSubset(s1) && inter.IsSubset(s2)

     

       311
       311
       +
       	}

     

       312
       312
       +
       

     

       313
       313
       +
       	if err := quick.Check(f, nil); err != nil {

     

       314
       314
       +
       		t.Error(err)

     

       315
       315
       +
       	}

     

       316
       316
       +
       }

     

       317
       317
       +
       

     

       318
       318
       +
       func TestPropertyUnionIsSuperset(t *testing.T) {

     

       319
       319
       +
       	f := func(s1 Set[int], s2 Set[int]) bool {

     

       320
       320
       +
       		union := Collect(s1.Union(s2))

     

       321
       321
       +
       		return union.IsSuperset(s1) && union.IsSuperset(s2)

     

       322
       322
       +
       	}

     

       323
       323
       +
       

     

       324
       324
       +
       	if err := quick.Check(f, nil); err != nil {

     

       325
       325
       +
       		t.Error(err)

     

       326
       326
       +
       	}

     

       327
       327
       +
       }

     

       328
       328
       +
       

     

       329
       329
       +
       func TestPropertyDifferenceDisjoint(t *testing.T) {

     

       330
       330
       +
       	f := func(s1 Set[int], s2 Set[int]) bool {

     

       331
       331
       +
       		diff := Collect(s1.Difference(s2))

     

       332
       332
       +
       		return diff.IsDisjoint(s2)

     

       333
       333
       +
       	}

     

       334
       334
       +
       

     

       335
       335
       +
       	if err := quick.Check(f, nil); err != nil {

     

       336
       336
       +
       		t.Error(err)

     

       337
       337
       +
       	}

     

       338
       338
       +
       }

     

       339
       339
       +
       

     

       340
       340
       +
       func TestPropertySymmetricDifferenceCommutative(t *testing.T) {

     

       341
       341
       +
       	f := func(s1 Set[int], s2 Set[int]) bool {

     

       342
       342
       +
       		symDiff1 := Collect(s1.SymmetricDifference(s2))

     

       343
       343
       +
       		symDiff2 := Collect(s2.SymmetricDifference(s1))

     

       344
       344
       +
       		return symDiff1.Equal(symDiff2)

     

       345
       345
       +
       	}

     

       346
       346
       +
       

     

       347
       347
       +
       	if err := quick.Check(f, nil); err != nil {

     

       348
       348
       +
       		t.Error(err)

     

       349
       349
       +
       	}

     

       350
       350
       +
       }

     

       351
       351
       +
       

     

       352
       352
       +
       func TestPropertyRemoveWorks(t *testing.T) {

     

       353
       353
       +
       	f := func(s Set[int], item int) bool {

     

       354
       354
       +
       		clone := s.Clone()

     

       355
       355
       +
       		clone.Insert(item)

     

       356
       356
       +
       		clone.Remove(item)

     

       357
       357
       +
       		return !clone.Contains(item)

     

       358
       358
       +
       	}

     

       359
       359
       +
       

     

       360
       360
       +
       	if err := quick.Check(f, nil); err != nil {

     

       361
       361
       +
       		t.Error(err)

     

       362
       362
       +
       	}

     

       363
       363
       +
       }

     

       364
       364
       +
       

     

       365
       365
       +
       func TestPropertyClearEmpty(t *testing.T) {

     

       366
       366
       +
       	f := func(s Set[int]) bool {

     

       367
       367
       +
       		s.Clear()

     

       368
       368
       +
       		return s.IsEmpty() && s.Len() == 0

     

       369
       369
       +
       	}

     

       370
       370
       +
       

     

       371
       371
       +
       	if err := quick.Check(f, nil); err != nil {

     

       372
       372
       +
       		t.Error(err)

     

       373
       373
       +
       	}

     

       374
       374
       +
       }

     

       375
       375
       +
       

     

       376
       376
       +
       func TestPropertyIsSubsetReflexive(t *testing.T) {

     

       377
       377
       +
       	f := func(s Set[int]) bool {

     

       378
       378
       +
       		return s.IsSubset(s)

     

       379
       379
       +
       	}

     

       380
       380
       +
       

     

       381
       381
       +
       	if err := quick.Check(f, nil); err != nil {

     

       382
       382
       +
       		t.Error(err)

     

       383
       383
       +
       	}

     

       384
       384
       +
       }

     

       385
       385
       +
       

     

       386
       386
       +
       func TestPropertyDeMorganUnion(t *testing.T) {

     

       387
       387
       +
       	f := func(s1 Set[int], s2 Set[int], universe Set[int]) bool {

     

       388
       388
       +
       		// create a universe that contains both sets

     

       389
       389
       +
       		u := universe.Clone()

     

       390
       390
       +
       		for item := range s1.All() {

     

       391
       391
       +
       			u.Insert(item)

     

       392
       392
       +
       		}

     

       393
       393
       +
       		for item := range s2.All() {

     

       394
       394
       +
       			u.Insert(item)

     

       395
       395
       +
       		}

     

       396
       396
       +
       

     

       397
       397
       +
       		// (A u B)' = A' n B'

     

       398
       398
       +
       		union := Collect(s1.Union(s2))

     

       399
       399
       +
       		complementUnion := Collect(u.Difference(union))

     

       400
       400
       +
       

     

       401
       401
       +
       		complementS1 := Collect(u.Difference(s1))

     

       402
       402
       +
       		complementS2 := Collect(u.Difference(s2))

     

       403
       403
       +
       		intersectionComplements := Collect(complementS1.Intersection(complementS2))

     

       404
       404
       +
       

     

       405
       405
       +
       		return complementUnion.Equal(intersectionComplements)

     

       406
       406
       +
       	}

     

       407
       407
       +
       

     

       408
       408
       +
       	if err := quick.Check(f, nil); err != nil {

     

       409
       409
       +
       		t.Error(err)

     

       410
       410
       +
       	}

     

       411
       411
       +
       }

+1 -1

spindle/config/config.go

···

       13
       13
        
       	DBPath            string  `env:"DB_PATH, default=spindle.db"`

     

       14
       14
        
       	Hostname          string  `env:"HOSTNAME, required"`

     

       15
       15
        
       	JetstreamEndpoint string  `env:"JETSTREAM_ENDPOINT, default=wss://jetstream1.us-west.bsky.network/subscribe"`

     

       16
       16
       -
       	PlcUrl            string  `env:"PLC_URL, default=plc.directory"`

     

       16
       16
       +
       	PlcUrl            string  `env:"PLC_URL, default=https://plc.directory"`

     

       17
       17
        
       	Dev               bool    `env:"DEV, default=false"`

     

       18
       18
        
       	Owner             string  `env:"OWNER, required"`

     

       19
       19
        
       	Secrets           Secrets `env:",prefix=SECRETS_"`

+10 -9

spindle/engines/nixery/engine.go

···

       73
       73
        
       type addlFields struct {

     

       74
       74
        
       	image     string

     

       75
       75
        
       	container string

     

       76
       76
       -
       	env       map[string]string

     

       77
       76
        
       }

     

       78
       77
        
       

     

       79
       78
        
       func (e *Engine) InitWorkflow(twf tangled.Pipeline_Workflow, tpl tangled.Pipeline) (*models.Workflow, error) {

     
···

       103
       102
        
       		swf.Steps = append(swf.Steps, sstep)

     

       104
       103
        
       	}

     

       105
       104
        
       	swf.Name = twf.Name

     

       106
       106
       -
       	addl.env = dwf.Environment

     

       105
       105
       +
       	swf.Environment = dwf.Environment

     

       107
       106
        
       	addl.image = workflowImage(dwf.Dependencies, e.cfg.NixeryPipelines.Nixery)

     

       108
       107
        
       

     

       109
       108
        
       	setup := &setupSteps{}

     

       110
       109
        
       

     

       111
       110
        
       	setup.addStep(nixConfStep())

     

       112
       112
       -
       	setup.addStep(cloneStep(twf, *tpl.TriggerMetadata, e.cfg.Server.Dev))

     

       111
       111
       +
       	setup.addStep(models.BuildCloneStep(twf, *tpl.TriggerMetadata, e.cfg.Server.Dev))

     

       113
       112
        
       	// this step could be empty

     

       114
       113
        
       	if s := dependencyStep(dwf.Dependencies); s != nil {

     

       115
       114
        
       		setup.addStep(*s)

     
···

       288
       287
        
       

     

       289
       288
        
       func (e *Engine) RunStep(ctx context.Context, wid models.WorkflowId, w *models.Workflow, idx int, secrets []secrets.UnlockedSecret, wfLogger *models.WorkflowLogger) error {

     

       290
       289
        
       	addl := w.Data.(addlFields)

     

       291
       291
       -
       	workflowEnvs := ConstructEnvs(addl.env)

     

       290
       290
       +
       	workflowEnvs := ConstructEnvs(w.Environment)

     

       292
       291
        
       	// TODO(winter): should SetupWorkflow also have secret access?

     

       293
       292
        
       	// IMO yes, but probably worth thinking on.

     

       294
       293
        
       	for _, s := range secrets {

     

       295
       294
        
       		workflowEnvs.AddEnv(s.Key, s.Value)

     

       296
       295
        
       	}

     

       297
       296
        
       

     

       298
       298
       -
       	step := w.Steps[idx].(Step)

     

       297
       297
       +
       	step := w.Steps[idx]

     

       299
       298
        
       

     

       300
       299
        
       	select {

     

       301
       300
        
       	case <-ctx.Done():

     
···

       304
       303
        
       	}

     

       305
       304
        
       

     

       306
       305
        
       	envs := append(EnvVars(nil), workflowEnvs...)

     

       307
       307
       -
       	for k, v := range step.environment {

     

       308
       308
       -
       		envs.AddEnv(k, v)

     

       306
       306
       +
       	if nixStep, ok := step.(Step); ok {

     

       307
       307
       +
       		for k, v := range nixStep.environment {

     

       308
       308
       +
       			envs.AddEnv(k, v)

     

       309
       309
       +
       		}

     

       309
       310
        
       	}

     

       310
       311
        
       	envs.AddEnv("HOME", homeDir)

     

       311
       312
        
       

     

       312
       313
        
       	mkExecResp, err := e.docker.ContainerExecCreate(ctx, addl.container, container.ExecOptions{

     

       313
       313
       -
       		Cmd:          []string{"bash", "-c", step.command},

     

       314
       314
       +
       		Cmd:          []string{"bash", "-c", step.Command()},

     

       314
       315
        
       		AttachStdout: true,

     

       315
       316
        
       		AttachStderr: true,

     

       316
       317
        
       		Env:          envs,

     
···

       333
       334
        
       		// Docker doesn't provide an API to kill an exec run

     

       334
       335
        
       		// (sure, we could grab the PID and kill it ourselves,

     

       335
       336
        
       		// but that's wasted effort)

     

       336
       336
       -
       		e.l.Warn("step timed out", "step", step.Name)

     

       337
       337
       +
       		e.l.Warn("step timed out", "step", step.Name())

     

       337
       338
        
       

     

       338
       339
        
       		<-tailDone

     

       339
       340

-73

spindle/engines/nixery/setup_steps.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"fmt"

     

       5
       5
       -
       	"path"

     

       6
       5
        
       	"strings"

     

       7
       7
       -
       

     

       8
       8
       -
       	"tangled.org/core/api/tangled"

     

       9
       9
       -
       	"tangled.org/core/workflow"

     

       10
       6
        
       )

     

       11
       7
        
       

     

       12
       8
        
       func nixConfStep() Step {

     
···

       17
       13
        
       		command: setupCmd,

     

       18
       14
        
       		name:    "Configure Nix",

     

       19
       15
        
       	}

     

       20
       20
       -
       }

     

       21
       21
       -
       

     

       22
       22
       -
       // cloneOptsAsSteps processes clone options and adds corresponding steps

     

       23
       23
       -
       // to the beginning of the workflow's step list if cloning is not skipped.

     

       24
       24
       -
       //

     

       25
       25
       -
       // the steps to do here are:

     

       26
       26
       -
       // - git init

     

       27
       27
       -
       // - git remote add origin <url>

     

       28
       28
       -
       // - git fetch --depth=<d> --recurse-submodules=<yes|no> <sha>

     

       29
       29
       -
       // - git checkout FETCH_HEAD

     

       30
       30
       -
       func cloneStep(twf tangled.Pipeline_Workflow, tr tangled.Pipeline_TriggerMetadata, dev bool) Step {

     

       31
       31
       -
       	if twf.Clone.Skip {

     

       32
       32
       -
       		return Step{}

     

       33
       33
       -
       	}

     

       34
       34
       -
       

     

       35
       35
       -
       	var commands []string

     

       36
       36
       -
       

     

       37
       37
       -
       	// initialize git repo in workspace

     

       38
       38
       -
       	commands = append(commands, "git init")

     

       39
       39
       -
       

     

       40
       40
       -
       	// add repo as git remote

     

       41
       41
       -
       	scheme := "https://"

     

       42
       42
       -
       	if dev {

     

       43
       43
       -
       		scheme = "http://"

     

       44
       44
       -
       		tr.Repo.Knot = strings.ReplaceAll(tr.Repo.Knot, "localhost", "host.docker.internal")

     

       45
       45
       -
       	}

     

       46
       46
       -
       	url := scheme + path.Join(tr.Repo.Knot, tr.Repo.Did, tr.Repo.Repo)

     

       47
       47
       -
       	commands = append(commands, fmt.Sprintf("git remote add origin %s", url))

     

       48
       48
       -
       

     

       49
       49
       -
       	// run git fetch

     

       50
       50
       -
       	{

     

       51
       51
       -
       		var fetchArgs []string

     

       52
       52
       -
       

     

       53
       53
       -
       		// default clone depth is 1

     

       54
       54
       -
       		depth := 1

     

       55
       55
       -
       		if twf.Clone.Depth > 1 {

     

       56
       56
       -
       			depth = int(twf.Clone.Depth)

     

       57
       57
       -
       		}

     

       58
       58
       -
       		fetchArgs = append(fetchArgs, fmt.Sprintf("--depth=%d", depth))

     

       59
       59
       -
       

     

       60
       60
       -
       		// optionally recurse submodules

     

       61
       61
       -
       		if twf.Clone.Submodules {

     

       62
       62
       -
       			fetchArgs = append(fetchArgs, "--recurse-submodules=yes")

     

       63
       63
       -
       		}

     

       64
       64
       -
       

     

       65
       65
       -
       		// set remote to fetch from

     

       66
       66
       -
       		fetchArgs = append(fetchArgs, "origin")

     

       67
       67
       -
       

     

       68
       68
       -
       		// set revision to checkout

     

       69
       69
       -
       		switch workflow.TriggerKind(tr.Kind) {

     

       70
       70
       -
       		case workflow.TriggerKindManual:

     

       71
       71
       -
       			// TODO: unimplemented

     

       72
       72
       -
       		case workflow.TriggerKindPush:

     

       73
       73
       -
       			fetchArgs = append(fetchArgs, tr.Push.NewSha)

     

       74
       74
       -
       		case workflow.TriggerKindPullRequest:

     

       75
       75
       -
       			fetchArgs = append(fetchArgs, tr.PullRequest.SourceSha)

     

       76
       76
       -
       		}

     

       77
       77
       -
       

     

       78
       78
       -
       		commands = append(commands, fmt.Sprintf("git fetch %s", strings.Join(fetchArgs, " ")))

     

       79
       79
       -
       	}

     

       80
       80
       -
       

     

       81
       81
       -
       	// run git checkout

     

       82
       82
       -
       	commands = append(commands, "git checkout FETCH_HEAD")

     

       83
       83
       -
       

     

       84
       84
       -
       	cloneStep := Step{

     

       85
       85
       -
       		command: strings.Join(commands, "\n"),

     

       86
       86
       -
       		name:    "Clone repository into workspace",

     

       87
       87
       -
       	}

     

       88
       88
       -
       	return cloneStep

     

       89
       16
        
       }

     

       90
       17
        
       

     

       91
       18
        
       // dependencyStep processes dependencies defined in the workflow.

+150

spindle/models/clone.go

···

       1
       1
       +
       package models

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"fmt"

     

       5
       5
       +
       	"strings"

     

       6
       6
       +
       

     

       7
       7
       +
       	"tangled.org/core/api/tangled"

     

       8
       8
       +
       	"tangled.org/core/workflow"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       type CloneStep struct {

     

       12
       12
       +
       	name     string

     

       13
       13
       +
       	kind     StepKind

     

       14
       14
       +
       	commands []string

     

       15
       15
       +
       }

     

       16
       16
       +
       

     

       17
       17
       +
       func (s CloneStep) Name() string {

     

       18
       18
       +
       	return s.name

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       func (s CloneStep) Commands() []string {

     

       22
       22
       +
       	return s.commands

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       func (s CloneStep) Command() string {

     

       26
       26
       +
       	return strings.Join(s.commands, "\n")

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       29
       29
       +
       func (s CloneStep) Kind() StepKind {

     

       30
       30
       +
       	return s.kind

     

       31
       31
       +
       }

     

       32
       32
       +
       

     

       33
       33
       +
       // BuildCloneStep generates git clone commands.

     

       34
       34
       +
       // The caller must ensure the current working directory is set to the desired

     

       35
       35
       +
       // workspace directory before executing these commands.

     

       36
       36
       +
       //

     

       37
       37
       +
       // The generated commands are:

     

       38
       38
       +
       // - git init

     

       39
       39
       +
       // - git remote add origin <url>

     

       40
       40
       +
       // - git fetch --depth=<d> --recurse-submodules=<yes|no> <sha>

     

       41
       41
       +
       // - git checkout FETCH_HEAD

     

       42
       42
       +
       //

     

       43
       43
       +
       // Supports all trigger types (push, PR, manual) and clone options.

     

       44
       44
       +
       func BuildCloneStep(twf tangled.Pipeline_Workflow, tr tangled.Pipeline_TriggerMetadata, dev bool) CloneStep {

     

       45
       45
       +
       	if twf.Clone != nil && twf.Clone.Skip {

     

       46
       46
       +
       		return CloneStep{}

     

       47
       47
       +
       	}

     

       48
       48
       +
       

     

       49
       49
       +
       	commitSHA, err := extractCommitSHA(tr)

     

       50
       50
       +
       	if err != nil {

     

       51
       51
       +
       		return CloneStep{

     

       52
       52
       +
       			kind:     StepKindSystem,

     

       53
       53
       +
       			name:     "Clone repository into workspace (error)",

     

       54
       54
       +
       			commands: []string{fmt.Sprintf("echo 'Failed to get clone info: %s' && exit 1", err.Error())},

     

       55
       55
       +
       		}

     

       56
       56
       +
       	}

     

       57
       57
       +
       

     

       58
       58
       +
       	repoURL := BuildRepoURL(tr.Repo, dev)

     

       59
       59
       +
       

     

       60
       60
       +
       	var cloneOpts tangled.Pipeline_CloneOpts

     

       61
       61
       +
       	if twf.Clone != nil {

     

       62
       62
       +
       		cloneOpts = *twf.Clone

     

       63
       63
       +
       	}

     

       64
       64
       +
       	fetchArgs := buildFetchArgs(cloneOpts, commitSHA)

     

       65
       65
       +
       

     

       66
       66
       +
       	return CloneStep{

     

       67
       67
       +
       		kind: StepKindSystem,

     

       68
       68
       +
       		name: "Clone repository into workspace",

     

       69
       69
       +
       		commands: []string{

     

       70
       70
       +
       			"git init",

     

       71
       71
       +
       			fmt.Sprintf("git remote add origin %s", repoURL),

     

       72
       72
       +
       			fmt.Sprintf("git fetch %s", strings.Join(fetchArgs, " ")),

     

       73
       73
       +
       			"git checkout FETCH_HEAD",

     

       74
       74
       +
       		},

     

       75
       75
       +
       	}

     

       76
       76
       +
       }

     

       77
       77
       +
       

     

       78
       78
       +
       // extractCommitSHA extracts the commit SHA from trigger metadata based on trigger type

     

       79
       79
       +
       func extractCommitSHA(tr tangled.Pipeline_TriggerMetadata) (string, error) {

     

       80
       80
       +
       	switch workflow.TriggerKind(tr.Kind) {

     

       81
       81
       +
       	case workflow.TriggerKindPush:

     

       82
       82
       +
       		if tr.Push == nil {

     

       83
       83
       +
       			return "", fmt.Errorf("push trigger metadata is nil")

     

       84
       84
       +
       		}

     

       85
       85
       +
       		return tr.Push.NewSha, nil

     

       86
       86
       +
       

     

       87
       87
       +
       	case workflow.TriggerKindPullRequest:

     

       88
       88
       +
       		if tr.PullRequest == nil {

     

       89
       89
       +
       			return "", fmt.Errorf("pull request trigger metadata is nil")

     

       90
       90
       +
       		}

     

       91
       91
       +
       		return tr.PullRequest.SourceSha, nil

     

       92
       92
       +
       

     

       93
       93
       +
       	case workflow.TriggerKindManual:

     

       94
       94
       +
       		// Manual triggers don't have an explicit SHA in the metadata

     

       95
       95
       +
       		// For now, return empty string - could be enhanced to fetch from default branch

     

       96
       96
       +
       		// TODO: Implement manual trigger SHA resolution (fetch default branch HEAD)

     

       97
       97
       +
       		return "", nil

     

       98
       98
       +
       

     

       99
       99
       +
       	default:

     

       100
       100
       +
       		return "", fmt.Errorf("unknown trigger kind: %s", tr.Kind)

     

       101
       101
       +
       	}

     

       102
       102
       +
       }

     

       103
       103
       +
       

     

       104
       104
       +
       // BuildRepoURL constructs the repository URL from repo metadata.

     

       105
       105
       +
       func BuildRepoURL(repo *tangled.Pipeline_TriggerRepo, devMode bool) string {

     

       106
       106
       +
       	if repo == nil {

     

       107
       107
       +
       		return ""

     

       108
       108
       +
       	}

     

       109
       109
       +
       

     

       110
       110
       +
       	scheme := "https://"

     

       111
       111
       +
       	if devMode {

     

       112
       112
       +
       		scheme = "http://"

     

       113
       113
       +
       	}

     

       114
       114
       +
       

     

       115
       115
       +
       	// Get host from knot

     

       116
       116
       +
       	host := repo.Knot

     

       117
       117
       +
       

     

       118
       118
       +
       	// In dev mode, replace localhost with host.docker.internal for Docker networking

     

       119
       119
       +
       	if devMode && strings.Contains(host, "localhost") {

     

       120
       120
       +
       		host = strings.ReplaceAll(host, "localhost", "host.docker.internal")

     

       121
       121
       +
       	}

     

       122
       122
       +
       

     

       123
       123
       +
       	// Build URL: {scheme}{knot}/{did}/{repo}

     

       124
       124
       +
       	return fmt.Sprintf("%s%s/%s/%s", scheme, host, repo.Did, repo.Repo)

     

       125
       125
       +
       }

     

       126
       126
       +
       

     

       127
       127
       +
       // buildFetchArgs constructs the arguments for git fetch based on clone options

     

       128
       128
       +
       func buildFetchArgs(clone tangled.Pipeline_CloneOpts, sha string) []string {

     

       129
       129
       +
       	args := []string{}

     

       130
       130
       +
       

     

       131
       131
       +
       	// Set fetch depth (default to 1 for shallow clone)

     

       132
       132
       +
       	depth := clone.Depth

     

       133
       133
       +
       	if depth == 0 {

     

       134
       134
       +
       		depth = 1

     

       135
       135
       +
       	}

     

       136
       136
       +
       	args = append(args, fmt.Sprintf("--depth=%d", depth))

     

       137
       137
       +
       

     

       138
       138
       +
       	// Add submodules if requested

     

       139
       139
       +
       	if clone.Submodules {

     

       140
       140
       +
       		args = append(args, "--recurse-submodules=yes")

     

       141
       141
       +
       	}

     

       142
       142
       +
       

     

       143
       143
       +
       	// Add remote and SHA

     

       144
       144
       +
       	args = append(args, "origin")

     

       145
       145
       +
       	if sha != "" {

     

       146
       146
       +
       		args = append(args, sha)

     

       147
       147
       +
       	}

     

       148
       148
       +
       

     

       149
       149
       +
       	return args

     

       150
       150
       +
       }

+371

spindle/models/clone_test.go

···

       1
       1
       +
       package models

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"strings"

     

       5
       5
       +
       	"testing"

     

       6
       6
       +
       

     

       7
       7
       +
       	"tangled.org/core/api/tangled"

     

       8
       8
       +
       	"tangled.org/core/workflow"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       func TestBuildCloneStep_PushTrigger(t *testing.T) {

     

       12
       12
       +
       	twf := tangled.Pipeline_Workflow{

     

       13
       13
       +
       		Clone: &tangled.Pipeline_CloneOpts{

     

       14
       14
       +
       			Depth:      1,

     

       15
       15
       +
       			Submodules: false,

     

       16
       16
       +
       			Skip:       false,

     

       17
       17
       +
       		},

     

       18
       18
       +
       	}

     

       19
       19
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       20
       20
       +
       		Kind: string(workflow.TriggerKindPush),

     

       21
       21
       +
       		Push: &tangled.Pipeline_PushTriggerData{

     

       22
       22
       +
       			NewSha: "abc123",

     

       23
       23
       +
       			OldSha: "def456",

     

       24
       24
       +
       			Ref:    "refs/heads/main",

     

       25
       25
       +
       		},

     

       26
       26
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       27
       27
       +
       			Knot: "example.com",

     

       28
       28
       +
       			Did:  "did:plc:user123",

     

       29
       29
       +
       			Repo: "my-repo",

     

       30
       30
       +
       		},

     

       31
       31
       +
       	}

     

       32
       32
       +
       

     

       33
       33
       +
       	step := BuildCloneStep(twf, tr, false)

     

       34
       34
       +
       

     

       35
       35
       +
       	if step.Kind() != StepKindSystem {

     

       36
       36
       +
       		t.Errorf("Expected StepKindSystem, got %v", step.Kind())

     

       37
       37
       +
       	}

     

       38
       38
       +
       

     

       39
       39
       +
       	if step.Name() != "Clone repository into workspace" {

     

       40
       40
       +
       		t.Errorf("Expected 'Clone repository into workspace', got '%s'", step.Name())

     

       41
       41
       +
       	}

     

       42
       42
       +
       

     

       43
       43
       +
       	commands := step.Commands()

     

       44
       44
       +
       	if len(commands) != 4 {

     

       45
       45
       +
       		t.Errorf("Expected 4 commands, got %d", len(commands))

     

       46
       46
       +
       	}

     

       47
       47
       +
       

     

       48
       48
       +
       	// Verify commands contain expected git operations

     

       49
       49
       +
       	allCmds := strings.Join(commands, " ")

     

       50
       50
       +
       	if !strings.Contains(allCmds, "git init") {

     

       51
       51
       +
       		t.Error("Commands should contain 'git init'")

     

       52
       52
       +
       	}

     

       53
       53
       +
       	if !strings.Contains(allCmds, "git remote add origin") {

     

       54
       54
       +
       		t.Error("Commands should contain 'git remote add origin'")

     

       55
       55
       +
       	}

     

       56
       56
       +
       	if !strings.Contains(allCmds, "git fetch") {

     

       57
       57
       +
       		t.Error("Commands should contain 'git fetch'")

     

       58
       58
       +
       	}

     

       59
       59
       +
       	if !strings.Contains(allCmds, "abc123") {

     

       60
       60
       +
       		t.Error("Commands should contain commit SHA")

     

       61
       61
       +
       	}

     

       62
       62
       +
       	if !strings.Contains(allCmds, "git checkout FETCH_HEAD") {

     

       63
       63
       +
       		t.Error("Commands should contain 'git checkout FETCH_HEAD'")

     

       64
       64
       +
       	}

     

       65
       65
       +
       	if !strings.Contains(allCmds, "https://example.com/did:plc:user123/my-repo") {

     

       66
       66
       +
       		t.Error("Commands should contain expected repo URL")

     

       67
       67
       +
       	}

     

       68
       68
       +
       }

     

       69
       69
       +
       

     

       70
       70
       +
       func TestBuildCloneStep_PullRequestTrigger(t *testing.T) {

     

       71
       71
       +
       	twf := tangled.Pipeline_Workflow{

     

       72
       72
       +
       		Clone: &tangled.Pipeline_CloneOpts{

     

       73
       73
       +
       			Depth: 1,

     

       74
       74
       +
       			Skip:  false,

     

       75
       75
       +
       		},

     

       76
       76
       +
       	}

     

       77
       77
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       78
       78
       +
       		Kind: string(workflow.TriggerKindPullRequest),

     

       79
       79
       +
       		PullRequest: &tangled.Pipeline_PullRequestTriggerData{

     

       80
       80
       +
       			SourceSha:    "pr-sha-789",

     

       81
       81
       +
       			SourceBranch: "feature-branch",

     

       82
       82
       +
       			TargetBranch: "main",

     

       83
       83
       +
       			Action:       "opened",

     

       84
       84
       +
       		},

     

       85
       85
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       86
       86
       +
       			Knot: "example.com",

     

       87
       87
       +
       			Did:  "did:plc:user123",

     

       88
       88
       +
       			Repo: "my-repo",

     

       89
       89
       +
       		},

     

       90
       90
       +
       	}

     

       91
       91
       +
       

     

       92
       92
       +
       	step := BuildCloneStep(twf, tr, false)

     

       93
       93
       +
       

     

       94
       94
       +
       	allCmds := strings.Join(step.Commands(), " ")

     

       95
       95
       +
       	if !strings.Contains(allCmds, "pr-sha-789") {

     

       96
       96
       +
       		t.Error("Commands should contain PR commit SHA")

     

       97
       97
       +
       	}

     

       98
       98
       +
       }

     

       99
       99
       +
       

     

       100
       100
       +
       func TestBuildCloneStep_ManualTrigger(t *testing.T) {

     

       101
       101
       +
       	twf := tangled.Pipeline_Workflow{

     

       102
       102
       +
       		Clone: &tangled.Pipeline_CloneOpts{

     

       103
       103
       +
       			Depth: 1,

     

       104
       104
       +
       			Skip:  false,

     

       105
       105
       +
       		},

     

       106
       106
       +
       	}

     

       107
       107
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       108
       108
       +
       		Kind: string(workflow.TriggerKindManual),

     

       109
       109
       +
       		Manual: &tangled.Pipeline_ManualTriggerData{

     

       110
       110
       +
       			Inputs: nil,

     

       111
       111
       +
       		},

     

       112
       112
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       113
       113
       +
       			Knot: "example.com",

     

       114
       114
       +
       			Did:  "did:plc:user123",

     

       115
       115
       +
       			Repo: "my-repo",

     

       116
       116
       +
       		},

     

       117
       117
       +
       	}

     

       118
       118
       +
       

     

       119
       119
       +
       	step := BuildCloneStep(twf, tr, false)

     

       120
       120
       +
       

     

       121
       121
       +
       	// Manual triggers don't have a SHA yet (TODO), so git fetch won't include a SHA

     

       122
       122
       +
       	allCmds := strings.Join(step.Commands(), " ")

     

       123
       123
       +
       	// Should still have basic git commands

     

       124
       124
       +
       	if !strings.Contains(allCmds, "git init") {

     

       125
       125
       +
       		t.Error("Commands should contain 'git init'")

     

       126
       126
       +
       	}

     

       127
       127
       +
       	if !strings.Contains(allCmds, "git fetch") {

     

       128
       128
       +
       		t.Error("Commands should contain 'git fetch'")

     

       129
       129
       +
       	}

     

       130
       130
       +
       }

     

       131
       131
       +
       

     

       132
       132
       +
       func TestBuildCloneStep_SkipFlag(t *testing.T) {

     

       133
       133
       +
       	twf := tangled.Pipeline_Workflow{

     

       134
       134
       +
       		Clone: &tangled.Pipeline_CloneOpts{

     

       135
       135
       +
       			Skip: true,

     

       136
       136
       +
       		},

     

       137
       137
       +
       	}

     

       138
       138
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       139
       139
       +
       		Kind: string(workflow.TriggerKindPush),

     

       140
       140
       +
       		Push: &tangled.Pipeline_PushTriggerData{

     

       141
       141
       +
       			NewSha: "abc123",

     

       142
       142
       +
       		},

     

       143
       143
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       144
       144
       +
       			Knot: "example.com",

     

       145
       145
       +
       			Did:  "did:plc:user123",

     

       146
       146
       +
       			Repo: "my-repo",

     

       147
       147
       +
       		},

     

       148
       148
       +
       	}

     

       149
       149
       +
       

     

       150
       150
       +
       	step := BuildCloneStep(twf, tr, false)

     

       151
       151
       +
       

     

       152
       152
       +
       	// Empty step when skip is true

     

       153
       153
       +
       	if step.Name() != "" {

     

       154
       154
       +
       		t.Error("Expected empty step name when Skip is true")

     

       155
       155
       +
       	}

     

       156
       156
       +
       	if len(step.Commands()) != 0 {

     

       157
       157
       +
       		t.Errorf("Expected no commands when Skip is true, got %d commands", len(step.Commands()))

     

       158
       158
       +
       	}

     

       159
       159
       +
       }

     

       160
       160
       +
       

     

       161
       161
       +
       func TestBuildCloneStep_DevMode(t *testing.T) {

     

       162
       162
       +
       	twf := tangled.Pipeline_Workflow{

     

       163
       163
       +
       		Clone: &tangled.Pipeline_CloneOpts{

     

       164
       164
       +
       			Depth: 1,

     

       165
       165
       +
       			Skip:  false,

     

       166
       166
       +
       		},

     

       167
       167
       +
       	}

     

       168
       168
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       169
       169
       +
       		Kind: string(workflow.TriggerKindPush),

     

       170
       170
       +
       		Push: &tangled.Pipeline_PushTriggerData{

     

       171
       171
       +
       			NewSha: "abc123",

     

       172
       172
       +
       		},

     

       173
       173
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       174
       174
       +
       			Knot: "localhost:3000",

     

       175
       175
       +
       			Did:  "did:plc:user123",

     

       176
       176
       +
       			Repo: "my-repo",

     

       177
       177
       +
       		},

     

       178
       178
       +
       	}

     

       179
       179
       +
       

     

       180
       180
       +
       	step := BuildCloneStep(twf, tr, true)

     

       181
       181
       +
       

     

       182
       182
       +
       	// In dev mode, should use http:// and replace localhost with host.docker.internal

     

       183
       183
       +
       	allCmds := strings.Join(step.Commands(), " ")

     

       184
       184
       +
       	expectedURL := "http://host.docker.internal:3000/did:plc:user123/my-repo"

     

       185
       185
       +
       	if !strings.Contains(allCmds, expectedURL) {

     

       186
       186
       +
       		t.Errorf("Expected dev mode URL '%s' in commands", expectedURL)

     

       187
       187
       +
       	}

     

       188
       188
       +
       }

     

       189
       189
       +
       

     

       190
       190
       +
       func TestBuildCloneStep_DepthAndSubmodules(t *testing.T) {

     

       191
       191
       +
       	twf := tangled.Pipeline_Workflow{

     

       192
       192
       +
       		Clone: &tangled.Pipeline_CloneOpts{

     

       193
       193
       +
       			Depth:      10,

     

       194
       194
       +
       			Submodules: true,

     

       195
       195
       +
       			Skip:       false,

     

       196
       196
       +
       		},

     

       197
       197
       +
       	}

     

       198
       198
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       199
       199
       +
       		Kind: string(workflow.TriggerKindPush),

     

       200
       200
       +
       		Push: &tangled.Pipeline_PushTriggerData{

     

       201
       201
       +
       			NewSha: "abc123",

     

       202
       202
       +
       		},

     

       203
       203
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       204
       204
       +
       			Knot: "example.com",

     

       205
       205
       +
       			Did:  "did:plc:user123",

     

       206
       206
       +
       			Repo: "my-repo",

     

       207
       207
       +
       		},

     

       208
       208
       +
       	}

     

       209
       209
       +
       

     

       210
       210
       +
       	step := BuildCloneStep(twf, tr, false)

     

       211
       211
       +
       

     

       212
       212
       +
       	allCmds := strings.Join(step.Commands(), " ")

     

       213
       213
       +
       	if !strings.Contains(allCmds, "--depth=10") {

     

       214
       214
       +
       		t.Error("Commands should contain '--depth=10'")

     

       215
       215
       +
       	}

     

       216
       216
       +
       

     

       217
       217
       +
       	if !strings.Contains(allCmds, "--recurse-submodules=yes") {

     

       218
       218
       +
       		t.Error("Commands should contain '--recurse-submodules=yes'")

     

       219
       219
       +
       	}

     

       220
       220
       +
       }

     

       221
       221
       +
       

     

       222
       222
       +
       func TestBuildCloneStep_DefaultDepth(t *testing.T) {

     

       223
       223
       +
       	twf := tangled.Pipeline_Workflow{

     

       224
       224
       +
       		Clone: &tangled.Pipeline_CloneOpts{

     

       225
       225
       +
       			Depth: 0, // Default should be 1

     

       226
       226
       +
       			Skip:  false,

     

       227
       227
       +
       		},

     

       228
       228
       +
       	}

     

       229
       229
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       230
       230
       +
       		Kind: string(workflow.TriggerKindPush),

     

       231
       231
       +
       		Push: &tangled.Pipeline_PushTriggerData{

     

       232
       232
       +
       			NewSha: "abc123",

     

       233
       233
       +
       		},

     

       234
       234
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       235
       235
       +
       			Knot: "example.com",

     

       236
       236
       +
       			Did:  "did:plc:user123",

     

       237
       237
       +
       			Repo: "my-repo",

     

       238
       238
       +
       		},

     

       239
       239
       +
       	}

     

       240
       240
       +
       

     

       241
       241
       +
       	step := BuildCloneStep(twf, tr, false)

     

       242
       242
       +
       

     

       243
       243
       +
       	allCmds := strings.Join(step.Commands(), " ")

     

       244
       244
       +
       	if !strings.Contains(allCmds, "--depth=1") {

     

       245
       245
       +
       		t.Error("Commands should default to '--depth=1'")

     

       246
       246
       +
       	}

     

       247
       247
       +
       }

     

       248
       248
       +
       

     

       249
       249
       +
       func TestBuildCloneStep_NilPushData(t *testing.T) {

     

       250
       250
       +
       	twf := tangled.Pipeline_Workflow{

     

       251
       251
       +
       		Clone: &tangled.Pipeline_CloneOpts{

     

       252
       252
       +
       			Depth: 1,

     

       253
       253
       +
       			Skip:  false,

     

       254
       254
       +
       		},

     

       255
       255
       +
       	}

     

       256
       256
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       257
       257
       +
       		Kind: string(workflow.TriggerKindPush),

     

       258
       258
       +
       		Push: nil, // Nil push data should create error step

     

       259
       259
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       260
       260
       +
       			Knot: "example.com",

     

       261
       261
       +
       			Did:  "did:plc:user123",

     

       262
       262
       +
       			Repo: "my-repo",

     

       263
       263
       +
       		},

     

       264
       264
       +
       	}

     

       265
       265
       +
       

     

       266
       266
       +
       	step := BuildCloneStep(twf, tr, false)

     

       267
       267
       +
       

     

       268
       268
       +
       	// Should return an error step

     

       269
       269
       +
       	if !strings.Contains(step.Name(), "error") {

     

       270
       270
       +
       		t.Error("Expected error in step name when push data is nil")

     

       271
       271
       +
       	}

     

       272
       272
       +
       

     

       273
       273
       +
       	allCmds := strings.Join(step.Commands(), " ")

     

       274
       274
       +
       	if !strings.Contains(allCmds, "Failed to get clone info") {

     

       275
       275
       +
       		t.Error("Commands should contain error message")

     

       276
       276
       +
       	}

     

       277
       277
       +
       	if !strings.Contains(allCmds, "exit 1") {

     

       278
       278
       +
       		t.Error("Commands should exit with error")

     

       279
       279
       +
       	}

     

       280
       280
       +
       }

     

       281
       281
       +
       

     

       282
       282
       +
       func TestBuildCloneStep_NilPRData(t *testing.T) {

     

       283
       283
       +
       	twf := tangled.Pipeline_Workflow{

     

       284
       284
       +
       		Clone: &tangled.Pipeline_CloneOpts{

     

       285
       285
       +
       			Depth: 1,

     

       286
       286
       +
       			Skip:  false,

     

       287
       287
       +
       		},

     

       288
       288
       +
       	}

     

       289
       289
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       290
       290
       +
       		Kind:        string(workflow.TriggerKindPullRequest),

     

       291
       291
       +
       		PullRequest: nil, // Nil PR data should create error step

     

       292
       292
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       293
       293
       +
       			Knot: "example.com",

     

       294
       294
       +
       			Did:  "did:plc:user123",

     

       295
       295
       +
       			Repo: "my-repo",

     

       296
       296
       +
       		},

     

       297
       297
       +
       	}

     

       298
       298
       +
       

     

       299
       299
       +
       	step := BuildCloneStep(twf, tr, false)

     

       300
       300
       +
       

     

       301
       301
       +
       	// Should return an error step

     

       302
       302
       +
       	if !strings.Contains(step.Name(), "error") {

     

       303
       303
       +
       		t.Error("Expected error in step name when pull request data is nil")

     

       304
       304
       +
       	}

     

       305
       305
       +
       

     

       306
       306
       +
       	allCmds := strings.Join(step.Commands(), " ")

     

       307
       307
       +
       	if !strings.Contains(allCmds, "Failed to get clone info") {

     

       308
       308
       +
       		t.Error("Commands should contain error message")

     

       309
       309
       +
       	}

     

       310
       310
       +
       }

     

       311
       311
       +
       

     

       312
       312
       +
       func TestBuildCloneStep_UnknownTriggerKind(t *testing.T) {

     

       313
       313
       +
       	twf := tangled.Pipeline_Workflow{

     

       314
       314
       +
       		Clone: &tangled.Pipeline_CloneOpts{

     

       315
       315
       +
       			Depth: 1,

     

       316
       316
       +
       			Skip:  false,

     

       317
       317
       +
       		},

     

       318
       318
       +
       	}

     

       319
       319
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       320
       320
       +
       		Kind: "unknown_trigger",

     

       321
       321
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       322
       322
       +
       			Knot: "example.com",

     

       323
       323
       +
       			Did:  "did:plc:user123",

     

       324
       324
       +
       			Repo: "my-repo",

     

       325
       325
       +
       		},

     

       326
       326
       +
       	}

     

       327
       327
       +
       

     

       328
       328
       +
       	step := BuildCloneStep(twf, tr, false)

     

       329
       329
       +
       

     

       330
       330
       +
       	// Should return an error step

     

       331
       331
       +
       	if !strings.Contains(step.Name(), "error") {

     

       332
       332
       +
       		t.Error("Expected error in step name for unknown trigger kind")

     

       333
       333
       +
       	}

     

       334
       334
       +
       

     

       335
       335
       +
       	allCmds := strings.Join(step.Commands(), " ")

     

       336
       336
       +
       	if !strings.Contains(allCmds, "unknown trigger kind") {

     

       337
       337
       +
       		t.Error("Commands should contain error message about unknown trigger kind")

     

       338
       338
       +
       	}

     

       339
       339
       +
       }

     

       340
       340
       +
       

     

       341
       341
       +
       func TestBuildCloneStep_NilCloneOpts(t *testing.T) {

     

       342
       342
       +
       	twf := tangled.Pipeline_Workflow{

     

       343
       343
       +
       		Clone: nil, // Nil clone options should use defaults

     

       344
       344
       +
       	}

     

       345
       345
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       346
       346
       +
       		Kind: string(workflow.TriggerKindPush),

     

       347
       347
       +
       		Push: &tangled.Pipeline_PushTriggerData{

     

       348
       348
       +
       			NewSha: "abc123",

     

       349
       349
       +
       		},

     

       350
       350
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       351
       351
       +
       			Knot: "example.com",

     

       352
       352
       +
       			Did:  "did:plc:user123",

     

       353
       353
       +
       			Repo: "my-repo",

     

       354
       354
       +
       		},

     

       355
       355
       +
       	}

     

       356
       356
       +
       

     

       357
       357
       +
       	step := BuildCloneStep(twf, tr, false)

     

       358
       358
       +
       

     

       359
       359
       +
       	// Should still work with default options

     

       360
       360
       +
       	if step.Kind() != StepKindSystem {

     

       361
       361
       +
       		t.Errorf("Expected StepKindSystem, got %v", step.Kind())

     

       362
       362
       +
       	}

     

       363
       363
       +
       

     

       364
       364
       +
       	allCmds := strings.Join(step.Commands(), " ")

     

       365
       365
       +
       	if !strings.Contains(allCmds, "--depth=1") {

     

       366
       366
       +
       		t.Error("Commands should default to '--depth=1' when Clone is nil")

     

       367
       367
       +
       	}

     

       368
       368
       +
       	if !strings.Contains(allCmds, "git init") {

     

       369
       369
       +
       		t.Error("Commands should contain 'git init'")

     

       370
       370
       +
       	}

     

       371
       371
       +
       }

+4 -3

spindle/models/pipeline.go

···

       22
       22
        
       )

     

       23
       23
        
       

     

       24
       24
        
       type Workflow struct {

     

       25
       25
       -
       	Steps []Step

     

       26
       26
       -
       	Name  string

     

       27
       27
       -
       	Data  any

     

       25
       25
       +
       	Steps       []Step

     

       26
       26
       +
       	Name        string

     

       27
       27
       +
       	Data        any

     

       28
       28
       +
       	Environment map[string]string

     

       28
       29
        
       }

+77

spindle/models/pipeline_env.go

···

       1
       1
       +
       package models

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"strings"

     

       5
       5
       +
       

     

       6
       6
       +
       	"github.com/go-git/go-git/v5/plumbing"

     

       7
       7
       +
       	"tangled.org/core/api/tangled"

     

       8
       8
       +
       	"tangled.org/core/workflow"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       // PipelineEnvVars extracts environment variables from pipeline trigger metadata.

     

       12
       12
       +
       // These are framework-provided variables that are injected into workflow steps.

     

       13
       13
       +
       func PipelineEnvVars(tr *tangled.Pipeline_TriggerMetadata, pipelineId PipelineId, devMode bool) map[string]string {

     

       14
       14
       +
       	if tr == nil {

     

       15
       15
       +
       		return nil

     

       16
       16
       +
       	}

     

       17
       17
       +
       

     

       18
       18
       +
       	env := make(map[string]string)

     

       19
       19
       +
       

     

       20
       20
       +
       	// Standard CI environment variable

     

       21
       21
       +
       	env["CI"] = "true"

     

       22
       22
       +
       

     

       23
       23
       +
       	env["TANGLED_PIPELINE_ID"] = pipelineId.Rkey

     

       24
       24
       +
       

     

       25
       25
       +
       	// Repo info

     

       26
       26
       +
       	if tr.Repo != nil {

     

       27
       27
       +
       		env["TANGLED_REPO_KNOT"] = tr.Repo.Knot

     

       28
       28
       +
       		env["TANGLED_REPO_DID"] = tr.Repo.Did

     

       29
       29
       +
       		env["TANGLED_REPO_NAME"] = tr.Repo.Repo

     

       30
       30
       +
       		env["TANGLED_REPO_DEFAULT_BRANCH"] = tr.Repo.DefaultBranch

     

       31
       31
       +
       		env["TANGLED_REPO_URL"] = BuildRepoURL(tr.Repo, devMode)

     

       32
       32
       +
       	}

     

       33
       33
       +
       

     

       34
       34
       +
       	switch workflow.TriggerKind(tr.Kind) {

     

       35
       35
       +
       	case workflow.TriggerKindPush:

     

       36
       36
       +
       		if tr.Push != nil {

     

       37
       37
       +
       			refName := plumbing.ReferenceName(tr.Push.Ref)

     

       38
       38
       +
       			refType := "branch"

     

       39
       39
       +
       			if refName.IsTag() {

     

       40
       40
       +
       				refType = "tag"

     

       41
       41
       +
       			}

     

       42
       42
       +
       

     

       43
       43
       +
       			env["TANGLED_REF"] = tr.Push.Ref

     

       44
       44
       +
       			env["TANGLED_REF_NAME"] = refName.Short()

     

       45
       45
       +
       			env["TANGLED_REF_TYPE"] = refType

     

       46
       46
       +
       			env["TANGLED_SHA"] = tr.Push.NewSha

     

       47
       47
       +
       			env["TANGLED_COMMIT_SHA"] = tr.Push.NewSha

     

       48
       48
       +
       		}

     

       49
       49
       +
       

     

       50
       50
       +
       	case workflow.TriggerKindPullRequest:

     

       51
       51
       +
       		if tr.PullRequest != nil {

     

       52
       52
       +
       			// For PRs, the "ref" is the source branch

     

       53
       53
       +
       			env["TANGLED_REF"] = "refs/heads/" + tr.PullRequest.SourceBranch

     

       54
       54
       +
       			env["TANGLED_REF_NAME"] = tr.PullRequest.SourceBranch

     

       55
       55
       +
       			env["TANGLED_REF_TYPE"] = "branch"

     

       56
       56
       +
       			env["TANGLED_SHA"] = tr.PullRequest.SourceSha

     

       57
       57
       +
       			env["TANGLED_COMMIT_SHA"] = tr.PullRequest.SourceSha

     

       58
       58
       +
       

     

       59
       59
       +
       			// PR-specific variables

     

       60
       60
       +
       			env["TANGLED_PR_SOURCE_BRANCH"] = tr.PullRequest.SourceBranch

     

       61
       61
       +
       			env["TANGLED_PR_TARGET_BRANCH"] = tr.PullRequest.TargetBranch

     

       62
       62
       +
       			env["TANGLED_PR_SOURCE_SHA"] = tr.PullRequest.SourceSha

     

       63
       63
       +
       			env["TANGLED_PR_ACTION"] = tr.PullRequest.Action

     

       64
       64
       +
       		}

     

       65
       65
       +
       

     

       66
       66
       +
       	case workflow.TriggerKindManual:

     

       67
       67
       +
       		// Manual triggers may not have ref/sha info

     

       68
       68
       +
       		// Include any manual inputs if present

     

       69
       69
       +
       		if tr.Manual != nil {

     

       70
       70
       +
       			for _, pair := range tr.Manual.Inputs {

     

       71
       71
       +
       				env["TANGLED_INPUT_"+strings.ToUpper(pair.Key)] = pair.Value

     

       72
       72
       +
       			}

     

       73
       73
       +
       		}

     

       74
       74
       +
       	}

     

       75
       75
       +
       

     

       76
       76
       +
       	return env

     

       77
       77
       +
       }

+260

spindle/models/pipeline_env_test.go

···

       1
       1
       +
       package models

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"testing"

     

       5
       5
       +
       

     

       6
       6
       +
       	"tangled.org/core/api/tangled"

     

       7
       7
       +
       	"tangled.org/core/workflow"

     

       8
       8
       +
       )

     

       9
       9
       +
       

     

       10
       10
       +
       func TestPipelineEnvVars_PushBranch(t *testing.T) {

     

       11
       11
       +
       	tr := &tangled.Pipeline_TriggerMetadata{

     

       12
       12
       +
       		Kind: string(workflow.TriggerKindPush),

     

       13
       13
       +
       		Push: &tangled.Pipeline_PushTriggerData{

     

       14
       14
       +
       			NewSha: "abc123def456",

     

       15
       15
       +
       			OldSha: "000000000000",

     

       16
       16
       +
       			Ref:    "refs/heads/main",

     

       17
       17
       +
       		},

     

       18
       18
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       19
       19
       +
       			Knot:          "example.com",

     

       20
       20
       +
       			Did:           "did:plc:user123",

     

       21
       21
       +
       			Repo:          "my-repo",

     

       22
       22
       +
       			DefaultBranch: "main",

     

       23
       23
       +
       		},

     

       24
       24
       +
       	}

     

       25
       25
       +
       	id := PipelineId{

     

       26
       26
       +
       		Knot: "example.com",

     

       27
       27
       +
       		Rkey: "123123",

     

       28
       28
       +
       	}

     

       29
       29
       +
       	env := PipelineEnvVars(tr, id, false)

     

       30
       30
       +
       

     

       31
       31
       +
       	// Check standard CI variable

     

       32
       32
       +
       	if env["CI"] != "true" {

     

       33
       33
       +
       		t.Errorf("Expected CI='true', got '%s'", env["CI"])

     

       34
       34
       +
       	}

     

       35
       35
       +
       

     

       36
       36
       +
       	// Check ref variables

     

       37
       37
       +
       	if env["TANGLED_REF"] != "refs/heads/main" {

     

       38
       38
       +
       		t.Errorf("Expected TANGLED_REF='refs/heads/main', got '%s'", env["TANGLED_REF"])

     

       39
       39
       +
       	}

     

       40
       40
       +
       	if env["TANGLED_REF_NAME"] != "main" {

     

       41
       41
       +
       		t.Errorf("Expected TANGLED_REF_NAME='main', got '%s'", env["TANGLED_REF_NAME"])

     

       42
       42
       +
       	}

     

       43
       43
       +
       	if env["TANGLED_REF_TYPE"] != "branch" {

     

       44
       44
       +
       		t.Errorf("Expected TANGLED_REF_TYPE='branch', got '%s'", env["TANGLED_REF_TYPE"])

     

       45
       45
       +
       	}

     

       46
       46
       +
       

     

       47
       47
       +
       	// Check SHA variables

     

       48
       48
       +
       	if env["TANGLED_SHA"] != "abc123def456" {

     

       49
       49
       +
       		t.Errorf("Expected TANGLED_SHA='abc123def456', got '%s'", env["TANGLED_SHA"])

     

       50
       50
       +
       	}

     

       51
       51
       +
       	if env["TANGLED_COMMIT_SHA"] != "abc123def456" {

     

       52
       52
       +
       		t.Errorf("Expected TANGLED_COMMIT_SHA='abc123def456', got '%s'", env["TANGLED_COMMIT_SHA"])

     

       53
       53
       +
       	}

     

       54
       54
       +
       

     

       55
       55
       +
       	// Check repo variables

     

       56
       56
       +
       	if env["TANGLED_REPO_KNOT"] != "example.com" {

     

       57
       57
       +
       		t.Errorf("Expected TANGLED_REPO_KNOT='example.com', got '%s'", env["TANGLED_REPO_KNOT"])

     

       58
       58
       +
       	}

     

       59
       59
       +
       	if env["TANGLED_REPO_DID"] != "did:plc:user123" {

     

       60
       60
       +
       		t.Errorf("Expected TANGLED_REPO_DID='did:plc:user123', got '%s'", env["TANGLED_REPO_DID"])

     

       61
       61
       +
       	}

     

       62
       62
       +
       	if env["TANGLED_REPO_NAME"] != "my-repo" {

     

       63
       63
       +
       		t.Errorf("Expected TANGLED_REPO_NAME='my-repo', got '%s'", env["TANGLED_REPO_NAME"])

     

       64
       64
       +
       	}

     

       65
       65
       +
       	if env["TANGLED_REPO_DEFAULT_BRANCH"] != "main" {

     

       66
       66
       +
       		t.Errorf("Expected TANGLED_REPO_DEFAULT_BRANCH='main', got '%s'", env["TANGLED_REPO_DEFAULT_BRANCH"])

     

       67
       67
       +
       	}

     

       68
       68
       +
       	if env["TANGLED_REPO_URL"] != "https://example.com/did:plc:user123/my-repo" {

     

       69
       69
       +
       		t.Errorf("Expected TANGLED_REPO_URL='https://example.com/did:plc:user123/my-repo', got '%s'", env["TANGLED_REPO_URL"])

     

       70
       70
       +
       	}

     

       71
       71
       +
       }

     

       72
       72
       +
       

     

       73
       73
       +
       func TestPipelineEnvVars_PushTag(t *testing.T) {

     

       74
       74
       +
       	tr := &tangled.Pipeline_TriggerMetadata{

     

       75
       75
       +
       		Kind: string(workflow.TriggerKindPush),

     

       76
       76
       +
       		Push: &tangled.Pipeline_PushTriggerData{

     

       77
       77
       +
       			NewSha: "abc123def456",

     

       78
       78
       +
       			OldSha: "000000000000",

     

       79
       79
       +
       			Ref:    "refs/tags/v1.2.3",

     

       80
       80
       +
       		},

     

       81
       81
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       82
       82
       +
       			Knot: "example.com",

     

       83
       83
       +
       			Did:  "did:plc:user123",

     

       84
       84
       +
       			Repo: "my-repo",

     

       85
       85
       +
       		},

     

       86
       86
       +
       	}

     

       87
       87
       +
       	id := PipelineId{

     

       88
       88
       +
       		Knot: "example.com",

     

       89
       89
       +
       		Rkey: "123123",

     

       90
       90
       +
       	}

     

       91
       91
       +
       	env := PipelineEnvVars(tr, id, false)

     

       92
       92
       +
       

     

       93
       93
       +
       	if env["TANGLED_REF"] != "refs/tags/v1.2.3" {

     

       94
       94
       +
       		t.Errorf("Expected TANGLED_REF='refs/tags/v1.2.3', got '%s'", env["TANGLED_REF"])

     

       95
       95
       +
       	}

     

       96
       96
       +
       	if env["TANGLED_REF_NAME"] != "v1.2.3" {

     

       97
       97
       +
       		t.Errorf("Expected TANGLED_REF_NAME='v1.2.3', got '%s'", env["TANGLED_REF_NAME"])

     

       98
       98
       +
       	}

     

       99
       99
       +
       	if env["TANGLED_REF_TYPE"] != "tag" {

     

       100
       100
       +
       		t.Errorf("Expected TANGLED_REF_TYPE='tag', got '%s'", env["TANGLED_REF_TYPE"])

     

       101
       101
       +
       	}

     

       102
       102
       +
       }

     

       103
       103
       +
       

     

       104
       104
       +
       func TestPipelineEnvVars_PullRequest(t *testing.T) {

     

       105
       105
       +
       	tr := &tangled.Pipeline_TriggerMetadata{

     

       106
       106
       +
       		Kind: string(workflow.TriggerKindPullRequest),

     

       107
       107
       +
       		PullRequest: &tangled.Pipeline_PullRequestTriggerData{

     

       108
       108
       +
       			SourceBranch: "feature-branch",

     

       109
       109
       +
       			TargetBranch: "main",

     

       110
       110
       +
       			SourceSha:    "pr-sha-789",

     

       111
       111
       +
       			Action:       "opened",

     

       112
       112
       +
       		},

     

       113
       113
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       114
       114
       +
       			Knot: "example.com",

     

       115
       115
       +
       			Did:  "did:plc:user123",

     

       116
       116
       +
       			Repo: "my-repo",

     

       117
       117
       +
       		},

     

       118
       118
       +
       	}

     

       119
       119
       +
       	id := PipelineId{

     

       120
       120
       +
       		Knot: "example.com",

     

       121
       121
       +
       		Rkey: "123123",

     

       122
       122
       +
       	}

     

       123
       123
       +
       	env := PipelineEnvVars(tr, id, false)

     

       124
       124
       +
       

     

       125
       125
       +
       	// Check ref variables for PR

     

       126
       126
       +
       	if env["TANGLED_REF"] != "refs/heads/feature-branch" {

     

       127
       127
       +
       		t.Errorf("Expected TANGLED_REF='refs/heads/feature-branch', got '%s'", env["TANGLED_REF"])

     

       128
       128
       +
       	}

     

       129
       129
       +
       	if env["TANGLED_REF_NAME"] != "feature-branch" {

     

       130
       130
       +
       		t.Errorf("Expected TANGLED_REF_NAME='feature-branch', got '%s'", env["TANGLED_REF_NAME"])

     

       131
       131
       +
       	}

     

       132
       132
       +
       	if env["TANGLED_REF_TYPE"] != "branch" {

     

       133
       133
       +
       		t.Errorf("Expected TANGLED_REF_TYPE='branch', got '%s'", env["TANGLED_REF_TYPE"])

     

       134
       134
       +
       	}

     

       135
       135
       +
       

     

       136
       136
       +
       	// Check SHA variables

     

       137
       137
       +
       	if env["TANGLED_SHA"] != "pr-sha-789" {

     

       138
       138
       +
       		t.Errorf("Expected TANGLED_SHA='pr-sha-789', got '%s'", env["TANGLED_SHA"])

     

       139
       139
       +
       	}

     

       140
       140
       +
       	if env["TANGLED_COMMIT_SHA"] != "pr-sha-789" {

     

       141
       141
       +
       		t.Errorf("Expected TANGLED_COMMIT_SHA='pr-sha-789', got '%s'", env["TANGLED_COMMIT_SHA"])

     

       142
       142
       +
       	}

     

       143
       143
       +
       

     

       144
       144
       +
       	// Check PR-specific variables

     

       145
       145
       +
       	if env["TANGLED_PR_SOURCE_BRANCH"] != "feature-branch" {

     

       146
       146
       +
       		t.Errorf("Expected TANGLED_PR_SOURCE_BRANCH='feature-branch', got '%s'", env["TANGLED_PR_SOURCE_BRANCH"])

     

       147
       147
       +
       	}

     

       148
       148
       +
       	if env["TANGLED_PR_TARGET_BRANCH"] != "main" {

     

       149
       149
       +
       		t.Errorf("Expected TANGLED_PR_TARGET_BRANCH='main', got '%s'", env["TANGLED_PR_TARGET_BRANCH"])

     

       150
       150
       +
       	}

     

       151
       151
       +
       	if env["TANGLED_PR_SOURCE_SHA"] != "pr-sha-789" {

     

       152
       152
       +
       		t.Errorf("Expected TANGLED_PR_SOURCE_SHA='pr-sha-789', got '%s'", env["TANGLED_PR_SOURCE_SHA"])

     

       153
       153
       +
       	}

     

       154
       154
       +
       	if env["TANGLED_PR_ACTION"] != "opened" {

     

       155
       155
       +
       		t.Errorf("Expected TANGLED_PR_ACTION='opened', got '%s'", env["TANGLED_PR_ACTION"])

     

       156
       156
       +
       	}

     

       157
       157
       +
       }

     

       158
       158
       +
       

     

       159
       159
       +
       func TestPipelineEnvVars_ManualWithInputs(t *testing.T) {

     

       160
       160
       +
       	tr := &tangled.Pipeline_TriggerMetadata{

     

       161
       161
       +
       		Kind: string(workflow.TriggerKindManual),

     

       162
       162
       +
       		Manual: &tangled.Pipeline_ManualTriggerData{

     

       163
       163
       +
       			Inputs: []*tangled.Pipeline_Pair{

     

       164
       164
       +
       				{Key: "version", Value: "1.0.0"},

     

       165
       165
       +
       				{Key: "environment", Value: "production"},

     

       166
       166
       +
       			},

     

       167
       167
       +
       		},

     

       168
       168
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       169
       169
       +
       			Knot: "example.com",

     

       170
       170
       +
       			Did:  "did:plc:user123",

     

       171
       171
       +
       			Repo: "my-repo",

     

       172
       172
       +
       		},

     

       173
       173
       +
       	}

     

       174
       174
       +
       	id := PipelineId{

     

       175
       175
       +
       		Knot: "example.com",

     

       176
       176
       +
       		Rkey: "123123",

     

       177
       177
       +
       	}

     

       178
       178
       +
       	env := PipelineEnvVars(tr, id, false)

     

       179
       179
       +
       

     

       180
       180
       +
       	// Check manual input variables

     

       181
       181
       +
       	if env["TANGLED_INPUT_VERSION"] != "1.0.0" {

     

       182
       182
       +
       		t.Errorf("Expected TANGLED_INPUT_VERSION='1.0.0', got '%s'", env["TANGLED_INPUT_VERSION"])

     

       183
       183
       +
       	}

     

       184
       184
       +
       	if env["TANGLED_INPUT_ENVIRONMENT"] != "production" {

     

       185
       185
       +
       		t.Errorf("Expected TANGLED_INPUT_ENVIRONMENT='production', got '%s'", env["TANGLED_INPUT_ENVIRONMENT"])

     

       186
       186
       +
       	}

     

       187
       187
       +
       

     

       188
       188
       +
       	// Manual triggers shouldn't have ref/sha variables

     

       189
       189
       +
       	if _, ok := env["TANGLED_REF"]; ok {

     

       190
       190
       +
       		t.Error("Manual trigger should not have TANGLED_REF")

     

       191
       191
       +
       	}

     

       192
       192
       +
       	if _, ok := env["TANGLED_SHA"]; ok {

     

       193
       193
       +
       		t.Error("Manual trigger should not have TANGLED_SHA")

     

       194
       194
       +
       	}

     

       195
       195
       +
       }

     

       196
       196
       +
       

     

       197
       197
       +
       func TestPipelineEnvVars_DevMode(t *testing.T) {

     

       198
       198
       +
       	tr := &tangled.Pipeline_TriggerMetadata{

     

       199
       199
       +
       		Kind: string(workflow.TriggerKindPush),

     

       200
       200
       +
       		Push: &tangled.Pipeline_PushTriggerData{

     

       201
       201
       +
       			NewSha: "abc123",

     

       202
       202
       +
       			Ref:    "refs/heads/main",

     

       203
       203
       +
       		},

     

       204
       204
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       205
       205
       +
       			Knot: "localhost:3000",

     

       206
       206
       +
       			Did:  "did:plc:user123",

     

       207
       207
       +
       			Repo: "my-repo",

     

       208
       208
       +
       		},

     

       209
       209
       +
       	}

     

       210
       210
       +
       	id := PipelineId{

     

       211
       211
       +
       		Knot: "example.com",

     

       212
       212
       +
       		Rkey: "123123",

     

       213
       213
       +
       	}

     

       214
       214
       +
       	env := PipelineEnvVars(tr, id, true)

     

       215
       215
       +
       

     

       216
       216
       +
       	// Dev mode should use http:// and replace localhost with host.docker.internal

     

       217
       217
       +
       	expectedURL := "http://host.docker.internal:3000/did:plc:user123/my-repo"

     

       218
       218
       +
       	if env["TANGLED_REPO_URL"] != expectedURL {

     

       219
       219
       +
       		t.Errorf("Expected TANGLED_REPO_URL='%s', got '%s'", expectedURL, env["TANGLED_REPO_URL"])

     

       220
       220
       +
       	}

     

       221
       221
       +
       }

     

       222
       222
       +
       

     

       223
       223
       +
       func TestPipelineEnvVars_NilTrigger(t *testing.T) {

     

       224
       224
       +
       	id := PipelineId{

     

       225
       225
       +
       		Knot: "example.com",

     

       226
       226
       +
       		Rkey: "123123",

     

       227
       227
       +
       	}

     

       228
       228
       +
       	env := PipelineEnvVars(nil, id, false)

     

       229
       229
       +
       

     

       230
       230
       +
       	if env != nil {

     

       231
       231
       +
       		t.Error("Expected nil env for nil trigger")

     

       232
       232
       +
       	}

     

       233
       233
       +
       }

     

       234
       234
       +
       

     

       235
       235
       +
       func TestPipelineEnvVars_NilPushData(t *testing.T) {

     

       236
       236
       +
       	tr := &tangled.Pipeline_TriggerMetadata{

     

       237
       237
       +
       		Kind: string(workflow.TriggerKindPush),

     

       238
       238
       +
       		Push: nil,

     

       239
       239
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       240
       240
       +
       			Knot: "example.com",

     

       241
       241
       +
       			Did:  "did:plc:user123",

     

       242
       242
       +
       			Repo: "my-repo",

     

       243
       243
       +
       		},

     

       244
       244
       +
       	}

     

       245
       245
       +
       	id := PipelineId{

     

       246
       246
       +
       		Knot: "example.com",

     

       247
       247
       +
       		Rkey: "123123",

     

       248
       248
       +
       	}

     

       249
       249
       +
       	env := PipelineEnvVars(tr, id, false)

     

       250
       250
       +
       

     

       251
       251
       +
       	// Should still have repo variables

     

       252
       252
       +
       	if env["TANGLED_REPO_KNOT"] != "example.com" {

     

       253
       253
       +
       		t.Errorf("Expected TANGLED_REPO_KNOT='example.com', got '%s'", env["TANGLED_REPO_KNOT"])

     

       254
       254
       +
       	}

     

       255
       255
       +
       

     

       256
       256
       +
       	// Should not have ref/sha variables

     

       257
       257
       +
       	if _, ok := env["TANGLED_REF"]; ok {

     

       258
       258
       +
       		t.Error("Should not have TANGLED_REF when push data is nil")

     

       259
       259
       +
       	}

     

       260
       260
       +
       }

+15 -7

spindle/secrets/openbao.go

···

       13
       13
        
       )

     

       14
       14
        
       

     

       15
       15
        
       type OpenBaoManager struct {

     

       16
       16
       -
       	client    *vault.Client

     

       17
       17
       -
       	mountPath string

     

       18
       18
       -
       	logger    *slog.Logger

     

       16
       16
       +
       	client            *vault.Client

     

       17
       17
       +
       	mountPath         string

     

       18
       18
       +
       	logger            *slog.Logger

     

       19
       19
       +
       	connectionTimeout time.Duration

     

       19
       20
        
       }

     

       20
       21
        
       

     

       21
       22
        
       type OpenBaoManagerOpt func(*OpenBaoManager)

     
···

       26
       27
        
       	}

     

       27
       28
        
       }

     

       28
       29
        
       

     

       30
       30
       +
       func WithConnectionTimeout(timeout time.Duration) OpenBaoManagerOpt {

     

       31
       31
       +
       	return func(v *OpenBaoManager) {

     

       32
       32
       +
       		v.connectionTimeout = timeout

     

       33
       33
       +
       	}

     

       34
       34
       +
       }

     

       35
       35
       +
       

     

       29
       36
        
       // NewOpenBaoManager creates a new OpenBao manager that connects to a Bao Proxy

     

       30
       37
        
       // The proxyAddress should point to the local Bao Proxy (e.g., "http://127.0.0.1:8200")

     

       31
       38
        
       // The proxy handles all authentication automatically via Auto-Auth

     
···

       43
       50
        
       	}

     

       44
       51
        
       

     

       45
       52
        
       	manager := &OpenBaoManager{

     

       46
       46
       -
       		client:    client,

     

       47
       47
       -
       		mountPath: "spindle", // default KV v2 mount path

     

       48
       48
       -
       		logger:    logger,

     

       53
       53
       +
       		client:            client,

     

       54
       54
       +
       		mountPath:         "spindle", // default KV v2 mount path

     

       55
       55
       +
       		logger:            logger,

     

       56
       56
       +
       		connectionTimeout: 10 * time.Second, // default connection timeout

     

       49
       57
        
       	}

     

       50
       58
        
       

     

       51
       59
        
       	for _, opt := range opts {

     
···

       62
       70
        
       

     

       63
       71
        
       // testConnection verifies that we can connect to the proxy

     

       64
       72
        
       func (v *OpenBaoManager) testConnection() error {

     

       65
       65
       -
       	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)

     

       73
       73
       +
       	ctx, cancel := context.WithTimeout(context.Background(), v.connectionTimeout)

     

       66
       74
        
       	defer cancel()

     

       67
       75
        
       

     

       68
       76
        
       	// try token self-lookup as a quick way to verify proxy works

+5 -2

spindle/secrets/openbao_test.go

···

       152
       152
        
       	for _, tt := range tests {

     

       153
       153
        
       		t.Run(tt.name, func(t *testing.T) {

     

       154
       154
        
       			logger := slog.New(slog.NewTextHandler(os.Stderr, nil))

     

       155
       155
       -
       			manager, err := NewOpenBaoManager(tt.proxyAddr, logger, tt.opts...)

     

       155
       155
       +
       			// Use shorter timeout for tests to avoid long waits

     

       156
       156
       +
       			opts := append(tt.opts, WithConnectionTimeout(1*time.Second))

     

       157
       157
       +
       			manager, err := NewOpenBaoManager(tt.proxyAddr, logger, opts...)

     

       156
       158
        
       

     

       157
       159
        
       			if tt.expectError {

     

       158
       160
        
       				assert.Error(t, err)

     
···

       596
       598
        
       

     

       597
       599
        
       			// All these will fail because no real proxy is running

     

       598
       600
        
       			// but we can test that the configuration is properly accepted

     

       599
       599
       -
       			manager, err := NewOpenBaoManager(tt.proxyAddr, logger)

     

       601
       601
       +
       			// Use shorter timeout for tests to avoid long waits

     

       602
       602
       +
       			manager, err := NewOpenBaoManager(tt.proxyAddr, logger, WithConnectionTimeout(1*time.Second))

     

       600
       603
        
       			assert.Error(t, err) // Expected because no real proxy

     

       601
       604
        
       			assert.Nil(t, manager)

     

       602
       605
        
       			assert.Contains(t, err.Error(), "failed to connect to bao proxy")

+96 -40

spindle/server.go

···

       6
       6
        
       	"encoding/json"

     

       7
       7
        
       	"fmt"

     

       8
       8
        
       	"log/slog"

     

       9
       9
       +
       	"maps"

     

       9
       10
        
       	"net/http"

     

       10
       11
        
       

     

       11
       12
        
       	"github.com/go-chi/chi/v5"

     
···

       49
       50
        
       	vault secrets.Manager

     

       50
       51
        
       }

     

       51
       52
        
       

     

       52
       52
       -
       func Run(ctx context.Context) error {

     

       53
       53
       +
       // New creates a new Spindle server with the provided configuration and engines.

     

       54
       54
       +
       func New(ctx context.Context, cfg *config.Config, engines map[string]models.Engine) (*Spindle, error) {

     

       53
       55
        
       	logger := log.FromContext(ctx)

     

       54
       54
       -
       

     

       55
       55
       -
       	cfg, err := config.Load(ctx)

     

       56
       56
       -
       	if err != nil {

     

       57
       57
       -
       		return fmt.Errorf("failed to load config: %w", err)

     

       58
       58
       -
       	}

     

       59
       56
        
       

     

       60
       57
        
       	d, err := db.Make(cfg.Server.DBPath)

     

       61
       58
        
       	if err != nil {

     

       62
       62
       -
       		return fmt.Errorf("failed to setup db: %w", err)

     

       59
       59
       +
       		return nil, fmt.Errorf("failed to setup db: %w", err)

     

       63
       60
        
       	}

     

       64
       61
        
       

     

       65
       62
        
       	e, err := rbac.NewEnforcer(cfg.Server.DBPath)

     

       66
       63
        
       	if err != nil {

     

       67
       67
       -
       		return fmt.Errorf("failed to setup rbac enforcer: %w", err)

     

       64
       64
       +
       		return nil, fmt.Errorf("failed to setup rbac enforcer: %w", err)

     

       68
       65
        
       	}

     

       69
       66
        
       	e.E.EnableAutoSave(true)

     

       70
       67
        
       

     
···

       74
       71
        
       	switch cfg.Server.Secrets.Provider {

     

       75
       72
        
       	case "openbao":

     

       76
       73
        
       		if cfg.Server.Secrets.OpenBao.ProxyAddr == "" {

     

       77
       77
       -
       			return fmt.Errorf("openbao proxy address is required when using openbao secrets provider")

     

       74
       74
       +
       			return nil, fmt.Errorf("openbao proxy address is required when using openbao secrets provider")

     

       78
       75
        
       		}

     

       79
       76
        
       		vault, err = secrets.NewOpenBaoManager(

     

       80
       77
        
       			cfg.Server.Secrets.OpenBao.ProxyAddr,

     
···

       82
       79
        
       			secrets.WithMountPath(cfg.Server.Secrets.OpenBao.Mount),

     

       83
       80
        
       		)

     

       84
       81
        
       		if err != nil {

     

       85
       85
       -
       			return fmt.Errorf("failed to setup openbao secrets provider: %w", err)

     

       82
       82
       +
       			return nil, fmt.Errorf("failed to setup openbao secrets provider: %w", err)

     

       86
       83
        
       		}

     

       87
       84
        
       		logger.Info("using openbao secrets provider", "proxy_address", cfg.Server.Secrets.OpenBao.ProxyAddr, "mount", cfg.Server.Secrets.OpenBao.Mount)

     

       88
       85
        
       	case "sqlite", "":

     

       89
       86
        
       		vault, err = secrets.NewSQLiteManager(cfg.Server.DBPath, secrets.WithTableName("secrets"))

     

       90
       87
        
       		if err != nil {

     

       91
       91
       -
       			return fmt.Errorf("failed to setup sqlite secrets provider: %w", err)

     

       88
       88
       +
       			return nil, fmt.Errorf("failed to setup sqlite secrets provider: %w", err)

     

       92
       89
        
       		}

     

       93
       90
        
       		logger.Info("using sqlite secrets provider", "path", cfg.Server.DBPath)

     

       94
       91
        
       	default:

     

       95
       95
       -
       		return fmt.Errorf("unknown secrets provider: %s", cfg.Server.Secrets.Provider)

     

       96
       96
       -
       	}

     

       97
       97
       -
       

     

       98
       98
       -
       	nixeryEng, err := nixery.New(ctx, cfg)

     

       99
       99
       -
       	if err != nil {

     

       100
       100
       -
       		return err

     

       92
       92
       +
       		return nil, fmt.Errorf("unknown secrets provider: %s", cfg.Server.Secrets.Provider)

     

       101
       93
        
       	}

     

       102
       94
        
       

     

       103
       95
        
       	jq := queue.NewQueue(cfg.Server.QueueSize, cfg.Server.MaxJobCount)

     
···

       110
       102
        
       	}

     

       111
       103
        
       	jc, err := jetstream.NewJetstreamClient(cfg.Server.JetstreamEndpoint, "spindle", collections, nil, log.SubLogger(logger, "jetstream"), d, true, true)

     

       112
       104
        
       	if err != nil {

     

       113
       113
       -
       		return fmt.Errorf("failed to setup jetstream client: %w", err)

     

       105
       105
       +
       		return nil, fmt.Errorf("failed to setup jetstream client: %w", err)

     

       114
       106
        
       	}

     

       115
       107
        
       	jc.AddDid(cfg.Server.Owner)

     

       116
       108
        
       

     

       117
       109
        
       	// Check if the spindle knows about any Dids;

     

       118
       110
        
       	dids, err := d.GetAllDids()

     

       119
       111
        
       	if err != nil {

     

       120
       120
       -
       		return fmt.Errorf("failed to get all dids: %w", err)

     

       112
       112
       +
       		return nil, fmt.Errorf("failed to get all dids: %w", err)

     

       121
       113
        
       	}

     

       122
       114
        
       	for _, d := range dids {

     

       123
       115
        
       		jc.AddDid(d)

     
···

       125
       117
        
       

     

       126
       118
        
       	resolver := idresolver.DefaultResolver(cfg.Server.PlcUrl)

     

       127
       119
        
       

     

       128
       128
       -
       	spindle := Spindle{

     

       120
       120
       +
       	spindle := &Spindle{

     

       129
       121
        
       		jc:    jc,

     

       130
       122
        
       		e:     e,

     

       131
       123
        
       		db:    d,

     

       132
       124
        
       		l:     logger,

     

       133
       125
        
       		n:     &n,

     

       134
       134
       -
       		engs:  map[string]models.Engine{"nixery": nixeryEng},

     

       126
       126
       +
       		engs:  engines,

     

       135
       127
        
       		jq:    jq,

     

       136
       128
        
       		cfg:   cfg,

     

       137
       129
        
       		res:   resolver,

     
···

       140
       132
        
       

     

       141
       133
        
       	err = e.AddSpindle(rbacDomain)

     

       142
       134
        
       	if err != nil {

     

       143
       143
       -
       		return fmt.Errorf("failed to set rbac domain: %w", err)

     

       135
       135
       +
       		return nil, fmt.Errorf("failed to set rbac domain: %w", err)

     

       144
       136
        
       	}

     

       145
       137
        
       	err = spindle.configureOwner()

     

       146
       138
        
       	if err != nil {

     

       147
       147
       -
       		return err

     

       139
       139
       +
       		return nil, err

     

       148
       140
        
       	}

     

       149
       141
        
       	logger.Info("owner set", "did", cfg.Server.Owner)

     

       150
       142
        
       

     

       151
       151
       -
       	// starts a job queue runner in the background

     

       152
       152
       -
       	jq.Start()

     

       153
       153
       -
       	defer jq.Stop()

     

       154
       154
       -
       

     

       155
       155
       -
       	// Stop vault token renewal if it implements Stopper

     

       156
       156
       -
       	if stopper, ok := vault.(secrets.Stopper); ok {

     

       157
       157
       -
       		defer stopper.Stop()

     

       158
       158
       -
       	}

     

       159
       159
       -
       

     

       160
       143
        
       	cursorStore, err := cursor.NewSQLiteStore(cfg.Server.DBPath)

     

       161
       144
        
       	if err != nil {

     

       162
       162
       -
       		return fmt.Errorf("failed to setup sqlite3 cursor store: %w", err)

     

       145
       145
       +
       		return nil, fmt.Errorf("failed to setup sqlite3 cursor store: %w", err)

     

       163
       146
        
       	}

     

       164
       147
        
       

     

       165
       148
        
       	err = jc.StartJetstream(ctx, spindle.ingest())

     

       166
       149
        
       	if err != nil {

     

       167
       167
       -
       		return fmt.Errorf("failed to start jetstream consumer: %w", err)

     

       150
       150
       +
       		return nil, fmt.Errorf("failed to start jetstream consumer: %w", err)

     

       168
       151
        
       	}

     

       169
       152
        
       

     

       170
       153
        
       	// for each incoming sh.tangled.pipeline, we execute

     
···

       177
       160
        
       	ccfg.CursorStore = cursorStore

     

       178
       161
        
       	knownKnots, err := d.Knots()

     

       179
       162
        
       	if err != nil {

     

       180
       180
       -
       		return err

     

       163
       163
       +
       		return nil, err

     

       181
       164
        
       	}

     

       182
       165
        
       	for _, knot := range knownKnots {

     

       183
       166
        
       		logger.Info("adding source start", "knot", knot)

     
···

       185
       168
        
       	}

     

       186
       169
        
       	spindle.ks = eventconsumer.NewConsumer(*ccfg)

     

       187
       170
        
       

     

       171
       171
       +
       	return spindle, nil

     

       172
       172
       +
       }

     

       173
       173
       +
       

     

       174
       174
       +
       // DB returns the database instance.

     

       175
       175
       +
       func (s *Spindle) DB() *db.DB {

     

       176
       176
       +
       	return s.db

     

       177
       177
       +
       }

     

       178
       178
       +
       

     

       179
       179
       +
       // Queue returns the job queue instance.

     

       180
       180
       +
       func (s *Spindle) Queue() *queue.Queue {

     

       181
       181
       +
       	return s.jq

     

       182
       182
       +
       }

     

       183
       183
       +
       

     

       184
       184
       +
       // Engines returns the map of available engines.

     

       185
       185
       +
       func (s *Spindle) Engines() map[string]models.Engine {

     

       186
       186
       +
       	return s.engs

     

       187
       187
       +
       }

     

       188
       188
       +
       

     

       189
       189
       +
       // Vault returns the secrets manager instance.

     

       190
       190
       +
       func (s *Spindle) Vault() secrets.Manager {

     

       191
       191
       +
       	return s.vault

     

       192
       192
       +
       }

     

       193
       193
       +
       

     

       194
       194
       +
       // Notifier returns the notifier instance.

     

       195
       195
       +
       func (s *Spindle) Notifier() *notifier.Notifier {

     

       196
       196
       +
       	return s.n

     

       197
       197
       +
       }

     

       198
       198
       +
       

     

       199
       199
       +
       // Enforcer returns the RBAC enforcer instance.

     

       200
       200
       +
       func (s *Spindle) Enforcer() *rbac.Enforcer {

     

       201
       201
       +
       	return s.e

     

       202
       202
       +
       }

     

       203
       203
       +
       

     

       204
       204
       +
       // Start starts the Spindle server (blocking).

     

       205
       205
       +
       func (s *Spindle) Start(ctx context.Context) error {

     

       206
       206
       +
       	// starts a job queue runner in the background

     

       207
       207
       +
       	s.jq.Start()

     

       208
       208
       +
       	defer s.jq.Stop()

     

       209
       209
       +
       

     

       210
       210
       +
       	// Stop vault token renewal if it implements Stopper

     

       211
       211
       +
       	if stopper, ok := s.vault.(secrets.Stopper); ok {

     

       212
       212
       +
       		defer stopper.Stop()

     

       213
       213
       +
       	}

     

       214
       214
       +
       

     

       188
       215
        
       	go func() {

     

       189
       189
       -
       		logger.Info("starting knot event consumer")

     

       190
       190
       -
       		spindle.ks.Start(ctx)

     

       216
       216
       +
       		s.l.Info("starting knot event consumer")

     

       217
       217
       +
       		s.ks.Start(ctx)

     

       191
       218
        
       	}()

     

       192
       219
        
       

     

       193
       193
       -
       	logger.Info("starting spindle server", "address", cfg.Server.ListenAddr)

     

       194
       194
       -
       	logger.Error("server error", "error", http.ListenAndServe(cfg.Server.ListenAddr, spindle.Router()))

     

       220
       220
       +
       	s.l.Info("starting spindle server", "address", s.cfg.Server.ListenAddr)

     

       221
       221
       +
       	return http.ListenAndServe(s.cfg.Server.ListenAddr, s.Router())

     

       222
       222
       +
       }

     

       195
       223
        
       

     

       196
       196
       -
       	return nil

     

       224
       224
       +
       func Run(ctx context.Context) error {

     

       225
       225
       +
       	cfg, err := config.Load(ctx)

     

       226
       226
       +
       	if err != nil {

     

       227
       227
       +
       		return fmt.Errorf("failed to load config: %w", err)

     

       228
       228
       +
       	}

     

       229
       229
       +
       

     

       230
       230
       +
       	nixeryEng, err := nixery.New(ctx, cfg)

     

       231
       231
       +
       	if err != nil {

     

       232
       232
       +
       		return err

     

       233
       233
       +
       	}

     

       234
       234
       +
       

     

       235
       235
       +
       	s, err := New(ctx, cfg, map[string]models.Engine{

     

       236
       236
       +
       		"nixery": nixeryEng,

     

       237
       237
       +
       	})

     

       238
       238
       +
       	if err != nil {

     

       239
       239
       +
       		return err

     

       240
       240
       +
       	}

     

       241
       241
       +
       

     

       242
       242
       +
       	return s.Start(ctx)

     

       197
       243
        
       }

     

       198
       244
        
       

     

       199
       245
        
       func (s *Spindle) Router() http.Handler {

     
···

       266
       312
        
       

     

       267
       313
        
       		workflows := make(map[models.Engine][]models.Workflow)

     

       268
       314
        
       

     

       315
       315
       +
       		// Build pipeline environment variables once for all workflows

     

       316
       316
       +
       		pipelineEnv := models.PipelineEnvVars(tpl.TriggerMetadata, pipelineId, s.cfg.Server.Dev)

     

       317
       317
       +
       

     

       269
       318
        
       		for _, w := range tpl.Workflows {

     

       270
       319
        
       			if w != nil {

     

       271
       320
        
       				if _, ok := s.engs[w.Engine]; !ok {

     
···

       290
       339
        
       				if err != nil {

     

       291
       340
        
       					return err

     

       292
       341
        
       				}

     

       342
       342
       +
       

     

       343
       343
       +
       				// inject TANGLED_* env vars after InitWorkflow

     

       344
       344
       +
       				// This prevents user-defined env vars from overriding them

     

       345
       345
       +
       				if ewf.Environment == nil {

     

       346
       346
       +
       					ewf.Environment = make(map[string]string)

     

       347
       347
       +
       				}

     

       348
       348
       +
       				maps.Copy(ewf.Environment, pipelineEnv)

     

       293
       349
        
       

     

       294
       350
        
       				workflows[eng] = append(workflows[eng], *ewf)

     

       295
       351

spindle/stream.go

···

       213
       213
        
       			if err := conn.WriteMessage(websocket.TextMessage, []byte(line.Text)); err != nil {

     

       214
       214
        
       				return fmt.Errorf("failed to write to websocket: %w", err)

     

       215
       215
        
       			}

     

       216
       216
       +
       		case <-time.After(30 * time.Second):

     

       217
       217
       +
       			// send a keep-alive

     

       218
       218
       +
       			if err := conn.WriteControl(websocket.PingMessage, []byte{}, time.Now().Add(time.Second)); err != nil {

     

       219
       219
       +
       				return fmt.Errorf("failed to write control: %w", err)

     

       220
       220
       +
       			}

     

       216
       221
        
       		}

     

       217
       222
        
       	}

     

       218
       223
        
       }

+199

types/commit.go

···

       1
       1
       +
       package types

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"bytes"

     

       5
       5
       +
       	"encoding/json"

     

       6
       6
       +
       	"fmt"

     

       7
       7
       +
       	"maps"

     

       8
       8
       +
       	"regexp"

     

       9
       9
       +
       	"strings"

     

       10
       10
       +
       

     

       11
       11
       +
       	"github.com/go-git/go-git/v5/plumbing"

     

       12
       12
       +
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       13
       13
       +
       )

     

       14
       14
       +
       

     

       15
       15
       +
       type Commit struct {

     

       16
       16
       +
       	// hash of the commit object.

     

       17
       17
       +
       	Hash plumbing.Hash `json:"hash,omitempty"`

     

       18
       18
       +
       

     

       19
       19
       +
       	// author is the original author of the commit.

     

       20
       20
       +
       	Author object.Signature `json:"author"`

     

       21
       21
       +
       

     

       22
       22
       +
       	// committer is the one performing the commit, might be different from author.

     

       23
       23
       +
       	Committer object.Signature `json:"committer"`

     

       24
       24
       +
       

     

       25
       25
       +
       	// message is the commit message, contains arbitrary text.

     

       26
       26
       +
       	Message string `json:"message"`

     

       27
       27
       +
       

     

       28
       28
       +
       	// treehash is the hash of the root tree of the commit.

     

       29
       29
       +
       	Tree string `json:"tree"`

     

       30
       30
       +
       

     

       31
       31
       +
       	// parents are the hashes of the parent commits of the commit.

     

       32
       32
       +
       	ParentHashes []plumbing.Hash `json:"parent_hashes,omitempty"`

     

       33
       33
       +
       

     

       34
       34
       +
       	// pgpsignature is the pgp signature of the commit.

     

       35
       35
       +
       	PGPSignature string `json:"pgp_signature,omitempty"`

     

       36
       36
       +
       

     

       37
       37
       +
       	// mergetag is the embedded tag object when a merge commit is created by

     

       38
       38
       +
       	// merging a signed tag.

     

       39
       39
       +
       	MergeTag string `json:"merge_tag,omitempty"`

     

       40
       40
       +
       

     

       41
       41
       +
       	// changeid is a unique identifier for the change (e.g., gerrit change-id).

     

       42
       42
       +
       	ChangeId string `json:"change_id,omitempty"`

     

       43
       43
       +
       

     

       44
       44
       +
       	// extraheaders contains additional headers not captured by other fields.

     

       45
       45
       +
       	ExtraHeaders map[string][]byte `json:"extra_headers,omitempty"`

     

       46
       46
       +
       

     

       47
       47
       +
       	// deprecated: kept for backwards compatibility with old json format.

     

       48
       48
       +
       	This string `json:"this,omitempty"`

     

       49
       49
       +
       

     

       50
       50
       +
       	// deprecated: kept for backwards compatibility with old json format.

     

       51
       51
       +
       	Parent string `json:"parent,omitempty"`

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       // types.Commit is an unify two commit structs:

     

       55
       55
       +
       //   - git.object.Commit from

     

       56
       56
       +
       //   - types.NiceDiff.commit

     

       57
       57
       +
       //

     

       58
       58
       +
       // to do this in backwards compatible fashion, we define the base struct

     

       59
       59
       +
       // to use the same fields as NiceDiff.Commit, and then we also unmarshal

     

       60
       60
       +
       // the struct fields from go-git structs, this custom unmarshal makes sense

     

       61
       61
       +
       // of both representations and unifies them to have maximal data in either

     

       62
       62
       +
       // form.

     

       63
       63
       +
       func (c *Commit) UnmarshalJSON(data []byte) error {

     

       64
       64
       +
       	type Alias Commit

     

       65
       65
       +
       

     

       66
       66
       +
       	aux := &struct {

     

       67
       67
       +
       		*object.Commit

     

       68
       68
       +
       		*Alias

     

       69
       69
       +
       	}{

     

       70
       70
       +
       		Alias: (*Alias)(c),

     

       71
       71
       +
       	}

     

       72
       72
       +
       

     

       73
       73
       +
       	if err := json.Unmarshal(data, aux); err != nil {

     

       74
       74
       +
       		return err

     

       75
       75
       +
       	}

     

       76
       76
       +
       

     

       77
       77
       +
       	c.FromGoGitCommit(aux.Commit)

     

       78
       78
       +
       

     

       79
       79
       +
       	return nil

     

       80
       80
       +
       }

     

       81
       81
       +
       

     

       82
       82
       +
       // fill in as much of Commit as possible from the given go-git commit

     

       83
       83
       +
       func (c *Commit) FromGoGitCommit(gc *object.Commit) {

     

       84
       84
       +
       	if gc == nil {

     

       85
       85
       +
       		return

     

       86
       86
       +
       	}

     

       87
       87
       +
       

     

       88
       88
       +
       	if c.Hash.IsZero() {

     

       89
       89
       +
       		c.Hash = gc.Hash

     

       90
       90
       +
       	}

     

       91
       91
       +
       	if c.This == "" {

     

       92
       92
       +
       		c.This = gc.Hash.String()

     

       93
       93
       +
       	}

     

       94
       94
       +
       	if isEmptySignature(c.Author) {

     

       95
       95
       +
       		c.Author = gc.Author

     

       96
       96
       +
       	}

     

       97
       97
       +
       	if isEmptySignature(c.Committer) {

     

       98
       98
       +
       		c.Committer = gc.Committer

     

       99
       99
       +
       	}

     

       100
       100
       +
       	if c.Message == "" {

     

       101
       101
       +
       		c.Message = gc.Message

     

       102
       102
       +
       	}

     

       103
       103
       +
       	if c.Tree == "" {

     

       104
       104
       +
       		c.Tree = gc.TreeHash.String()

     

       105
       105
       +
       	}

     

       106
       106
       +
       	if c.PGPSignature == "" {

     

       107
       107
       +
       		c.PGPSignature = gc.PGPSignature

     

       108
       108
       +
       	}

     

       109
       109
       +
       	if c.MergeTag == "" {

     

       110
       110
       +
       		c.MergeTag = gc.MergeTag

     

       111
       111
       +
       	}

     

       112
       112
       +
       

     

       113
       113
       +
       	if len(c.ParentHashes) == 0 {

     

       114
       114
       +
       		c.ParentHashes = gc.ParentHashes

     

       115
       115
       +
       	}

     

       116
       116
       +
       	if c.Parent == "" && len(gc.ParentHashes) > 0 {

     

       117
       117
       +
       		c.Parent = gc.ParentHashes[0].String()

     

       118
       118
       +
       	}

     

       119
       119
       +
       

     

       120
       120
       +
       	if len(c.ExtraHeaders) == 0 {

     

       121
       121
       +
       		c.ExtraHeaders = make(map[string][]byte)

     

       122
       122
       +
       		maps.Copy(c.ExtraHeaders, gc.ExtraHeaders)

     

       123
       123
       +
       	}

     

       124
       124
       +
       

     

       125
       125
       +
       	if c.ChangeId == "" {

     

       126
       126
       +
       		if v, ok := gc.ExtraHeaders["change-id"]; ok {

     

       127
       127
       +
       			c.ChangeId = string(v)

     

       128
       128
       +
       		}

     

       129
       129
       +
       	}

     

       130
       130
       +
       }

     

       131
       131
       +
       

     

       132
       132
       +
       func isEmptySignature(s object.Signature) bool {

     

       133
       133
       +
       	return s.Email == "" && s.Name == "" && s.When.IsZero()

     

       134
       134
       +
       }

     

       135
       135
       +
       

     

       136
       136
       +
       // produce a verifiable payload from this commit's metadata

     

       137
       137
       +
       func (c *Commit) Payload() string {

     

       138
       138
       +
       	author := bytes.NewBuffer([]byte{})

     

       139
       139
       +
       	c.Author.Encode(author)

     

       140
       140
       +
       

     

       141
       141
       +
       	committer := bytes.NewBuffer([]byte{})

     

       142
       142
       +
       	c.Committer.Encode(committer)

     

       143
       143
       +
       

     

       144
       144
       +
       	payload := strings.Builder{}

     

       145
       145
       +
       

     

       146
       146
       +
       	fmt.Fprintf(&payload, "tree %s\n", c.Tree)

     

       147
       147
       +
       

     

       148
       148
       +
       	if len(c.ParentHashes) > 0 {

     

       149
       149
       +
       		for _, p := range c.ParentHashes {

     

       150
       150
       +
       			fmt.Fprintf(&payload, "parent %s\n", p.String())

     

       151
       151
       +
       		}

     

       152
       152
       +
       	} else {

     

       153
       153
       +
       		// present for backwards compatibility

     

       154
       154
       +
       		fmt.Fprintf(&payload, "parent %s\n", c.Parent)

     

       155
       155
       +
       	}

     

       156
       156
       +
       

     

       157
       157
       +
       	fmt.Fprintf(&payload, "author %s\n", author.String())

     

       158
       158
       +
       	fmt.Fprintf(&payload, "committer %s\n", committer.String())

     

       159
       159
       +
       

     

       160
       160
       +
       	if c.ChangeId != "" {

     

       161
       161
       +
       		fmt.Fprintf(&payload, "change-id %s\n", c.ChangeId)

     

       162
       162
       +
       	} else if v, ok := c.ExtraHeaders["change-id"]; ok {

     

       163
       163
       +
       		fmt.Fprintf(&payload, "change-id %s\n", string(v))

     

       164
       164
       +
       	}

     

       165
       165
       +
       

     

       166
       166
       +
       	fmt.Fprintf(&payload, "\n%s", c.Message)

     

       167
       167
       +
       

     

       168
       168
       +
       	return payload.String()

     

       169
       169
       +
       }

     

       170
       170
       +
       

     

       171
       171
       +
       var (

     

       172
       172
       +
       	coAuthorRegex = regexp.MustCompile(`(?im)^Co-authored-by:\s*(.+?)\s*<([^>]+)>`)

     

       173
       173
       +
       )

     

       174
       174
       +
       

     

       175
       175
       +
       func (commit Commit) CoAuthors() []object.Signature {

     

       176
       176
       +
       	var coAuthors []object.Signature

     

       177
       177
       +
       	seen := make(map[string]bool)

     

       178
       178
       +
       	matches := coAuthorRegex.FindAllStringSubmatch(commit.Message, -1)

     

       179
       179
       +
       

     

       180
       180
       +
       	for _, match := range matches {

     

       181
       181
       +
       		if len(match) >= 3 {

     

       182
       182
       +
       			name := strings.TrimSpace(match[1])

     

       183
       183
       +
       			email := strings.TrimSpace(match[2])

     

       184
       184
       +
       

     

       185
       185
       +
       			if seen[email] {

     

       186
       186
       +
       				continue

     

       187
       187
       +
       			}

     

       188
       188
       +
       			seen[email] = true

     

       189
       189
       +
       

     

       190
       190
       +
       			coAuthors = append(coAuthors, object.Signature{

     

       191
       191
       +
       				Name:  name,

     

       192
       192
       +
       				Email: email,

     

       193
       193
       +
       				When:  commit.Committer.When,

     

       194
       194
       +
       			})

     

       195
       195
       +
       		}

     

       196
       196
       +
       	}

     

       197
       197
       +
       

     

       198
       198
       +
       	return coAuthors

     

       199
       199
       +
       }

+2 -12

types/diff.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"github.com/bluekeyes/go-gitdiff/gitdiff"

     

       5
       5
       -
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       6
       5
        
       )

     

       7
       6
        
       

     

       8
       7
        
       type DiffOpts struct {

     
···

       43
       42
        
       

     

       44
       43
        
       // A nicer git diff representation.

     

       45
       44
        
       type NiceDiff struct {

     

       46
       46
       -
       	Commit struct {

     

       47
       47
       -
       		Message      string           `json:"message"`

     

       48
       48
       -
       		Author       object.Signature `json:"author"`

     

       49
       49
       -
       		This         string           `json:"this"`

     

       50
       50
       -
       		Parent       string           `json:"parent"`

     

       51
       51
       -
       		PGPSignature string           `json:"pgp_signature"`

     

       52
       52
       -
       		Committer    object.Signature `json:"committer"`

     

       53
       53
       -
       		Tree         string           `json:"tree"`

     

       54
       54
       -
       		ChangedId    string           `json:"change_id"`

     

       55
       55
       -
       	} `json:"commit"`

     

       56
       56
       -
       	Stat struct {

     

       45
       45
       +
       	Commit Commit `json:"commit"`

     

       46
       46
       +
       	Stat   struct {

     

       57
       47
        
       		FilesChanged int `json:"files_changed"`

     

       58
       48
        
       		Insertions   int `json:"insertions"`

     

       59
       49
        
       		Deletions    int `json:"deletions"`

+39 -18

types/repo.go

···

       1
       1
        
       package types

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       

     

       4
       6
        
       	"github.com/bluekeyes/go-gitdiff/gitdiff"

     

       5
       7
        
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       6
       8
        
       )

     

       7
       9
        
       

     

       8
       10
        
       type RepoIndexResponse struct {

     

       9
       9
       -
       	IsEmpty        bool             `json:"is_empty"`

     

       10
       10
       -
       	Ref            string           `json:"ref,omitempty"`

     

       11
       11
       -
       	Readme         string           `json:"readme,omitempty"`

     

       12
       12
       -
       	ReadmeFileName string           `json:"readme_file_name,omitempty"`

     

       13
       13
       -
       	Commits        []*object.Commit `json:"commits,omitempty"`

     

       14
       14
       -
       	Description    string           `json:"description,omitempty"`

     

       15
       15
       -
       	Files          []NiceTree       `json:"files,omitempty"`

     

       16
       16
       -
       	Branches       []Branch         `json:"branches,omitempty"`

     

       17
       17
       -
       	Tags           []*TagReference  `json:"tags,omitempty"`

     

       18
       18
       -
       	TotalCommits   int              `json:"total_commits,omitempty"`

     

       11
       11
       +
       	IsEmpty        bool            `json:"is_empty"`

     

       12
       12
       +
       	Ref            string          `json:"ref,omitempty"`

     

       13
       13
       +
       	Readme         string          `json:"readme,omitempty"`

     

       14
       14
       +
       	ReadmeFileName string          `json:"readme_file_name,omitempty"`

     

       15
       15
       +
       	Commits        []Commit        `json:"commits,omitempty"`

     

       16
       16
       +
       	Description    string          `json:"description,omitempty"`

     

       17
       17
       +
       	Files          []NiceTree      `json:"files,omitempty"`

     

       18
       18
       +
       	Branches       []Branch        `json:"branches,omitempty"`

     

       19
       19
       +
       	Tags           []*TagReference `json:"tags,omitempty"`

     

       20
       20
       +
       	TotalCommits   int             `json:"total_commits,omitempty"`

     

       19
       21
        
       }

     

       20
       22
        
       

     

       21
       23
        
       type RepoLogResponse struct {

     

       22
       22
       -
       	Commits     []*object.Commit `json:"commits,omitempty"`

     

       23
       23
       -
       	Ref         string           `json:"ref,omitempty"`

     

       24
       24
       -
       	Description string           `json:"description,omitempty"`

     

       25
       25
       -
       	Log         bool             `json:"log,omitempty"`

     

       26
       26
       -
       	Total       int              `json:"total,omitempty"`

     

       27
       27
       -
       	Page        int              `json:"page,omitempty"`

     

       28
       28
       -
       	PerPage     int              `json:"per_page,omitempty"`

     

       24
       24
       +
       	Commits     []Commit `json:"commits,omitempty"`

     

       25
       25
       +
       	Ref         string   `json:"ref,omitempty"`

     

       26
       26
       +
       	Description string   `json:"description,omitempty"`

     

       27
       27
       +
       	Log         bool     `json:"log,omitempty"`

     

       28
       28
       +
       	Total       int      `json:"total,omitempty"`

     

       29
       29
       +
       	Page        int      `json:"page,omitempty"`

     

       30
       30
       +
       	PerPage     int      `json:"per_page,omitempty"`

     

       29
       31
        
       }

     

       30
       32
        
       

     

       31
       33
        
       type RepoCommitResponse struct {

     
···

       66
       68
        
       type Branch struct {

     

       67
       69
        
       	Reference `json:"reference"`

     

       68
       70
        
       	Commit    *object.Commit `json:"commit,omitempty"`

     

       69
       69
       -
       	IsDefault bool           `json:"is_deafult,omitempty"`

     

       71
       71
       +
       	IsDefault bool           `json:"is_default,omitempty"`

     

       72
       72
       +
       }

     

       73
       73
       +
       

     

       74
       74
       +
       func (b *Branch) UnmarshalJSON(data []byte) error {

     

       75
       75
       +
       	aux := &struct {

     

       76
       76
       +
       		Reference          `json:"reference"`

     

       77
       77
       +
       		Commit             *object.Commit `json:"commit,omitempty"`

     

       78
       78
       +
       		IsDefault          bool           `json:"is_default,omitempty"`

     

       79
       79
       +
       		MispelledIsDefault bool           `json:"is_deafult,omitempty"` // mispelled name

     

       80
       80
       +
       	}{}

     

       81
       81
       +
       

     

       82
       82
       +
       	if err := json.Unmarshal(data, aux); err != nil {

     

       83
       83
       +
       		return err

     

       84
       84
       +
       	}

     

       85
       85
       +
       

     

       86
       86
       +
       	b.Reference = aux.Reference

     

       87
       87
       +
       	b.Commit = aux.Commit

     

       88
       88
       +
       	b.IsDefault = aux.IsDefault || aux.MispelledIsDefault // whichever was set

     

       89
       89
       +
       

     

       90
       90
       +
       	return nil

     

       70
       91
        
       }

     

       71
       92
        
       

     

       72
       93
        
       type RepoTagsResponse struct {

+88 -5

types/tree.go

···

       1
       1
        
       package types

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"fmt"

     

       5
       5
       +
       	"os"

     

       4
       6
        
       	"time"

     

       5
       7
        
       

     

       6
       8
        
       	"github.com/go-git/go-git/v5/plumbing"

     

       9
       9
       +
       	"github.com/go-git/go-git/v5/plumbing/filemode"

     

       7
       10
        
       )

     

       8
       11
        
       

     

       9
       12
        
       // A nicer git tree representation.

     

       10
       13
        
       type NiceTree struct {

     

       11
       14
        
       	// Relative path

     

       12
       12
       -
       	Name      string `json:"name"`

     

       13
       13
       -
       	Mode      string `json:"mode"`

     

       14
       14
       -
       	Size      int64  `json:"size"`

     

       15
       15
       -
       	IsFile    bool   `json:"is_file"`

     

       16
       16
       -
       	IsSubtree bool   `json:"is_subtree"`

     

       15
       15
       +
       	Name string `json:"name"`

     

       16
       16
       +
       	Mode string `json:"mode"`

     

       17
       17
       +
       	Size int64  `json:"size"`

     

       17
       18
        
       

     

       18
       19
        
       	LastCommit *LastCommitInfo `json:"last_commit,omitempty"`

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       func (t *NiceTree) FileMode() (filemode.FileMode, error) {

     

       23
       23
       +
       	if numericMode, err := filemode.New(t.Mode); err == nil {

     

       24
       24
       +
       		return numericMode, nil

     

       25
       25
       +
       	}

     

       26
       26
       +
       

     

       27
       27
       +
       	// TODO: this is here for backwards compat, can be removed in future versions

     

       28
       28
       +
       	osMode, err := parseModeString(t.Mode)

     

       29
       29
       +
       	if err != nil {

     

       30
       30
       +
       		return filemode.Empty, nil

     

       31
       31
       +
       	}

     

       32
       32
       +
       

     

       33
       33
       +
       	conv, err := filemode.NewFromOSFileMode(osMode)

     

       34
       34
       +
       	if err != nil {

     

       35
       35
       +
       		return filemode.Empty, nil

     

       36
       36
       +
       	}

     

       37
       37
       +
       

     

       38
       38
       +
       	return conv, nil

     

       39
       39
       +
       }

     

       40
       40
       +
       

     

       41
       41
       +
       // ParseFileModeString parses a file mode string like "-rw-r--r--"

     

       42
       42
       +
       // and returns an os.FileMode

     

       43
       43
       +
       func parseModeString(modeStr string) (os.FileMode, error) {

     

       44
       44
       +
       	if len(modeStr) != 10 {

     

       45
       45
       +
       		return 0, fmt.Errorf("invalid mode string length: expected 10, got %d", len(modeStr))

     

       46
       46
       +
       	}

     

       47
       47
       +
       

     

       48
       48
       +
       	var mode os.FileMode

     

       49
       49
       +
       

     

       50
       50
       +
       	// Parse file type (first character)

     

       51
       51
       +
       	switch modeStr[0] {

     

       52
       52
       +
       	case 'd':

     

       53
       53
       +
       		mode |= os.ModeDir

     

       54
       54
       +
       	case 'l':

     

       55
       55
       +
       		mode |= os.ModeSymlink

     

       56
       56
       +
       	case '-':

     

       57
       57
       +
       		// regular file

     

       58
       58
       +
       	default:

     

       59
       59
       +
       		return 0, fmt.Errorf("unknown file type: %c", modeStr[0])

     

       60
       60
       +
       	}

     

       61
       61
       +
       

     

       62
       62
       +
       	// parse permissions for owner, group, and other

     

       63
       63
       +
       	perms := modeStr[1:]

     

       64
       64
       +
       	shifts := []int{6, 3, 0} // bit shifts for owner, group, other

     

       65
       65
       +
       

     

       66
       66
       +
       	for i := range 3 {

     

       67
       67
       +
       		offset := i * 3

     

       68
       68
       +
       		shift := shifts[i]

     

       69
       69
       +
       

     

       70
       70
       +
       		if perms[offset] == 'r' {

     

       71
       71
       +
       			mode |= os.FileMode(4 << shift)

     

       72
       72
       +
       		}

     

       73
       73
       +
       		if perms[offset+1] == 'w' {

     

       74
       74
       +
       			mode |= os.FileMode(2 << shift)

     

       75
       75
       +
       		}

     

       76
       76
       +
       		if perms[offset+2] == 'x' {

     

       77
       77
       +
       			mode |= os.FileMode(1 << shift)

     

       78
       78
       +
       		}

     

       79
       79
       +
       	}

     

       80
       80
       +
       

     

       81
       81
       +
       	return mode, nil

     

       82
       82
       +
       }

     

       83
       83
       +
       

     

       84
       84
       +
       func (t *NiceTree) IsFile() bool {

     

       85
       85
       +
       	m, err := t.FileMode()

     

       86
       86
       +
       

     

       87
       87
       +
       	if err != nil {

     

       88
       88
       +
       		return false

     

       89
       89
       +
       	}

     

       90
       90
       +
       

     

       91
       91
       +
       	return m.IsFile()

     

       92
       92
       +
       }

     

       93
       93
       +
       

     

       94
       94
       +
       func (t *NiceTree) IsSubmodule() bool {

     

       95
       95
       +
       	m, err := t.FileMode()

     

       96
       96
       +
       

     

       97
       97
       +
       	if err != nil {

     

       98
       98
       +
       		return false

     

       99
       99
       +
       	}

     

       100
       100
       +
       

     

       101
       101
       +
       	return m == filemode.Submodule

     

       19
       102
        
       }

     

       20
       103
        
       

     

       21
       104
        
       type LastCommitInfo struct {

Compare changes