+16 -73

api/tangled/cbor_gen.go

··· 5898 } 5899 5900 cw := cbg.NewCborWriter(w) 5901 - fieldCount := 6 5902 - 5903 - if t.Owner == nil { 5904 - fieldCount-- 5905 - } 5906 5907 - if t.Repo == nil { 5908 fieldCount-- 5909 } 5910 ··· 5935 return err 5936 } 5937 5938 - // t.Repo (string) (string) 5939 - if t.Repo != nil { 5940 - 5941 - if len("repo") > 1000000 { 5942 - return xerrors.Errorf("Value in field \"repo\" was too long") 5943 - } 5944 - 5945 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 5946 - return err 5947 - } 5948 - if _, err := cw.WriteString(string("repo")); err != nil { 5949 - return err 5950 - } 5951 - 5952 - if t.Repo == nil { 5953 - if _, err := cw.Write(cbg.CborNull); err != nil { 5954 - return err 5955 - } 5956 - } else { 5957 - if len(*t.Repo) > 1000000 { 5958 - return xerrors.Errorf("Value in field t.Repo was too long") 5959 - } 5960 - 5961 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil { 5962 - return err 5963 - } 5964 - if _, err := cw.WriteString(string(*t.Repo)); err != nil { 5965 - return err 5966 - } 5967 - } 5968 - } 5969 - 5970 // t.LexiconTypeID (string) (string) 5971 if len("$type") > 1000000 { 5972 return xerrors.Errorf("Value in field \"$type\" was too long") ··· 6009 return err 6010 } 6011 6012 - // t.Owner (string) (string) 6013 - if t.Owner != nil { 6014 6015 - if len("owner") > 1000000 { 6016 - return xerrors.Errorf("Value in field \"owner\" was too long") 6017 } 6018 6019 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil { 6020 return err 6021 } 6022 - if _, err := cw.WriteString(string("owner")); err != nil { 6023 return err 6024 } 6025 6026 - if t.Owner == nil { 6027 if _, err := cw.Write(cbg.CborNull); err != nil { 6028 return err 6029 } 6030 } else { 6031 - if len(*t.Owner) > 1000000 { 6032 - return xerrors.Errorf("Value in field t.Owner was too long") 6033 } 6034 6035 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Owner))); err != nil { 6036 return err 6037 } 6038 - if _, err := cw.WriteString(string(*t.Owner)); err != nil { 6039 return err 6040 } 6041 } ··· 6118 6119 t.Body = string(sval) 6120 } 6121 - // t.Repo (string) (string) 6122 - case "repo": 6123 - 6124 - { 6125 - b, err := cr.ReadByte() 6126 - if err != nil { 6127 - return err 6128 - } 6129 - if b != cbg.CborNull[0] { 6130 - if err := cr.UnreadByte(); err != nil { 6131 - return err 6132 - } 6133 - 6134 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6135 - if err != nil { 6136 - return err 6137 - } 6138 - 6139 - t.Repo = (*string)(&sval) 6140 - } 6141 - } 6142 // t.LexiconTypeID (string) (string) 6143 case "$type": 6144 ··· 6161 6162 t.Issue = string(sval) 6163 } 6164 - // t.Owner (string) (string) 6165 - case "owner": 6166 6167 { 6168 b, err := cr.ReadByte() ··· 6179 return err 6180 } 6181 6182 - t.Owner = (*string)(&sval) 6183 } 6184 } 6185 // t.CreatedAt (string) (string)

··· 5898 } 5899 5900 cw := cbg.NewCborWriter(w) 5901 + fieldCount := 5 0 0 0 0 5902 5903 + if t.ReplyTo == nil { 5904 fieldCount-- 5905 } 5906 ··· 5931 return err 5932 } 5933 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 5934 // t.LexiconTypeID (string) (string) 5935 if len("$type") > 1000000 { 5936 return xerrors.Errorf("Value in field \"$type\" was too long") ··· 5973 return err 5974 } 5975 5976 + // t.ReplyTo (string) (string) 5977 + if t.ReplyTo != nil { 5978 5979 + if len("replyTo") > 1000000 { 5980 + return xerrors.Errorf("Value in field \"replyTo\" was too long") 5981 } 5982 5983 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("replyTo"))); err != nil { 5984 return err 5985 } 5986 + if _, err := cw.WriteString(string("replyTo")); err != nil { 5987 return err 5988 } 5989 5990 + if t.ReplyTo == nil { 5991 if _, err := cw.Write(cbg.CborNull); err != nil { 5992 return err 5993 } 5994 } else { 5995 + if len(*t.ReplyTo) > 1000000 { 5996 + return xerrors.Errorf("Value in field t.ReplyTo was too long") 5997 } 5998 5999 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.ReplyTo))); err != nil { 6000 return err 6001 } 6002 + if _, err := cw.WriteString(string(*t.ReplyTo)); err != nil { 6003 return err 6004 } 6005 } ··· 6082 6083 t.Body = string(sval) 6084 } 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6085 // t.LexiconTypeID (string) (string) 6086 case "$type": 6087 ··· 6104 6105 t.Issue = string(sval) 6106 } 6107 + // t.ReplyTo (string) (string) 6108 + case "replyTo": 6109 6110 { 6111 b, err := cr.ReadByte() ··· 6122 return err 6123 } 6124 6125 + t.ReplyTo = (*string)(&sval) 6126 } 6127 } 6128 // t.CreatedAt (string) (string)

+1 -2

api/tangled/issuecomment.go

··· 21 Body string `json:"body" cborgen:"body"` 22 CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 Issue string `json:"issue" cborgen:"issue"` 24 - Owner *string `json:"owner,omitempty" cborgen:"owner,omitempty"` 25 - Repo *string `json:"repo,omitempty" cborgen:"repo,omitempty"` 26 }

··· 21 Body string `json:"body" cborgen:"body"` 22 CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 Issue string `json:"issue" cborgen:"issue"` 24 + ReplyTo *string `json:"replyTo,omitempty" cborgen:"replyTo,omitempty"` 0 25 }

+30

api/tangled/knotversion.go

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 + 3 + package tangled 4 + 5 + // schema: sh.tangled.knot.version 6 + 7 + import ( 8 + "context" 9 + 10 + "github.com/bluesky-social/indigo/lex/util" 11 + ) 12 + 13 + const ( 14 + KnotVersionNSID = "sh.tangled.knot.version" 15 + ) 16 + 17 + // KnotVersion_Output is the output of a sh.tangled.knot.version call. 18 + type KnotVersion_Output struct { 19 + Version string `json:"version" cborgen:"version"` 20 + } 21 + 22 + // KnotVersion calls the XRPC method "sh.tangled.knot.version". 23 + func KnotVersion(ctx context.Context, c util.LexClient) (*KnotVersion_Output, error) { 24 + var out KnotVersion_Output 25 + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.knot.version", nil, nil, &out); err != nil { 26 + return nil, err 27 + } 28 + 29 + return &out, nil 30 + }

+30

api/tangled/tangledowner.go

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 + 3 + package tangled 4 + 5 + // schema: sh.tangled.owner 6 + 7 + import ( 8 + "context" 9 + 10 + "github.com/bluesky-social/indigo/lex/util" 11 + ) 12 + 13 + const ( 14 + OwnerNSID = "sh.tangled.owner" 15 + ) 16 + 17 + // Owner_Output is the output of a sh.tangled.owner call. 18 + type Owner_Output struct { 19 + Owner string `json:"owner" cborgen:"owner"` 20 + } 21 + 22 + // Owner calls the XRPC method "sh.tangled.owner". 23 + func Owner(ctx context.Context, c util.LexClient) (*Owner_Output, error) { 24 + var out Owner_Output 25 + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.owner", nil, nil, &out); err != nil { 26 + return nil, err 27 + } 28 + 29 + return &out, nil 30 + }

+169

appview/db/db.go

··· 703 return err 704 }) 705 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 706 return &DB{db}, nil 707 } 708 ··· 747 } 748 749 return nil 0 0 0 0 750 } 751 752 type filter struct {

··· 703 return err 704 }) 705 706 + // repurpose the read-only column to "needs-upgrade" 707 + runMigration(conn, "rename-registrations-read-only-to-needs-upgrade", func(tx *sql.Tx) error { 708 + _, err := tx.Exec(` 709 + alter table registrations rename column read_only to needs_upgrade; 710 + `) 711 + return err 712 + }) 713 + 714 + // require all knots to upgrade after the release of total xrpc 715 + runMigration(conn, "migrate-knots-to-total-xrpc", func(tx *sql.Tx) error { 716 + _, err := tx.Exec(` 717 + update registrations set needs_upgrade = 1; 718 + `) 719 + return err 720 + }) 721 + 722 + // require all knots to upgrade after the release of total xrpc 723 + runMigration(conn, "migrate-spindles-to-xrpc-owner", func(tx *sql.Tx) error { 724 + _, err := tx.Exec(` 725 + alter table spindles add column needs_upgrade integer not null default 0; 726 + `) 727 + if err != nil { 728 + return err 729 + } 730 + 731 + _, err = tx.Exec(` 732 + update spindles set needs_upgrade = 1; 733 + `) 734 + return err 735 + }) 736 + 737 + // remove issue_at from issues and replace with generated column 738 + // 739 + // this requires a full table recreation because stored columns 740 + // cannot be added via alter 741 + // 742 + // couple other changes: 743 + // - columns renamed to be more consistent 744 + // - adds edited and deleted fields 745 + // 746 + // disable foreign-keys for the next migration 747 + conn.ExecContext(ctx, "pragma foreign_keys = off;") 748 + runMigration(conn, "remove-issue-at-from-issues", func(tx *sql.Tx) error { 749 + _, err := tx.Exec(` 750 + create table if not exists issues_new ( 751 + -- identifiers 752 + id integer primary key autoincrement, 753 + did text not null, 754 + rkey text not null, 755 + at_uri text generated always as ('at://' || did || '/' || 'sh.tangled.repo.issue' || '/' || rkey) stored, 756 + 757 + -- at identifiers 758 + repo_at text not null, 759 + 760 + -- content 761 + issue_id integer not null, 762 + title text not null, 763 + body text not null, 764 + open integer not null default 1, 765 + created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')), 766 + edited text, -- timestamp 767 + deleted text, -- timestamp 768 + 769 + unique(did, rkey), 770 + unique(repo_at, issue_id), 771 + unique(at_uri), 772 + foreign key (repo_at) references repos(at_uri) on delete cascade 773 + ); 774 + `) 775 + if err != nil { 776 + return err 777 + } 778 + 779 + // transfer data 780 + _, err = tx.Exec(` 781 + insert into issues_new (id, did, rkey, repo_at, issue_id, title, body, open, created) 782 + select 783 + i.id, 784 + i.owner_did, 785 + i.rkey, 786 + i.repo_at, 787 + i.issue_id, 788 + i.title, 789 + i.body, 790 + i.open, 791 + i.created 792 + from issues i; 793 + `) 794 + if err != nil { 795 + return err 796 + } 797 + 798 + // drop old table 799 + _, err = tx.Exec(`drop table issues`) 800 + if err != nil { 801 + return err 802 + } 803 + 804 + // rename new table 805 + _, err = tx.Exec(`alter table issues_new rename to issues`) 806 + return err 807 + }) 808 + conn.ExecContext(ctx, "pragma foreign_keys = on;") 809 + 810 + // - renames the comments table to 'issue_comments' 811 + // - rework issue comments to update constraints: 812 + // * unique(did, rkey) 813 + // * remove comment-id and just use the global ID 814 + // * foreign key (repo_at, issue_id) 815 + // - new columns 816 + // * column "reply_to" which can be any other comment 817 + // * column "at-uri" which is a generated column 818 + runMigration(conn, "rework-issue-comments", func(tx *sql.Tx) error { 819 + _, err := tx.Exec(` 820 + create table if not exists issue_comments ( 821 + -- identifiers 822 + id integer primary key autoincrement, 823 + did text not null, 824 + rkey text, 825 + at_uri text generated always as ('at://' || did || '/' || 'sh.tangled.repo.issue.comment' || '/' || rkey) stored, 826 + 827 + -- at identifiers 828 + issue_at text not null, 829 + reply_to text, -- at_uri of parent comment 830 + 831 + -- content 832 + body text not null, 833 + created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')), 834 + edited text, 835 + deleted text, 836 + 837 + -- constraints 838 + unique(did, rkey), 839 + unique(at_uri), 840 + foreign key (issue_at) references issues(at_uri) on delete cascade 841 + ); 842 + `) 843 + if err != nil { 844 + return err 845 + } 846 + 847 + // transfer data 848 + _, err = tx.Exec(` 849 + insert into issue_comments (id, did, rkey, issue_at, body, created, edited, deleted) 850 + select 851 + c.id, 852 + c.owner_did, 853 + c.rkey, 854 + i.at_uri, -- get at_uri from issues table 855 + c.body, 856 + c.created, 857 + c.edited, 858 + c.deleted 859 + from comments c 860 + join issues i on c.repo_at = i.repo_at and c.issue_id = i.issue_id; 861 + `) 862 + if err != nil { 863 + return err 864 + } 865 + 866 + // drop old table 867 + _, err = tx.Exec(`drop table comments`) 868 + return err 869 + }) 870 + 871 return &DB{db}, nil 872 } 873 ··· 912 } 913 914 return nil 915 + } 916 + 917 + func (d *DB) Close() error { 918 + return d.DB.Close() 919 } 920 921 type filter struct {

+410 -453

appview/db/issues.go

··· 3 import ( 4 "database/sql" 5 "fmt" 6 - mathrand "math/rand/v2" 0 0 7 "strings" 8 "time" 9 ··· 13 ) 14 15 type Issue struct { 16 - ID int64 17 - RepoAt syntax.ATURI 18 - OwnerDid string 19 - IssueId int 20 - Rkey string 21 - Created time.Time 22 - Title string 23 - Body string 24 - Open bool 0 0 25 26 // optionally, populate this when querying for reverse mappings 27 // like comment counts, parent repo etc. 28 - Metadata *IssueMetadata 0 29 } 30 31 - type IssueMetadata struct { 32 - CommentCount int 33 - Repo *Repo 34 - // labels, assignee etc. 35 } 36 37 - type Comment struct { 38 - OwnerDid string 39 - RepoAt syntax.ATURI 40 - Rkey string 41 - Issue int 42 - CommentId int 43 - Body string 44 - Created *time.Time 45 - Deleted *time.Time 46 - Edited *time.Time 47 } 48 49 - func (i *Issue) AtUri() syntax.ATURI { 50 - return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", i.OwnerDid, tangled.RepoIssueNSID, i.Rkey)) 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 51 } 52 53 func IssueFromRecord(did, rkey string, record tangled.RepoIssue) Issue { ··· 62 } 63 64 return Issue{ 65 - RepoAt: syntax.ATURI(record.Repo), 66 - OwnerDid: did, 67 - Rkey: rkey, 68 - Created: created, 69 - Title: record.Title, 70 - Body: body, 71 - Open: true, // new issues are open by default 72 } 73 } 74 75 - func ResolveIssueFromAtUri(e Execer, issueUri syntax.ATURI) (syntax.ATURI, int, error) { 76 - ownerDid := issueUri.Authority().String() 77 - issueRkey := issueUri.RecordKey().String() 0 0 0 0 0 0 0 0 78 79 - var repoAt string 80 - var issueId int 0 81 82 - query := `select repo_at, issue_id from issues where owner_did = ? and rkey = ?` 83 - err := e.QueryRow(query, ownerDid, issueRkey).Scan(&repoAt, &issueId) 84 - if err != nil { 85 - return "", 0, err 0 0 86 } 0 87 88 - return syntax.ATURI(repoAt), issueId, nil 0 89 } 90 91 - func IssueCommentFromRecord(e Execer, did, rkey string, record tangled.RepoIssueComment) (Comment, error) { 92 created, err := time.Parse(time.RFC3339, record.CreatedAt) 93 if err != nil { 94 created = time.Now() 95 } 96 97 ownerDid := did 98 - if record.Owner != nil { 99 - ownerDid = *record.Owner 100 - } 101 102 - issueUri, err := syntax.ParseATURI(record.Issue) 103 - if err != nil { 104 - return Comment{}, err 105 - } 106 - 107 - repoAt, issueId, err := ResolveIssueFromAtUri(e, issueUri) 108 - if err != nil { 109 - return Comment{}, err 110 } 111 112 - comment := Comment{ 113 - OwnerDid: ownerDid, 114 - RepoAt: repoAt, 115 - Rkey: rkey, 116 - Body: record.Body, 117 - Issue: issueId, 118 - CommentId: mathrand.IntN(1000000), 119 - Created: &created, 120 } 121 122 - return comment, nil 123 } 124 125 - func NewIssue(tx *sql.Tx, issue *Issue) error { 126 - defer tx.Rollback() 127 - 128 _, err := tx.Exec(` 129 insert or ignore into repo_issue_seqs (repo_at, next_issue_id) 130 values (?, 1) 131 - `, issue.RepoAt) 132 if err != nil { 133 return err 134 } 135 136 - var nextId int 137 - err = tx.QueryRow(` 138 - update repo_issue_seqs 139 - set next_issue_id = next_issue_id + 1 140 - where repo_at = ? 141 - returning next_issue_id - 1 142 - `, issue.RepoAt).Scan(&nextId) 143 - if err != nil { 144 return err 145 - } 146 - 147 - issue.IssueId = nextId 0 0 0 0 0 0 0 148 149 - res, err := tx.Exec(` 150 - insert into issues (repo_at, owner_did, rkey, issue_at, issue_id, title, body) 151 - values (?, ?, ?, ?, ?, ?, ?) 152 - `, issue.RepoAt, issue.OwnerDid, issue.Rkey, issue.AtUri(), issue.IssueId, issue.Title, issue.Body) 153 - if err != nil { 154 - return err 155 } 0 156 157 - lastID, err := res.LastInsertId() 0 0 0 0 0 0 0 0 158 if err != nil { 159 return err 160 } 161 - issue.ID = lastID 162 163 - if err := tx.Commit(); err != nil { 164 - return err 165 - } 0 0 0 166 167 - return nil 168 } 169 170 - func GetIssueAt(e Execer, repoAt syntax.ATURI, issueId int) (string, error) { 171 - var issueAt string 172 - err := e.QueryRow(`select issue_at from issues where repo_at = ? and issue_id = ?`, repoAt, issueId).Scan(&issueAt) 173 - return issueAt, err 174 - } 175 - 176 - func GetIssueOwnerDid(e Execer, repoAt syntax.ATURI, issueId int) (string, error) { 177 - var ownerDid string 178 - err := e.QueryRow(`select owner_did from issues where repo_at = ? and issue_id = ?`, repoAt, issueId).Scan(&ownerDid) 179 - return ownerDid, err 180 - } 181 - 182 - func GetIssuesPaginated(e Execer, repoAt syntax.ATURI, isOpen bool, page pagination.Page) ([]Issue, error) { 183 - var issues []Issue 184 - openValue := 0 185 - if isOpen { 186 - openValue = 1 187 - } 188 - 189 - rows, err := e.Query( 190 - ` 191 - with numbered_issue as ( 192 - select 193 - i.id, 194 - i.owner_did, 195 - i.rkey, 196 - i.issue_id, 197 - i.created, 198 - i.title, 199 - i.body, 200 - i.open, 201 - count(c.id) as comment_count, 202 - row_number() over (order by i.created desc) as row_num 203 - from 204 - issues i 205 - left join 206 - comments c on i.repo_at = c.repo_at and i.issue_id = c.issue_id 207 - where 208 - i.repo_at = ? and i.open = ? 209 - group by 210 - i.id, i.owner_did, i.issue_id, i.created, i.title, i.body, i.open 211 - ) 212 - select 213 - id, 214 - owner_did, 215 - rkey, 216 - issue_id, 217 - created, 218 - title, 219 - body, 220 - open, 221 - comment_count 222 - from 223 - numbered_issue 224 - where 225 - row_num between ? and ?`, 226 - repoAt, openValue, page.Offset+1, page.Offset+page.Limit) 227 - if err != nil { 228 - return nil, err 229 - } 230 - defer rows.Close() 231 - 232 - for rows.Next() { 233 - var issue Issue 234 - var createdAt string 235 - var metadata IssueMetadata 236 - err := rows.Scan(&issue.ID, &issue.OwnerDid, &issue.Rkey, &issue.IssueId, &createdAt, &issue.Title, &issue.Body, &issue.Open, &metadata.CommentCount) 237 - if err != nil { 238 - return nil, err 239 - } 240 - 241 - createdTime, err := time.Parse(time.RFC3339, createdAt) 242 - if err != nil { 243 - return nil, err 244 - } 245 - issue.Created = createdTime 246 - issue.Metadata = &metadata 247 - 248 - issues = append(issues, issue) 249 - } 250 - 251 - if err := rows.Err(); err != nil { 252 - return nil, err 253 - } 254 - 255 - return issues, nil 256 } 257 258 - func GetIssuesWithLimit(e Execer, limit int, filters ...filter) ([]Issue, error) { 259 - issues := make([]Issue, 0, limit) 260 261 var conditions []string 262 var args []any 0 263 for _, filter := range filters { 264 conditions = append(conditions, filter.Condition()) 265 args = append(args, filter.Arg()...) ··· 269 if conditions != nil { 270 whereClause = " where " + strings.Join(conditions, " and ") 271 } 272 - limitClause := "" 273 - if limit != 0 { 274 - limitClause = fmt.Sprintf(" limit %d ", limit) 275 - } 0 0 0 276 277 query := fmt.Sprintf( 278 - `select 279 - i.id, 280 - i.owner_did, 281 - i.repo_at, 282 - i.issue_id, 283 - i.created, 284 - i.title, 285 - i.body, 286 - i.open 287 - from 288 - issues i 0 0 0 0 0 0 0 0 289 %s 290 - order by 291 - i.created desc 292 - %s`, 293 - whereClause, limitClause) 294 295 rows, err := e.Query(query, args...) 296 if err != nil { 297 - return nil, err 298 } 299 defer rows.Close() 300 301 for rows.Next() { 302 var issue Issue 303 - var issueCreatedAt string 0 0 304 err := rows.Scan( 305 - &issue.ID, 306 - &issue.OwnerDid, 0 307 &issue.RepoAt, 308 &issue.IssueId, 309 - &issueCreatedAt, 310 &issue.Title, 311 &issue.Body, 312 &issue.Open, 0 0 0 0 313 ) 314 if err != nil { 315 - return nil, err 0 0 0 0 0 0 0 0 0 0 316 } 317 318 - issueCreatedTime, err := time.Parse(time.RFC3339, issueCreatedAt) 319 - if err != nil { 320 - return nil, err 0 321 } 322 - issue.Created = issueCreatedTime 323 324 - issues = append(issues, issue) 0 325 } 326 327 - if err := rows.Err(); err != nil { 328 - return nil, err 0 0 329 } 330 331 - return issues, nil 332 - } 333 - 334 - func GetIssues(e Execer, filters ...filter) ([]Issue, error) { 335 - return GetIssuesWithLimit(e, 0, filters...) 336 - } 337 - 338 - // timeframe here is directly passed into the sql query filter, and any 339 - // timeframe in the past should be negative; e.g.: "-3 months" 340 - func GetIssuesByOwnerDid(e Execer, ownerDid string, timeframe string) ([]Issue, error) { 341 - var issues []Issue 342 - 343 - rows, err := e.Query( 344 - `select 345 - i.id, 346 - i.owner_did, 347 - i.rkey, 348 - i.repo_at, 349 - i.issue_id, 350 - i.created, 351 - i.title, 352 - i.body, 353 - i.open, 354 - r.did, 355 - r.name, 356 - r.knot, 357 - r.rkey, 358 - r.created 359 - from 360 - issues i 361 - join 362 - repos r on i.repo_at = r.at_uri 363 - where 364 - i.owner_did = ? and i.created >= date ('now', ?) 365 - order by 366 - i.created desc`, 367 - ownerDid, timeframe) 368 if err != nil { 369 - return nil, err 370 } 371 - defer rows.Close() 372 373 - for rows.Next() { 374 - var issue Issue 375 - var issueCreatedAt, repoCreatedAt string 376 - var repo Repo 377 - err := rows.Scan( 378 - &issue.ID, 379 - &issue.OwnerDid, 380 - &issue.Rkey, 381 - &issue.RepoAt, 382 - &issue.IssueId, 383 - &issueCreatedAt, 384 - &issue.Title, 385 - &issue.Body, 386 - &issue.Open, 387 - &repo.Did, 388 - &repo.Name, 389 - &repo.Knot, 390 - &repo.Rkey, 391 - &repoCreatedAt, 392 - ) 393 - if err != nil { 394 - return nil, err 395 - } 396 397 - issueCreatedTime, err := time.Parse(time.RFC3339, issueCreatedAt) 398 - if err != nil { 399 - return nil, err 0 0 0 0 400 } 401 - issue.Created = issueCreatedTime 402 403 - repoCreatedTime, err := time.Parse(time.RFC3339, repoCreatedAt) 404 - if err != nil { 405 - return nil, err 406 - } 407 - repo.Created = repoCreatedTime 0 408 409 - issue.Metadata = &IssueMetadata{ 410 - Repo: &repo, 0 0 411 } 412 - 413 - issues = append(issues, issue) 414 } 415 416 - if err := rows.Err(); err != nil { 417 - return nil, err 0 418 } 419 0 0 0 0 420 return issues, nil 421 } 422 0 0 0 0 423 func GetIssue(e Execer, repoAt syntax.ATURI, issueId int) (*Issue, error) { 424 query := `select id, owner_did, rkey, created, title, body, open from issues where repo_at = ? and issue_id = ?` 425 row := e.QueryRow(query, repoAt, issueId) 426 427 var issue Issue 428 var createdAt string 429 - err := row.Scan(&issue.ID, &issue.OwnerDid, &issue.Rkey, &createdAt, &issue.Title, &issue.Body, &issue.Open) 430 if err != nil { 431 return nil, err 432 } ··· 440 return &issue, nil 441 } 442 443 - func GetIssueWithComments(e Execer, repoAt syntax.ATURI, issueId int) (*Issue, []Comment, error) { 444 - query := `select id, owner_did, rkey, issue_id, created, title, body, open from issues where repo_at = ? and issue_id = ?` 445 - row := e.QueryRow(query, repoAt, issueId) 446 - 447 - var issue Issue 448 - var createdAt string 449 - err := row.Scan(&issue.ID, &issue.OwnerDid, &issue.Rkey, &issue.IssueId, &createdAt, &issue.Title, &issue.Body, &issue.Open) 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 450 if err != nil { 451 - return nil, nil, err 452 } 453 454 - createdTime, err := time.Parse(time.RFC3339, createdAt) 455 if err != nil { 456 - return nil, nil, err 457 } 458 - issue.Created = createdTime 0 0 459 460 - comments, err := GetComments(e, repoAt, issueId) 461 - if err != nil { 462 - return nil, nil, err 0 0 0 463 } 464 465 - return &issue, comments, nil 466 - } 0 0 467 468 - func NewIssueComment(e Execer, comment *Comment) error { 469 - query := `insert into comments (owner_did, repo_at, rkey, issue_id, comment_id, body) values (?, ?, ?, ?, ?, ?)` 470 - _, err := e.Exec( 471 - query, 472 - comment.OwnerDid, 473 - comment.RepoAt, 474 - comment.Rkey, 475 - comment.Issue, 476 - comment.CommentId, 477 - comment.Body, 478 - ) 479 return err 480 } 481 482 - func GetComments(e Execer, repoAt syntax.ATURI, issueId int) ([]Comment, error) { 483 - var comments []Comment 0 0 0 0 0 0 0 0 0 0 0 0 484 485 - rows, err := e.Query(` 486 select 487 - owner_did, 488 - issue_id, 489 - comment_id, 490 rkey, 0 0 491 body, 492 created, 493 edited, 494 deleted 495 from 496 - comments 497 - where 498 - repo_at = ? and issue_id = ? 499 - order by 500 - created asc`, 501 - repoAt, 502 - issueId, 503 - ) 504 - if err == sql.ErrNoRows { 505 - return []Comment{}, nil 506 - } 507 if err != nil { 508 return nil, err 509 } 510 - defer rows.Close() 511 512 for rows.Next() { 513 - var comment Comment 514 - var createdAt string 515 - var deletedAt, editedAt, rkey sql.NullString 516 - err := rows.Scan(&comment.OwnerDid, &comment.Issue, &comment.CommentId, &rkey, &comment.Body, &createdAt, &editedAt, &deletedAt) 0 0 0 0 0 0 0 0 0 0 517 if err != nil { 518 return nil, err 519 } 520 521 - createdAtTime, err := time.Parse(time.RFC3339, createdAt) 522 - if err != nil { 523 - return nil, err 524 } 525 - comment.Created = &createdAtTime 526 527 - if deletedAt.Valid { 528 - deletedTime, err := time.Parse(time.RFC3339, deletedAt.String) 529 - if err != nil { 530 - return nil, err 0 0 0 531 } 532 - comment.Deleted = &deletedTime 533 } 534 535 - if editedAt.Valid { 536 - editedTime, err := time.Parse(time.RFC3339, editedAt.String) 537 - if err != nil { 538 - return nil, err 539 } 540 - comment.Edited = &editedTime 541 } 542 543 - if rkey.Valid { 544 - comment.Rkey = rkey.String 545 } 546 547 comments = append(comments, comment) 548 } 549 550 - if err := rows.Err(); err != nil { 551 return nil, err 552 } 553 554 return comments, nil 555 } 556 557 - func GetComment(e Execer, repoAt syntax.ATURI, issueId, commentId int) (*Comment, error) { 558 - query := ` 559 - select 560 - owner_did, body, rkey, created, deleted, edited 561 - from 562 - comments where repo_at = ? and issue_id = ? and comment_id = ? 563 - ` 564 - row := e.QueryRow(query, repoAt, issueId, commentId) 565 - 566 - var comment Comment 567 - var createdAt string 568 - var deletedAt, editedAt, rkey sql.NullString 569 - err := row.Scan(&comment.OwnerDid, &comment.Body, &rkey, &createdAt, &deletedAt, &editedAt) 570 - if err != nil { 571 - return nil, err 572 } 573 574 - createdTime, err := time.Parse(time.RFC3339, createdAt) 575 - if err != nil { 576 - return nil, err 577 } 578 - comment.Created = &createdTime 579 580 - if deletedAt.Valid { 581 - deletedTime, err := time.Parse(time.RFC3339, deletedAt.String) 582 - if err != nil { 583 - return nil, err 584 - } 585 - comment.Deleted = &deletedTime 586 - } 587 588 - if editedAt.Valid { 589 - editedTime, err := time.Parse(time.RFC3339, editedAt.String) 590 - if err != nil { 591 - return nil, err 592 - } 593 - comment.Edited = &editedTime 594 } 595 596 - if rkey.Valid { 597 - comment.Rkey = rkey.String 0 598 } 599 600 - comment.RepoAt = repoAt 601 - comment.Issue = issueId 602 - comment.CommentId = commentId 603 - 604 - return &comment, nil 605 - } 606 - 607 - func EditComment(e Execer, repoAt syntax.ATURI, issueId, commentId int, newBody string) error { 608 - _, err := e.Exec( 609 - ` 610 - update comments 611 - set body = ?, 612 - edited = strftime('%Y-%m-%dT%H:%M:%SZ', 'now') 613 - where repo_at = ? and issue_id = ? and comment_id = ? 614 - `, newBody, repoAt, issueId, commentId) 615 return err 616 } 617 618 - func DeleteComment(e Execer, repoAt syntax.ATURI, issueId, commentId int) error { 619 - _, err := e.Exec( 620 - ` 621 - update comments 622 - set body = "", 623 - deleted = strftime('%Y-%m-%dT%H:%M:%SZ', 'now') 624 - where repo_at = ? and issue_id = ? and comment_id = ? 625 - `, repoAt, issueId, commentId) 626 - return err 627 - } 628 629 - func UpdateCommentByRkey(e Execer, ownerDid, rkey, newBody string) error { 630 - _, err := e.Exec( 631 - ` 632 - update comments 633 - set body = ?, 634 - edited = strftime('%Y-%m-%dT%H:%M:%SZ', 'now') 635 - where owner_did = ? and rkey = ? 636 - `, newBody, ownerDid, rkey) 637 - return err 638 - } 639 640 - func DeleteCommentByRkey(e Execer, ownerDid, rkey string) error { 641 - _, err := e.Exec( 642 - ` 643 - update comments 644 - set body = "", 645 - deleted = strftime('%Y-%m-%dT%H:%M:%SZ', 'now') 646 - where owner_did = ? and rkey = ? 647 - `, ownerDid, rkey) 648 - return err 649 - } 650 - 651 - func UpdateIssueByRkey(e Execer, ownerDid, rkey, title, body string) error { 652 - _, err := e.Exec(`update issues set title = ?, body = ? where owner_did = ? and rkey = ?`, title, body, ownerDid, rkey) 653 - return err 654 - } 655 - 656 - func DeleteIssueByRkey(e Execer, ownerDid, rkey string) error { 657 - _, err := e.Exec(`delete from issues where owner_did = ? and rkey = ?`, ownerDid, rkey) 658 - return err 659 - } 660 - 661 - func CloseIssue(e Execer, repoAt syntax.ATURI, issueId int) error { 662 - _, err := e.Exec(`update issues set open = 0 where repo_at = ? and issue_id = ?`, repoAt, issueId) 663 - return err 664 - } 665 - 666 - func ReopenIssue(e Execer, repoAt syntax.ATURI, issueId int) error { 667 - _, err := e.Exec(`update issues set open = 1 where repo_at = ? and issue_id = ?`, repoAt, issueId) 668 return err 669 } 670

··· 3 import ( 4 "database/sql" 5 "fmt" 6 + "maps" 7 + "slices" 8 + "sort" 9 "strings" 10 "time" 11 ··· 15 ) 16 17 type Issue struct { 18 + Id int64 19 + Did string 20 + Rkey string 21 + RepoAt syntax.ATURI 22 + IssueId int 23 + Created time.Time 24 + Edited *time.Time 25 + Deleted *time.Time 26 + Title string 27 + Body string 28 + Open bool 29 30 // optionally, populate this when querying for reverse mappings 31 // like comment counts, parent repo etc. 32 + Comments []IssueComment 33 + Repo *Repo 34 } 35 36 + func (i *Issue) AtUri() syntax.ATURI { 37 + return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", i.Did, tangled.RepoIssueNSID, i.Rkey)) 0 0 38 } 39 40 + func (i *Issue) AsRecord() tangled.RepoIssue { 41 + return tangled.RepoIssue{ 42 + Repo: i.RepoAt.String(), 43 + Title: i.Title, 44 + Body: &i.Body, 45 + CreatedAt: i.Created.Format(time.RFC3339), 46 + } 0 0 0 47 } 48 49 + func (i *Issue) State() string { 50 + if i.Open { 51 + return "open" 52 + } 53 + return "closed" 54 + } 55 + 56 + type CommentListItem struct { 57 + Self *IssueComment 58 + Replies []*IssueComment 59 + } 60 + 61 + func (i *Issue) CommentList() []CommentListItem { 62 + // Create a map to quickly find comments by their aturi 63 + toplevel := make(map[string]*CommentListItem) 64 + var replies []*IssueComment 65 + 66 + // collect top level comments into the map 67 + for _, comment := range i.Comments { 68 + if comment.IsTopLevel() { 69 + toplevel[comment.AtUri().String()] = &CommentListItem{ 70 + Self: &comment, 71 + } 72 + } else { 73 + replies = append(replies, &comment) 74 + } 75 + } 76 + 77 + for _, r := range replies { 78 + parentAt := *r.ReplyTo 79 + if parent, exists := toplevel[parentAt]; exists { 80 + parent.Replies = append(parent.Replies, r) 81 + } 82 + } 83 + 84 + var listing []CommentListItem 85 + for _, v := range toplevel { 86 + listing = append(listing, *v) 87 + } 88 + 89 + // sort everything 90 + sortFunc := func(a, b *IssueComment) bool { 91 + return a.Created.Before(b.Created) 92 + } 93 + sort.Slice(listing, func(i, j int) bool { 94 + return sortFunc(listing[i].Self, listing[j].Self) 95 + }) 96 + for _, r := range listing { 97 + sort.Slice(r.Replies, func(i, j int) bool { 98 + return sortFunc(r.Replies[i], r.Replies[j]) 99 + }) 100 + } 101 + 102 + return listing 103 } 104 105 func IssueFromRecord(did, rkey string, record tangled.RepoIssue) Issue { ··· 114 } 115 116 return Issue{ 117 + RepoAt: syntax.ATURI(record.Repo), 118 + Did: did, 119 + Rkey: rkey, 120 + Created: created, 121 + Title: record.Title, 122 + Body: body, 123 + Open: true, // new issues are open by default 124 } 125 } 126 127 + type IssueComment struct { 128 + Id int64 129 + Did string 130 + Rkey string 131 + IssueAt string 132 + ReplyTo *string 133 + Body string 134 + Created time.Time 135 + Edited *time.Time 136 + Deleted *time.Time 137 + } 138 139 + func (i *IssueComment) AtUri() syntax.ATURI { 140 + return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", i.Did, tangled.RepoIssueCommentNSID, i.Rkey)) 141 + } 142 143 + func (i *IssueComment) AsRecord() tangled.RepoIssueComment { 144 + return tangled.RepoIssueComment{ 145 + Body: i.Body, 146 + Issue: i.IssueAt, 147 + CreatedAt: i.Created.Format(time.RFC3339), 148 + ReplyTo: i.ReplyTo, 149 } 150 + } 151 152 + func (i *IssueComment) IsTopLevel() bool { 153 + return i.ReplyTo == nil 154 } 155 156 + func IssueCommentFromRecord(e Execer, did, rkey string, record tangled.RepoIssueComment) (*IssueComment, error) { 157 created, err := time.Parse(time.RFC3339, record.CreatedAt) 158 if err != nil { 159 created = time.Now() 160 } 161 162 ownerDid := did 0 0 0 163 164 + if _, err = syntax.ParseATURI(record.Issue); err != nil { 165 + return nil, err 0 0 0 0 0 0 166 } 167 168 + comment := IssueComment{ 169 + Did: ownerDid, 170 + Rkey: rkey, 171 + Body: record.Body, 172 + IssueAt: record.Issue, 173 + ReplyTo: record.ReplyTo, 174 + Created: created, 0 175 } 176 177 + return &comment, nil 178 } 179 180 + func PutIssue(tx *sql.Tx, issue *Issue) error { 181 + // ensure sequence exists 0 182 _, err := tx.Exec(` 183 insert or ignore into repo_issue_seqs (repo_at, next_issue_id) 184 values (?, 1) 185 + `, issue.RepoAt) 186 if err != nil { 187 return err 188 } 189 190 + issues, err := GetIssues( 191 + tx, 192 + FilterEq("did", issue.Did), 193 + FilterEq("rkey", issue.Rkey), 194 + ) 195 + switch { 196 + case err != nil: 0 197 return err 198 + case len(issues) == 0: 199 + return createNewIssue(tx, issue) 200 + case len(issues) != 1: // should be unreachable 201 + return fmt.Errorf("invalid number of issues returned: %d", len(issues)) 202 + default: 203 + // if content is identical, do not edit 204 + existingIssue := issues[0] 205 + if existingIssue.Title == issue.Title && existingIssue.Body == issue.Body { 206 + return nil 207 + } 208 209 + issue.Id = existingIssue.Id 210 + issue.IssueId = existingIssue.IssueId 211 + return updateIssue(tx, issue) 0 0 0 212 } 213 + } 214 215 + func createNewIssue(tx *sql.Tx, issue *Issue) error { 216 + // get next issue_id 217 + var newIssueId int 218 + err := tx.QueryRow(` 219 + update repo_issue_seqs 220 + set next_issue_id = next_issue_id + 1 221 + where repo_at = ? 222 + returning next_issue_id - 1 223 + `, issue.RepoAt).Scan(&newIssueId) 224 if err != nil { 225 return err 226 } 0 227 228 + // insert new issue 229 + row := tx.QueryRow(` 230 + insert into issues (repo_at, did, rkey, issue_id, title, body) 231 + values (?, ?, ?, ?, ?, ?) 232 + returning rowid, issue_id 233 + `, issue.RepoAt, issue.Did, issue.Rkey, newIssueId, issue.Title, issue.Body) 234 235 + return row.Scan(&issue.Id, &issue.IssueId) 236 } 237 238 + func updateIssue(tx *sql.Tx, issue *Issue) error { 239 + // update existing issue 240 + _, err := tx.Exec(` 241 + update issues 242 + set title = ?, body = ?, edited = ? 243 + where did = ? and rkey = ? 244 + `, issue.Title, issue.Body, time.Now().Format(time.RFC3339), issue.Did, issue.Rkey) 245 + return err 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 246 } 247 248 + func GetIssuesPaginated(e Execer, page pagination.Page, filters ...filter) ([]Issue, error) { 249 + issueMap := make(map[string]*Issue) // at-uri -> issue 250 251 var conditions []string 252 var args []any 253 + 254 for _, filter := range filters { 255 conditions = append(conditions, filter.Condition()) 256 args = append(args, filter.Arg()...) ··· 260 if conditions != nil { 261 whereClause = " where " + strings.Join(conditions, " and ") 262 } 263 + 264 + pLower := FilterGte("row_num", page.Offset+1) 265 + pUpper := FilterLte("row_num", page.Offset+page.Limit) 266 + 267 + args = append(args, pLower.Arg()...) 268 + args = append(args, pUpper.Arg()...) 269 + pagination := " where " + pLower.Condition() + " and " + pUpper.Condition() 270 271 query := fmt.Sprintf( 272 + ` 273 + select * from ( 274 + select 275 + id, 276 + did, 277 + rkey, 278 + repo_at, 279 + issue_id, 280 + title, 281 + body, 282 + open, 283 + created, 284 + edited, 285 + deleted, 286 + row_number() over (order by created desc) as row_num 287 + from 288 + issues 289 + %s 290 + ) ranked_issues 291 %s 292 + `, 293 + whereClause, 294 + pagination, 295 + ) 296 297 rows, err := e.Query(query, args...) 298 if err != nil { 299 + return nil, fmt.Errorf("failed to query issues table: %w", err) 300 } 301 defer rows.Close() 302 303 for rows.Next() { 304 var issue Issue 305 + var createdAt string 306 + var editedAt, deletedAt sql.Null[string] 307 + var rowNum int64 308 err := rows.Scan( 309 + &issue.Id, 310 + &issue.Did, 311 + &issue.Rkey, 312 &issue.RepoAt, 313 &issue.IssueId, 0 314 &issue.Title, 315 &issue.Body, 316 &issue.Open, 317 + &createdAt, 318 + &editedAt, 319 + &deletedAt, 320 + &rowNum, 321 ) 322 if err != nil { 323 + return nil, fmt.Errorf("failed to scan issue: %w", err) 324 + } 325 + 326 + if t, err := time.Parse(time.RFC3339, createdAt); err == nil { 327 + issue.Created = t 328 + } 329 + 330 + if editedAt.Valid { 331 + if t, err := time.Parse(time.RFC3339, editedAt.V); err == nil { 332 + issue.Edited = &t 333 + } 334 } 335 336 + if deletedAt.Valid { 337 + if t, err := time.Parse(time.RFC3339, deletedAt.V); err == nil { 338 + issue.Deleted = &t 339 + } 340 } 0 341 342 + atUri := issue.AtUri().String() 343 + issueMap[atUri] = &issue 344 } 345 346 + // collect reverse repos 347 + repoAts := make([]string, 0, len(issueMap)) // or just []string{} 348 + for _, issue := range issueMap { 349 + repoAts = append(repoAts, string(issue.RepoAt)) 350 } 351 352 + repos, err := GetRepos(e, 0, FilterIn("at_uri", repoAts)) 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 353 if err != nil { 354 + return nil, fmt.Errorf("failed to build repo mappings: %w", err) 355 } 0 356 357 + repoMap := make(map[string]*Repo) 358 + for i := range repos { 359 + repoMap[string(repos[i].RepoAt())] = &repos[i] 360 + } 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 361 362 + for issueAt, i := range issueMap { 363 + if r, ok := repoMap[string(i.RepoAt)]; ok { 364 + i.Repo = r 365 + } else { 366 + // do not show up the issue if the repo is deleted 367 + // TODO: foreign key where? 368 + delete(issueMap, issueAt) 369 } 370 + } 371 372 + // collect comments 373 + issueAts := slices.Collect(maps.Keys(issueMap)) 374 + comments, err := GetIssueComments(e, FilterIn("issue_at", issueAts)) 375 + if err != nil { 376 + return nil, fmt.Errorf("failed to query comments: %w", err) 377 + } 378 379 + for i := range comments { 380 + issueAt := comments[i].IssueAt 381 + if issue, ok := issueMap[issueAt]; ok { 382 + issue.Comments = append(issue.Comments, comments[i]) 383 } 0 0 384 } 385 386 + var issues []Issue 387 + for _, i := range issueMap { 388 + issues = append(issues, *i) 389 } 390 391 + sort.Slice(issues, func(i, j int) bool { 392 + return issues[i].Created.After(issues[j].Created) 393 + }) 394 + 395 return issues, nil 396 } 397 398 + func GetIssues(e Execer, filters ...filter) ([]Issue, error) { 399 + return GetIssuesPaginated(e, pagination.FirstPage(), filters...) 400 + } 401 + 402 func GetIssue(e Execer, repoAt syntax.ATURI, issueId int) (*Issue, error) { 403 query := `select id, owner_did, rkey, created, title, body, open from issues where repo_at = ? and issue_id = ?` 404 row := e.QueryRow(query, repoAt, issueId) 405 406 var issue Issue 407 var createdAt string 408 + err := row.Scan(&issue.Id, &issue.Did, &issue.Rkey, &createdAt, &issue.Title, &issue.Body, &issue.Open) 409 if err != nil { 410 return nil, err 411 } ··· 419 return &issue, nil 420 } 421 422 + func AddIssueComment(e Execer, c IssueComment) (int64, error) { 423 + result, err := e.Exec( 424 + `insert into issue_comments ( 425 + did, 426 + rkey, 427 + issue_at, 428 + body, 429 + reply_to, 430 + created, 431 + edited 432 + ) 433 + values (?, ?, ?, ?, ?, ?, null) 434 + on conflict(did, rkey) do update set 435 + issue_at = excluded.issue_at, 436 + body = excluded.body, 437 + edited = case 438 + when 439 + issue_comments.issue_at != excluded.issue_at 440 + or issue_comments.body != excluded.body 441 + or issue_comments.reply_to != excluded.reply_to 442 + then ? 443 + else issue_comments.edited 444 + end`, 445 + c.Did, 446 + c.Rkey, 447 + c.IssueAt, 448 + c.Body, 449 + c.ReplyTo, 450 + c.Created.Format(time.RFC3339), 451 + time.Now().Format(time.RFC3339), 452 + ) 453 if err != nil { 454 + return 0, err 455 } 456 457 + id, err := result.LastInsertId() 458 if err != nil { 459 + return 0, err 460 } 461 + 462 + return id, nil 463 + } 464 465 + func DeleteIssueComments(e Execer, filters ...filter) error { 466 + var conditions []string 467 + var args []any 468 + for _, filter := range filters { 469 + conditions = append(conditions, filter.Condition()) 470 + args = append(args, filter.Arg()...) 471 } 472 473 + whereClause := "" 474 + if conditions != nil { 475 + whereClause = " where " + strings.Join(conditions, " and ") 476 + } 477 478 + query := fmt.Sprintf(`update issue_comments set body = "", deleted = strftime('%%Y-%%m-%%dT%%H:%%M:%%SZ', 'now') %s`, whereClause) 479 + 480 + _, err := e.Exec(query, args...) 0 0 0 0 0 0 0 0 481 return err 482 } 483 484 + func GetIssueComments(e Execer, filters ...filter) ([]IssueComment, error) { 485 + var comments []IssueComment 486 + 487 + var conditions []string 488 + var args []any 489 + for _, filter := range filters { 490 + conditions = append(conditions, filter.Condition()) 491 + args = append(args, filter.Arg()...) 492 + } 493 + 494 + whereClause := "" 495 + if conditions != nil { 496 + whereClause = " where " + strings.Join(conditions, " and ") 497 + } 498 499 + query := fmt.Sprintf(` 500 select 501 + id, 502 + did, 0 503 rkey, 504 + issue_at, 505 + reply_to, 506 body, 507 created, 508 edited, 509 deleted 510 from 511 + issue_comments 512 + %s 513 + `, whereClause) 514 + 515 + rows, err := e.Query(query, args...) 0 0 0 0 0 0 516 if err != nil { 517 return nil, err 518 } 0 519 520 for rows.Next() { 521 + var comment IssueComment 522 + var created string 523 + var rkey, edited, deleted, replyTo sql.Null[string] 524 + err := rows.Scan( 525 + &comment.Id, 526 + &comment.Did, 527 + &rkey, 528 + &comment.IssueAt, 529 + &replyTo, 530 + &comment.Body, 531 + &created, 532 + &edited, 533 + &deleted, 534 + ) 535 if err != nil { 536 return nil, err 537 } 538 539 + // this is a remnant from old times, newer comments always have rkey 540 + if rkey.Valid { 541 + comment.Rkey = rkey.V 542 } 0 543 544 + if t, err := time.Parse(time.RFC3339, created); err == nil { 545 + comment.Created = t 546 + } 547 + 548 + if edited.Valid { 549 + if t, err := time.Parse(time.RFC3339, edited.V); err == nil { 550 + comment.Edited = &t 551 } 0 552 } 553 554 + if deleted.Valid { 555 + if t, err := time.Parse(time.RFC3339, deleted.V); err == nil { 556 + comment.Deleted = &t 0 557 } 0 558 } 559 560 + if replyTo.Valid { 561 + comment.ReplyTo = &replyTo.V 562 } 563 564 comments = append(comments, comment) 565 } 566 567 + if err = rows.Err(); err != nil { 568 return nil, err 569 } 570 571 return comments, nil 572 } 573 574 + func DeleteIssues(e Execer, filters ...filter) error { 575 + var conditions []string 576 + var args []any 577 + for _, filter := range filters { 578 + conditions = append(conditions, filter.Condition()) 579 + args = append(args, filter.Arg()...) 0 0 0 0 0 0 0 0 0 580 } 581 582 + whereClause := "" 583 + if conditions != nil { 584 + whereClause = " where " + strings.Join(conditions, " and ") 585 } 0 586 587 + query := fmt.Sprintf(`delete from issues %s`, whereClause) 588 + _, err := e.Exec(query, args...) 589 + return err 590 + } 0 0 0 591 592 + func CloseIssues(e Execer, filters ...filter) error { 593 + var conditions []string 594 + var args []any 595 + for _, filter := range filters { 596 + conditions = append(conditions, filter.Condition()) 597 + args = append(args, filter.Arg()...) 598 } 599 600 + whereClause := "" 601 + if conditions != nil { 602 + whereClause = " where " + strings.Join(conditions, " and ") 603 } 604 605 + query := fmt.Sprintf(`update issues set open = 0 %s`, whereClause) 606 + _, err := e.Exec(query, args...) 0 0 0 0 0 0 0 0 0 0 0 0 0 607 return err 608 } 609 610 + func ReopenIssues(e Execer, filters ...filter) error { 611 + var conditions []string 612 + var args []any 613 + for _, filter := range filters { 614 + conditions = append(conditions, filter.Condition()) 615 + args = append(args, filter.Arg()...) 616 + } 0 0 0 617 618 + whereClause := "" 619 + if conditions != nil { 620 + whereClause = " where " + strings.Join(conditions, " and ") 621 + } 0 0 0 0 0 0 622 623 + query := fmt.Sprintf(`update issues set open = 1 %s`, whereClause) 624 + _, err := e.Exec(query, args...) 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 625 return err 626 } 627

+9 -5

appview/db/profile.go

··· 132 *items = append(*items, &pull) 133 } 134 135 - issues, err := GetIssuesByOwnerDid(e, forDid, timeframe) 0 0 0 0 136 if err != nil { 137 return nil, fmt.Errorf("error getting issues by owner did: %w", err) 138 } ··· 151 *items = append(*items, &issue) 152 } 153 154 - repos, err := GetAllReposByDid(e, forDid) 155 if err != nil { 156 return nil, fmt.Errorf("error getting all repos by did: %w", err) 157 } ··· 549 query = `select count(id) from pulls where owner_did = ? and state = ?` 550 args = append(args, did, PullOpen) 551 case VanityStatOpenIssueCount: 552 - query = `select count(id) from issues where owner_did = ? and open = 1` 553 args = append(args, did) 554 case VanityStatClosedIssueCount: 555 - query = `select count(id) from issues where owner_did = ? and open = 0` 556 args = append(args, did) 557 case VanityStatRepositoryCount: 558 query = `select count(id) from repos where did = ?` ··· 586 } 587 588 // ensure all pinned repos are either own repos or collaborating repos 589 - repos, err := GetAllReposByDid(e, profile.Did) 590 if err != nil { 591 log.Printf("getting repos for %s: %s", profile.Did, err) 592 }

··· 132 *items = append(*items, &pull) 133 } 134 135 + issues, err := GetIssues( 136 + e, 137 + FilterEq("did", forDid), 138 + FilterGte("created", time.Now().AddDate(0, -TimeframeMonths, 0)), 139 + ) 140 if err != nil { 141 return nil, fmt.Errorf("error getting issues by owner did: %w", err) 142 } ··· 155 *items = append(*items, &issue) 156 } 157 158 + repos, err := GetRepos(e, 0, FilterEq("did", forDid)) 159 if err != nil { 160 return nil, fmt.Errorf("error getting all repos by did: %w", err) 161 } ··· 553 query = `select count(id) from pulls where owner_did = ? and state = ?` 554 args = append(args, did, PullOpen) 555 case VanityStatOpenIssueCount: 556 + query = `select count(id) from issues where did = ? and open = 1` 557 args = append(args, did) 558 case VanityStatClosedIssueCount: 559 + query = `select count(id) from issues where did = ? and open = 0` 560 args = append(args, did) 561 case VanityStatRepositoryCount: 562 query = `select count(id) from repos where did = ?` ··· 590 } 591 592 // ensure all pinned repos are either own repos or collaborating repos 593 + repos, err := GetRepos(e, 0, FilterEq("did", profile.Did)) 594 if err != nil { 595 log.Printf("getting repos for %s: %s", profile.Did, err) 596 }

+17 -17

appview/db/registration.go

··· 10 // Registration represents a knot registration. Knot would've been a better 11 // name but we're stuck with this for historical reasons. 12 type Registration struct { 13 - Id int64 14 - Domain string 15 - ByDid string 16 - Created *time.Time 17 - Registered *time.Time 18 - ReadOnly bool 19 } 20 21 func (r *Registration) Status() Status { 22 - if r.ReadOnly { 23 - return ReadOnly 24 } else if r.Registered != nil { 25 return Registered 26 } else { ··· 32 return r.Status() == Registered 33 } 34 35 - func (r *Registration) IsReadOnly() bool { 36 - return r.Status() == ReadOnly 37 } 38 39 func (r *Registration) IsPending() bool { ··· 45 const ( 46 Registered Status = iota 47 Pending 48 - ReadOnly 49 ) 50 51 func GetRegistrations(e Execer, filters ...filter) ([]Registration, error) { ··· 64 } 65 66 query := fmt.Sprintf(` 67 - select id, domain, did, created, registered, read_only 68 from registrations 69 %s 70 order by created ··· 80 for rows.Next() { 81 var createdAt string 82 var registeredAt sql.Null[string] 83 - var readOnly int 84 var reg Registration 85 86 - err = rows.Scan(&reg.Id, &reg.Domain, &reg.ByDid, &createdAt, &registeredAt, &readOnly) 87 if err != nil { 88 return nil, err 89 } ··· 98 } 99 } 100 101 - if readOnly != 0 { 102 - reg.ReadOnly = true 103 } 104 105 registrations = append(registrations, reg) ··· 116 args = append(args, filter.Arg()...) 117 } 118 119 - query := "update registrations set registered = strftime('%Y-%m-%dT%H:%M:%SZ', 'now'), read_only = 0" 120 if len(conditions) > 0 { 121 query += " where " + strings.Join(conditions, " and ") 122 }

··· 10 // Registration represents a knot registration. Knot would've been a better 11 // name but we're stuck with this for historical reasons. 12 type Registration struct { 13 + Id int64 14 + Domain string 15 + ByDid string 16 + Created *time.Time 17 + Registered *time.Time 18 + NeedsUpgrade bool 19 } 20 21 func (r *Registration) Status() Status { 22 + if r.NeedsUpgrade { 23 + return NeedsUpgrade 24 } else if r.Registered != nil { 25 return Registered 26 } else { ··· 32 return r.Status() == Registered 33 } 34 35 + func (r *Registration) IsNeedsUpgrade() bool { 36 + return r.Status() == NeedsUpgrade 37 } 38 39 func (r *Registration) IsPending() bool { ··· 45 const ( 46 Registered Status = iota 47 Pending 48 + NeedsUpgrade 49 ) 50 51 func GetRegistrations(e Execer, filters ...filter) ([]Registration, error) { ··· 64 } 65 66 query := fmt.Sprintf(` 67 + select id, domain, did, created, registered, needs_upgrade 68 from registrations 69 %s 70 order by created ··· 80 for rows.Next() { 81 var createdAt string 82 var registeredAt sql.Null[string] 83 + var needsUpgrade int 84 var reg Registration 85 86 + err = rows.Scan(&reg.Id, &reg.Domain, &reg.ByDid, &createdAt, &registeredAt, &needsUpgrade) 87 if err != nil { 88 return nil, err 89 } ··· 98 } 99 } 100 101 + if needsUpgrade != 0 { 102 + reg.NeedsUpgrade = true 103 } 104 105 registrations = append(registrations, reg) ··· 116 args = append(args, filter.Arg()...) 117 } 118 119 + query := "update registrations set registered = strftime('%Y-%m-%dT%H:%M:%SZ', 'now'), needs_upgrade = 0" 120 if len(conditions) > 0 { 121 query += " where " + strings.Join(conditions, " and ") 122 }

-67

appview/db/repos.go

··· 309 return count, nil 310 } 311 312 - func GetAllReposByDid(e Execer, did string) ([]Repo, error) { 313 - var repos []Repo 314 - 315 - rows, err := e.Query( 316 - `select 317 - r.did, 318 - r.name, 319 - r.knot, 320 - r.rkey, 321 - r.description, 322 - r.created, 323 - count(s.id) as star_count, 324 - r.source 325 - from 326 - repos r 327 - left join 328 - stars s on r.at_uri = s.repo_at 329 - where 330 - r.did = ? 331 - group by 332 - r.at_uri 333 - order by r.created desc`, 334 - did) 335 - if err != nil { 336 - return nil, err 337 - } 338 - defer rows.Close() 339 - 340 - for rows.Next() { 341 - var repo Repo 342 - var repoStats RepoStats 343 - var createdAt string 344 - var nullableDescription sql.NullString 345 - var nullableSource sql.NullString 346 - 347 - err := rows.Scan(&repo.Did, &repo.Name, &repo.Knot, &repo.Rkey, &nullableDescription, &createdAt, &repoStats.StarCount, &nullableSource) 348 - if err != nil { 349 - return nil, err 350 - } 351 - 352 - if nullableDescription.Valid { 353 - repo.Description = nullableDescription.String 354 - } 355 - 356 - if nullableSource.Valid { 357 - repo.Source = nullableSource.String 358 - } 359 - 360 - createdAtTime, err := time.Parse(time.RFC3339, createdAt) 361 - if err != nil { 362 - repo.Created = time.Now() 363 - } else { 364 - repo.Created = createdAtTime 365 - } 366 - 367 - repo.RepoStats = &repoStats 368 - 369 - repos = append(repos, repo) 370 - } 371 - 372 - if err := rows.Err(); err != nil { 373 - return nil, err 374 - } 375 - 376 - return repos, nil 377 - } 378 - 379 func GetRepo(e Execer, did, name string) (*Repo, error) { 380 var repo Repo 381 var description, spindle sql.NullString

··· 309 return count, nil 310 } 311 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 312 func GetRepo(e Execer, did, name string) (*Repo, error) { 313 var repo Repo 314 var description, spindle sql.NullString

+14 -7

appview/db/spindle.go

··· 10 ) 11 12 type Spindle struct { 13 - Id int 14 - Owner syntax.DID 15 - Instance string 16 - Verified *time.Time 17 - Created time.Time 0 18 } 19 20 type SpindleMember struct { ··· 42 } 43 44 query := fmt.Sprintf( 45 - `select id, owner, instance, verified, created 46 from spindles 47 %s 48 order by created ··· 61 var spindle Spindle 62 var createdAt string 63 var verified sql.NullString 0 64 65 if err := rows.Scan( 66 &spindle.Id, ··· 68 &spindle.Instance, 69 &verified, 70 &createdAt, 0 71 ); err != nil { 72 return nil, err 73 } ··· 86 spindle.Verified = &t 87 } 88 0 0 0 0 89 spindles = append(spindles, spindle) 90 } 91 ··· 115 whereClause = " where " + strings.Join(conditions, " and ") 116 } 117 118 - query := fmt.Sprintf(`update spindles set verified = strftime('%%Y-%%m-%%dT%%H:%%M:%%SZ', 'now') %s`, whereClause) 119 120 res, err := e.Exec(query, args...) 121 if err != nil {

··· 10 ) 11 12 type Spindle struct { 13 + Id int 14 + Owner syntax.DID 15 + Instance string 16 + Verified *time.Time 17 + Created time.Time 18 + NeedsUpgrade bool 19 } 20 21 type SpindleMember struct { ··· 43 } 44 45 query := fmt.Sprintf( 46 + `select id, owner, instance, verified, created, needs_upgrade 47 from spindles 48 %s 49 order by created ··· 62 var spindle Spindle 63 var createdAt string 64 var verified sql.NullString 65 + var needsUpgrade int 66 67 if err := rows.Scan( 68 &spindle.Id, ··· 70 &spindle.Instance, 71 &verified, 72 &createdAt, 73 + &needsUpgrade, 74 ); err != nil { 75 return nil, err 76 } ··· 89 spindle.Verified = &t 90 } 91 92 + if needsUpgrade != 0 { 93 + spindle.NeedsUpgrade = true 94 + } 95 + 96 spindles = append(spindles, spindle) 97 } 98 ··· 122 whereClause = " where " + strings.Join(conditions, " and ") 123 } 124 125 + query := fmt.Sprintf(`update spindles set verified = strftime('%%Y-%%m-%%dT%%H:%%M:%%SZ', 'now'), needs_upgrade = 0 %s`, whereClause) 126 127 res, err := e.Exec(query, args...) 128 if err != nil {

+29 -74

appview/ingester.go

··· 5 "encoding/json" 6 "fmt" 7 "log/slog" 8 - "strings" 9 "time" 10 11 "github.com/bluesky-social/indigo/atproto/syntax" ··· 15 "tangled.sh/tangled.sh/core/api/tangled" 16 "tangled.sh/tangled.sh/core/appview/config" 17 "tangled.sh/tangled.sh/core/appview/db" 18 - "tangled.sh/tangled.sh/core/appview/pages/markup" 19 "tangled.sh/tangled.sh/core/appview/serververify" 0 20 "tangled.sh/tangled.sh/core/idresolver" 21 "tangled.sh/tangled.sh/core/rbac" 22 ) ··· 27 IdResolver *idresolver.Resolver 28 Config *config.Config 29 Logger *slog.Logger 0 30 } 31 32 type processFunc func(ctx context.Context, e *models.Event) error ··· 790 } 791 792 switch e.Commit.Operation { 793 - case models.CommitOperationCreate: 794 raw := json.RawMessage(e.Commit.Record) 795 record := tangled.RepoIssue{} 796 err = json.Unmarshal(raw, &record) ··· 801 802 issue := db.IssueFromRecord(did, rkey, record) 803 804 - sanitizer := markup.NewSanitizer() 805 - if st := strings.TrimSpace(sanitizer.SanitizeDescription(issue.Title)); st == "" { 806 - return fmt.Errorf("title is empty after HTML sanitization") 807 - } 808 - if sb := strings.TrimSpace(sanitizer.SanitizeDefault(issue.Body)); sb == "" { 809 - return fmt.Errorf("body is empty after HTML sanitization") 810 } 811 812 tx, err := ddb.BeginTx(ctx, nil) ··· 814 l.Error("failed to begin transaction", "err", err) 815 return err 816 } 0 817 818 - err = db.NewIssue(tx, &issue) 819 if err != nil { 820 l.Error("failed to create issue", "err", err) 821 return err 822 } 823 824 - return nil 825 - 826 - case models.CommitOperationUpdate: 827 - raw := json.RawMessage(e.Commit.Record) 828 - record := tangled.RepoIssue{} 829 - err = json.Unmarshal(raw, &record) 830 if err != nil { 831 - l.Error("invalid record", "err", err) 832 - return err 833 - } 834 - 835 - body := "" 836 - if record.Body != nil { 837 - body = *record.Body 838 - } 839 - 840 - sanitizer := markup.NewSanitizer() 841 - if st := strings.TrimSpace(sanitizer.SanitizeDescription(record.Title)); st == "" { 842 - return fmt.Errorf("title is empty after HTML sanitization") 843 - } 844 - if sb := strings.TrimSpace(sanitizer.SanitizeDefault(body)); sb == "" { 845 - return fmt.Errorf("body is empty after HTML sanitization") 846 - } 847 - 848 - err = db.UpdateIssueByRkey(ddb, did, rkey, record.Title, body) 849 - if err != nil { 850 - l.Error("failed to update issue", "err", err) 851 return err 852 } 853 854 return nil 855 856 case models.CommitOperationDelete: 857 - if err := db.DeleteIssueByRkey(ddb, did, rkey); err != nil { 0 0 0 0 858 l.Error("failed to delete", "err", err) 859 return fmt.Errorf("failed to delete issue record: %w", err) 860 } ··· 862 return nil 863 } 864 865 - return fmt.Errorf("unknown operation: %s", e.Commit.Operation) 866 } 867 868 func (i *Ingester) ingestIssueComment(e *models.Event) error { ··· 880 } 881 882 switch e.Commit.Operation { 883 - case models.CommitOperationCreate: 884 raw := json.RawMessage(e.Commit.Record) 885 record := tangled.RepoIssueComment{} 886 err = json.Unmarshal(raw, &record) 887 if err != nil { 888 - l.Error("invalid record", "err", err) 889 - return err 890 } 891 892 comment, err := db.IssueCommentFromRecord(ddb, did, rkey, record) 893 if err != nil { 894 - l.Error("failed to parse comment from record", "err", err) 895 - return err 896 } 897 898 - sanitizer := markup.NewSanitizer() 899 - if sb := strings.TrimSpace(sanitizer.SanitizeDefault(comment.Body)); sb == "" { 900 - return fmt.Errorf("body is empty after HTML sanitization") 901 } 902 903 - err = db.NewIssueComment(ddb, &comment) 904 if err != nil { 905 - l.Error("failed to create issue comment", "err", err) 906 - return err 907 - } 908 - 909 - return nil 910 - 911 - case models.CommitOperationUpdate: 912 - raw := json.RawMessage(e.Commit.Record) 913 - record := tangled.RepoIssueComment{} 914 - err = json.Unmarshal(raw, &record) 915 - if err != nil { 916 - l.Error("invalid record", "err", err) 917 - return err 918 - } 919 - 920 - sanitizer := markup.NewSanitizer() 921 - if sb := strings.TrimSpace(sanitizer.SanitizeDefault(record.Body)); sb == "" { 922 - return fmt.Errorf("body is empty after HTML sanitization") 923 - } 924 - 925 - err = db.UpdateCommentByRkey(ddb, did, rkey, record.Body) 926 - if err != nil { 927 - l.Error("failed to update issue comment", "err", err) 928 - return err 929 } 930 931 return nil 932 933 case models.CommitOperationDelete: 934 - if err := db.DeleteCommentByRkey(ddb, did, rkey); err != nil { 935 - l.Error("failed to delete", "err", err) 0 0 0 936 return fmt.Errorf("failed to delete issue comment record: %w", err) 937 } 938 939 return nil 940 } 941 942 - return fmt.Errorf("unknown operation: %s", e.Commit.Operation) 943 }

··· 5 "encoding/json" 6 "fmt" 7 "log/slog" 8 + 9 "time" 10 11 "github.com/bluesky-social/indigo/atproto/syntax" ··· 15 "tangled.sh/tangled.sh/core/api/tangled" 16 "tangled.sh/tangled.sh/core/appview/config" 17 "tangled.sh/tangled.sh/core/appview/db" 0 18 "tangled.sh/tangled.sh/core/appview/serververify" 19 + "tangled.sh/tangled.sh/core/appview/validator" 20 "tangled.sh/tangled.sh/core/idresolver" 21 "tangled.sh/tangled.sh/core/rbac" 22 ) ··· 27 IdResolver *idresolver.Resolver 28 Config *config.Config 29 Logger *slog.Logger 30 + Validator *validator.Validator 31 } 32 33 type processFunc func(ctx context.Context, e *models.Event) error ··· 791 } 792 793 switch e.Commit.Operation { 794 + case models.CommitOperationCreate, models.CommitOperationUpdate: 795 raw := json.RawMessage(e.Commit.Record) 796 record := tangled.RepoIssue{} 797 err = json.Unmarshal(raw, &record) ··· 802 803 issue := db.IssueFromRecord(did, rkey, record) 804 805 + if err := i.Validator.ValidateIssue(&issue); err != nil { 806 + return fmt.Errorf("failed to validate issue: %w", err) 0 0 0 0 807 } 808 809 tx, err := ddb.BeginTx(ctx, nil) ··· 811 l.Error("failed to begin transaction", "err", err) 812 return err 813 } 814 + defer tx.Rollback() 815 816 + err = db.PutIssue(tx, &issue) 817 if err != nil { 818 l.Error("failed to create issue", "err", err) 819 return err 820 } 821 822 + err = tx.Commit() 0 0 0 0 0 823 if err != nil { 824 + l.Error("failed to commit txn", "err", err) 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 825 return err 826 } 827 828 return nil 829 830 case models.CommitOperationDelete: 831 + if err := db.DeleteIssues( 832 + ddb, 833 + db.FilterEq("did", did), 834 + db.FilterEq("rkey", rkey), 835 + ); err != nil { 836 l.Error("failed to delete", "err", err) 837 return fmt.Errorf("failed to delete issue record: %w", err) 838 } ··· 840 return nil 841 } 842 843 + return nil 844 } 845 846 func (i *Ingester) ingestIssueComment(e *models.Event) error { ··· 858 } 859 860 switch e.Commit.Operation { 861 + case models.CommitOperationCreate, models.CommitOperationUpdate: 862 raw := json.RawMessage(e.Commit.Record) 863 record := tangled.RepoIssueComment{} 864 err = json.Unmarshal(raw, &record) 865 if err != nil { 866 + return fmt.Errorf("invalid record: %w", err) 0 867 } 868 869 comment, err := db.IssueCommentFromRecord(ddb, did, rkey, record) 870 if err != nil { 871 + return fmt.Errorf("failed to parse comment from record: %w", err) 0 872 } 873 874 + if err := i.Validator.ValidateIssueComment(comment); err != nil { 875 + return fmt.Errorf("failed to validate comment: %w", err) 0 876 } 877 878 + _, err = db.AddIssueComment(ddb, *comment) 879 if err != nil { 880 + return fmt.Errorf("failed to create issue comment: %w", err) 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 881 } 882 883 return nil 884 885 case models.CommitOperationDelete: 886 + if err := db.DeleteIssueComments( 887 + ddb, 888 + db.FilterEq("did", did), 889 + db.FilterEq("rkey", rkey), 890 + ); err != nil { 891 return fmt.Errorf("failed to delete issue comment record: %w", err) 892 } 893 894 return nil 895 } 896 897 + return nil 898 }

+477 -280

appview/issues/issues.go

··· 1 package issues 2 3 import ( 0 0 0 4 "fmt" 5 "log" 6 - mathrand "math/rand/v2" 7 "net/http" 8 "slices" 9 - "strconv" 10 - "strings" 11 "time" 12 13 comatproto "github.com/bluesky-social/indigo/api/atproto" 14 - "github.com/bluesky-social/indigo/atproto/data" 15 lexutil "github.com/bluesky-social/indigo/lex/util" 16 "github.com/go-chi/chi/v5" 17 ··· 21 "tangled.sh/tangled.sh/core/appview/notify" 22 "tangled.sh/tangled.sh/core/appview/oauth" 23 "tangled.sh/tangled.sh/core/appview/pages" 24 - "tangled.sh/tangled.sh/core/appview/pages/markup" 25 "tangled.sh/tangled.sh/core/appview/pagination" 26 "tangled.sh/tangled.sh/core/appview/reporesolver" 0 0 27 "tangled.sh/tangled.sh/core/idresolver" 0 28 "tangled.sh/tangled.sh/core/tid" 29 ) 30 ··· 36 db *db.DB 37 config *config.Config 38 notifier notify.Notifier 0 0 39 } 40 41 func New( ··· 46 db *db.DB, 47 config *config.Config, 48 notifier notify.Notifier, 0 49 ) *Issues { 50 return &Issues{ 51 oauth: oauth, ··· 55 db: db, 56 config: config, 57 notifier: notifier, 0 0 58 } 59 } 60 61 func (rp *Issues) RepoSingleIssue(w http.ResponseWriter, r *http.Request) { 0 62 user := rp.oauth.GetUser(r) 63 f, err := rp.repoResolver.Resolve(r) 64 if err != nil { ··· 66 return 67 } 68 69 - issueId := chi.URLParam(r, "issue") 70 - issueIdInt, err := strconv.Atoi(issueId) 71 - if err != nil { 72 - http.Error(w, "bad issue id", http.StatusBadRequest) 73 - log.Println("failed to parse issue id", err) 74 - return 75 - } 76 - 77 - issue, comments, err := db.GetIssueWithComments(rp.db, f.RepoAt(), issueIdInt) 78 - if err != nil { 79 - log.Println("failed to get issue and comments", err) 80 - rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.") 81 return 82 } 83 84 reactionCountMap, err := db.GetReactionCountMap(rp.db, issue.AtUri()) 85 if err != nil { 86 - log.Println("failed to get issue reactions") 87 - rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.") 88 } 89 90 userReactions := map[db.ReactionKind]bool{} ··· 92 userReactions = db.GetReactionStatusMap(rp.db, user.Did, issue.AtUri()) 93 } 94 95 - issueOwnerIdent, err := rp.idResolver.ResolveIdent(r.Context(), issue.OwnerDid) 96 - if err != nil { 97 - log.Println("failed to resolve issue owner", err) 98 - } 99 - 100 rp.pages.RepoSingleIssue(w, pages.RepoSingleIssueParams{ 101 - LoggedInUser: user, 102 - RepoInfo: f.RepoInfo(user), 103 - Issue: issue, 104 - Comments: comments, 105 - 106 - IssueOwnerHandle: issueOwnerIdent.Handle.String(), 107 - 108 OrderedReactionKinds: db.OrderedReactionKinds, 109 Reactions: reactionCountMap, 110 UserReacted: userReactions, 111 }) 112 - 113 } 114 115 - func (rp *Issues) CloseIssue(w http.ResponseWriter, r *http.Request) { 0 116 user := rp.oauth.GetUser(r) 117 f, err := rp.repoResolver.Resolve(r) 118 if err != nil { ··· 120 return 121 } 122 123 - issueId := chi.URLParam(r, "issue") 124 - issueIdInt, err := strconv.Atoi(issueId) 125 - if err != nil { 126 - http.Error(w, "bad issue id", http.StatusBadRequest) 127 - log.Println("failed to parse issue id", err) 128 return 129 } 130 131 - issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt) 132 - if err != nil { 133 - log.Println("failed to get issue", err) 134 - rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.") 135 - return 136 - } 0 0 0 0 0 0 137 138 - collaborators, err := f.Collaborators(r.Context()) 139 - if err != nil { 140 - log.Println("failed to fetch repo collaborators: %w", err) 141 - } 142 - isCollaborator := slices.ContainsFunc(collaborators, func(collab pages.Collaborator) bool { 143 - return user.Did == collab.Did 144 - }) 145 - isIssueOwner := user.Did == issue.OwnerDid 146 - 147 - // TODO: make this more granular 148 - if isIssueOwner || isCollaborator { 149 150 - closed := tangled.RepoIssueStateClosed 151 0 152 client, err := rp.oauth.AuthorizedClient(r) 153 if err != nil { 154 - log.Println("failed to get authorized client", err) 0 155 return 156 } 0 0 0 0 0 0 0 0 157 _, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{ 158 - Collection: tangled.RepoIssueStateNSID, 159 Repo: user.Did, 160 - Rkey: tid.TID(), 0 161 Record: &lexutil.LexiconTypeDecoder{ 162 - Val: &tangled.RepoIssueState{ 163 - Issue: issue.AtUri().String(), 164 - State: closed, 165 - }, 166 }, 167 }) 0 0 0 0 0 168 0 0 169 if err != nil { 170 - log.Println("failed to update issue state", err) 171 - rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.") 0 0 0 0 0 0 0 0 0 0 0 0 0 0 172 return 173 } 174 175 - err = db.CloseIssue(rp.db, f.RepoAt(), issueIdInt) 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 176 if err != nil { 177 log.Println("failed to close issue", err) 178 rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.") 179 return 180 } 181 182 - rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issueIdInt)) 183 return 184 } else { 185 log.Println("user is not permitted to close issue") ··· 189 } 190 191 func (rp *Issues) ReopenIssue(w http.ResponseWriter, r *http.Request) { 0 192 user := rp.oauth.GetUser(r) 193 f, err := rp.repoResolver.Resolve(r) 194 if err != nil { ··· 196 return 197 } 198 199 - issueId := chi.URLParam(r, "issue") 200 - issueIdInt, err := strconv.Atoi(issueId) 201 - if err != nil { 202 - http.Error(w, "bad issue id", http.StatusBadRequest) 203 - log.Println("failed to parse issue id", err) 204 - return 205 - } 206 - 207 - issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt) 208 - if err != nil { 209 - log.Println("failed to get issue", err) 210 - rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.") 211 return 212 } 213 ··· 218 isCollaborator := slices.ContainsFunc(collaborators, func(collab pages.Collaborator) bool { 219 return user.Did == collab.Did 220 }) 221 - isIssueOwner := user.Did == issue.OwnerDid 222 223 if isCollaborator || isIssueOwner { 224 - err := db.ReopenIssue(rp.db, f.RepoAt(), issueIdInt) 0 0 0 225 if err != nil { 226 log.Println("failed to reopen issue", err) 227 rp.pages.Notice(w, "issue-action", "Failed to reopen issue. Try again later.") 228 return 229 } 230 - rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issueIdInt)) 231 return 232 } else { 233 log.Println("user is not the owner of the repo") ··· 237 } 238 239 func (rp *Issues) NewIssueComment(w http.ResponseWriter, r *http.Request) { 0 240 user := rp.oauth.GetUser(r) 241 f, err := rp.repoResolver.Resolve(r) 242 if err != nil { 243 - log.Println("failed to get repo and knot", err) 244 return 245 } 246 247 - issueId := chi.URLParam(r, "issue") 248 - issueIdInt, err := strconv.Atoi(issueId) 249 - if err != nil { 250 - http.Error(w, "bad issue id", http.StatusBadRequest) 251 - log.Println("failed to parse issue id", err) 252 return 253 } 254 255 - switch r.Method { 256 - case http.MethodPost: 257 - body := r.FormValue("body") 258 - if body == "" { 259 - rp.pages.Notice(w, "issue", "Body is required") 260 - return 261 - } 262 263 - commentId := mathrand.IntN(1000000) 264 - rkey := tid.TID() 0 0 0 265 266 - err := db.NewIssueComment(rp.db, &db.Comment{ 267 - OwnerDid: user.Did, 268 - RepoAt: f.RepoAt(), 269 - Issue: issueIdInt, 270 - CommentId: commentId, 271 - Body: body, 272 - Rkey: rkey, 273 - }) 274 - if err != nil { 275 - log.Println("failed to create comment", err) 276 - rp.pages.Notice(w, "issue-comment", "Failed to create comment.") 277 - return 278 - } 0 279 280 - createdAt := time.Now().Format(time.RFC3339) 281 - ownerDid := user.Did 282 - issueAt, err := db.GetIssueAt(rp.db, f.RepoAt(), issueIdInt) 283 - if err != nil { 284 - log.Println("failed to get issue at", err) 285 - rp.pages.Notice(w, "issue-comment", "Failed to create comment.") 286 - return 287 - } 288 289 - atUri := f.RepoAt().String() 290 - client, err := rp.oauth.AuthorizedClient(r) 291 - if err != nil { 292 - log.Println("failed to get authorized client", err) 293 - rp.pages.Notice(w, "issue-comment", "Failed to create comment.") 294 - return 0 0 0 0 0 0 0 0 0 0 0 0 295 } 296 - _, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{ 297 - Collection: tangled.RepoIssueCommentNSID, 298 - Repo: user.Did, 299 - Rkey: rkey, 300 - Record: &lexutil.LexiconTypeDecoder{ 301 - Val: &tangled.RepoIssueComment{ 302 - Repo: &atUri, 303 - Issue: issueAt, 304 - Owner: &ownerDid, 305 - Body: body, 306 - CreatedAt: createdAt, 307 - }, 308 - }, 309 - }) 310 - if err != nil { 311 - log.Println("failed to create comment", err) 312 - rp.pages.Notice(w, "issue-comment", "Failed to create comment.") 313 - return 314 - } 315 316 - rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d#comment-%d", f.OwnerSlashRepo(), issueIdInt, commentId)) 0 0 0 317 return 318 } 0 0 0 0 319 } 320 321 func (rp *Issues) IssueComment(w http.ResponseWriter, r *http.Request) { 0 322 user := rp.oauth.GetUser(r) 323 f, err := rp.repoResolver.Resolve(r) 324 if err != nil { 325 - log.Println("failed to get repo and knot", err) 326 return 327 } 328 329 - issueId := chi.URLParam(r, "issue") 330 - issueIdInt, err := strconv.Atoi(issueId) 331 - if err != nil { 332 - http.Error(w, "bad issue id", http.StatusBadRequest) 333 - log.Println("failed to parse issue id", err) 334 return 335 } 336 337 - commentId := chi.URLParam(r, "comment_id") 338 - commentIdInt, err := strconv.Atoi(commentId) 0 0 0 339 if err != nil { 340 - http.Error(w, "bad comment id", http.StatusBadRequest) 341 - log.Println("failed to parse issue id", err) 342 return 343 } 344 - 345 - issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt) 346 - if err != nil { 347 - log.Println("failed to get issue", err) 348 - rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.") 349 return 350 } 0 351 352 - comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt) 353 - if err != nil { 354 - http.Error(w, "bad comment id", http.StatusBadRequest) 355 - return 356 - } 357 - 358 - rp.pages.SingleIssueCommentFragment(w, pages.SingleIssueCommentParams{ 359 LoggedInUser: user, 360 RepoInfo: f.RepoInfo(user), 361 Issue: issue, 362 - Comment: comment, 363 }) 364 } 365 366 func (rp *Issues) EditIssueComment(w http.ResponseWriter, r *http.Request) { 0 367 user := rp.oauth.GetUser(r) 368 f, err := rp.repoResolver.Resolve(r) 369 if err != nil { 370 - log.Println("failed to get repo and knot", err) 371 return 372 } 373 374 - issueId := chi.URLParam(r, "issue") 375 - issueIdInt, err := strconv.Atoi(issueId) 376 - if err != nil { 377 - http.Error(w, "bad issue id", http.StatusBadRequest) 378 - log.Println("failed to parse issue id", err) 379 return 380 } 381 382 - commentId := chi.URLParam(r, "comment_id") 383 - commentIdInt, err := strconv.Atoi(commentId) 0 0 0 384 if err != nil { 385 - http.Error(w, "bad comment id", http.StatusBadRequest) 386 - log.Println("failed to parse issue id", err) 387 return 388 } 389 - 390 - issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt) 391 - if err != nil { 392 - log.Println("failed to get issue", err) 393 - rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.") 394 return 395 } 0 396 397 - comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt) 398 - if err != nil { 399 - http.Error(w, "bad comment id", http.StatusBadRequest) 400 - return 401 - } 402 - 403 - if comment.OwnerDid != user.Did { 404 http.Error(w, "you are not the author of this comment", http.StatusUnauthorized) 405 return 406 } ··· 411 LoggedInUser: user, 412 RepoInfo: f.RepoInfo(user), 413 Issue: issue, 414 - Comment: comment, 415 }) 416 case http.MethodPost: 417 // extract form value ··· 422 rp.pages.Notice(w, "issue-comment", "Failed to create comment.") 423 return 424 } 425 - rkey := comment.Rkey 426 427 - // optimistic update 428 - edited := time.Now() 429 - err = db.EditComment(rp.db, comment.RepoAt, comment.Issue, comment.CommentId, newBody) 0 0 0 0 430 if err != nil { 431 log.Println("failed to perferom update-description query", err) 432 rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.") ··· 434 } 435 436 // rkey is optional, it was introduced later 437 - if comment.Rkey != "" { 438 // update the record on pds 439 - ex, err := client.RepoGetRecord(r.Context(), "", tangled.RepoIssueCommentNSID, user.Did, rkey) 440 if err != nil { 441 - // failed to get record 442 - log.Println(err, rkey) 443 rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "Failed to update description, no record found on PDS.") 444 return 445 } 446 - value, _ := ex.Value.MarshalJSON() // we just did get record; it is valid json 447 - record, _ := data.UnmarshalJSON(value) 448 - 449 - repoAt := record["repo"].(string) 450 - issueAt := record["issue"].(string) 451 - createdAt := record["createdAt"].(string) 452 453 _, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{ 454 Collection: tangled.RepoIssueCommentNSID, 455 Repo: user.Did, 456 - Rkey: rkey, 457 SwapRecord: ex.Cid, 458 Record: &lexutil.LexiconTypeDecoder{ 459 - Val: &tangled.RepoIssueComment{ 460 - Repo: &repoAt, 461 - Issue: issueAt, 462 - Owner: &comment.OwnerDid, 463 - Body: newBody, 464 - CreatedAt: createdAt, 465 - }, 466 }, 467 }) 468 if err != nil { 469 - log.Println(err) 470 } 471 } 472 473 - // optimistic update for htmx 474 - comment.Body = newBody 475 - comment.Edited = &edited 476 - 477 // return new comment body with htmx 478 - rp.pages.SingleIssueCommentFragment(w, pages.SingleIssueCommentParams{ 479 LoggedInUser: user, 480 RepoInfo: f.RepoInfo(user), 481 Issue: issue, 482 - Comment: comment, 483 }) 0 0 0 0 0 0 0 0 0 484 return 0 485 0 0 0 0 0 486 } 487 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 488 } 489 490 - func (rp *Issues) DeleteIssueComment(w http.ResponseWriter, r *http.Request) { 0 491 user := rp.oauth.GetUser(r) 492 f, err := rp.repoResolver.Resolve(r) 493 if err != nil { 494 - log.Println("failed to get repo and knot", err) 495 return 496 } 497 498 - issueId := chi.URLParam(r, "issue") 499 - issueIdInt, err := strconv.Atoi(issueId) 500 - if err != nil { 501 - http.Error(w, "bad issue id", http.StatusBadRequest) 502 - log.Println("failed to parse issue id", err) 503 return 504 } 505 506 - issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt) 0 0 0 0 507 if err != nil { 508 - log.Println("failed to get issue", err) 509 - rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.") 510 return 511 } 0 0 0 0 0 0 512 513 - commentId := chi.URLParam(r, "comment_id") 514 - commentIdInt, err := strconv.Atoi(commentId) 0 0 0 0 0 0 0 0 0 0 515 if err != nil { 516 - http.Error(w, "bad comment id", http.StatusBadRequest) 517 - log.Println("failed to parse issue id", err) 518 return 519 } 520 521 - comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt) 0 0 0 0 0 0 0 0 0 0 0 522 if err != nil { 523 - http.Error(w, "bad comment id", http.StatusBadRequest) 0 524 return 525 } 0 0 0 0 0 0 526 527 - if comment.OwnerDid != user.Did { 0 528 http.Error(w, "you are not the author of this comment", http.StatusUnauthorized) 529 return 530 } ··· 536 537 // optimistic deletion 538 deleted := time.Now() 539 - err = db.DeleteComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt) 540 if err != nil { 541 - log.Println("failed to delete comment") 542 rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "failed to delete comment") 543 return 544 } ··· 552 return 553 } 554 _, err = client.RepoDeleteRecord(r.Context(), &comatproto.RepoDeleteRecord_Input{ 555 - Collection: tangled.GraphFollowNSID, 556 Repo: user.Did, 557 Rkey: comment.Rkey, 558 }) ··· 566 comment.Deleted = &deleted 567 568 // htmx fragment of comment after deletion 569 - rp.pages.SingleIssueCommentFragment(w, pages.SingleIssueCommentParams{ 570 LoggedInUser: user, 571 RepoInfo: f.RepoInfo(user), 572 Issue: issue, 573 - Comment: comment, 574 }) 575 } 576 ··· 600 return 601 } 602 603 - issues, err := db.GetIssuesPaginated(rp.db, f.RepoAt(), isOpen, page) 0 0 0 0 0 0 0 0 0 604 if err != nil { 605 log.Println("failed to get issues", err) 606 rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.") ··· 617 } 618 619 func (rp *Issues) NewIssue(w http.ResponseWriter, r *http.Request) { 0 620 user := rp.oauth.GetUser(r) 621 622 f, err := rp.repoResolver.Resolve(r) 623 if err != nil { 624 - log.Println("failed to get repo and knot", err) 625 return 626 } 627 ··· 632 RepoInfo: f.RepoInfo(user), 633 }) 634 case http.MethodPost: 635 - title := r.FormValue("title") 636 - body := r.FormValue("body") 0 0 0 0 0 0 637 638 - if title == "" || body == "" { 639 - rp.pages.Notice(w, "issues", "Title and body are required") 0 640 return 641 } 642 643 - sanitizer := markup.NewSanitizer() 644 - if st := strings.TrimSpace(sanitizer.SanitizeDescription(title)); st == "" { 645 - rp.pages.Notice(w, "issues", "Title is empty after HTML sanitization") 0 0 0 0 646 return 647 } 648 - if sb := strings.TrimSpace(sanitizer.SanitizeDefault(body)); sb == "" { 649 - rp.pages.Notice(w, "issues", "Body is empty after HTML sanitization") 0 0 0 0 0 0 0 0 0 650 return 651 } 0 652 653 tx, err := rp.db.BeginTx(r.Context(), nil) 654 if err != nil { 655 rp.pages.Notice(w, "issues", "Failed to create issue, try again later") 656 return 657 } 0 0 0 658 659 - issue := &db.Issue{ 660 - RepoAt: f.RepoAt(), 661 - Rkey: tid.TID(), 662 - Title: title, 663 - Body: body, 664 - OwnerDid: user.Did, 0 665 } 666 - err = db.NewIssue(tx, issue) 0 0 667 if err != nil { 668 log.Println("failed to create issue", err) 669 rp.pages.Notice(w, "issues", "Failed to create issue.") 670 return 671 } 672 673 - client, err := rp.oauth.AuthorizedClient(r) 674 - if err != nil { 675 - log.Println("failed to get authorized client", err) 676 - rp.pages.Notice(w, "issues", "Failed to create issue.") 677 - return 678 - } 679 - atUri := f.RepoAt().String() 680 - _, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{ 681 - Collection: tangled.RepoIssueNSID, 682 - Repo: user.Did, 683 - Rkey: issue.Rkey, 684 - Record: &lexutil.LexiconTypeDecoder{ 685 - Val: &tangled.RepoIssue{ 686 - Repo: atUri, 687 - Title: title, 688 - Body: &body, 689 - }, 690 - }, 691 - }) 692 - if err != nil { 693 log.Println("failed to create issue", err) 694 rp.pages.Notice(w, "issues", "Failed to create issue.") 695 return 696 } 697 0 0 698 rp.notifier.NewIssue(r.Context(), issue) 699 - 700 rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId)) 701 return 702 } 703 } 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 package issues 2 3 import ( 4 + "context" 5 + "database/sql" 6 + "errors" 7 "fmt" 8 "log" 9 + "log/slog" 10 "net/http" 11 "slices" 0 0 12 "time" 13 14 comatproto "github.com/bluesky-social/indigo/api/atproto" 15 + "github.com/bluesky-social/indigo/atproto/syntax" 16 lexutil "github.com/bluesky-social/indigo/lex/util" 17 "github.com/go-chi/chi/v5" 18 ··· 22 "tangled.sh/tangled.sh/core/appview/notify" 23 "tangled.sh/tangled.sh/core/appview/oauth" 24 "tangled.sh/tangled.sh/core/appview/pages" 0 25 "tangled.sh/tangled.sh/core/appview/pagination" 26 "tangled.sh/tangled.sh/core/appview/reporesolver" 27 + "tangled.sh/tangled.sh/core/appview/validator" 28 + "tangled.sh/tangled.sh/core/appview/xrpcclient" 29 "tangled.sh/tangled.sh/core/idresolver" 30 + tlog "tangled.sh/tangled.sh/core/log" 31 "tangled.sh/tangled.sh/core/tid" 32 ) 33 ··· 39 db *db.DB 40 config *config.Config 41 notifier notify.Notifier 42 + logger *slog.Logger 43 + validator *validator.Validator 44 } 45 46 func New( ··· 51 db *db.DB, 52 config *config.Config, 53 notifier notify.Notifier, 54 + validator *validator.Validator, 55 ) *Issues { 56 return &Issues{ 57 oauth: oauth, ··· 61 db: db, 62 config: config, 63 notifier: notifier, 64 + logger: tlog.New("issues"), 65 + validator: validator, 66 } 67 } 68 69 func (rp *Issues) RepoSingleIssue(w http.ResponseWriter, r *http.Request) { 70 + l := rp.logger.With("handler", "RepoSingleIssue") 71 user := rp.oauth.GetUser(r) 72 f, err := rp.repoResolver.Resolve(r) 73 if err != nil { ··· 75 return 76 } 77 78 + issue, ok := r.Context().Value("issue").(*db.Issue) 79 + if !ok { 80 + l.Error("failed to get issue") 81 + rp.pages.Error404(w) 0 0 0 0 0 0 0 0 82 return 83 } 84 85 reactionCountMap, err := db.GetReactionCountMap(rp.db, issue.AtUri()) 86 if err != nil { 87 + l.Error("failed to get issue reactions", "err", err) 0 88 } 89 90 userReactions := map[db.ReactionKind]bool{} ··· 92 userReactions = db.GetReactionStatusMap(rp.db, user.Did, issue.AtUri()) 93 } 94 0 0 0 0 0 95 rp.pages.RepoSingleIssue(w, pages.RepoSingleIssueParams{ 96 + LoggedInUser: user, 97 + RepoInfo: f.RepoInfo(user), 98 + Issue: issue, 99 + CommentList: issue.CommentList(), 0 0 0 100 OrderedReactionKinds: db.OrderedReactionKinds, 101 Reactions: reactionCountMap, 102 UserReacted: userReactions, 103 }) 0 104 } 105 106 + func (rp *Issues) EditIssue(w http.ResponseWriter, r *http.Request) { 107 + l := rp.logger.With("handler", "EditIssue") 108 user := rp.oauth.GetUser(r) 109 f, err := rp.repoResolver.Resolve(r) 110 if err != nil { ··· 112 return 113 } 114 115 + issue, ok := r.Context().Value("issue").(*db.Issue) 116 + if !ok { 117 + l.Error("failed to get issue") 118 + rp.pages.Error404(w) 0 119 return 120 } 121 122 + switch r.Method { 123 + case http.MethodGet: 124 + rp.pages.EditIssueFragment(w, pages.EditIssueParams{ 125 + LoggedInUser: user, 126 + RepoInfo: f.RepoInfo(user), 127 + Issue: issue, 128 + }) 129 + case http.MethodPost: 130 + noticeId := "issues" 131 + newIssue := issue 132 + newIssue.Title = r.FormValue("title") 133 + newIssue.Body = r.FormValue("body") 134 135 + if err := rp.validator.ValidateIssue(newIssue); err != nil { 136 + l.Error("validation error", "err", err) 137 + rp.pages.Notice(w, noticeId, fmt.Sprintf("Failed to edit issue: %s", err)) 138 + return 139 + } 0 0 0 0 0 0 140 141 + newRecord := newIssue.AsRecord() 142 143 + // edit an atproto record 144 client, err := rp.oauth.AuthorizedClient(r) 145 if err != nil { 146 + l.Error("failed to get authorized client", "err", err) 147 + rp.pages.Notice(w, noticeId, "Failed to edit issue.") 148 return 149 } 150 + 151 + ex, err := client.RepoGetRecord(r.Context(), "", tangled.RepoIssueNSID, user.Did, newIssue.Rkey) 152 + if err != nil { 153 + l.Error("failed to get record", "err", err) 154 + rp.pages.Notice(w, noticeId, "Failed to edit issue, no record found on PDS.") 155 + return 156 + } 157 + 158 _, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{ 159 + Collection: tangled.RepoIssueNSID, 160 Repo: user.Did, 161 + Rkey: newIssue.Rkey, 162 + SwapRecord: ex.Cid, 163 Record: &lexutil.LexiconTypeDecoder{ 164 + Val: &newRecord, 0 0 0 165 }, 166 }) 167 + if err != nil { 168 + l.Error("failed to edit record on PDS", "err", err) 169 + rp.pages.Notice(w, noticeId, "Failed to edit issue on PDS.") 170 + return 171 + } 172 173 + // modify on DB -- TODO: transact this cleverly 174 + tx, err := rp.db.Begin() 175 if err != nil { 176 + l.Error("failed to edit issue on DB", "err", err) 177 + rp.pages.Notice(w, noticeId, "Failed to edit issue.") 178 + return 179 + } 180 + defer tx.Rollback() 181 + 182 + err = db.PutIssue(tx, newIssue) 183 + if err != nil { 184 + log.Println("failed to edit issue", err) 185 + rp.pages.Notice(w, "issues", "Failed to edit issue.") 186 + return 187 + } 188 + 189 + if err = tx.Commit(); err != nil { 190 + l.Error("failed to edit issue", "err", err) 191 + rp.pages.Notice(w, "issues", "Failed to cedit issue.") 192 return 193 } 194 195 + rp.pages.HxRefresh(w) 196 + } 197 + } 198 + 199 + func (rp *Issues) DeleteIssue(w http.ResponseWriter, r *http.Request) { 200 + l := rp.logger.With("handler", "DeleteIssue") 201 + noticeId := "issue-actions-error" 202 + 203 + user := rp.oauth.GetUser(r) 204 + 205 + f, err := rp.repoResolver.Resolve(r) 206 + if err != nil { 207 + l.Error("failed to get repo and knot", "err", err) 208 + return 209 + } 210 + 211 + issue, ok := r.Context().Value("issue").(*db.Issue) 212 + if !ok { 213 + l.Error("failed to get issue") 214 + rp.pages.Notice(w, noticeId, "Failed to delete issue.") 215 + return 216 + } 217 + l = l.With("did", issue.Did, "rkey", issue.Rkey) 218 + 219 + // delete from PDS 220 + client, err := rp.oauth.AuthorizedClient(r) 221 + if err != nil { 222 + log.Println("failed to get authorized client", err) 223 + rp.pages.Notice(w, "issue-comment", "Failed to delete comment.") 224 + return 225 + } 226 + _, err = client.RepoDeleteRecord(r.Context(), &comatproto.RepoDeleteRecord_Input{ 227 + Collection: tangled.RepoIssueNSID, 228 + Repo: issue.Did, 229 + Rkey: issue.Rkey, 230 + }) 231 + if err != nil { 232 + // TODO: transact this better 233 + l.Error("failed to delete issue from PDS", "err", err) 234 + rp.pages.Notice(w, noticeId, "Failed to delete issue.") 235 + return 236 + } 237 + 238 + // delete from db 239 + if err := db.DeleteIssues(rp.db, db.FilterEq("id", issue.Id)); err != nil { 240 + l.Error("failed to delete issue", "err", err) 241 + rp.pages.Notice(w, noticeId, "Failed to delete issue.") 242 + return 243 + } 244 + 245 + // return to all issues page 246 + rp.pages.HxRedirect(w, "/"+f.RepoInfo(user).FullName()+"/issues") 247 + } 248 + 249 + func (rp *Issues) CloseIssue(w http.ResponseWriter, r *http.Request) { 250 + l := rp.logger.With("handler", "CloseIssue") 251 + user := rp.oauth.GetUser(r) 252 + f, err := rp.repoResolver.Resolve(r) 253 + if err != nil { 254 + l.Error("failed to get repo and knot", "err", err) 255 + return 256 + } 257 + 258 + issue, ok := r.Context().Value("issue").(*db.Issue) 259 + if !ok { 260 + l.Error("failed to get issue") 261 + rp.pages.Error404(w) 262 + return 263 + } 264 + 265 + collaborators, err := f.Collaborators(r.Context()) 266 + if err != nil { 267 + log.Println("failed to fetch repo collaborators: %w", err) 268 + } 269 + isCollaborator := slices.ContainsFunc(collaborators, func(collab pages.Collaborator) bool { 270 + return user.Did == collab.Did 271 + }) 272 + isIssueOwner := user.Did == issue.Did 273 + 274 + // TODO: make this more granular 275 + if isIssueOwner || isCollaborator { 276 + err = db.CloseIssues( 277 + rp.db, 278 + db.FilterEq("id", issue.Id), 279 + ) 280 if err != nil { 281 log.Println("failed to close issue", err) 282 rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.") 283 return 284 } 285 286 + rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId)) 287 return 288 } else { 289 log.Println("user is not permitted to close issue") ··· 293 } 294 295 func (rp *Issues) ReopenIssue(w http.ResponseWriter, r *http.Request) { 296 + l := rp.logger.With("handler", "ReopenIssue") 297 user := rp.oauth.GetUser(r) 298 f, err := rp.repoResolver.Resolve(r) 299 if err != nil { ··· 301 return 302 } 303 304 + issue, ok := r.Context().Value("issue").(*db.Issue) 305 + if !ok { 306 + l.Error("failed to get issue") 307 + rp.pages.Error404(w) 0 0 0 0 0 0 0 0 308 return 309 } 310 ··· 315 isCollaborator := slices.ContainsFunc(collaborators, func(collab pages.Collaborator) bool { 316 return user.Did == collab.Did 317 }) 318 + isIssueOwner := user.Did == issue.Did 319 320 if isCollaborator || isIssueOwner { 321 + err := db.ReopenIssues( 322 + rp.db, 323 + db.FilterEq("id", issue.Id), 324 + ) 325 if err != nil { 326 log.Println("failed to reopen issue", err) 327 rp.pages.Notice(w, "issue-action", "Failed to reopen issue. Try again later.") 328 return 329 } 330 + rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId)) 331 return 332 } else { 333 log.Println("user is not the owner of the repo") ··· 337 } 338 339 func (rp *Issues) NewIssueComment(w http.ResponseWriter, r *http.Request) { 340 + l := rp.logger.With("handler", "NewIssueComment") 341 user := rp.oauth.GetUser(r) 342 f, err := rp.repoResolver.Resolve(r) 343 if err != nil { 344 + l.Error("failed to get repo and knot", "err", err) 345 return 346 } 347 348 + issue, ok := r.Context().Value("issue").(*db.Issue) 349 + if !ok { 350 + l.Error("failed to get issue") 351 + rp.pages.Error404(w) 0 352 return 353 } 354 355 + body := r.FormValue("body") 356 + if body == "" { 357 + rp.pages.Notice(w, "issue", "Body is required") 358 + return 359 + } 0 0 360 361 + replyToUri := r.FormValue("reply-to") 362 + var replyTo *string 363 + if replyToUri != "" { 364 + replyTo = &replyToUri 365 + } 366 367 + comment := db.IssueComment{ 368 + Did: user.Did, 369 + Rkey: tid.TID(), 370 + IssueAt: issue.AtUri().String(), 371 + ReplyTo: replyTo, 372 + Body: body, 373 + Created: time.Now(), 374 + } 375 + if err = rp.validator.ValidateIssueComment(&comment); err != nil { 376 + l.Error("failed to validate comment", "err", err) 377 + rp.pages.Notice(w, "issue-comment", "Failed to create comment.") 378 + return 379 + } 380 + record := comment.AsRecord() 381 382 + client, err := rp.oauth.AuthorizedClient(r) 383 + if err != nil { 384 + l.Error("failed to get authorized client", "err", err) 385 + rp.pages.Notice(w, "issue-comment", "Failed to create comment.") 386 + return 387 + } 0 0 388 389 + // create a record first 390 + resp, err := client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{ 391 + Collection: tangled.RepoIssueCommentNSID, 392 + Repo: comment.Did, 393 + Rkey: comment.Rkey, 394 + Record: &lexutil.LexiconTypeDecoder{ 395 + Val: &record, 396 + }, 397 + }) 398 + if err != nil { 399 + l.Error("failed to create comment", "err", err) 400 + rp.pages.Notice(w, "issue-comment", "Failed to create comment.") 401 + return 402 + } 403 + atUri := resp.Uri 404 + defer func() { 405 + if err := rollbackRecord(context.Background(), atUri, client); err != nil { 406 + l.Error("rollback failed", "err", err) 407 } 408 + }() 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 409 410 + commentId, err := db.AddIssueComment(rp.db, comment) 411 + if err != nil { 412 + l.Error("failed to create comment", "err", err) 413 + rp.pages.Notice(w, "issue-comment", "Failed to create comment.") 414 return 415 } 416 + 417 + // reset atUri to make rollback a no-op 418 + atUri = "" 419 + rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d#comment-%d", f.OwnerSlashRepo(), issue.IssueId, commentId)) 420 } 421 422 func (rp *Issues) IssueComment(w http.ResponseWriter, r *http.Request) { 423 + l := rp.logger.With("handler", "IssueComment") 424 user := rp.oauth.GetUser(r) 425 f, err := rp.repoResolver.Resolve(r) 426 if err != nil { 427 + l.Error("failed to get repo and knot", "err", err) 428 return 429 } 430 431 + issue, ok := r.Context().Value("issue").(*db.Issue) 432 + if !ok { 433 + l.Error("failed to get issue") 434 + rp.pages.Error404(w) 0 435 return 436 } 437 438 + commentId := chi.URLParam(r, "commentId") 439 + comments, err := db.GetIssueComments( 440 + rp.db, 441 + db.FilterEq("id", commentId), 442 + ) 443 if err != nil { 444 + l.Error("failed to fetch comment", "id", commentId) 445 + http.Error(w, "failed to fetch comment id", http.StatusBadRequest) 446 return 447 } 448 + if len(comments) != 1 { 449 + l.Error("incorrect number of comments returned", "id", commentId, "len(comments)", len(comments)) 450 + http.Error(w, "invalid comment id", http.StatusBadRequest) 0 0 451 return 452 } 453 + comment := comments[0] 454 455 + rp.pages.IssueCommentBodyFragment(w, pages.IssueCommentBodyParams{ 0 0 0 0 0 0 456 LoggedInUser: user, 457 RepoInfo: f.RepoInfo(user), 458 Issue: issue, 459 + Comment: &comment, 460 }) 461 } 462 463 func (rp *Issues) EditIssueComment(w http.ResponseWriter, r *http.Request) { 464 + l := rp.logger.With("handler", "EditIssueComment") 465 user := rp.oauth.GetUser(r) 466 f, err := rp.repoResolver.Resolve(r) 467 if err != nil { 468 + l.Error("failed to get repo and knot", "err", err) 469 return 470 } 471 472 + issue, ok := r.Context().Value("issue").(*db.Issue) 473 + if !ok { 474 + l.Error("failed to get issue") 475 + rp.pages.Error404(w) 0 476 return 477 } 478 479 + commentId := chi.URLParam(r, "commentId") 480 + comments, err := db.GetIssueComments( 481 + rp.db, 482 + db.FilterEq("id", commentId), 483 + ) 484 if err != nil { 485 + l.Error("failed to fetch comment", "id", commentId) 486 + http.Error(w, "failed to fetch comment id", http.StatusBadRequest) 487 return 488 } 489 + if len(comments) != 1 { 490 + l.Error("incorrect number of comments returned", "id", commentId, "len(comments)", len(comments)) 491 + http.Error(w, "invalid comment id", http.StatusBadRequest) 0 0 492 return 493 } 494 + comment := comments[0] 495 496 + if comment.Did != user.Did { 497 + l.Error("unauthorized comment edit", "expectedDid", comment.Did, "gotDid", user.Did) 0 0 0 0 0 498 http.Error(w, "you are not the author of this comment", http.StatusUnauthorized) 499 return 500 } ··· 505 LoggedInUser: user, 506 RepoInfo: f.RepoInfo(user), 507 Issue: issue, 508 + Comment: &comment, 509 }) 510 case http.MethodPost: 511 // extract form value ··· 516 rp.pages.Notice(w, "issue-comment", "Failed to create comment.") 517 return 518 } 0 519 520 + now := time.Now() 521 + newComment := comment 522 + newComment.Body = newBody 523 + newComment.Edited = &now 524 + record := newComment.AsRecord() 525 + 526 + _, err = db.AddIssueComment(rp.db, newComment) 527 if err != nil { 528 log.Println("failed to perferom update-description query", err) 529 rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.") ··· 531 } 532 533 // rkey is optional, it was introduced later 534 + if newComment.Rkey != "" { 535 // update the record on pds 536 + ex, err := client.RepoGetRecord(r.Context(), "", tangled.RepoIssueCommentNSID, user.Did, comment.Rkey) 537 if err != nil { 538 + log.Println("failed to get record", "err", err, "did", newComment.Did, "rkey", newComment.Rkey) 0 539 rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "Failed to update description, no record found on PDS.") 540 return 541 } 0 0 0 0 0 0 542 543 _, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{ 544 Collection: tangled.RepoIssueCommentNSID, 545 Repo: user.Did, 546 + Rkey: newComment.Rkey, 547 SwapRecord: ex.Cid, 548 Record: &lexutil.LexiconTypeDecoder{ 549 + Val: &record, 0 0 0 0 0 0 550 }, 551 }) 552 if err != nil { 553 + l.Error("failed to update record on PDS", "err", err) 554 } 555 } 556 0 0 0 0 557 // return new comment body with htmx 558 + rp.pages.IssueCommentBodyFragment(w, pages.IssueCommentBodyParams{ 559 LoggedInUser: user, 560 RepoInfo: f.RepoInfo(user), 561 Issue: issue, 562 + Comment: &newComment, 563 }) 564 + } 565 + } 566 + 567 + func (rp *Issues) ReplyIssueCommentPlaceholder(w http.ResponseWriter, r *http.Request) { 568 + l := rp.logger.With("handler", "ReplyIssueCommentPlaceholder") 569 + user := rp.oauth.GetUser(r) 570 + f, err := rp.repoResolver.Resolve(r) 571 + if err != nil { 572 + l.Error("failed to get repo and knot", "err", err) 573 return 574 + } 575 576 + issue, ok := r.Context().Value("issue").(*db.Issue) 577 + if !ok { 578 + l.Error("failed to get issue") 579 + rp.pages.Error404(w) 580 + return 581 } 582 583 + commentId := chi.URLParam(r, "commentId") 584 + comments, err := db.GetIssueComments( 585 + rp.db, 586 + db.FilterEq("id", commentId), 587 + ) 588 + if err != nil { 589 + l.Error("failed to fetch comment", "id", commentId) 590 + http.Error(w, "failed to fetch comment id", http.StatusBadRequest) 591 + return 592 + } 593 + if len(comments) != 1 { 594 + l.Error("incorrect number of comments returned", "id", commentId, "len(comments)", len(comments)) 595 + http.Error(w, "invalid comment id", http.StatusBadRequest) 596 + return 597 + } 598 + comment := comments[0] 599 + 600 + rp.pages.ReplyIssueCommentPlaceholderFragment(w, pages.ReplyIssueCommentPlaceholderParams{ 601 + LoggedInUser: user, 602 + RepoInfo: f.RepoInfo(user), 603 + Issue: issue, 604 + Comment: &comment, 605 + }) 606 } 607 608 + func (rp *Issues) ReplyIssueComment(w http.ResponseWriter, r *http.Request) { 609 + l := rp.logger.With("handler", "ReplyIssueComment") 610 user := rp.oauth.GetUser(r) 611 f, err := rp.repoResolver.Resolve(r) 612 if err != nil { 613 + l.Error("failed to get repo and knot", "err", err) 614 return 615 } 616 617 + issue, ok := r.Context().Value("issue").(*db.Issue) 618 + if !ok { 619 + l.Error("failed to get issue") 620 + rp.pages.Error404(w) 0 621 return 622 } 623 624 + commentId := chi.URLParam(r, "commentId") 625 + comments, err := db.GetIssueComments( 626 + rp.db, 627 + db.FilterEq("id", commentId), 628 + ) 629 if err != nil { 630 + l.Error("failed to fetch comment", "id", commentId) 631 + http.Error(w, "failed to fetch comment id", http.StatusBadRequest) 632 return 633 } 634 + if len(comments) != 1 { 635 + l.Error("incorrect number of comments returned", "id", commentId, "len(comments)", len(comments)) 636 + http.Error(w, "invalid comment id", http.StatusBadRequest) 637 + return 638 + } 639 + comment := comments[0] 640 641 + rp.pages.ReplyIssueCommentFragment(w, pages.ReplyIssueCommentParams{ 642 + LoggedInUser: user, 643 + RepoInfo: f.RepoInfo(user), 644 + Issue: issue, 645 + Comment: &comment, 646 + }) 647 + } 648 + 649 + func (rp *Issues) DeleteIssueComment(w http.ResponseWriter, r *http.Request) { 650 + l := rp.logger.With("handler", "DeleteIssueComment") 651 + user := rp.oauth.GetUser(r) 652 + f, err := rp.repoResolver.Resolve(r) 653 if err != nil { 654 + l.Error("failed to get repo and knot", "err", err) 0 655 return 656 } 657 658 + issue, ok := r.Context().Value("issue").(*db.Issue) 659 + if !ok { 660 + l.Error("failed to get issue") 661 + rp.pages.Error404(w) 662 + return 663 + } 664 + 665 + commentId := chi.URLParam(r, "commentId") 666 + comments, err := db.GetIssueComments( 667 + rp.db, 668 + db.FilterEq("id", commentId), 669 + ) 670 if err != nil { 671 + l.Error("failed to fetch comment", "id", commentId) 672 + http.Error(w, "failed to fetch comment id", http.StatusBadRequest) 673 return 674 } 675 + if len(comments) != 1 { 676 + l.Error("incorrect number of comments returned", "id", commentId, "len(comments)", len(comments)) 677 + http.Error(w, "invalid comment id", http.StatusBadRequest) 678 + return 679 + } 680 + comment := comments[0] 681 682 + if comment.Did != user.Did { 683 + l.Error("unauthorized action", "expectedDid", comment.Did, "gotDid", user.Did) 684 http.Error(w, "you are not the author of this comment", http.StatusUnauthorized) 685 return 686 } ··· 692 693 // optimistic deletion 694 deleted := time.Now() 695 + err = db.DeleteIssueComments(rp.db, db.FilterEq("id", comment.Id)) 696 if err != nil { 697 + l.Error("failed to delete comment", "err", err) 698 rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "failed to delete comment") 699 return 700 } ··· 708 return 709 } 710 _, err = client.RepoDeleteRecord(r.Context(), &comatproto.RepoDeleteRecord_Input{ 711 + Collection: tangled.RepoIssueCommentNSID, 712 Repo: user.Did, 713 Rkey: comment.Rkey, 714 }) ··· 722 comment.Deleted = &deleted 723 724 // htmx fragment of comment after deletion 725 + rp.pages.IssueCommentBodyFragment(w, pages.IssueCommentBodyParams{ 726 LoggedInUser: user, 727 RepoInfo: f.RepoInfo(user), 728 Issue: issue, 729 + Comment: &comment, 730 }) 731 } 732 ··· 756 return 757 } 758 759 + openVal := 0 760 + if isOpen { 761 + openVal = 1 762 + } 763 + issues, err := db.GetIssuesPaginated( 764 + rp.db, 765 + page, 766 + db.FilterEq("repo_at", f.RepoAt()), 767 + db.FilterEq("open", openVal), 768 + ) 769 if err != nil { 770 log.Println("failed to get issues", err) 771 rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.") ··· 782 } 783 784 func (rp *Issues) NewIssue(w http.ResponseWriter, r *http.Request) { 785 + l := rp.logger.With("handler", "NewIssue") 786 user := rp.oauth.GetUser(r) 787 788 f, err := rp.repoResolver.Resolve(r) 789 if err != nil { 790 + l.Error("failed to get repo and knot", "err", err) 791 return 792 } 793 ··· 798 RepoInfo: f.RepoInfo(user), 799 }) 800 case http.MethodPost: 801 + issue := &db.Issue{ 802 + RepoAt: f.RepoAt(), 803 + Rkey: tid.TID(), 804 + Title: r.FormValue("title"), 805 + Body: r.FormValue("body"), 806 + Did: user.Did, 807 + Created: time.Now(), 808 + } 809 810 + if err := rp.validator.ValidateIssue(issue); err != nil { 811 + l.Error("validation error", "err", err) 812 + rp.pages.Notice(w, "issues", fmt.Sprintf("Failed to create issue: %s", err)) 813 return 814 } 815 816 + record := issue.AsRecord() 817 + 818 + // create an atproto record 819 + client, err := rp.oauth.AuthorizedClient(r) 820 + if err != nil { 821 + l.Error("failed to get authorized client", "err", err) 822 + rp.pages.Notice(w, "issues", "Failed to create issue.") 823 return 824 } 825 + resp, err := client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{ 826 + Collection: tangled.RepoIssueNSID, 827 + Repo: user.Did, 828 + Rkey: issue.Rkey, 829 + Record: &lexutil.LexiconTypeDecoder{ 830 + Val: &record, 831 + }, 832 + }) 833 + if err != nil { 834 + l.Error("failed to create issue", "err", err) 835 + rp.pages.Notice(w, "issues", "Failed to create issue.") 836 return 837 } 838 + atUri := resp.Uri 839 840 tx, err := rp.db.BeginTx(r.Context(), nil) 841 if err != nil { 842 rp.pages.Notice(w, "issues", "Failed to create issue, try again later") 843 return 844 } 845 + rollback := func() { 846 + err1 := tx.Rollback() 847 + err2 := rollbackRecord(context.Background(), atUri, client) 848 849 + if errors.Is(err1, sql.ErrTxDone) { 850 + err1 = nil 851 + } 852 + 853 + if err := errors.Join(err1, err2); err != nil { 854 + l.Error("failed to rollback txn", "err", err) 855 + } 856 } 857 + defer rollback() 858 + 859 + err = db.PutIssue(tx, issue) 860 if err != nil { 861 log.Println("failed to create issue", err) 862 rp.pages.Notice(w, "issues", "Failed to create issue.") 863 return 864 } 865 866 + if err = tx.Commit(); err != nil { 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 867 log.Println("failed to create issue", err) 868 rp.pages.Notice(w, "issues", "Failed to create issue.") 869 return 870 } 871 872 + // everything is successful, do not rollback the atproto record 873 + atUri = "" 874 rp.notifier.NewIssue(r.Context(), issue) 0 875 rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId)) 876 return 877 } 878 } 879 + 880 + // this is used to rollback changes made to the PDS 881 + // 882 + // it is a no-op if the provided ATURI is empty 883 + func rollbackRecord(ctx context.Context, aturi string, xrpcc *xrpcclient.Client) error { 884 + if aturi == "" { 885 + return nil 886 + } 887 + 888 + parsed := syntax.ATURI(aturi) 889 + 890 + collection := parsed.Collection().String() 891 + repo := parsed.Authority().String() 892 + rkey := parsed.RecordKey().String() 893 + 894 + _, err := xrpcc.RepoDeleteRecord(ctx, &comatproto.RepoDeleteRecord_Input{ 895 + Collection: collection, 896 + Repo: repo, 897 + Rkey: rkey, 898 + }) 899 + return err 900 + }

+24 -10

appview/issues/router.go

··· 12 13 r.Route("/", func(r chi.Router) { 14 r.With(middleware.Paginate).Get("/", i.RepoIssues) 15 - r.Get("/{issue}", i.RepoSingleIssue) 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 16 17 r.Group(func(r chi.Router) { 18 r.Use(middleware.AuthMiddleware(i.oauth)) 19 r.Get("/new", i.NewIssue) 20 r.Post("/new", i.NewIssue) 21 - r.Post("/{issue}/comment", i.NewIssueComment) 22 - r.Route("/{issue}/comment/{comment_id}/", func(r chi.Router) { 23 - r.Get("/", i.IssueComment) 24 - r.Delete("/", i.DeleteIssueComment) 25 - r.Get("/edit", i.EditIssueComment) 26 - r.Post("/edit", i.EditIssueComment) 27 - }) 28 - r.Post("/{issue}/close", i.CloseIssue) 29 - r.Post("/{issue}/reopen", i.ReopenIssue) 30 }) 31 }) 32

··· 12 13 r.Route("/", func(r chi.Router) { 14 r.With(middleware.Paginate).Get("/", i.RepoIssues) 15 + 16 + r.Route("/{issue}", func(r chi.Router) { 17 + r.Use(mw.ResolveIssue()) 18 + r.Get("/", i.RepoSingleIssue) 19 + 20 + // authenticated routes 21 + r.Group(func(r chi.Router) { 22 + r.Use(middleware.AuthMiddleware(i.oauth)) 23 + r.Post("/comment", i.NewIssueComment) 24 + r.Route("/comment/{commentId}/", func(r chi.Router) { 25 + r.Get("/", i.IssueComment) 26 + r.Delete("/", i.DeleteIssueComment) 27 + r.Get("/edit", i.EditIssueComment) 28 + r.Post("/edit", i.EditIssueComment) 29 + r.Get("/reply", i.ReplyIssueComment) 30 + r.Get("/replyPlaceholder", i.ReplyIssueCommentPlaceholder) 31 + }) 32 + r.Get("/edit", i.EditIssue) 33 + r.Post("/edit", i.EditIssue) 34 + r.Delete("/", i.DeleteIssue) 35 + r.Post("/close", i.CloseIssue) 36 + r.Post("/reopen", i.ReopenIssue) 37 + }) 38 + }) 39 40 r.Group(func(r chi.Router) { 41 r.Use(middleware.AuthMiddleware(i.oauth)) 42 r.Get("/new", i.NewIssue) 43 r.Post("/new", i.NewIssue) 0 0 0 0 0 0 0 0 0 44 }) 45 }) 46

+5 -57

appview/knots/knots.go

··· 3 import ( 4 "errors" 5 "fmt" 6 - "log" 7 "log/slog" 8 "net/http" 9 "slices" ··· 17 "tangled.sh/tangled.sh/core/appview/oauth" 18 "tangled.sh/tangled.sh/core/appview/pages" 19 "tangled.sh/tangled.sh/core/appview/serververify" 0 20 "tangled.sh/tangled.sh/core/eventconsumer" 21 "tangled.sh/tangled.sh/core/idresolver" 22 "tangled.sh/tangled.sh/core/rbac" ··· 49 r.With(middleware.AuthMiddleware(k.OAuth)).Post("/{domain}/retry", k.retry) 50 r.With(middleware.AuthMiddleware(k.OAuth)).Post("/{domain}/add", k.addMember) 51 r.With(middleware.AuthMiddleware(k.OAuth)).Post("/{domain}/remove", k.removeMember) 52 - 53 - r.With(middleware.AuthMiddleware(k.OAuth)).Get("/upgradeBanner", k.banner) 54 55 return r 56 } ··· 399 if err != nil { 400 l.Error("verification failed", "err", err) 401 402 - if errors.Is(err, serververify.FetchError) { 403 - k.Pages.Notice(w, noticeId, "Failed to verify knot, unable to fetch owner.") 404 return 405 } 406 ··· 420 return 421 } 422 423 - // if this knot was previously read-only, then emit a record too 424 // 425 // this is part of migrating from the old knot system to the new one 426 - if registration.ReadOnly { 427 // re-announce by registering under same rkey 428 client, err := k.OAuth.AuthorizedClient(r) 429 if err != nil { ··· 484 return 485 } 486 updatedRegistration := registrations[0] 487 - 488 - log.Println(updatedRegistration) 489 490 w.Header().Set("HX-Reswap", "outerHTML") 491 k.Pages.KnotListing(w, pages.KnotListingParams{ ··· 678 // ok 679 k.Pages.HxRefresh(w) 680 } 681 - 682 - func (k *Knots) banner(w http.ResponseWriter, r *http.Request) { 683 - user := k.OAuth.GetUser(r) 684 - l := k.Logger.With("handler", "banner") 685 - l = l.With("did", user.Did) 686 - l = l.With("handle", user.Handle) 687 - 688 - allRegistrations, err := db.GetRegistrations( 689 - k.Db, 690 - db.FilterEq("did", user.Did), 691 - ) 692 - if err != nil { 693 - l.Error("non-fatal: failed to get registrations") 694 - return 695 - } 696 - 697 - httpClient := &http.Client{Timeout: 5 * time.Second} 698 - regs404 := []db.Registration{} 699 - for _, reg := range allRegistrations { 700 - healthURL := fmt.Sprintf("http://%s/xrpc/_health", reg.Domain) 701 - 702 - fmt.Println(healthURL) 703 - 704 - req, err := http.NewRequestWithContext(r.Context(), http.MethodGet, healthURL, nil) 705 - if err != nil { 706 - l.Error("failed to create health check request", "domain", reg.Domain, "err", err) 707 - continue 708 - } 709 - 710 - resp, err := httpClient.Do(req) 711 - if err != nil { 712 - l.Error("failed to make health check request", "domain", reg.Domain, "err", err) 713 - continue 714 - } 715 - defer resp.Body.Close() 716 - 717 - if resp.StatusCode == http.StatusNotFound { 718 - regs404 = append(regs404, reg) 719 - } 720 - } 721 - if len(regs404) == 0 { 722 - return 723 - } 724 - 725 - k.Pages.KnotBanner(w, pages.KnotBannerParams{ 726 - Registrations: regs404, 727 - }) 728 - }

··· 3 import ( 4 "errors" 5 "fmt" 0 6 "log/slog" 7 "net/http" 8 "slices" ··· 16 "tangled.sh/tangled.sh/core/appview/oauth" 17 "tangled.sh/tangled.sh/core/appview/pages" 18 "tangled.sh/tangled.sh/core/appview/serververify" 19 + "tangled.sh/tangled.sh/core/appview/xrpcclient" 20 "tangled.sh/tangled.sh/core/eventconsumer" 21 "tangled.sh/tangled.sh/core/idresolver" 22 "tangled.sh/tangled.sh/core/rbac" ··· 49 r.With(middleware.AuthMiddleware(k.OAuth)).Post("/{domain}/retry", k.retry) 50 r.With(middleware.AuthMiddleware(k.OAuth)).Post("/{domain}/add", k.addMember) 51 r.With(middleware.AuthMiddleware(k.OAuth)).Post("/{domain}/remove", k.removeMember) 0 0 52 53 return r 54 } ··· 397 if err != nil { 398 l.Error("verification failed", "err", err) 399 400 + if errors.Is(err, xrpcclient.ErrXrpcUnsupported) { 401 + k.Pages.Notice(w, noticeId, "Failed to verify knot, XRPC queries are unsupported on this knot, consider upgrading!") 402 return 403 } 404 ··· 418 return 419 } 420 421 + // if this knot requires upgrade, then emit a record too 422 // 423 // this is part of migrating from the old knot system to the new one 424 + if registration.NeedsUpgrade { 425 // re-announce by registering under same rkey 426 client, err := k.OAuth.AuthorizedClient(r) 427 if err != nil { ··· 482 return 483 } 484 updatedRegistration := registrations[0] 0 0 485 486 w.Header().Set("HX-Reswap", "outerHTML") 487 k.Pages.KnotListing(w, pages.KnotListingParams{ ··· 674 // ok 675 k.Pages.HxRefresh(w) 676 } 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

+40

appview/middleware/middleware.go

··· 275 } 276 } 277 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 278 // this should serve the go-import meta tag even if the path is technically 279 // a 404 like tangled.sh/oppi.li/go-git/v5 280 func (mw Middleware) GoImport() middlewareFunc {

··· 275 } 276 } 277 278 + // middleware that is tacked on top of /{user}/{repo}/issues/{issue} 279 + func (mw Middleware) ResolveIssue() middlewareFunc { 280 + return func(next http.Handler) http.Handler { 281 + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 282 + f, err := mw.repoResolver.Resolve(r) 283 + if err != nil { 284 + log.Println("failed to fully resolve repo", err) 285 + mw.pages.ErrorKnot404(w) 286 + return 287 + } 288 + 289 + issueIdStr := chi.URLParam(r, "issue") 290 + issueId, err := strconv.Atoi(issueIdStr) 291 + if err != nil { 292 + log.Println("failed to fully resolve issue ID", err) 293 + mw.pages.ErrorKnot404(w) 294 + return 295 + } 296 + 297 + issues, err := db.GetIssues( 298 + mw.db, 299 + db.FilterEq("repo_at", f.RepoAt()), 300 + db.FilterEq("issue_id", issueId), 301 + ) 302 + if err != nil { 303 + log.Println("failed to get issues", "err", err) 304 + return 305 + } 306 + if len(issues) != 1 { 307 + log.Println("got incorrect number of issues", "len(issuse)", len(issues)) 308 + return 309 + } 310 + issue := issues[0] 311 + 312 + ctx := context.WithValue(r.Context(), "issue", &issue) 313 + next.ServeHTTP(w, r.WithContext(ctx)) 314 + }) 315 + } 316 + } 317 + 318 // this should serve the go-import meta tag even if the path is technically 319 // a 404 like tangled.sh/oppi.li/go-git/v5 320 func (mw Middleware) GoImport() middlewareFunc {

+18

appview/notify/merged_notifier.go

··· 66 notifier.UpdateProfile(ctx, profile) 67 } 68 } 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 66 notifier.UpdateProfile(ctx, profile) 67 } 68 } 69 + 70 + func (m *mergedNotifier) NewString(ctx context.Context, string *db.String) { 71 + for _, notifier := range m.notifiers { 72 + notifier.NewString(ctx, string) 73 + } 74 + } 75 + 76 + func (m *mergedNotifier) EditString(ctx context.Context, string *db.String) { 77 + for _, notifier := range m.notifiers { 78 + notifier.EditString(ctx, string) 79 + } 80 + } 81 + 82 + func (m *mergedNotifier) DeleteString(ctx context.Context, did, rkey string) { 83 + for _, notifier := range m.notifiers { 84 + notifier.DeleteString(ctx, did, rkey) 85 + } 86 + }

+8

appview/notify/notifier.go

··· 21 NewPullComment(ctx context.Context, comment *db.PullComment) 22 23 UpdateProfile(ctx context.Context, profile *db.Profile) 0 0 0 0 24 } 25 26 // BaseNotifier is a listener that does nothing ··· 42 func (m *BaseNotifier) NewPullComment(ctx context.Context, comment *db.PullComment) {} 43 44 func (m *BaseNotifier) UpdateProfile(ctx context.Context, profile *db.Profile) {} 0 0 0 0

··· 21 NewPullComment(ctx context.Context, comment *db.PullComment) 22 23 UpdateProfile(ctx context.Context, profile *db.Profile) 24 + 25 + NewString(ctx context.Context, s *db.String) 26 + EditString(ctx context.Context, s *db.String) 27 + DeleteString(ctx context.Context, did, rkey string) 28 } 29 30 // BaseNotifier is a listener that does nothing ··· 46 func (m *BaseNotifier) NewPullComment(ctx context.Context, comment *db.PullComment) {} 47 48 func (m *BaseNotifier) UpdateProfile(ctx context.Context, profile *db.Profile) {} 49 + 50 + func (m *BaseNotifier) NewString(ctx context.Context, s *db.String) {} 51 + func (m *BaseNotifier) EditString(ctx context.Context, s *db.String) {} 52 + func (m *BaseNotifier) DeleteString(ctx context.Context, did, rkey string) {}

+3

appview/pages/funcmap.go

··· 29 "split": func(s string) []string { 30 return strings.Split(s, "\n") 31 }, 0 0 0 32 "resolve": func(s string) string { 33 identity, err := p.resolver.ResolveIdent(context.Background(), s) 34

··· 29 "split": func(s string) []string { 30 return strings.Split(s, "\n") 31 }, 32 + "contains": func(s string, target string) bool { 33 + return strings.Contains(s, target) 34 + }, 35 "resolve": func(s string) string { 36 identity, err := p.resolver.ResolveIdent(context.Background(), s) 37

+1 -1

appview/pages/markup/markdown.go

··· 235 repoName := fmt.Sprintf("%s/%s", rctx.RepoInfo.OwnerDid, rctx.RepoInfo.Name) 236 237 query := fmt.Sprintf("repo=%s&ref=%s&path=%s&raw=true", 238 - repoName, url.PathEscape(rctx.RepoInfo.Ref), actualPath) 239 240 parsedURL := &url.URL{ 241 Scheme: scheme,

··· 235 repoName := fmt.Sprintf("%s/%s", rctx.RepoInfo.OwnerDid, rctx.RepoInfo.Name) 236 237 query := fmt.Sprintf("repo=%s&ref=%s&path=%s&raw=true", 238 + url.PathEscape(repoName), url.PathEscape(rctx.RepoInfo.Ref), actualPath) 239 240 parsedURL := &url.URL{ 241 Scheme: scheme,

+51 -49

appview/pages/pages.go

··· 117 return fragmentPaths, nil 118 } 119 120 - func (p *Pages) fragments() (*template.Template, error) { 121 - fragmentPaths, err := p.fragmentPaths() 122 - if err != nil { 123 - return nil, err 124 - } 125 - 126 - funcs := p.funcMap() 127 - 128 - // parse all fragments together 129 - allFragments := template.New("").Funcs(funcs) 130 - for _, f := range fragmentPaths { 131 - name := p.pathToName(f) 132 - 133 - pf, err := template.New(name). 134 - Funcs(funcs). 135 - ParseFS(p.embedFS, f) 136 - if err != nil { 137 - return nil, err 138 - } 139 - 140 - allFragments, err = allFragments.AddParseTree(name, pf.Tree) 141 - if err != nil { 142 - return nil, err 143 - } 144 - } 145 - 146 - return allFragments, nil 147 - } 148 - 149 // parse without memoization 150 func (p *Pages) rawParse(stack ...string) (*template.Template, error) { 151 paths, err := p.fragmentPaths() ··· 351 return p.execute("user/settings/emails", w, params) 352 } 353 354 - type KnotBannerParams struct { 355 Registrations []db.Registration 0 356 } 357 358 - func (p *Pages) KnotBanner(w io.Writer, params KnotBannerParams) error { 359 - return p.executePlain("knots/fragments/bannerRequiresUpgrade", w, params) 360 } 361 362 type KnotsParams struct { ··· 908 RepoInfo repoinfo.RepoInfo 909 Active string 910 Issue *db.Issue 911 - Comments []db.Comment 912 IssueOwnerHandle string 913 914 OrderedReactionKinds []db.ReactionKind 915 Reactions map[db.ReactionKind]int 916 UserReacted map[db.ReactionKind]bool 0 917 918 - State string 0 0 0 0 0 0 0 0 0 0 0 0 0 0 919 } 920 921 type ThreadReactionFragmentParams struct { ··· 929 return p.executePlain("repo/fragments/reaction", w, params) 930 } 931 932 - func (p *Pages) RepoSingleIssue(w io.Writer, params RepoSingleIssueParams) error { 933 - params.Active = "issues" 934 - if params.Issue.Open { 935 - params.State = "open" 936 - } else { 937 - params.State = "closed" 938 - } 939 - return p.executeRepo("repo/issues/issue", w, params) 940 - } 941 - 942 type RepoNewIssueParams struct { 943 LoggedInUser *oauth.User 944 RepoInfo repoinfo.RepoInfo 0 945 Active string 0 946 } 947 948 func (p *Pages) RepoNewIssue(w io.Writer, params RepoNewIssueParams) error { 949 params.Active = "issues" 0 950 return p.executeRepo("repo/issues/new", w, params) 951 } 952 ··· 954 LoggedInUser *oauth.User 955 RepoInfo repoinfo.RepoInfo 956 Issue *db.Issue 957 - Comment *db.Comment 958 } 959 960 func (p *Pages) EditIssueCommentFragment(w io.Writer, params EditIssueCommentParams) error { 961 return p.executePlain("repo/issues/fragments/editIssueComment", w, params) 962 } 963 964 - type SingleIssueCommentParams struct { 965 LoggedInUser *oauth.User 966 RepoInfo repoinfo.RepoInfo 967 Issue *db.Issue 968 - Comment *db.Comment 969 } 970 971 - func (p *Pages) SingleIssueCommentFragment(w io.Writer, params SingleIssueCommentParams) error { 972 - return p.executePlain("repo/issues/fragments/issueComment", w, params) 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 973 } 974 975 type RepoNewPullParams struct {

··· 117 return fragmentPaths, nil 118 } 119 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 120 // parse without memoization 121 func (p *Pages) rawParse(stack ...string) (*template.Template, error) { 122 paths, err := p.fragmentPaths() ··· 322 return p.execute("user/settings/emails", w, params) 323 } 324 325 + type UpgradeBannerParams struct { 326 Registrations []db.Registration 327 + Spindles []db.Spindle 328 } 329 330 + func (p *Pages) UpgradeBanner(w io.Writer, params UpgradeBannerParams) error { 331 + return p.executePlain("banner", w, params) 332 } 333 334 type KnotsParams struct { ··· 880 RepoInfo repoinfo.RepoInfo 881 Active string 882 Issue *db.Issue 883 + CommentList []db.CommentListItem 884 IssueOwnerHandle string 885 886 OrderedReactionKinds []db.ReactionKind 887 Reactions map[db.ReactionKind]int 888 UserReacted map[db.ReactionKind]bool 889 + } 890 891 + func (p *Pages) RepoSingleIssue(w io.Writer, params RepoSingleIssueParams) error { 892 + params.Active = "issues" 893 + return p.executeRepo("repo/issues/issue", w, params) 894 + } 895 + 896 + type EditIssueParams struct { 897 + LoggedInUser *oauth.User 898 + RepoInfo repoinfo.RepoInfo 899 + Issue *db.Issue 900 + Action string 901 + } 902 + 903 + func (p *Pages) EditIssueFragment(w io.Writer, params EditIssueParams) error { 904 + params.Action = "edit" 905 + return p.executePlain("repo/issues/fragments/putIssue", w, params) 906 } 907 908 type ThreadReactionFragmentParams struct { ··· 916 return p.executePlain("repo/fragments/reaction", w, params) 917 } 918 0 0 0 0 0 0 0 0 0 0 919 type RepoNewIssueParams struct { 920 LoggedInUser *oauth.User 921 RepoInfo repoinfo.RepoInfo 922 + Issue *db.Issue // existing issue if any -- passed when editing 923 Active string 924 + Action string 925 } 926 927 func (p *Pages) RepoNewIssue(w io.Writer, params RepoNewIssueParams) error { 928 params.Active = "issues" 929 + params.Action = "create" 930 return p.executeRepo("repo/issues/new", w, params) 931 } 932 ··· 934 LoggedInUser *oauth.User 935 RepoInfo repoinfo.RepoInfo 936 Issue *db.Issue 937 + Comment *db.IssueComment 938 } 939 940 func (p *Pages) EditIssueCommentFragment(w io.Writer, params EditIssueCommentParams) error { 941 return p.executePlain("repo/issues/fragments/editIssueComment", w, params) 942 } 943 944 + type ReplyIssueCommentPlaceholderParams struct { 945 LoggedInUser *oauth.User 946 RepoInfo repoinfo.RepoInfo 947 Issue *db.Issue 948 + Comment *db.IssueComment 949 } 950 951 + func (p *Pages) ReplyIssueCommentPlaceholderFragment(w io.Writer, params ReplyIssueCommentPlaceholderParams) error { 952 + return p.executePlain("repo/issues/fragments/replyIssueCommentPlaceholder", w, params) 953 + } 954 + 955 + type ReplyIssueCommentParams struct { 956 + LoggedInUser *oauth.User 957 + RepoInfo repoinfo.RepoInfo 958 + Issue *db.Issue 959 + Comment *db.IssueComment 960 + } 961 + 962 + func (p *Pages) ReplyIssueCommentFragment(w io.Writer, params ReplyIssueCommentParams) error { 963 + return p.executePlain("repo/issues/fragments/replyComment", w, params) 964 + } 965 + 966 + type IssueCommentBodyParams struct { 967 + LoggedInUser *oauth.User 968 + RepoInfo repoinfo.RepoInfo 969 + Issue *db.Issue 970 + Comment *db.IssueComment 971 + } 972 + 973 + func (p *Pages) IssueCommentBodyFragment(w io.Writer, params IssueCommentBodyParams) error { 974 + return p.executePlain("repo/issues/fragments/issueCommentBody", w, params) 975 } 976 977 type RepoNewPullParams struct {

+38

appview/pages/templates/banner.html

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + {{ define "banner" }} 2 + <div class="flex items-center justify-center mx-auto w-full bg-red-100 dark:bg-red-900 border border-red-200 dark:border-red-800 rounded-b drop-shadow-sm text-red-800 dark:text-red-200"> 3 + <details class="group p-2"> 4 + <summary class="list-none cursor-pointer"> 5 + <div class="flex gap-4 items-center"> 6 + <span class="group-open:hidden inline">{{ i "triangle-alert" "w-4 h-4" }}</span> 7 + <span class="hidden group-open:inline">{{ i "x" "w-4 h-4" }}</span> 8 + 9 + <span class="group-open:hidden inline">Some services that you administer require an update. Click to show more.</span> 10 + <span class="hidden group-open:inline">Some services that you administer will have to be updated to be compatible with Tangled.</span> 11 + </div> 12 + </summary> 13 + 14 + {{ if .Registrations }} 15 + <ul class="list-disc mx-12 my-2"> 16 + {{range .Registrations}} 17 + <li>Knot: {{ .Domain }}</li> 18 + {{ end }} 19 + </ul> 20 + {{ end }} 21 + 22 + {{ if .Spindles }} 23 + <ul class="list-disc mx-12 my-2"> 24 + {{range .Spindles}} 25 + <li>Spindle: {{ .Instance }}</li> 26 + {{ end }} 27 + </ul> 28 + {{ end }} 29 + 30 + <div class="mx-6"> 31 + These services may not be fully accessible until upgraded. 32 + <a class="underline text-red-800 dark:text-red-200" 33 + href="https://tangled.sh/@tangled.sh/core/tree/master/docs/migrations.md"> 34 + Click to read the upgrade guide</a>. 35 + </div> 36 + </details> 37 + </div> 38 + {{ end }}

+8

appview/pages/templates/fragments/logotype.html

··· 0 0 0 0 0 0 0 0

··· 1 + {{ define "fragments/logotype" }} 2 + <span class="flex items-center gap-2"> 3 + <span class="font-bold italic">tangled</span> 4 + <span class="font-normal not-italic text-xs rounded bg-gray-100 dark:bg-gray-700 px-1"> 5 + alpha 6 + </span> 7 + <span> 8 + {{ end }}

+90

appview/pages/templates/fragments/multiline-select.html

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + {{ define "fragments/multiline-select" }} 2 + <script> 3 + function highlight(scroll = false) { 4 + document.querySelectorAll(".hl").forEach(el => { 5 + el.classList.remove("hl"); 6 + }); 7 + 8 + const hash = window.location.hash; 9 + if (!hash || !hash.startsWith("#L")) { 10 + return; 11 + } 12 + 13 + const rangeStr = hash.substring(2); 14 + const parts = rangeStr.split("-"); 15 + let startLine, endLine; 16 + 17 + if (parts.length === 2) { 18 + startLine = parseInt(parts[0], 10); 19 + endLine = parseInt(parts[1], 10); 20 + } else { 21 + startLine = parseInt(parts[0], 10); 22 + endLine = startLine; 23 + } 24 + 25 + if (isNaN(startLine) || isNaN(endLine)) { 26 + console.log("nan"); 27 + console.log(startLine); 28 + console.log(endLine); 29 + return; 30 + } 31 + 32 + let target = null; 33 + 34 + for (let i = startLine; i<= endLine; i++) { 35 + const idEl = document.getElementById(`L${i}`); 36 + if (idEl) { 37 + const el = idEl.closest(".line"); 38 + if (el) { 39 + el.classList.add("hl"); 40 + target = el; 41 + } 42 + } 43 + } 44 + 45 + if (scroll && target) { 46 + target.scrollIntoView({ 47 + behavior: "smooth", 48 + block: "center", 49 + }); 50 + } 51 + } 52 + 53 + document.addEventListener("DOMContentLoaded", () => { 54 + console.log("DOMContentLoaded"); 55 + highlight(true); 56 + }); 57 + window.addEventListener("hashchange", () => { 58 + console.log("hashchange"); 59 + highlight(); 60 + }); 61 + window.addEventListener("popstate", () => { 62 + console.log("popstate"); 63 + highlight(); 64 + }); 65 + 66 + const lineNumbers = document.querySelectorAll('a[href^="#L"'); 67 + let startLine = null; 68 + 69 + lineNumbers.forEach(el => { 70 + el.addEventListener("click", (event) => { 71 + event.preventDefault(); 72 + const currentLine = parseInt(el.href.split("#L")[1]); 73 + 74 + if (event.shiftKey && startLine !== null) { 75 + const endLine = currentLine; 76 + const min = Math.min(startLine, endLine); 77 + const max = Math.max(startLine, endLine); 78 + const newHash = `#L${min}-${max}`; 79 + history.pushState(null, '', newHash); 80 + } else { 81 + const newHash = `#L${currentLine}`; 82 + history.pushState(null, '', newHash); 83 + startLine = currentLine; 84 + } 85 + 86 + highlight(); 87 + }); 88 + }); 89 + </script> 90 + {{ end }}

-8

appview/pages/templates/knots/fragments/bannerReadOnly.html

··· 1 - {{ define "knots/fragments/bannerReadOnly" }} 2 - <div class="w-full px-6 py-2 -z-15 bg-yellow-100 text-yellow-800 dark:bg-yellow-900 dark:text-yellow-200 border border-yellow-200 dark:border-yellow-800 rounded-b drop-shadow-sm"> 3 - A knot ({{range $i, $r := .Registrations}}{{if ne $i 0}}, {{end}}{{ $r.Domain }}{{ end }}) 4 - that you administer is presently read-only. Consider upgrading this knot to 5 - continue creating repositories on it. 6 - <a href="https://tangled.sh/@tangled.sh/core/blob/master/docs/migrations/knot-1.7.0.md">Click to read the upgrade guide</a>. 7 - </div> 8 - {{ end }}

··· 0 0 0 0 0 0 0 0

-12

appview/pages/templates/knots/fragments/bannerRequiresUpgrade.html

··· 1 - {{ define "knots/fragments/bannerRequiresUpgrade" }} 2 - <div class="prose mx-auto w-96 px-6 py-2 bg-yellow-100 text-yellow-800 dark:bg-yellow-900 dark:text-yellow-200 border border-yellow-200 dark:border-yellow-800 rounded-b drop-shadow-sm"> 3 - The following knots that you administer require upgrade to be compatible with the latest version of Tangled: 4 - <ul> 5 - {{range $i, $r := .Registrations}} 6 - <li>{{ $r.Domain }}</li> 7 - {{ end }} 8 - </ul> 9 - Repositories hosted on these knots will not be accessible until upgraded. 10 - <a href="https://tangled.sh/@tangled.sh/core/blob/master/docs/migrations/knot-1.8.0.md">Click to read the upgrade guide</a>. 11 - </div> 12 - {{ end }}

··· 0 0 0 0 0 0 0 0 0 0 0 0

+2 -2

appview/pages/templates/knots/fragments/knotListing.html

··· 36 </span> 37 {{ template "knots/fragments/addMemberModal" . }} 38 {{ block "knotDeleteButton" . }} {{ end }} 39 - {{ else if .IsReadOnly }} 40 <span class="bg-yellow-100 text-yellow-800 dark:bg-yellow-900 dark:text-yellow-200 {{$style}}"> 41 - {{ i "shield-alert" "w-4 h-4" }} read-only 42 </span> 43 {{ block "knotRetryButton" . }} {{ end }} 44 {{ block "knotDeleteButton" . }} {{ end }}

··· 36 </span> 37 {{ template "knots/fragments/addMemberModal" . }} 38 {{ block "knotDeleteButton" . }} {{ end }} 39 + {{ else if .IsNeedsUpgrade }} 40 <span class="bg-yellow-100 text-yellow-800 dark:bg-yellow-900 dark:text-yellow-200 {{$style}}"> 41 + {{ i "shield-alert" "w-4 h-4" }} needs upgrade 42 </span> 43 {{ block "knotRetryButton" . }} {{ end }} 44 {{ block "knotDeleteButton" . }} {{ end }}

+3 -6

appview/pages/templates/knots/index.html

··· 1 {{ define "title" }}knots{{ end }} 2 3 {{ define "content" }} 4 - <div class="px-6 py-4 flex items-end justify-start gap-4 align-bottom"> 5 <h1 class="text-xl font-bold dark:text-white">Knots</h1> 6 - 7 - <span class="flex items-center gap-1 text-sm"> 8 {{ i "book" "w-3 h-3" }} 9 - <a href="https://tangled.sh/@tangled.sh/core/blob/master/docs/knot-hosting.md"> 10 - docs 11 - </a> 12 </span> 13 </div> 14

··· 1 {{ define "title" }}knots{{ end }} 2 3 {{ define "content" }} 4 + <div class="px-6 py-4 flex items-center justify-between gap-4 align-bottom"> 5 <h1 class="text-xl font-bold dark:text-white">Knots</h1> 6 + <span class="flex items-center gap-1"> 0 7 {{ i "book" "w-3 h-3" }} 8 + <a href="https://tangled.sh/@tangled.sh/core/blob/master/docs/knot-hosting.md">docs</a> 0 0 9 </span> 10 </div> 11

+12 -4

appview/pages/templates/layouts/base.html

··· 21 <title>{{ block "title" . }}{{ end }} · tangled</title> 22 {{ block "extrameta" . }}{{ end }} 23 </head> 24 - <body class="min-h-screen grid grid-cols-1 grid-rows-[min-content_auto_min-content] md:grid-cols-12 gap-4 bg-slate-100 dark:bg-gray-900 dark:text-white transition-colors duration-200"> 25 {{ block "topbarLayout" . }} 26 - <header class="px-1 col-span-1 md:col-start-3 md:col-span-8" style="z-index: 20;"> 0 0 0 0 0 0 0 0 27 {{ template "layouts/fragments/topbar" . }} 28 </header> 29 {{ end }} 30 31 {{ block "mainLayout" . }} 32 - <div class="px-1 col-span-1 md:col-start-3 md:col-span-8 flex flex-col gap-4"> 33 {{ block "contentLayout" . }} 34 <main class="col-span-1 md:col-span-8"> 35 {{ block "content" . }}{{ end }} ··· 45 {{ end }} 46 47 {{ block "footerLayout" . }} 48 - <footer class="px-1 col-span-1 md:col-start-3 md:col-span-8 mt-12"> 49 {{ template "layouts/fragments/footer" . }} 50 </footer> 51 {{ end }}

··· 21 <title>{{ block "title" . }}{{ end }} · tangled</title> 22 {{ block "extrameta" . }}{{ end }} 23 </head> 24 + <body class="min-h-screen grid grid-cols-1 grid-rows-[min-content_auto_min-content] md:grid-cols-10 lg:grid-cols-12 gap-4 bg-slate-100 dark:bg-gray-900 dark:text-white transition-colors duration-200"> 25 {{ block "topbarLayout" . }} 26 + <header class="px-1 col-span-1 md:col-start-2 md:col-span-8 lg:col-start-3" style="z-index: 20;"> 27 + 28 + {{ if .LoggedInUser }} 29 + <div id="upgrade-banner" 30 + hx-get="/upgradeBanner" 31 + hx-trigger="load" 32 + hx-swap="innerHTML"> 33 + </div> 34 + {{ end }} 35 {{ template "layouts/fragments/topbar" . }} 36 </header> 37 {{ end }} 38 39 {{ block "mainLayout" . }} 40 + <div class="px-1 col-span-1 md:col-start-2 md:col-span-8 lg:col-start-3 flex flex-col gap-4"> 41 {{ block "contentLayout" . }} 42 <main class="col-span-1 md:col-span-8"> 43 {{ block "content" . }}{{ end }} ··· 53 {{ end }} 54 55 {{ block "footerLayout" . }} 56 + <footer class="px-1 col-span-1 md:col-start-2 md:col-span-8 lg:col-start-3 mt-12"> 57 {{ template "layouts/fragments/footer" . }} 58 </footer> 59 {{ end }}

+1 -10

appview/pages/templates/layouts/fragments/topbar.html

··· 2 <nav class="space-x-4 px-6 py-2 rounded bg-white dark:bg-gray-800 dark:text-white drop-shadow-sm"> 3 <div class="flex justify-between p-0 items-center"> 4 <div id="left-items"> 5 - <a href="/" hx-boost="true" class="flex gap-2 font-bold italic"> 6 - tangled_alpha 7 - </a> 8 </div> 9 10 <div id="right-items" class="flex items-center gap-2"> ··· 21 </div> 22 </div> 23 </nav> 24 - {{ if .LoggedInUser }} 25 - <div id="upgrade-banner" 26 - hx-get="/knots/upgradeBanner" 27 - hx-trigger="load" 28 - hx-swap="innerHTML"> 29 - </div> 30 - {{ end }} 31 {{ end }} 32 33 {{ define "newButton" }}

··· 2 <nav class="space-x-4 px-6 py-2 rounded bg-white dark:bg-gray-800 dark:text-white drop-shadow-sm"> 3 <div class="flex justify-between p-0 items-center"> 4 <div id="left-items"> 5 + <a href="/" hx-boost="true" class="text-lg">{{ template "fragments/logotype" }}</a> 0 0 6 </div> 7 8 <div id="right-items" class="flex items-center gap-2"> ··· 19 </div> 20 </div> 21 </nav> 0 0 0 0 0 0 0 22 {{ end }} 23 24 {{ define "newButton" }}

+7 -2

appview/pages/templates/layouts/profilebase.html

··· 9 10 {{ define "content" }} 11 {{ template "profileTabs" . }} 12 - <section class="bg-white dark:bg-gray-800 p-6 rounded w-full dark:text-white drop-shadow-sm"> 13 <div class="grid grid-cols-1 md:grid-cols-11 gap-4"> 14 - <div class="md:col-span-3 order-1 md:order-1"> 0 0 0 0 15 <div class="flex flex-col gap-4"> 16 {{ template "user/fragments/profileCard" .Card }} 17 {{ block "punchcard" .Card.Punchcard }} {{ end }} 18 </div> 19 </div> 0 20 {{ block "profileContent" . }} {{ end }} 21 </div> 22 </section>

··· 9 10 {{ define "content" }} 11 {{ template "profileTabs" . }} 12 + <section class="bg-white dark:bg-gray-800 px-2 py-6 md:p-6 rounded w-full dark:text-white drop-shadow-sm"> 13 <div class="grid grid-cols-1 md:grid-cols-11 gap-4"> 14 + {{ $style := "hidden md:block md:col-span-3" }} 15 + {{ if eq $.Active "overview" }} 16 + {{ $style = "md:col-span-3" }} 17 + {{ end }} 18 + <div class="{{ $style }} order-1 order-1"> 19 <div class="flex flex-col gap-4"> 20 {{ template "user/fragments/profileCard" .Card }} 21 {{ block "punchcard" .Card.Punchcard }} {{ end }} 22 </div> 23 </div> 24 + 25 {{ block "profileContent" . }} {{ end }} 26 </div> 27 </section>

+2 -2

appview/pages/templates/layouts/repobase.html

··· 42 </section> 43 44 <section 45 - class="w-full flex flex-col drop-shadow-sm" 46 > 47 <nav class="w-full pl-4 overflow-auto"> 48 <div class="flex z-60"> ··· 81 </div> 82 </nav> 83 <section 84 - class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white" 85 > 86 {{ block "repoContent" . }}{{ end }} 87 </section>

··· 42 </section> 43 44 <section 45 + class="w-full flex flex-col" 46 > 47 <nav class="w-full pl-4 overflow-auto"> 48 <div class="flex z-60"> ··· 81 </div> 82 </nav> 83 <section 84 + class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto dark:text-white" 85 > 86 {{ block "repoContent" . }}{{ end }} 87 </section>

+1

appview/pages/templates/repo/blob.html

··· 78 {{ end }} 79 </div> 80 {{ end }} 0 81 {{ end }}

··· 78 {{ end }} 79 </div> 80 {{ end }} 81 + {{ template "fragments/multiline-select" }} 82 {{ end }}

+6

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

··· 0 0 0 0 0 0

··· 1 + {{ define "repo/fragments/languageBall" }} 2 + <div 3 + class="size-2 rounded-full" 4 + style="background: radial-gradient(circle at 35% 35%, color-mix(in srgb, {{ langColor . }} 70%, white), {{ langColor . }} 30%, color-mix(in srgb, {{ langColor . }} 85%, black));" 5 + ></div> 6 + {{ end }}

+6 -1

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

··· 1 {{ define "repo/fragments/shortTimeAgo" }} 2 - {{ template "repo/fragments/timeWrapper" (dict "Time" . "Content" (print (. | shortRelTimeFmt) " ago")) }} 0 0 0 0 0 3 {{ end }} 4

··· 1 {{ define "repo/fragments/shortTimeAgo" }} 2 + {{ $formatted := shortRelTimeFmt . }} 3 + {{ $content := printf "%s ago" $formatted }} 4 + {{ if eq $formatted "now" }} 5 + {{ $content = "now" }} 6 + {{ end }} 7 + {{ template "repo/fragments/timeWrapper" (dict "Time" . "Content" $content) }} 8 {{ end }} 9

+2 -7

appview/pages/templates/repo/index.html

··· 44 ></div> 45 {{ end }} 46 </summary> 47 - <div class="px-4 py-2 bg-gray-50 dark:bg-gray-700 border-b border-gray-200 dark:border-gray-600 flex items-center gap-4 flex-wrap"> 48 {{ range $value := .Languages }} 49 <div 50 class="flex flex-grow items-center gap-2 text-xs align-items-center justify-center" 51 > 52 - <div 53 - class="rounded-full h-2 w-2" 54 - style="background: radial-gradient(circle at 35% 35%, color-mix(in srgb, {{ $value.Color }} 70%, white), {{ $value.Color }} 30%, color-mix(in srgb, {{ $value.Color }} 85%, black));" 55 - > 56 - </div> 57 <div>{{ or $value.Name "Other" }} 58 <span class="text-gray-500 dark:text-gray-400"> 59 {{ if lt $value.Percentage 0.05 }} ··· 67 </div> 68 </details> 69 {{ end }} 70 - 71 72 {{ define "branchSelector" }} 73 <div class="flex gap-2 items-center justify-between w-full">

··· 44 ></div> 45 {{ end }} 46 </summary> 47 + <div class="px-4 py-2 border-b border-gray-200 dark:border-gray-600 flex items-center gap-4 flex-wrap"> 48 {{ range $value := .Languages }} 49 <div 50 class="flex flex-grow items-center gap-2 text-xs align-items-center justify-center" 51 > 52 + {{ template "repo/fragments/languageBall" $value.Name }} 0 0 0 0 53 <div>{{ or $value.Name "Other" }} 54 <span class="text-gray-500 dark:text-gray-400"> 55 {{ if lt $value.Percentage 0.05 }} ··· 63 </div> 64 </details> 65 {{ end }} 0 66 67 {{ define "branchSelector" }} 68 <div class="flex gap-2 items-center justify-between w-full">

+58

appview/pages/templates/repo/issues/fragments/commentList.html

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + {{ define "repo/issues/fragments/commentList" }} 2 + <div class="flex flex-col gap-8"> 3 + {{ range $item := .CommentList }} 4 + {{ template "commentListing" (list $ .) }} 5 + {{ end }} 6 + <div> 7 + {{ end }} 8 + 9 + {{ define "commentListing" }} 10 + {{ $root := index . 0 }} 11 + {{ $comment := index . 1 }} 12 + {{ $params := 13 + (dict 14 + "RepoInfo" $root.RepoInfo 15 + "LoggedInUser" $root.LoggedInUser 16 + "Issue" $root.Issue 17 + "Comment" $comment.Self) }} 18 + 19 + <div class="rounded border border-gray-300 dark:border-gray-700 w-full overflow-hidden shadow-sm"> 20 + {{ template "topLevelComment" $params }} 21 + 22 + <div class="relative ml-4 border-l border-gray-300 dark:border-gray-700"> 23 + {{ range $index, $reply := $comment.Replies }} 24 + <div class="relative "> 25 + <!-- Horizontal connector --> 26 + <div class="absolute left-0 top-6 w-4 h-px bg-gray-300 dark:bg-gray-700"></div> 27 + 28 + <div class="pl-2"> 29 + {{ 30 + template "replyComment" 31 + (dict 32 + "RepoInfo" $root.RepoInfo 33 + "LoggedInUser" $root.LoggedInUser 34 + "Issue" $root.Issue 35 + "Comment" $reply) 36 + }} 37 + </div> 38 + </div> 39 + {{ end }} 40 + </div> 41 + 42 + {{ template "repo/issues/fragments/replyIssueCommentPlaceholder" $params }} 43 + </div> 44 + {{ end }} 45 + 46 + {{ define "topLevelComment" }} 47 + <div class="rounded px-6 py-4 bg-white dark:bg-gray-800"> 48 + {{ template "repo/issues/fragments/issueCommentHeader" . }} 49 + {{ template "repo/issues/fragments/issueCommentBody" . }} 50 + </div> 51 + {{ end }} 52 + 53 + {{ define "replyComment" }} 54 + <div class="p-4 w-full mx-auto overflow-hidden"> 55 + {{ template "repo/issues/fragments/issueCommentHeader" . }} 56 + {{ template "repo/issues/fragments/issueCommentBody" . }} 57 + </div> 58 + {{ end }}

+37 -45

appview/pages/templates/repo/issues/fragments/editIssueComment.html

··· 1 {{ define "repo/issues/fragments/editIssueComment" }} 2 - {{ with .Comment }} 3 - <div id="comment-container-{{.CommentId}}"> 4 - <div class="flex items-center gap-2 mb-2 text-gray-500 dark:text-gray-400 text-sm flex-wrap"> 5 - {{ $owner := didOrHandle $.LoggedInUser.Did $.LoggedInUser.Handle }} 6 - <a href="/{{ $owner }}" class="no-underline hover:underline">{{ $owner }}</a> 0 0 7 8 - <!-- show user "hats" --> 9 - {{ $isIssueAuthor := eq .OwnerDid $.Issue.OwnerDid }} 10 - {{ if $isIssueAuthor }} 11 - <span class="before:content-['·']"></span> 12 - author 13 - {{ end }} 14 - 15 - <span class="before:content-['·']"></span> 16 - <a 17 - href="#{{ .CommentId }}" 18 - class="text-gray-500 dark:text-gray-400 hover:text-gray-500 dark:hover:text-gray-400 hover:underline no-underline" 19 - id="{{ .CommentId }}"> 20 - {{ template "repo/fragments/time" .Created }} 21 - </a> 22 - 23 - <button 24 - class="btn px-2 py-1 flex items-center gap-2 text-sm group" 25 - hx-post="/{{ $.RepoInfo.FullName }}/issues/{{ .Issue }}/comment/{{ .CommentId }}/edit" 26 - hx-include="#edit-textarea-{{ .CommentId }}" 27 - hx-target="#comment-container-{{ .CommentId }}" 28 - hx-swap="outerHTML"> 29 - {{ i "check" "w-4 h-4" }} 30 - {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 31 - </button> 32 - <button 33 - class="btn px-2 py-1 flex items-center gap-2 text-sm" 34 - hx-get="/{{ $.RepoInfo.FullName }}/issues/{{ .Issue }}/comment/{{ .CommentId }}/" 35 - hx-target="#comment-container-{{ .CommentId }}" 36 - hx-swap="outerHTML"> 37 - {{ i "x" "w-4 h-4" }} 38 - </button> 39 - <span id="comment-{{.CommentId}}-status"></span> 40 - </div> 41 42 - <div> 43 - <textarea 44 - id="edit-textarea-{{ .CommentId }}" 45 - name="body" 46 - class="w-full p-2 border rounded min-h-[100px]">{{ .Body }}</textarea> 47 - </div> 48 </div> 49 - {{ end }} 0 0 0 0 0 0 0 0 0 0 0 0 50 {{ end }} 51 0 0 0 0 0 0 0 0 0 0

··· 1 {{ define "repo/issues/fragments/editIssueComment" }} 2 + <div id="comment-body-{{.Comment.Id}}" class="pt-2"> 3 + <textarea 4 + id="edit-textarea-{{ .Comment.Id }}" 5 + name="body" 6 + class="w-full p-2 rounded border border-gray-200 dark:border-gray-700" 7 + rows="5" 8 + autofocus>{{ .Comment.Body }}</textarea> 9 10 + {{ template "editActions" $ }} 11 + </div> 12 + {{ end }} 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 13 14 + {{ define "editActions" }} 15 + <div class="flex flex-wrap items-center justify-end gap-2 text-gray-500 dark:text-gray-400 text-sm pt-2"> 16 + {{ template "cancel" . }} 17 + {{ template "save" . }} 0 0 18 </div> 19 + {{ end }} 20 + 21 + {{ define "save" }} 22 + <button 23 + class="btn-create py-0 flex gap-1 items-center group text-sm" 24 + hx-post="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/comment/{{ .Comment.Id }}/edit" 25 + hx-include="#edit-textarea-{{ .Comment.Id }}" 26 + hx-target="#comment-body-{{ .Comment.Id }}" 27 + hx-swap="outerHTML"> 28 + {{ i "check" "size-4" }} 29 + save 30 + {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 31 + </button> 32 {{ end }} 33 34 + {{ define "cancel" }} 35 + <button 36 + class="btn py-0 text-red-500 dark:text-red-400 flex gap-1 items-center group" 37 + hx-get="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/comment/{{ .Comment.Id }}/" 38 + hx-target="#comment-body-{{ .Comment.Id }}" 39 + hx-swap="outerHTML"> 40 + {{ i "x" "size-4" }} 41 + cancel 42 + </button> 43 + {{ end }}

-58

appview/pages/templates/repo/issues/fragments/issueComment.html

··· 1 - {{ define "repo/issues/fragments/issueComment" }} 2 - {{ with .Comment }} 3 - <div id="comment-container-{{.CommentId}}"> 4 - <div class="flex items-center gap-2 mb-2 text-gray-500 dark:text-gray-400 text-sm flex-wrap"> 5 - {{ template "user/fragments/picHandleLink" .OwnerDid }} 6 - 7 - <!-- show user "hats" --> 8 - {{ $isIssueAuthor := eq .OwnerDid $.Issue.OwnerDid }} 9 - {{ if $isIssueAuthor }} 10 - <span class="before:content-['·']"></span> 11 - author 12 - {{ end }} 13 - 14 - <span class="before:content-['·']"></span> 15 - <a 16 - href="#{{ .CommentId }}" 17 - class="text-gray-500 dark:text-gray-400 hover:text-gray-500 dark:hover:text-gray-400 hover:underline no-underline" 18 - id="{{ .CommentId }}"> 19 - {{ if .Deleted }} 20 - deleted {{ template "repo/fragments/time" .Deleted }} 21 - {{ else if .Edited }} 22 - edited {{ template "repo/fragments/time" .Edited }} 23 - {{ else }} 24 - {{ template "repo/fragments/time" .Created }} 25 - {{ end }} 26 - </a> 27 - 28 - {{ $isCommentOwner := and $.LoggedInUser (eq $.LoggedInUser.Did .OwnerDid) }} 29 - {{ if and $isCommentOwner (not .Deleted) }} 30 - <button 31 - class="btn px-2 py-1 text-sm" 32 - hx-get="/{{ $.RepoInfo.FullName }}/issues/{{ .Issue }}/comment/{{ .CommentId }}/edit" 33 - hx-swap="outerHTML" 34 - hx-target="#comment-container-{{.CommentId}}" 35 - > 36 - {{ i "pencil" "w-4 h-4" }} 37 - </button> 38 - <button 39 - class="btn px-2 py-1 text-sm text-red-500 flex gap-2 items-center group" 40 - hx-delete="/{{ $.RepoInfo.FullName }}/issues/{{ .Issue }}/comment/{{ .CommentId }}/" 41 - hx-confirm="Are you sure you want to delete your comment?" 42 - hx-swap="outerHTML" 43 - hx-target="#comment-container-{{.CommentId}}" 44 - > 45 - {{ i "trash-2" "w-4 h-4" }} 46 - {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 47 - </button> 48 - {{ end }} 49 - 50 - </div> 51 - {{ if not .Deleted }} 52 - <div class="prose dark:prose-invert"> 53 - {{ .Body | markdown }} 54 - </div> 55 - {{ end }} 56 - </div> 57 - {{ end }} 58 - {{ end }}

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

+34

appview/pages/templates/repo/issues/fragments/issueCommentActions.html

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + {{ define "repo/issues/fragments/issueCommentActions" }} 2 + {{ $isCommentOwner := and .LoggedInUser (eq .LoggedInUser.Did .Comment.Did) }} 3 + {{ if and $isCommentOwner (not .Comment.Deleted) }} 4 + <div class="flex flex-wrap items-center gap-4 text-gray-500 dark:text-gray-400 text-sm pt-2"> 5 + {{ template "edit" . }} 6 + {{ template "delete" . }} 7 + </div> 8 + {{ end }} 9 + {{ end }} 10 + 11 + {{ define "edit" }} 12 + <a 13 + class="text-gray-500 dark:text-gray-400 flex gap-1 items-center group" 14 + hx-get="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/comment/{{ .Comment.Id }}/edit" 15 + hx-swap="outerHTML" 16 + hx-target="#comment-body-{{.Comment.Id}}"> 17 + {{ i "pencil" "size-3" }} 18 + edit 19 + </a> 20 + {{ end }} 21 + 22 + {{ define "delete" }} 23 + <a 24 + class="text-gray-500 dark:text-gray-400 flex gap-1 items-center group" 25 + hx-delete="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/comment/{{ .Comment.Id }}/" 26 + hx-confirm="Are you sure you want to delete your comment?" 27 + hx-swap="outerHTML" 28 + hx-target="#comment-body-{{.Comment.Id}}" 29 + > 30 + {{ i "trash-2" "size-3" }} 31 + delete 32 + {{ i "loader-circle" "size-3 animate-spin hidden group-[.htmx-request]:inline" }} 33 + </a> 34 + {{ end }}

+9

appview/pages/templates/repo/issues/fragments/issueCommentBody.html

··· 0 0 0 0 0 0 0 0 0

··· 1 + {{ define "repo/issues/fragments/issueCommentBody" }} 2 + <div id="comment-body-{{.Comment.Id}}"> 3 + {{ if not .Comment.Deleted }} 4 + <div class="prose dark:prose-invert">{{ .Comment.Body | markdown }}</div> 5 + {{ else }} 6 + <div class="prose dark:prose-invert italic text-gray-500 dark:text-gray-400">[deleted by author]</div> 7 + {{ end }} 8 + </div> 9 + {{ end }}

+56

appview/pages/templates/repo/issues/fragments/issueCommentHeader.html

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + {{ define "repo/issues/fragments/issueCommentHeader" }} 2 + <div class="flex flex-wrap items-center gap-2 text-sm text-gray-500 dark:text-gray-400 "> 3 + {{ template "user/fragments/picHandleLink" .Comment.Did }} 4 + {{ template "hats" $ }} 5 + {{ template "timestamp" . }} 6 + {{ $isCommentOwner := and .LoggedInUser (eq .LoggedInUser.Did .Comment.Did) }} 7 + {{ if and $isCommentOwner (not .Comment.Deleted) }} 8 + {{ template "editIssueComment" . }} 9 + {{ template "deleteIssueComment" . }} 10 + {{ end }} 11 + </div> 12 + {{ end }} 13 + 14 + {{ define "hats" }} 15 + {{ $isIssueAuthor := eq .Comment.Did .Issue.Did }} 16 + {{ if $isIssueAuthor }} 17 + (author) 18 + {{ end }} 19 + {{ end }} 20 + 21 + {{ define "timestamp" }} 22 + <a href="#{{ .Comment.Id }}" 23 + class="text-gray-500 dark:text-gray-400 hover:text-gray-500 dark:hover:text-gray-400 hover:underline no-underline" 24 + id="{{ .Comment.Id }}"> 25 + {{ if .Comment.Deleted }} 26 + {{ template "repo/fragments/shortTimeAgo" .Comment.Deleted }} 27 + {{ else if .Comment.Edited }} 28 + edited {{ template "repo/fragments/shortTimeAgo" .Comment.Edited }} 29 + {{ else }} 30 + {{ template "repo/fragments/shortTimeAgo" .Comment.Created }} 31 + {{ end }} 32 + </a> 33 + {{ end }} 34 + 35 + {{ define "editIssueComment" }} 36 + <a 37 + class="text-gray-500 dark:text-gray-400 flex gap-1 items-center group" 38 + hx-get="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/comment/{{ .Comment.Id }}/edit" 39 + hx-swap="outerHTML" 40 + hx-target="#comment-body-{{.Comment.Id}}"> 41 + {{ i "pencil" "size-3" }} 42 + </a> 43 + {{ end }} 44 + 45 + {{ define "deleteIssueComment" }} 46 + <a 47 + class="text-gray-500 dark:text-gray-400 flex gap-1 items-center group" 48 + hx-delete="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/comment/{{ .Comment.Id }}/" 49 + hx-confirm="Are you sure you want to delete your comment?" 50 + hx-swap="outerHTML" 51 + hx-target="#comment-body-{{.Comment.Id}}" 52 + > 53 + {{ i "trash-2" "size-3" }} 54 + {{ i "loader-circle" "size-3 animate-spin hidden group-[.htmx-request]:inline" }} 55 + </a> 56 + {{ end }}

+145

appview/pages/templates/repo/issues/fragments/newComment.html

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + {{ define "repo/issues/fragments/newComment" }} 2 + {{ if .LoggedInUser }} 3 + <form 4 + id="comment-form" 5 + hx-post="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/comment" 6 + hx-on::after-request="if(event.detail.successful) this.reset()" 7 + > 8 + <div class="bg-white dark:bg-gray-800 rounded drop-shadow-sm py-4 px-4 relative w-full"> 9 + <div class="text-sm pb-2 text-gray-500 dark:text-gray-400"> 10 + {{ template "user/fragments/picHandleLink" .LoggedInUser.Did }} 11 + </div> 12 + <textarea 13 + id="comment-textarea" 14 + name="body" 15 + class="w-full p-2 rounded border border-gray-200 dark:border-gray-700" 16 + placeholder="Add to the discussion. Markdown is supported." 17 + onkeyup="updateCommentForm()" 18 + rows="5" 19 + ></textarea> 20 + <div id="issue-comment"></div> 21 + <div id="issue-action" class="error"></div> 22 + </div> 23 + 24 + <div class="flex gap-2 mt-2"> 25 + <button 26 + id="comment-button" 27 + hx-post="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/comment" 28 + type="submit" 29 + hx-disabled-elt="#comment-button" 30 + class="btn-create p-2 flex items-center gap-2 no-underline hover:no-underline group" 31 + disabled 32 + > 33 + {{ i "message-square-plus" "w-4 h-4" }} 34 + comment 35 + {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 36 + </button> 37 + 38 + {{ $isIssueAuthor := and .LoggedInUser (eq .LoggedInUser.Did .Issue.Did) }} 39 + {{ $isRepoCollaborator := .RepoInfo.Roles.IsCollaborator }} 40 + {{ $isRepoOwner := .RepoInfo.Roles.IsOwner }} 41 + {{ if and (or $isIssueAuthor $isRepoCollaborator $isRepoOwner) .Issue.Open }} 42 + <button 43 + id="close-button" 44 + type="button" 45 + class="btn flex items-center gap-2" 46 + hx-indicator="#close-spinner" 47 + hx-trigger="click" 48 + > 49 + {{ i "ban" "w-4 h-4" }} 50 + close 51 + <span id="close-spinner" class="group"> 52 + {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 53 + </span> 54 + </button> 55 + <div 56 + id="close-with-comment" 57 + hx-post="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/comment" 58 + hx-trigger="click from:#close-button" 59 + hx-disabled-elt="#close-with-comment" 60 + hx-target="#issue-comment" 61 + hx-indicator="#close-spinner" 62 + hx-vals="js:{body: document.getElementById('comment-textarea').value.trim() !== '' ? document.getElementById('comment-textarea').value : ''}" 63 + hx-swap="none" 64 + > 65 + </div> 66 + <div 67 + id="close-issue" 68 + hx-disabled-elt="#close-issue" 69 + hx-post="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/close" 70 + hx-trigger="click from:#close-button" 71 + hx-target="#issue-action" 72 + hx-indicator="#close-spinner" 73 + hx-swap="none" 74 + > 75 + </div> 76 + <script> 77 + document.addEventListener('htmx:configRequest', function(evt) { 78 + if (evt.target.id === 'close-with-comment') { 79 + const commentText = document.getElementById('comment-textarea').value.trim(); 80 + if (commentText === '') { 81 + evt.detail.parameters = {}; 82 + evt.preventDefault(); 83 + } 84 + } 85 + }); 86 + </script> 87 + {{ else if and (or $isIssueAuthor $isRepoCollaborator $isRepoOwner) (not .Issue.Open) }} 88 + <button 89 + type="button" 90 + class="btn flex items-center gap-2" 91 + hx-post="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/reopen" 92 + hx-indicator="#reopen-spinner" 93 + hx-swap="none" 94 + > 95 + {{ i "refresh-ccw-dot" "w-4 h-4" }} 96 + reopen 97 + <span id="reopen-spinner" class="group"> 98 + {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 99 + </span> 100 + </button> 101 + {{ end }} 102 + 103 + <script> 104 + function updateCommentForm() { 105 + const textarea = document.getElementById('comment-textarea'); 106 + const commentButton = document.getElementById('comment-button'); 107 + const closeButton = document.getElementById('close-button'); 108 + 109 + if (textarea.value.trim() !== '') { 110 + commentButton.removeAttribute('disabled'); 111 + } else { 112 + commentButton.setAttribute('disabled', ''); 113 + } 114 + 115 + if (closeButton) { 116 + if (textarea.value.trim() !== '') { 117 + closeButton.innerHTML = ` 118 + {{ i "ban" "w-4 h-4" }} 119 + <span>close with comment</span> 120 + <span id="close-spinner" class="group"> 121 + {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 122 + </span>`; 123 + } else { 124 + closeButton.innerHTML = ` 125 + {{ i "ban" "w-4 h-4" }} 126 + <span>close</span> 127 + <span id="close-spinner" class="group"> 128 + {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 129 + </span>`; 130 + } 131 + } 132 + } 133 + 134 + document.addEventListener('DOMContentLoaded', function() { 135 + updateCommentForm(); 136 + }); 137 + </script> 138 + </div> 139 + </form> 140 + {{ else }} 141 + <div class="bg-white dark:bg-gray-800 rounded drop-shadow-sm py-4 px-4 relative w-fit"> 142 + <a href="/login" class="underline">login</a> to join the discussion 143 + </div> 144 + {{ end }} 145 + {{ end }}

+57

appview/pages/templates/repo/issues/fragments/putIssue.html

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + {{ define "repo/issues/fragments/putIssue" }} 2 + <!-- this form is used for new and edit, .Issue is passed when editing --> 3 + <form 4 + {{ if eq .Action "edit" }} 5 + hx-post="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/edit" 6 + {{ else }} 7 + hx-post="/{{ .RepoInfo.FullName }}/issues/new" 8 + {{ end }} 9 + hx-swap="none" 10 + hx-indicator="#spinner"> 11 + <div class="flex flex-col gap-2"> 12 + <div> 13 + <label for="title">title</label> 14 + <input type="text" name="title" id="title" class="w-full" value="{{ if .Issue }}{{ .Issue.Title }}{{ end }}" /> 15 + </div> 16 + <div> 17 + <label for="body">body</label> 18 + <textarea 19 + name="body" 20 + id="body" 21 + rows="6" 22 + class="w-full resize-y" 23 + placeholder="Describe your issue. Markdown is supported." 24 + >{{ if .Issue }}{{ .Issue.Body }}{{ end }}</textarea> 25 + </div> 26 + <div class="flex justify-between"> 27 + <div id="issues" class="error"></div> 28 + <div class="flex gap-2 items-center"> 29 + <a 30 + class="btn flex items-center gap-2 no-underline hover:no-underline" 31 + type="button" 32 + {{ if .Issue }} 33 + href="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}" 34 + {{ else }} 35 + href="/{{ .RepoInfo.FullName }}/issues" 36 + {{ end }} 37 + > 38 + {{ i "x" "w-4 h-4" }} 39 + cancel 40 + </a> 41 + <button type="submit" class="btn-create flex items-center gap-2"> 42 + {{ if eq .Action "edit" }} 43 + {{ i "pencil" "w-4 h-4" }} 44 + {{ .Action }} issue 45 + {{ else }} 46 + {{ i "circle-plus" "w-4 h-4" }} 47 + {{ .Action }} issue 48 + {{ end }} 49 + <span id="spinner" class="group"> 50 + {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 51 + </span> 52 + </button> 53 + </div> 54 + </div> 55 + </div> 56 + </form> 57 + {{ end }}

+61

appview/pages/templates/repo/issues/fragments/replyComment.html

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + {{ define "repo/issues/fragments/replyComment" }} 2 + <form 3 + class="p-2 group w-full border-t border-gray-200 dark:border-gray-700 flex flex-col gap-2" 4 + id="reply-form-{{ .Comment.Id }}" 5 + hx-post="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/comment" 6 + hx-on::after-request="if(event.detail.successful) this.reset()" 7 + hx-disabled-elt="#reply-{{ .Comment.Id }}" 8 + > 9 + {{ template "user/fragments/picHandleLink" .LoggedInUser.Did }} 10 + <textarea 11 + id="reply-{{.Comment.Id}}-textarea" 12 + name="body" 13 + class="w-full p-2" 14 + placeholder="Leave a reply..." 15 + autofocus 16 + rows="3" 17 + hx-trigger="keydown[ctrlKey&&key=='Enter']" 18 + hx-target="#reply-form-{{ .Comment.Id }}" 19 + hx-get="#" 20 + hx-on:htmx:before-request="event.preventDefault(); document.getElementById('reply-form-{{ .Comment.Id }}').requestSubmit()"></textarea> 21 + 22 + <input 23 + type="text" 24 + id="reply-to" 25 + name="reply-to" 26 + required 27 + value="{{ .Comment.AtUri }}" 28 + class="hidden" 29 + /> 30 + {{ template "replyActions" . }} 31 + </form> 32 + {{ end }} 33 + 34 + {{ define "replyActions" }} 35 + <div class="flex flex-wrap items-stretch justify-end gap-2 text-gray-500 dark:text-gray-400 text-sm"> 36 + {{ template "cancel" . }} 37 + {{ template "reply" . }} 38 + </div> 39 + {{ end }} 40 + 41 + {{ define "cancel" }} 42 + <button 43 + class="btn text-red-500 dark:text-red-400 flex gap-2 items-center group" 44 + hx-get="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/comment/{{ .Comment.Id }}/replyPlaceholder" 45 + hx-target="#reply-form-{{ .Comment.Id }}" 46 + hx-swap="outerHTML"> 47 + {{ i "x" "size-4" }} 48 + cancel 49 + </button> 50 + {{ end }} 51 + 52 + {{ define "reply" }} 53 + <button 54 + id="reply-{{ .Comment.Id }}" 55 + type="submit" 56 + class="btn-create flex items-center gap-2 no-underline hover:no-underline"> 57 + {{ i "reply" "w-4 h-4 inline group-[.htmx-request]:hidden" }} 58 + {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 59 + reply 60 + </button> 61 + {{ end }}

+20

appview/pages/templates/repo/issues/fragments/replyIssueCommentPlaceholder.html

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + {{ define "repo/issues/fragments/replyIssueCommentPlaceholder" }} 2 + <div class="p-2 border-t flex gap-2 items-center border-gray-300 dark:border-gray-700"> 3 + {{ if .LoggedInUser }} 4 + <img 5 + src="{{ tinyAvatar .LoggedInUser.Did }}" 6 + alt="" 7 + class="rounded-full h-6 w-6 mr-1 border border-gray-300 dark:border-gray-700" 8 + /> 9 + {{ end }} 10 + <input 11 + class="w-full py-2 border-none focus:outline-none" 12 + placeholder="Leave a reply..." 13 + hx-get="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/comment/{{ .Comment.Id }}/reply" 14 + hx-trigger="focus" 15 + hx-target="closest div" 16 + hx-swap="outerHTML" 17 + > 18 + </input> 19 + </div> 20 + {{ end }}

+95 -202

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

··· 9 {{ end }} 10 11 {{ define "repoContent" }} 12 - <header class="pb-4"> 13 - <h1 class="text-2xl"> 14 - {{ .Issue.Title | description }} 15 - <span class="text-gray-500 dark:text-gray-400">#{{ .Issue.IssueId }}</span> 16 - </h1> 17 - </header> 0 0 0 18 19 - {{ $bgColor := "bg-gray-800 dark:bg-gray-700" }} 20 - {{ $icon := "ban" }} 21 - {{ if eq .State "open" }} 22 - {{ $bgColor = "bg-green-600 dark:bg-green-700" }} 23 - {{ $icon = "circle-dot" }} 24 - {{ end }} 0 0 25 26 - <section class="mt-2"> 27 - <div class="inline-flex items-center gap-2"> 28 - <div id="state" 29 - class="inline-flex items-center rounded px-3 py-1 {{ $bgColor }}"> 30 - {{ i $icon "w-4 h-4 mr-1.5 text-white" }} 31 - <span class="text-white">{{ .State }}</span> 32 - </div> 33 - <span class="text-gray-500 dark:text-gray-400 text-sm flex flex-wrap items-center gap-1"> 34 - opened by 35 - {{ $owner := didOrHandle .Issue.OwnerDid .IssueOwnerHandle }} 36 - {{ template "user/fragments/picHandleLink" $owner }} 37 - <span class="select-none before:content-['\00B7']"></span> 38 - {{ template "repo/fragments/time" .Issue.Created }} 39 - </span> 40 - </div> 0 0 0 0 0 0 0 0 41 42 - {{ if .Issue.Body }} 43 - <article id="body" class="mt-8 prose dark:prose-invert"> 44 - {{ .Issue.Body | markdown }} 45 - </article> 46 - {{ end }} 0 47 48 - <div class="flex items-center gap-2 mt-2"> 49 - {{ template "repo/fragments/reactionsPopUp" .OrderedReactionKinds }} 50 - {{ range $kind := .OrderedReactionKinds }} 51 - {{ 52 - template "repo/fragments/reaction" 53 - (dict 54 - "Kind" $kind 55 - "Count" (index $.Reactions $kind) 56 - "IsReacted" (index $.UserReacted $kind) 57 - "ThreadAt" $.Issue.AtUri) 58 - }} 59 - {{ end }} 60 - </div> 61 - </section> 62 {{ end }} 63 64 - {{ define "repoAfter" }} 65 - <section id="comments" class="my-2 mt-2 space-y-2 relative"> 66 - {{ range $index, $comment := .Comments }} 67 - <div 68 - id="comment-{{ .CommentId }}" 69 - class="bg-white dark:bg-gray-800 rounded drop-shadow-sm py-2 px-4 relative w-full md:max-w-3/5 md:w-fit"> 70 - {{ if gt $index 0 }} 71 - <div class="absolute left-8 -top-2 w-px h-2 bg-gray-300 dark:bg-gray-600"></div> 72 - {{ end }} 73 - {{ template "repo/issues/fragments/issueComment" (dict "RepoInfo" $.RepoInfo "LoggedInUser" $.LoggedInUser "Issue" $.Issue "Comment" .)}} 74 - </div> 75 - {{ end }} 76 - </section> 77 78 - {{ block "newComment" . }} {{ end }} 0 0 0 0 0 0 0 0 0 79 0 0 0 0 0 0 0 0 0 0 0 0 0 0 80 {{ end }} 81 82 - {{ define "newComment" }} 83 - {{ if .LoggedInUser }} 84 - <form 85 - id="comment-form" 86 - hx-post="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/comment" 87 - hx-on::after-request="if(event.detail.successful) this.reset()" 88 - > 89 - <div class="bg-white dark:bg-gray-800 rounded drop-shadow-sm py-4 px-4 relative w-full md:w-3/5"> 90 - <div class="text-sm pb-2 text-gray-500 dark:text-gray-400"> 91 - {{ template "user/fragments/picHandleLink" (didOrHandle .LoggedInUser.Did .LoggedInUser.Handle) }} 92 - </div> 93 - <textarea 94 - id="comment-textarea" 95 - name="body" 96 - class="w-full p-2 rounded border border-gray-200 dark:border-gray-700" 97 - placeholder="Add to the discussion. Markdown is supported." 98 - onkeyup="updateCommentForm()" 99 - ></textarea> 100 - <div id="issue-comment"></div> 101 - <div id="issue-action" class="error"></div> 102 - </div> 103 - 104 - <div class="flex gap-2 mt-2"> 105 - <button 106 - id="comment-button" 107 - hx-post="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/comment" 108 - type="submit" 109 - hx-disabled-elt="#comment-button" 110 - class="btn p-2 flex items-center gap-2 no-underline hover:no-underline group" 111 - disabled 112 - > 113 - {{ i "message-square-plus" "w-4 h-4" }} 114 - comment 115 - {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 116 - </button> 117 - 118 - {{ $isIssueAuthor := and .LoggedInUser (eq .LoggedInUser.Did .Issue.OwnerDid) }} 119 - {{ $isRepoCollaborator := .RepoInfo.Roles.IsCollaborator }} 120 - {{ $isRepoOwner := .RepoInfo.Roles.IsOwner }} 121 - {{ if and (or $isIssueAuthor $isRepoCollaborator $isRepoOwner) (eq .State "open") }} 122 - <button 123 - id="close-button" 124 - type="button" 125 - class="btn flex items-center gap-2" 126 - hx-indicator="#close-spinner" 127 - hx-trigger="click" 128 - > 129 - {{ i "ban" "w-4 h-4" }} 130 - close 131 - <span id="close-spinner" class="group"> 132 - {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 133 - </span> 134 - </button> 135 - <div 136 - id="close-with-comment" 137 - hx-post="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/comment" 138 - hx-trigger="click from:#close-button" 139 - hx-disabled-elt="#close-with-comment" 140 - hx-target="#issue-comment" 141 - hx-indicator="#close-spinner" 142 - hx-vals="js:{body: document.getElementById('comment-textarea').value.trim() !== '' ? document.getElementById('comment-textarea').value : ''}" 143 - hx-swap="none" 144 - > 145 - </div> 146 - <div 147 - id="close-issue" 148 - hx-disabled-elt="#close-issue" 149 - hx-post="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/close" 150 - hx-trigger="click from:#close-button" 151 - hx-target="#issue-action" 152 - hx-indicator="#close-spinner" 153 - hx-swap="none" 154 - > 155 - </div> 156 - <script> 157 - document.addEventListener('htmx:configRequest', function(evt) { 158 - if (evt.target.id === 'close-with-comment') { 159 - const commentText = document.getElementById('comment-textarea').value.trim(); 160 - if (commentText === '') { 161 - evt.detail.parameters = {}; 162 - evt.preventDefault(); 163 - } 164 - } 165 - }); 166 - </script> 167 - {{ else if and (or $isIssueAuthor $isRepoCollaborator $isRepoOwner) (eq .State "closed") }} 168 - <button 169 - type="button" 170 - class="btn flex items-center gap-2" 171 - hx-post="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/reopen" 172 - hx-indicator="#reopen-spinner" 173 - hx-swap="none" 174 - > 175 - {{ i "refresh-ccw-dot" "w-4 h-4" }} 176 - reopen 177 - <span id="reopen-spinner" class="group"> 178 - {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 179 - </span> 180 - </button> 181 - {{ end }} 182 - 183 - <script> 184 - function updateCommentForm() { 185 - const textarea = document.getElementById('comment-textarea'); 186 - const commentButton = document.getElementById('comment-button'); 187 - const closeButton = document.getElementById('close-button'); 188 - 189 - if (textarea.value.trim() !== '') { 190 - commentButton.removeAttribute('disabled'); 191 - } else { 192 - commentButton.setAttribute('disabled', ''); 193 - } 194 195 - if (closeButton) { 196 - if (textarea.value.trim() !== '') { 197 - closeButton.innerHTML = ` 198 - {{ i "ban" "w-4 h-4" }} 199 - <span>close with comment</span> 200 - <span id="close-spinner" class="group"> 201 - {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 202 - </span>`; 203 - } else { 204 - closeButton.innerHTML = ` 205 - {{ i "ban" "w-4 h-4" }} 206 - <span>close</span> 207 - <span id="close-spinner" class="group"> 208 - {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 209 - </span>`; 210 - } 211 - } 212 - } 213 214 - document.addEventListener('DOMContentLoaded', function() { 215 - updateCommentForm(); 216 - }); 217 - </script> 218 - </div> 219 - </form> 220 - {{ else }} 221 - <div class="bg-white dark:bg-gray-800 rounded drop-shadow-sm py-4 px-4 relative w-fit"> 222 - <a href="/login" class="underline">login</a> to join the discussion 223 - </div> 224 - {{ end }} 225 - {{ end }}

··· 9 {{ end }} 10 11 {{ define "repoContent" }} 12 + <section id="issue-{{ .Issue.IssueId }}"> 13 + {{ template "issueHeader" .Issue }} 14 + {{ template "issueInfo" . }} 15 + {{ if .Issue.Body }} 16 + <article id="body" class="mt-4 prose dark:prose-invert">{{ .Issue.Body | markdown }}</article> 17 + {{ end }} 18 + {{ template "issueReactions" . }} 19 + </section> 20 + {{ end }} 21 22 + {{ define "issueHeader" }} 23 + <header class="pb-2"> 24 + <h1 class="text-2xl"> 25 + {{ .Title | description }} 26 + <span class="text-gray-500 dark:text-gray-400">#{{ .IssueId }}</span> 27 + </h1> 28 + </header> 29 + {{ end }} 30 31 + {{ define "issueInfo" }} 32 + {{ $bgColor := "bg-gray-800 dark:bg-gray-700" }} 33 + {{ $icon := "ban" }} 34 + {{ if eq .Issue.State "open" }} 35 + {{ $bgColor = "bg-green-600 dark:bg-green-700" }} 36 + {{ $icon = "circle-dot" }} 37 + {{ end }} 38 + <div class="inline-flex items-center gap-2"> 39 + <div id="state" 40 + class="inline-flex items-center rounded px-3 py-1 {{ $bgColor }}"> 41 + {{ i $icon "w-4 h-4 mr-1.5 text-white" }} 42 + <span class="text-white">{{ .Issue.State }}</span> 43 + </div> 44 + <span class="text-gray-500 dark:text-gray-400 text-sm flex flex-wrap items-center gap-1"> 45 + opened by 46 + {{ template "user/fragments/picHandleLink" .Issue.Did }} 47 + <span class="select-none before:content-['\00B7']"></span> 48 + {{ if .Issue.Edited }} 49 + edited {{ template "repo/fragments/time" .Issue.Edited }} 50 + {{ else }} 51 + {{ template "repo/fragments/time" .Issue.Created }} 52 + {{ end }} 53 + </span> 54 55 + {{ if and .LoggedInUser (eq .LoggedInUser.Did .Issue.Did) }} 56 + {{ template "issueActions" . }} 57 + {{ end }} 58 + </div> 59 + <div id="issue-actions-error" class="error"></div> 60 + {{ end }} 61 62 + {{ define "issueActions" }} 63 + {{ template "editIssue" . }} 64 + {{ template "deleteIssue" . }} 0 0 0 0 0 0 0 0 0 0 0 65 {{ end }} 66 67 + {{ define "editIssue" }} 68 + <a 69 + class="text-gray-500 dark:text-gray-400 flex gap-1 items-center group" 70 + hx-get="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/edit" 71 + hx-swap="innerHTML" 72 + hx-target="#issue-{{.Issue.IssueId}}"> 73 + {{ i "pencil" "size-3" }} 74 + </a> 75 + {{ end }} 0 0 0 0 76 77 + {{ define "deleteIssue" }} 78 + <a 79 + class="text-gray-500 dark:text-gray-400 flex gap-1 items-center group" 80 + hx-delete="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/" 81 + hx-confirm="Are you sure you want to delete your issue?" 82 + hx-swap="none"> 83 + {{ i "trash-2" "size-3" }} 84 + {{ i "loader-circle" "size-3 animate-spin hidden group-[.htmx-request]:inline" }} 85 + </a> 86 + {{ end }} 87 88 + {{ define "issueReactions" }} 89 + <div class="flex items-center gap-2 mt-2"> 90 + {{ template "repo/fragments/reactionsPopUp" .OrderedReactionKinds }} 91 + {{ range $kind := .OrderedReactionKinds }} 92 + {{ 93 + template "repo/fragments/reaction" 94 + (dict 95 + "Kind" $kind 96 + "Count" (index $.Reactions $kind) 97 + "IsReacted" (index $.UserReacted $kind) 98 + "ThreadAt" $.Issue.AtUri) 99 + }} 100 + {{ end }} 101 + </div> 102 {{ end }} 103 104 + {{ define "repoAfter" }} 105 + <div class="flex flex-col gap-4 mt-4"> 106 + {{ 107 + template "repo/issues/fragments/commentList" 108 + (dict 109 + "RepoInfo" $.RepoInfo 110 + "LoggedInUser" $.LoggedInUser 111 + "Issue" $.Issue 112 + "CommentList" $.Issue.CommentList) 113 + }} 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 114 115 + {{ template "repo/issues/fragments/newComment" . }} 116 + <div> 117 + {{ end }} 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 118 0 0 0 0 0 0 0 0 0 0 0 0

+42 -44

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

··· 37 {{ end }} 38 39 {{ define "repoAfter" }} 40 - <div class="flex flex-col gap-2 mt-2"> 41 - {{ range .Issues }} 42 - <div class="rounded drop-shadow-sm bg-white px-6 py-4 dark:bg-gray-800 dark:border-gray-700"> 43 - <div class="pb-2"> 44 - <a 45 - href="/{{ $.RepoInfo.FullName }}/issues/{{ .IssueId }}" 46 - class="no-underline hover:underline" 47 - > 48 - {{ .Title | description }} 49 - <span class="text-gray-500">#{{ .IssueId }}</span> 50 - </a> 51 - </div> 52 - <p class="text-sm text-gray-500 dark:text-gray-400 flex flex-wrap items-center gap-1"> 53 - {{ $bgColor := "bg-gray-800 dark:bg-gray-700" }} 54 - {{ $icon := "ban" }} 55 - {{ $state := "closed" }} 56 - {{ if .Open }} 57 - {{ $bgColor = "bg-green-600 dark:bg-green-700" }} 58 - {{ $icon = "circle-dot" }} 59 - {{ $state = "open" }} 60 - {{ end }} 61 62 - <span class="inline-flex items-center rounded px-2 py-[5px] {{ $bgColor }} text-sm"> 63 - {{ i $icon "w-3 h-3 mr-1.5 text-white dark:text-white" }} 64 - <span class="text-white dark:text-white">{{ $state }}</span> 65 - </span> 66 67 - <span class="ml-1"> 68 - {{ template "user/fragments/picHandleLink" .OwnerDid }} 69 - </span> 70 71 - <span class="before:content-['·']"> 72 - {{ template "repo/fragments/time" .Created }} 73 - </span> 74 75 - <span class="before:content-['·']"> 76 - {{ $s := "s" }} 77 - {{ if eq .Metadata.CommentCount 1 }} 78 - {{ $s = "" }} 79 - {{ end }} 80 - <a href="/{{ $.RepoInfo.FullName }}/issues/{{ .IssueId }}" class="text-gray-500 dark:text-gray-400">{{ .Metadata.CommentCount }} comment{{$s}}</a> 81 - </span> 82 - </p> 0 0 83 </div> 84 - {{ end }} 85 - </div> 86 - 87 - {{ block "pagination" . }} {{ end }} 88 - 89 {{ end }} 90 91 {{ define "pagination" }}

··· 37 {{ end }} 38 39 {{ define "repoAfter" }} 40 + <div class="flex flex-col gap-2 mt-2"> 41 + {{ range .Issues }} 42 + <div class="rounded drop-shadow-sm bg-white px-6 py-4 dark:bg-gray-800 dark:border-gray-700"> 43 + <div class="pb-2"> 44 + <a 45 + href="/{{ $.RepoInfo.FullName }}/issues/{{ .IssueId }}" 46 + class="no-underline hover:underline" 47 + > 48 + {{ .Title | description }} 49 + <span class="text-gray-500">#{{ .IssueId }}</span> 50 + </a> 51 + </div> 52 + <p class="text-sm text-gray-500 dark:text-gray-400 flex flex-wrap items-center gap-1"> 53 + {{ $bgColor := "bg-gray-800 dark:bg-gray-700" }} 54 + {{ $icon := "ban" }} 55 + {{ $state := "closed" }} 56 + {{ if .Open }} 57 + {{ $bgColor = "bg-green-600 dark:bg-green-700" }} 58 + {{ $icon = "circle-dot" }} 59 + {{ $state = "open" }} 60 + {{ end }} 61 62 + <span class="inline-flex items-center rounded px-2 py-[5px] {{ $bgColor }} text-sm"> 63 + {{ i $icon "w-3 h-3 mr-1.5 text-white dark:text-white" }} 64 + <span class="text-white dark:text-white">{{ $state }}</span> 65 + </span> 66 67 + <span class="ml-1"> 68 + {{ template "user/fragments/picHandleLink" .Did }} 69 + </span> 70 71 + <span class="before:content-['·']"> 72 + {{ template "repo/fragments/time" .Created }} 73 + </span> 74 75 + <span class="before:content-['·']"> 76 + {{ $s := "s" }} 77 + {{ if eq (len .Comments) 1 }} 78 + {{ $s = "" }} 79 + {{ end }} 80 + <a href="/{{ $.RepoInfo.FullName }}/issues/{{ .IssueId }}" class="text-gray-500 dark:text-gray-400">{{ len .Comments }} comment{{$s}}</a> 81 + </span> 82 + </p> 83 + </div> 84 + {{ end }} 85 </div> 86 + {{ block "pagination" . }} {{ end }} 0 0 0 0 87 {{ end }} 88 89 {{ define "pagination" }}

+1 -33

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

··· 1 {{ define "title" }}new issue &middot; {{ .RepoInfo.FullName }}{{ end }} 2 3 {{ define "repoContent" }} 4 - <form 5 - hx-post="/{{ .RepoInfo.FullName }}/issues/new" 6 - class="mt-6 space-y-6" 7 - hx-swap="none" 8 - hx-indicator="#spinner" 9 - > 10 - <div class="flex flex-col gap-4"> 11 - <div> 12 - <label for="title">title</label> 13 - <input type="text" name="title" id="title" class="w-full" /> 14 - </div> 15 - <div> 16 - <label for="body">body</label> 17 - <textarea 18 - name="body" 19 - id="body" 20 - rows="6" 21 - class="w-full resize-y" 22 - placeholder="Describe your issue. Markdown is supported." 23 - ></textarea> 24 - </div> 25 - <div> 26 - <button type="submit" class="btn-create flex items-center gap-2"> 27 - {{ i "circle-plus" "w-4 h-4" }} 28 - create issue 29 - <span id="create-pull-spinner" class="group"> 30 - {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 31 - </span> 32 - </button> 33 - </div> 34 - </div> 35 - <div id="issues" class="error"></div> 36 - </form> 37 {{ end }}

··· 1 {{ define "title" }}new issue &middot; {{ .RepoInfo.FullName }}{{ end }} 2 3 {{ define "repoContent" }} 4 + {{ template "repo/issues/fragments/putIssue" . }} 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 5 {{ end }}

+48 -12

appview/pages/templates/repo/needsUpgrade.html

··· 1 {{ define "title" }}{{ .RepoInfo.FullName }}{{ end }} 2 - 3 {{ define "extrameta" }} 4 {{ template "repo/fragments/meta" . }} 5 {{ template "repo/fragments/og" (dict "RepoInfo" .RepoInfo) }} 6 {{ end }} 7 - 8 {{ define "repoContent" }} 9 <main> 10 - <div class="w-full h-full flex place-content-center {{ if .LoggedInUser }} bg-yellow-100 dark:bg-yellow-900 {{ end }}"> 11 - <div class="py-6 w-fit flex flex-col gap-4 text-center"> 12 - {{ if .LoggedInUser }} 13 - <p class=" text-yellow-800 dark:text-yellow-200 text-center"> 14 - Your knot needs an upgrade. This repository is currently unavailable to users. 15 - </p> 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 16 {{ else }} 17 - <p class="text-gray-400 dark:text-gray-500 py-6 text-center"> 18 - The knot hosting this repository needs an upgrade. This repository is currently unavailable. 19 - </p> 20 {{ end }} 21 - </div> 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 22 </div> 0 0 0 0 0 0 0 23 </main> 24 {{ end }}

··· 1 {{ define "title" }}{{ .RepoInfo.FullName }}{{ end }} 0 2 {{ define "extrameta" }} 3 {{ template "repo/fragments/meta" . }} 4 {{ template "repo/fragments/og" (dict "RepoInfo" .RepoInfo) }} 5 {{ end }} 0 6 {{ define "repoContent" }} 7 <main> 8 + <div class="relative w-full h-96 flex items-center justify-center"> 9 + <div class="w-full h-full grid grid-cols-1 md:grid-cols-2 gap-4 md:divide-x divide-gray-300 dark:divide-gray-600 text-gray-300 dark:text-gray-600"> 10 + <!-- mimic the repo view here, placeholders are LLM generated --> 11 + <div id="file-list" class="flex flex-col gap-2 col-span-1 w-full h-full p-4 items-start justify-start text-left"> 12 + {{ $files := 13 + (list 14 + "src" 15 + "docs" 16 + "config" 17 + "lib" 18 + "index.html" 19 + "log.html" 20 + "needsUpgrade.html" 21 + "new.html" 22 + "tags.html" 23 + "tree.html") 24 + }} 25 + {{ range $files }} 26 + <span> 27 + {{ if (contains . ".") }} 28 + {{ i "file" "size-4 inline-flex" }} 29 {{ else }} 30 + {{ i "folder" "size-4 inline-flex fill-current" }} 0 0 31 {{ end }} 32 + 33 + {{ . }} 34 + </span> 35 + {{ end }} 36 + </div> 37 + <div id="commit-list" class="hidden md:flex md:flex-col gap-4 col-span-1 w-full h-full p-4 items-start justify-start text-left"> 38 + {{ $commits := 39 + (list 40 + "Fix authentication bug in login flow" 41 + "Add new dashboard widgets for metrics" 42 + "Implement real-time notifications system") 43 + }} 44 + {{ range $commits }} 45 + <div class="flex flex-col"> 46 + <span>{{ . }}</span> 47 + <span class="text-xs">{{ . }}</span> 48 + </div> 49 + {{ end }} 50 + </div> 51 </div> 52 + <div class="absolute inset-0 flex items-center justify-center py-12 text-red-500 dark:text-red-400 backdrop-blur"> 53 + <div class="text-center"> 54 + {{ i "triangle-alert" "size-5 inline-flex items-center align-middle" }} 55 + The knot hosting this repository needs an upgrade. This repository is currently unavailable. 56 + </div> 57 + </div> 58 + </div> 59 </main> 60 {{ end }}

+3 -3

appview/pages/templates/repo/tree.html

··· 25 <div class="flex flex-col md:flex-row md:justify-between gap-2"> 26 <div id="breadcrumbs" class="overflow-x-auto whitespace-nowrap text-gray-400 dark:text-gray-500"> 27 {{ range .BreadCrumbs }} 28 - <a href="{{ index . 1}}" class="text-bold text-gray-500 dark:text-gray-400 {{ $linkstyle }}">{{ pathUnescape (index . 0) }}</a> / 29 {{ end }} 30 </div> 31 <div id="dir-info" class="text-gray-500 dark:text-gray-400 text-xs md:text-sm flex flex-wrap items-center gap-1 md:gap-0"> 32 {{ $stats := .TreeStats }} 33 34 - <span>at <a href="/{{ $.RepoInfo.FullName }}/tree/{{ $.Ref }}">{{ $.Ref }}</a></span> 35 {{ if eq $stats.NumFolders 1 }} 36 <span class="select-none px-1 md:px-2 [&:before]:content-['·']"></span> 37 <span>{{ $stats.NumFolders }} folder</span> ··· 55 {{ range .Files }} 56 <div class="grid grid-cols-12 gap-4 items-center py-1"> 57 <div class="col-span-8 md:col-span-4"> 58 - {{ $link := printf "/%s/%s/%s/%s/%s" $.RepoInfo.FullName "tree" (urlquery $.Ref) $.TreePath .Name }} 59 {{ $icon := "folder" }} 60 {{ $iconStyle := "size-4 fill-current" }} 61

··· 25 <div class="flex flex-col md:flex-row md:justify-between gap-2"> 26 <div id="breadcrumbs" class="overflow-x-auto whitespace-nowrap text-gray-400 dark:text-gray-500"> 27 {{ range .BreadCrumbs }} 28 + <a href="{{ index . 1 }}" class="text-bold text-gray-500 dark:text-gray-400 {{ $linkstyle }}">{{ pathUnescape (index . 0) }}</a> / 29 {{ end }} 30 </div> 31 <div id="dir-info" class="text-gray-500 dark:text-gray-400 text-xs md:text-sm flex flex-wrap items-center gap-1 md:gap-0"> 32 {{ $stats := .TreeStats }} 33 34 + <span>at <a href="/{{ $.RepoInfo.FullName }}/tree/{{ pathEscape $.Ref }}">{{ $.Ref }}</a></span> 35 {{ if eq $stats.NumFolders 1 }} 36 <span class="select-none px-1 md:px-2 [&:before]:content-['·']"></span> 37 <span>{{ $stats.NumFolders }} folder</span> ··· 55 {{ range .Files }} 56 <div class="grid grid-cols-12 gap-4 items-center py-1"> 57 <div class="col-span-8 md:col-span-4"> 58 + {{ $link := printf "/%s/%s/%s/%s/%s" $.RepoInfo.FullName "tree" (pathEscape $.Ref) $.TreePath .Name }} 59 {{ $icon := "folder" }} 60 {{ $iconStyle := "size-4 fill-current" }} 61

+6 -1

appview/pages/templates/spindles/fragments/spindleListing.html

··· 30 {{ define "spindleRightSide" }} 31 <div id="right-side" class="flex gap-2"> 32 {{ $style := "px-2 py-1 rounded flex items-center flex-shrink-0 gap-2 text-sm" }} 33 - {{ if .Verified }} 0 0 0 0 34 <span class="bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-200 {{$style}}">{{ i "shield-check" "w-4 h-4" }} verified</span> 35 {{ template "spindles/fragments/addMemberModal" . }} 36 {{ else }} 37 <span class="bg-red-100 text-red-800 dark:bg-red-900 dark:text-red-200 {{$style}}">{{ i "shield-off" "w-4 h-4" }} unverified</span> 38 {{ block "spindleRetryButton" . }} {{ end }} 39 {{ end }} 0 40 {{ block "spindleDeleteButton" . }} {{ end }} 41 </div> 42 {{ end }}

··· 30 {{ define "spindleRightSide" }} 31 <div id="right-side" class="flex gap-2"> 32 {{ $style := "px-2 py-1 rounded flex items-center flex-shrink-0 gap-2 text-sm" }} 33 + 34 + {{ if .NeedsUpgrade }} 35 + <span class="bg-yellow-100 text-yellow-800 dark:bg-yellow-900 dark:text-yellow-200 {{$style}}"> {{ i "shield-alert" "w-4 h-4" }} needs upgrade </span> 36 + {{ block "spindleRetryButton" . }} {{ end }} 37 + {{ else if .Verified }} 38 <span class="bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-200 {{$style}}">{{ i "shield-check" "w-4 h-4" }} verified</span> 39 {{ template "spindles/fragments/addMemberModal" . }} 40 {{ else }} 41 <span class="bg-red-100 text-red-800 dark:bg-red-900 dark:text-red-200 {{$style}}">{{ i "shield-off" "w-4 h-4" }} unverified</span> 42 {{ block "spindleRetryButton" . }} {{ end }} 43 {{ end }} 44 + 45 {{ block "spindleDeleteButton" . }} {{ end }} 46 </div> 47 {{ end }}

+3 -7

appview/pages/templates/spindles/index.html

··· 1 {{ define "title" }}spindles{{ end }} 2 3 {{ define "content" }} 4 - <div class="px-6 py-4 flex items-end justify-start gap-4 align-bottom"> 5 <h1 class="text-xl font-bold dark:text-white">Spindles</h1> 6 - 7 - 8 - <span class="flex items-center gap-1 text-sm"> 9 {{ i "book" "w-3 h-3" }} 10 - <a href="https://tangled.sh/@tangled.sh/core/blob/master/docs/spindle/hosting.md"> 11 - docs 12 - </a> 13 </span> 14 </div> 15

··· 1 {{ define "title" }}spindles{{ end }} 2 3 {{ define "content" }} 4 + <div class="px-6 py-4 flex items-center justify-between gap-4 align-bottom"> 5 <h1 class="text-xl font-bold dark:text-white">Spindles</h1> 6 + <span class="flex items-center gap-1"> 0 0 7 {{ i "book" "w-3 h-3" }} 8 + <a href="https://tangled.sh/@tangled.sh/core/blob/master/docs/spindle/hosting.md">docs</a> 0 0 9 </span> 10 </div> 11

+3 -2

appview/pages/templates/strings/string.html

··· 23 hx-boost="true" 24 href="/strings/{{ .String.Did }}/{{ .String.Rkey }}/edit"> 25 {{ i "pencil" "size-4" }} 26 - <span class="hidden md:inline">edit</span> 27 {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 28 </a> 29 <button ··· 34 hx-confirm="Are you sure you want to delete the string `{{ .String.Filename }}`?" 35 > 36 {{ i "trash-2" "size-4" }} 37 - <span class="hidden md:inline">delete</span> 38 {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 39 </button> 40 </div> ··· 80 <div id="blob-contents" class="whitespace-pre peer-target:bg-yellow-200 dark:peer-target:bg-yellow-900">{{ .String.Contents | escapeHtml }}</div> 81 {{ end }} 82 </div> 0 83 </section> 84 {{ end }}

··· 23 hx-boost="true" 24 href="/strings/{{ .String.Did }}/{{ .String.Rkey }}/edit"> 25 {{ i "pencil" "size-4" }} 26 + <span class="hidden md:inline">edit</span> 27 {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 28 </a> 29 <button ··· 34 hx-confirm="Are you sure you want to delete the string `{{ .String.Filename }}`?" 35 > 36 {{ i "trash-2" "size-4" }} 37 + <span class="hidden md:inline">delete</span> 38 {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 39 </button> 40 </div> ··· 80 <div id="blob-contents" class="whitespace-pre peer-target:bg-yellow-200 dark:peer-target:bg-yellow-900">{{ .String.Contents | escapeHtml }}</div> 81 {{ end }} 82 </div> 83 + {{ template "fragments/multiline-select" }} 84 </section> 85 {{ end }}

+1 -1

appview/pages/templates/timeline/fragments/hero.html

··· 23 24 <figure class="w-full hidden md:block md:w-auto"> 25 <a href="https://tangled.sh/@tangled.sh/core" class="block"> 26 - <img src="https://assets.tangled.network/hero-repo.png" alt="Screenshot of the Tangled monorepo." class="max-w-md mx-auto md:max-w-none w-full md:w-[30vw] h-auto shadow-sm rounded hover:shadow-md transition-shadow" /> 27 </a> 28 <figcaption class="text-sm text-gray-600 dark:text-gray-400 mt-2 text-center"> 29 Monorepo for Tangled, built in the open with the community.

··· 23 24 <figure class="w-full hidden md:block md:w-auto"> 25 <a href="https://tangled.sh/@tangled.sh/core" class="block"> 26 + <img src="https://assets.tangled.network/hero-repo.png" alt="Screenshot of the Tangled monorepo." class="max-w-md mx-auto md:max-w-none w-full md:w-[30vw] h-auto shadow-sm rounded" /> 27 </a> 28 <figcaption class="text-sm text-gray-600 dark:text-gray-400 mt-2 text-center"> 29 Monorepo for Tangled, built in the open with the community.

+3 -3

appview/pages/templates/timeline/home.html

··· 27 {{ define "feature" }} 28 {{ $info := index . 0 }} 29 {{ $bullets := index . 1 }} 30 - <div class="flex flex-col items-top gap-6 md:flex-row md:gap-12"> 31 <div class="flex-1"> 32 <h2 class="text-2xl font-bold text-black dark:text-white mb-6">{{ $info.title }}</h2> 33 <ul class="leading-normal"> ··· 38 </div> 39 <div class="flex-shrink-0 w-96 md:w-1/3"> 40 <a href="{{ $info.image }}"> 41 - <img src="{{ $info.image }}" alt="{{ $info.alt }}" class="w-full h-auto rounded" /> 42 </a> 43 </div> 44 </div> 45 {{ end }} 46 47 {{ define "features" }} 48 - <div class="prose dark:text-gray-200 space-y-12 px-6 py-4"> 49 {{ template "feature" (list 50 (dict 51 "title" "lightweight git repo hosting"

··· 27 {{ define "feature" }} 28 {{ $info := index . 0 }} 29 {{ $bullets := index . 1 }} 30 + <div class="flex flex-col items-center gap-6 md:flex-row md:items-top"> 31 <div class="flex-1"> 32 <h2 class="text-2xl font-bold text-black dark:text-white mb-6">{{ $info.title }}</h2> 33 <ul class="leading-normal"> ··· 38 </div> 39 <div class="flex-shrink-0 w-96 md:w-1/3"> 40 <a href="{{ $info.image }}"> 41 + <img src="{{ $info.image }}" alt="{{ $info.alt }}" class="w-full h-auto rounded shadow-sm" /> 42 </a> 43 </div> 44 </div> 45 {{ end }} 46 47 {{ define "features" }} 48 + <div class="prose dark:text-gray-200 space-y-12 px-6 py-4 bg-white dark:bg-gray-800 rounded drop-shadow-sm"> 49 {{ template "feature" (list 50 (dict 51 "title" "lightweight git repo hosting"

+2 -4

appview/pages/templates/user/completeSignup.html

··· 29 </head> 30 <body class="flex items-center justify-center min-h-screen"> 31 <main class="max-w-md px-6 -mt-4"> 32 - <h1 33 - class="text-center text-2xl font-semibold italic dark:text-white" 34 - > 35 - tangled 36 </h1> 37 <h2 class="text-center text-xl italic dark:text-white"> 38 tightly-knit social coding.

··· 29 </head> 30 <body class="flex items-center justify-center min-h-screen"> 31 <main class="max-w-md px-6 -mt-4"> 32 + <h1 class="flex place-content-center text-2xl font-semibold italic dark:text-white" > 33 + {{ template "fragments/logotype" }} 0 0 34 </h1> 35 <h2 class="text-center text-xl italic dark:text-white"> 36 tightly-knit social coding.

+1 -2

appview/pages/templates/user/fragments/repoCard.html

··· 36 <div class="text-gray-400 text-sm font-mono inline-flex gap-4 mt-auto"> 37 {{ with .Language }} 38 <div class="flex gap-2 items-center text-sm"> 39 - <div class="size-2 rounded-full" 40 - style="background: radial-gradient(circle at 35% 35%, color-mix(in srgb, {{ langColor . }} 70%, white), {{ langColor . }} 30%, color-mix(in srgb, {{ langColor . }} 85%, black));"></div> 41 <span>{{ . }}</span> 42 </div> 43 {{ end }}

··· 36 <div class="text-gray-400 text-sm font-mono inline-flex gap-4 mt-auto"> 37 {{ with .Language }} 38 <div class="flex gap-2 items-center text-sm"> 39 + {{ template "repo/fragments/languageBall" . }} 0 40 <span>{{ . }}</span> 41 </div> 42 {{ end }}

+2 -2

appview/pages/templates/user/login.html

··· 13 </head> 14 <body class="flex items-center justify-center min-h-screen"> 15 <main class="max-w-md px-6 -mt-4"> 16 - <h1 class="text-center text-2xl font-semibold italic dark:text-white" > 17 - tangled 18 </h1> 19 <h2 class="text-center text-xl italic dark:text-white"> 20 tightly-knit social coding.

··· 13 </head> 14 <body class="flex items-center justify-center min-h-screen"> 15 <main class="max-w-md px-6 -mt-4"> 16 + <h1 class="flex place-content-center text-2xl font-semibold italic dark:text-white" > 17 + {{ template "fragments/logotype" }} 18 </h1> 19 <h2 class="text-center text-xl italic dark:text-white"> 20 tightly-knit social coding.

+21 -10

appview/pages/templates/user/overview.html

··· 56 </summary> 57 <div class="py-2 text-sm flex flex-col gap-3 mb-2"> 58 {{ range . }} 59 - <div class="flex flex-wrap items-center gap-2"> 60 - <span class="text-gray-500 dark:text-gray-400"> 61 - {{ if .Source }} 0 62 {{ i "git-fork" "w-4 h-4" }} 63 - {{ else }} 64 {{ i "book-plus" "w-4 h-4" }} 65 - {{ end }} 0 0 0 0 66 </span> 67 - <a href="/{{ resolve .Repo.Did }}/{{ .Repo.Name }}" class="no-underline hover:underline"> 68 - {{- .Repo.Name -}} 69 - </a> 0 0 0 0 0 0 70 </div> 71 {{ end }} 72 </div> ··· 104 </summary> 105 <div class="py-2 text-sm flex flex-col gap-3 mb-2"> 106 {{ range $items }} 107 - {{ $repoOwner := resolve .Metadata.Repo.Did }} 108 - {{ $repoName := .Metadata.Repo.Name }} 109 {{ $repoUrl := printf "%s/%s" $repoOwner $repoName }} 110 111 <div class="flex gap-2 text-gray-600 dark:text-gray-300">

··· 56 </summary> 57 <div class="py-2 text-sm flex flex-col gap-3 mb-2"> 58 {{ range . }} 59 + <div class="flex flex-wrap items-center justify-between gap-2"> 60 + <span class="flex items-center gap-2"> 61 + <span class="text-gray-500 dark:text-gray-400"> 62 + {{ if .Source }} 63 {{ i "git-fork" "w-4 h-4" }} 64 + {{ else }} 65 {{ i "book-plus" "w-4 h-4" }} 66 + {{ end }} 67 + </span> 68 + <a href="/{{ resolve .Repo.Did }}/{{ .Repo.Name }}" class="no-underline hover:underline"> 69 + {{- .Repo.Name -}} 70 + </a> 71 </span> 72 + 73 + {{ with .Repo.RepoStats }} 74 + {{ with .Language }} 75 + <div class="flex gap-2 items-center text-xs font-mono text-gray-400 "> 76 + {{ template "repo/fragments/languageBall" . }} 77 + <span>{{ . }}</span> 78 + </div> 79 + {{end }} 80 + {{end }} 81 </div> 82 {{ end }} 83 </div> ··· 115 </summary> 116 <div class="py-2 text-sm flex flex-col gap-3 mb-2"> 117 {{ range $items }} 118 + {{ $repoOwner := resolve .Repo.Did }} 119 + {{ $repoName := .Repo.Name }} 120 {{ $repoUrl := printf "%s/%s" $repoOwner $repoName }} 121 122 <div class="flex gap-2 text-gray-600 dark:text-gray-300">

+3 -1

appview/pages/templates/user/signup.html

··· 13 </head> 14 <body class="flex items-center justify-center min-h-screen"> 15 <main class="max-w-md px-6 -mt-4"> 16 - <h1 class="text-center text-2xl font-semibold italic dark:text-white" >tangled</h1> 0 0 17 <h2 class="text-center text-xl italic dark:text-white">tightly-knit social coding.</h2> 18 <form 19 class="mt-4 max-w-sm mx-auto"

··· 13 </head> 14 <body class="flex items-center justify-center min-h-screen"> 15 <main class="max-w-md px-6 -mt-4"> 16 + <h1 class="flex place-content-center text-2xl font-semibold italic dark:text-white" > 17 + {{ template "fragments/logotype" }} 18 + </h1> 19 <h2 class="text-center text-xl italic dark:text-white">tightly-knit social coding.</h2> 20 <form 21 class="mt-4 max-w-sm mx-auto"

+34 -1

appview/posthog/notifier.go

··· 58 59 func (n *posthogNotifier) NewIssue(ctx context.Context, issue *db.Issue) { 60 err := n.client.Enqueue(posthog.Capture{ 61 - DistinctId: issue.OwnerDid, 62 Event: "new_issue", 63 Properties: posthog.Properties{ 64 "repo_at": issue.RepoAt.String(), ··· 129 log.Println("failed to enqueue posthog event:", err) 130 } 131 } 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 58 59 func (n *posthogNotifier) NewIssue(ctx context.Context, issue *db.Issue) { 60 err := n.client.Enqueue(posthog.Capture{ 61 + DistinctId: issue.Did, 62 Event: "new_issue", 63 Properties: posthog.Properties{ 64 "repo_at": issue.RepoAt.String(), ··· 129 log.Println("failed to enqueue posthog event:", err) 130 } 131 } 132 + 133 + func (n *posthogNotifier) DeleteString(ctx context.Context, did, rkey string) { 134 + err := n.client.Enqueue(posthog.Capture{ 135 + DistinctId: did, 136 + Event: "delete_string", 137 + Properties: posthog.Properties{"rkey": rkey}, 138 + }) 139 + if err != nil { 140 + log.Println("failed to enqueue posthog event:", err) 141 + } 142 + } 143 + 144 + func (n *posthogNotifier) EditString(ctx context.Context, string *db.String) { 145 + err := n.client.Enqueue(posthog.Capture{ 146 + DistinctId: string.Did.String(), 147 + Event: "edit_string", 148 + Properties: posthog.Properties{"rkey": string.Rkey}, 149 + }) 150 + if err != nil { 151 + log.Println("failed to enqueue posthog event:", err) 152 + } 153 + } 154 + 155 + func (n *posthogNotifier) CreateString(ctx context.Context, string *db.String) { 156 + err := n.client.Enqueue(posthog.Capture{ 157 + DistinctId: string.Did.String(), 158 + Event: "create_string", 159 + Properties: posthog.Properties{"rkey": string.Rkey}, 160 + }) 161 + if err != nil { 162 + log.Println("failed to enqueue posthog event:", err) 163 + } 164 + }

+7 -2

appview/repo/feed.go

··· 9 "time" 10 11 "tangled.sh/tangled.sh/core/appview/db" 0 12 "tangled.sh/tangled.sh/core/appview/reporesolver" 13 14 "github.com/bluesky-social/indigo/atproto/syntax" ··· 23 return nil, err 24 } 25 26 - issues, err := db.GetIssuesWithLimit(rp.db, feedLimitPerType, db.FilterEq("repo_at", f.RepoAt())) 0 0 0 0 27 if err != nil { 28 return nil, err 29 } ··· 104 } 105 106 func (rp *Repo) createIssueItem(ctx context.Context, issue db.Issue, f *reporesolver.ResolvedRepo) (*feeds.Item, error) { 107 - owner, err := rp.idResolver.ResolveIdent(ctx, issue.OwnerDid) 108 if err != nil { 109 return nil, err 110 }

··· 9 "time" 10 11 "tangled.sh/tangled.sh/core/appview/db" 12 + "tangled.sh/tangled.sh/core/appview/pagination" 13 "tangled.sh/tangled.sh/core/appview/reporesolver" 14 15 "github.com/bluesky-social/indigo/atproto/syntax" ··· 24 return nil, err 25 } 26 27 + issues, err := db.GetIssuesPaginated( 28 + rp.db, 29 + pagination.Page{Limit: feedLimitPerType}, 30 + db.FilterEq("repo_at", f.RepoAt()), 31 + ) 32 if err != nil { 33 return nil, err 34 } ··· 109 } 110 111 func (rp *Repo) createIssueItem(ctx context.Context, issue db.Issue, f *reporesolver.ResolvedRepo) (*feeds.Item, error) { 112 + owner, err := rp.idResolver.ResolveIdent(ctx, issue.Did) 113 if err != nil { 114 return nil, err 115 }

+25 -54

appview/repo/index.go

··· 5 "fmt" 6 "log" 7 "net/http" 0 8 "slices" 9 "sort" 10 "strings" ··· 31 32 func (rp *Repo) RepoIndex(w http.ResponseWriter, r *http.Request) { 33 ref := chi.URLParam(r, "ref") 0 34 35 f, err := rp.repoResolver.Resolve(r) 36 if err != nil { ··· 47 Host: host, 48 } 49 50 - var needsKnotUpgrade bool 0 0 51 // Build index response from multiple XRPC calls 52 result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref) 53 - if err != nil { 54 - if errors.Is(err, xrpcclient.ErrXrpcUnsupported) { 55 log.Println("failed to call XRPC repo.index", err) 56 - needsKnotUpgrade = true 0 0 0 0 57 return 58 } 59 ··· 119 log.Println(err) 120 } 121 122 - user := rp.oauth.GetUser(r) 123 - repoInfo := f.RepoInfo(user) 124 - 125 // TODO: a bit dirty 126 languageInfo, err := rp.getLanguageInfo(r.Context(), f, xrpcc, result.Ref, ref == "") 127 if err != nil { ··· 141 142 rp.pages.RepoIndexPage(w, pages.RepoIndexParams{ 143 LoggedInUser: user, 144 - NeedsKnotUpgrade: needsKnotUpgrade, 145 RepoInfo: repoInfo, 146 TagMap: tagMap, 147 RepoIndexResponse: *result, ··· 243 // first get branches to determine the ref if not specified 244 branchesBytes, err := tangled.RepoBranches(ctx, xrpcc, "", 0, repo) 245 if err != nil { 246 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 247 - log.Println("failed to call XRPC repo.branches", xrpcerr) 248 - return nil, xrpcerr 249 - } 250 - return nil, err 251 } 252 253 var branchesResp types.RepoBranchesResponse 254 if err := json.Unmarshal(branchesBytes, &branchesResp); err != nil { 255 - return nil, err 256 } 257 258 // if no ref specified, use default branch or first available 259 - if ref == "" && len(branchesResp.Branches) > 0 { 260 for _, branch := range branchesResp.Branches { 261 if branch.IsDefault { 262 ref = branch.Name 263 break 264 } 265 } 266 - if ref == "" { 267 - ref = branchesResp.Branches[0].Name 268 - } 269 } 270 271 - // check if repo is empty 272 - if len(branchesResp.Branches) == 0 { 273 return &types.RepoIndexResponse{ 274 IsEmpty: true, 275 Branches: branchesResp.Branches, ··· 278 279 // now run the remaining queries in parallel 280 var wg sync.WaitGroup 281 - var mu sync.Mutex 282 - var errs []error 283 284 var ( 285 tagsResp types.RepoTagsResponse ··· 295 defer wg.Done() 296 tagsBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, repo) 297 if err != nil { 298 - mu.Lock() 299 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 300 - log.Println("failed to call XRPC repo.tags", xrpcerr) 301 - errs = append(errs, xrpcerr) 302 - } else { 303 - errs = append(errs, err) 304 - } 305 - mu.Unlock() 306 return 307 } 308 309 if err := json.Unmarshal(tagsBytes, &tagsResp); err != nil { 310 - mu.Lock() 311 - errs = append(errs, err) 312 - mu.Unlock() 313 } 314 }() 315 ··· 319 defer wg.Done() 320 resp, err := tangled.RepoTree(ctx, xrpcc, "", ref, repo) 321 if err != nil { 322 - mu.Lock() 323 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 324 - log.Println("failed to call XRPC repo.tree", xrpcerr) 325 - errs = append(errs, xrpcerr) 326 - } else { 327 - errs = append(errs, err) 328 - } 329 - mu.Unlock() 330 return 331 } 332 treeResp = resp ··· 338 defer wg.Done() 339 logBytes, err := tangled.RepoLog(ctx, xrpcc, "", 50, "", ref, repo) 340 if err != nil { 341 - mu.Lock() 342 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 343 - log.Println("failed to call XRPC repo.log", xrpcerr) 344 - errs = append(errs, xrpcerr) 345 - } else { 346 - errs = append(errs, err) 347 - } 348 - mu.Unlock() 349 return 350 } 351 352 if err := json.Unmarshal(logBytes, &logResp); err != nil { 353 - mu.Lock() 354 - errs = append(errs, err) 355 - mu.Unlock() 356 } 357 }() 358 ··· 378 379 wg.Wait() 380 381 - if len(errs) > 0 { 382 - return nil, errs[0] // return first error 383 } 384 385 var files []types.NiceTree

··· 5 "fmt" 6 "log" 7 "net/http" 8 + "net/url" 9 "slices" 10 "sort" 11 "strings" ··· 32 33 func (rp *Repo) RepoIndex(w http.ResponseWriter, r *http.Request) { 34 ref := chi.URLParam(r, "ref") 35 + ref, _ = url.PathUnescape(ref) 36 37 f, err := rp.repoResolver.Resolve(r) 38 if err != nil { ··· 49 Host: host, 50 } 51 52 + user := rp.oauth.GetUser(r) 53 + repoInfo := f.RepoInfo(user) 54 + 55 // Build index response from multiple XRPC calls 56 result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref) 57 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 58 + if errors.Is(xrpcerr, xrpcclient.ErrXrpcUnsupported) { 59 log.Println("failed to call XRPC repo.index", err) 60 + rp.pages.RepoIndexPage(w, pages.RepoIndexParams{ 61 + LoggedInUser: user, 62 + NeedsKnotUpgrade: true, 63 + RepoInfo: repoInfo, 64 + }) 65 return 66 } 67 ··· 127 log.Println(err) 128 } 129 0 0 0 130 // TODO: a bit dirty 131 languageInfo, err := rp.getLanguageInfo(r.Context(), f, xrpcc, result.Ref, ref == "") 132 if err != nil { ··· 146 147 rp.pages.RepoIndexPage(w, pages.RepoIndexParams{ 148 LoggedInUser: user, 0 149 RepoInfo: repoInfo, 150 TagMap: tagMap, 151 RepoIndexResponse: *result, ··· 247 // first get branches to determine the ref if not specified 248 branchesBytes, err := tangled.RepoBranches(ctx, xrpcc, "", 0, repo) 249 if err != nil { 250 + return nil, fmt.Errorf("failed to call repoBranches: %w", err) 0 0 0 0 251 } 252 253 var branchesResp types.RepoBranchesResponse 254 if err := json.Unmarshal(branchesBytes, &branchesResp); err != nil { 255 + return nil, fmt.Errorf("failed to unmarshal branches response: %w", err) 256 } 257 258 // if no ref specified, use default branch or first available 259 + if ref == "" { 260 for _, branch := range branchesResp.Branches { 261 if branch.IsDefault { 262 ref = branch.Name 263 break 264 } 265 } 0 0 0 266 } 267 268 + // if ref is still empty, this means the default branch is not set 269 + if ref == "" { 270 return &types.RepoIndexResponse{ 271 IsEmpty: true, 272 Branches: branchesResp.Branches, ··· 275 276 // now run the remaining queries in parallel 277 var wg sync.WaitGroup 278 + var errs error 0 279 280 var ( 281 tagsResp types.RepoTagsResponse ··· 291 defer wg.Done() 292 tagsBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, repo) 293 if err != nil { 294 + errs = errors.Join(errs, fmt.Errorf("failed to call repoTags: %w", err)) 0 0 0 0 0 0 0 295 return 296 } 297 298 if err := json.Unmarshal(tagsBytes, &tagsResp); err != nil { 299 + errs = errors.Join(errs, fmt.Errorf("failed to unmarshal repoTags: %w", err)) 0 0 300 } 301 }() 302 ··· 306 defer wg.Done() 307 resp, err := tangled.RepoTree(ctx, xrpcc, "", ref, repo) 308 if err != nil { 309 + errs = errors.Join(errs, fmt.Errorf("failed to call repoTree: %w", err)) 0 0 0 0 0 0 0 310 return 311 } 312 treeResp = resp ··· 318 defer wg.Done() 319 logBytes, err := tangled.RepoLog(ctx, xrpcc, "", 50, "", ref, repo) 320 if err != nil { 321 + errs = errors.Join(errs, fmt.Errorf("failed to call repoLog: %w", err)) 0 0 0 0 0 0 0 322 return 323 } 324 325 if err := json.Unmarshal(logBytes, &logResp); err != nil { 326 + errs = errors.Join(errs, fmt.Errorf("failed to unmarshal repoLog: %w", err)) 0 0 327 } 328 }() 329 ··· 349 350 wg.Wait() 351 352 + if errs != nil { 353 + return nil, errs 354 } 355 356 var files []types.NiceTree

+98 -120

appview/repo/repo.go

··· 11 "log/slog" 12 "net/http" 13 "net/url" 14 - "path" 15 "path/filepath" 16 "slices" 17 "strconv" ··· 86 } 87 88 func (rp *Repo) DownloadArchive(w http.ResponseWriter, r *http.Request) { 89 - refParam := chi.URLParam(r, "ref") 0 0 90 f, err := rp.repoResolver.Resolve(r) 91 if err != nil { 92 log.Println("failed to get repo and knot", err) ··· 103 } 104 105 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 106 - archiveBytes, err := tangled.RepoArchive(r.Context(), xrpcc, "tar.gz", "", refParam, repo) 107 - if err != nil { 108 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 109 - log.Println("failed to call XRPC repo.archive", xrpcerr) 110 - rp.pages.Error503(w) 111 - return 112 - } 113 - rp.pages.Error404(w) 114 return 115 } 116 117 - // Set headers for file download 118 - filename := fmt.Sprintf("%s-%s.tar.gz", f.Name, refParam) 0 119 w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename)) 120 w.Header().Set("Content-Type", "application/gzip") 121 w.Header().Set("Content-Length", fmt.Sprintf("%d", len(archiveBytes))) ··· 140 } 141 142 ref := chi.URLParam(r, "ref") 0 143 144 scheme := "http" 145 if !rp.config.Core.Dev { ··· 160 161 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 162 xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo) 163 - if err != nil { 164 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 165 - log.Println("failed to call XRPC repo.log", xrpcerr) 166 - rp.pages.Error503(w) 167 - return 168 - } 169 - rp.pages.Error404(w) 170 return 171 } 172 ··· 178 } 179 180 tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 181 - if err != nil { 182 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 183 - log.Println("failed to call XRPC repo.tags", xrpcerr) 184 - rp.pages.Error503(w) 185 - return 186 - } 187 } 188 189 tagMap := make(map[string][]string) ··· 197 } 198 199 branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 200 - if err != nil { 201 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 202 - log.Println("failed to call XRPC repo.branches", xrpcerr) 203 - rp.pages.Error503(w) 204 - return 205 - } 206 } 207 208 if branchBytes != nil { ··· 354 return 355 } 356 ref := chi.URLParam(r, "ref") 0 357 358 var diffOpts types.DiffOpts 359 if d := r.URL.Query().Get("diff"); d == "split" { ··· 376 377 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 378 xrpcBytes, err := tangled.RepoDiff(r.Context(), xrpcc, ref, repo) 379 - if err != nil { 380 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 381 - log.Println("failed to call XRPC repo.diff", xrpcerr) 382 - rp.pages.Error503(w) 383 - return 384 - } 385 - rp.pages.Error404(w) 386 return 387 } 388 ··· 434 } 435 436 ref := chi.URLParam(r, "ref") 437 - treePath := chi.URLParam(r, "*") 438 439 // if the tree path has a trailing slash, let's strip it 440 // so we don't 404 0 0 441 treePath = strings.TrimSuffix(treePath, "/") 442 443 scheme := "http" ··· 451 452 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 453 xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo) 454 - if err != nil { 455 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 456 - log.Println("failed to call XRPC repo.tree", xrpcerr) 457 - rp.pages.Error503(w) 458 - return 459 - } 460 - rp.pages.Error404(w) 461 return 462 } 463 ··· 499 500 // redirects tree paths trying to access a blob; in this case the result.Files is unpopulated, 501 // so we can safely redirect to the "parent" (which is the same file). 502 - unescapedTreePath, _ := url.PathUnescape(treePath) 503 - if len(result.Files) == 0 && result.Parent == unescapedTreePath { 504 - http.Redirect(w, r, fmt.Sprintf("/%s/blob/%s/%s", f.OwnerSlashRepo(), ref, result.Parent), http.StatusFound) 505 return 506 } 507 508 user := rp.oauth.GetUser(r) 509 510 var breadcrumbs [][]string 511 - breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), ref)}) 512 if treePath != "" { 513 for idx, elem := range strings.Split(treePath, "/") { 514 - breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], elem)}) 515 } 516 } 517 ··· 544 545 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 546 xrpcBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 547 - if err != nil { 548 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 549 - log.Println("failed to call XRPC repo.tags", xrpcerr) 550 - rp.pages.Error503(w) 551 - return 552 - } 553 - rp.pages.Error404(w) 554 return 555 } 556 ··· 617 618 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 619 xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 620 - if err != nil { 621 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 622 - log.Println("failed to call XRPC repo.branches", xrpcerr) 623 - rp.pages.Error503(w) 624 - return 625 - } 626 - rp.pages.Error404(w) 627 return 628 } 629 ··· 652 } 653 654 ref := chi.URLParam(r, "ref") 0 0 655 filePath := chi.URLParam(r, "*") 0 656 657 scheme := "http" 658 if !rp.config.Core.Dev { ··· 665 666 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Repo.Name) 667 resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo) 668 - if err != nil { 669 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 670 - log.Println("failed to call XRPC repo.blob", xrpcerr) 671 - rp.pages.Error503(w) 672 - return 673 - } 674 - rp.pages.Error404(w) 675 return 676 } 677 678 // Use XRPC response directly instead of converting to internal types 679 680 var breadcrumbs [][]string 681 - breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), ref)}) 682 if filePath != "" { 683 for idx, elem := range strings.Split(filePath, "/") { 684 - breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], elem)}) 685 } 686 } 687 ··· 710 } 711 712 // fetch the raw binary content using sh.tangled.repo.blob xrpc 713 - repoName := path.Join("%s/%s", f.OwnerDid(), f.Name) 714 - blobURL := fmt.Sprintf("%s://%s/xrpc/sh.tangled.repo.blob?repo=%s&ref=%s&path=%s&raw=true", 715 - scheme, f.Knot, url.QueryEscape(repoName), url.QueryEscape(ref), url.QueryEscape(filePath)) 0 0 0 0 0 0 0 0 0 0 0 716 717 contentSrc = blobURL 718 if !rp.config.Core.Dev { ··· 767 } 768 769 ref := chi.URLParam(r, "ref") 0 0 770 filePath := chi.URLParam(r, "*") 0 771 772 scheme := "http" 773 if !rp.config.Core.Dev { ··· 775 } 776 777 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Repo.Name) 778 - blobURL := fmt.Sprintf("%s://%s/xrpc/sh.tangled.repo.blob?repo=%s&ref=%s&path=%s&raw=true", 779 - scheme, f.Knot, url.QueryEscape(repo), url.QueryEscape(ref), url.QueryEscape(filePath)) 0 0 0 0 0 0 0 0 0 0 780 781 req, err := http.NewRequest("GET", blobURL, nil) 782 if err != nil { ··· 1365 1366 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 1367 xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 1368 - if err != nil { 1369 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1370 - log.Println("failed to call XRPC repo.branches", xrpcerr) 1371 - rp.pages.Error503(w) 1372 - return 1373 - } 1374 rp.pages.Error503(w) 1375 return 1376 } ··· 1472 1473 func (rp *Repo) SyncRepoFork(w http.ResponseWriter, r *http.Request) { 1474 ref := chi.URLParam(r, "ref") 0 1475 1476 user := rp.oauth.GetUser(r) 1477 f, err := rp.repoResolver.Resolve(r) ··· 1760 1761 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 1762 branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 1763 - if err != nil { 1764 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1765 - log.Println("failed to call XRPC repo.branches", xrpcerr) 1766 - rp.pages.Error503(w) 1767 - return 1768 - } 1769 - rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.") 1770 return 1771 } 1772 ··· 1801 } 1802 1803 tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 1804 - if err != nil { 1805 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1806 - log.Println("failed to call XRPC repo.tags", xrpcerr) 1807 - rp.pages.Error503(w) 1808 - return 1809 - } 1810 - rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.") 1811 return 1812 } 1813 ··· 1878 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 1879 1880 branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 1881 - if err != nil { 1882 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1883 - log.Println("failed to call XRPC repo.branches", xrpcerr) 1884 - rp.pages.Error503(w) 1885 - return 1886 - } 1887 - rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.") 1888 return 1889 } 1890 ··· 1896 } 1897 1898 tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 1899 - if err != nil { 1900 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1901 - log.Println("failed to call XRPC repo.tags", xrpcerr) 1902 - rp.pages.Error503(w) 1903 - return 1904 - } 1905 - rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.") 1906 return 1907 } 1908 ··· 1914 } 1915 1916 compareBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, base, head) 1917 - if err != nil { 1918 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1919 - log.Println("failed to call XRPC repo.compare", xrpcerr) 1920 - rp.pages.Error503(w) 1921 - return 1922 - } 1923 - rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.") 1924 return 1925 } 1926

··· 11 "log/slog" 12 "net/http" 13 "net/url" 0 14 "path/filepath" 15 "slices" 16 "strconv" ··· 85 } 86 87 func (rp *Repo) DownloadArchive(w http.ResponseWriter, r *http.Request) { 88 + ref := chi.URLParam(r, "ref") 89 + ref, _ = url.PathUnescape(ref) 90 + 91 f, err := rp.repoResolver.Resolve(r) 92 if err != nil { 93 log.Println("failed to get repo and knot", err) ··· 104 } 105 106 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 107 + archiveBytes, err := tangled.RepoArchive(r.Context(), xrpcc, "tar.gz", "", ref, repo) 108 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 109 + log.Println("failed to call XRPC repo.archive", xrpcerr) 110 + rp.pages.Error503(w) 0 0 0 0 111 return 112 } 113 114 + // Set headers for file download, just pass along whatever the knot specifies 115 + safeRefFilename := strings.ReplaceAll(plumbing.ReferenceName(ref).Short(), "/", "-") 116 + filename := fmt.Sprintf("%s-%s.tar.gz", f.Name, safeRefFilename) 117 w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename)) 118 w.Header().Set("Content-Type", "application/gzip") 119 w.Header().Set("Content-Length", fmt.Sprintf("%d", len(archiveBytes))) ··· 138 } 139 140 ref := chi.URLParam(r, "ref") 141 + ref, _ = url.PathUnescape(ref) 142 143 scheme := "http" 144 if !rp.config.Core.Dev { ··· 159 160 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 161 xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo) 162 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 163 + log.Println("failed to call XRPC repo.log", xrpcerr) 164 + rp.pages.Error503(w) 0 0 0 0 165 return 166 } 167 ··· 173 } 174 175 tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 176 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 177 + log.Println("failed to call XRPC repo.tags", xrpcerr) 178 + rp.pages.Error503(w) 179 + return 0 0 180 } 181 182 tagMap := make(map[string][]string) ··· 190 } 191 192 branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 193 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 194 + log.Println("failed to call XRPC repo.branches", xrpcerr) 195 + rp.pages.Error503(w) 196 + return 0 0 197 } 198 199 if branchBytes != nil { ··· 345 return 346 } 347 ref := chi.URLParam(r, "ref") 348 + ref, _ = url.PathUnescape(ref) 349 350 var diffOpts types.DiffOpts 351 if d := r.URL.Query().Get("diff"); d == "split" { ··· 368 369 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 370 xrpcBytes, err := tangled.RepoDiff(r.Context(), xrpcc, ref, repo) 371 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 372 + log.Println("failed to call XRPC repo.diff", xrpcerr) 373 + rp.pages.Error503(w) 0 0 0 0 374 return 375 } 376 ··· 422 } 423 424 ref := chi.URLParam(r, "ref") 425 + ref, _ = url.PathUnescape(ref) 426 427 // if the tree path has a trailing slash, let's strip it 428 // so we don't 404 429 + treePath := chi.URLParam(r, "*") 430 + treePath, _ = url.PathUnescape(treePath) 431 treePath = strings.TrimSuffix(treePath, "/") 432 433 scheme := "http" ··· 441 442 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 443 xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo) 444 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 445 + log.Println("failed to call XRPC repo.tree", xrpcerr) 446 + rp.pages.Error503(w) 0 0 0 0 447 return 448 } 449 ··· 485 486 // redirects tree paths trying to access a blob; in this case the result.Files is unpopulated, 487 // so we can safely redirect to the "parent" (which is the same file). 488 + if len(result.Files) == 0 && result.Parent == treePath { 489 + redirectTo := fmt.Sprintf("/%s/blob/%s/%s", f.OwnerSlashRepo(), url.PathEscape(ref), result.Parent) 490 + http.Redirect(w, r, redirectTo, http.StatusFound) 491 return 492 } 493 494 user := rp.oauth.GetUser(r) 495 496 var breadcrumbs [][]string 497 + breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))}) 498 if treePath != "" { 499 for idx, elem := range strings.Split(treePath, "/") { 500 + breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], url.PathEscape(elem))}) 501 } 502 } 503 ··· 530 531 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 532 xrpcBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 533 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 534 + log.Println("failed to call XRPC repo.tags", xrpcerr) 535 + rp.pages.Error503(w) 0 0 0 0 536 return 537 } 538 ··· 599 600 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 601 xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 602 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 603 + log.Println("failed to call XRPC repo.branches", xrpcerr) 604 + rp.pages.Error503(w) 0 0 0 0 605 return 606 } 607 ··· 630 } 631 632 ref := chi.URLParam(r, "ref") 633 + ref, _ = url.PathUnescape(ref) 634 + 635 filePath := chi.URLParam(r, "*") 636 + filePath, _ = url.PathUnescape(filePath) 637 638 scheme := "http" 639 if !rp.config.Core.Dev { ··· 646 647 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Repo.Name) 648 resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo) 649 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 650 + log.Println("failed to call XRPC repo.blob", xrpcerr) 651 + rp.pages.Error503(w) 0 0 0 0 652 return 653 } 654 655 // Use XRPC response directly instead of converting to internal types 656 657 var breadcrumbs [][]string 658 + breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))}) 659 if filePath != "" { 660 for idx, elem := range strings.Split(filePath, "/") { 661 + breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], url.PathEscape(elem))}) 662 } 663 } 664 ··· 687 } 688 689 // fetch the raw binary content using sh.tangled.repo.blob xrpc 690 + repoName := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 691 + 692 + baseURL := &url.URL{ 693 + Scheme: scheme, 694 + Host: f.Knot, 695 + Path: "/xrpc/sh.tangled.repo.blob", 696 + } 697 + query := baseURL.Query() 698 + query.Set("repo", repoName) 699 + query.Set("ref", ref) 700 + query.Set("path", filePath) 701 + query.Set("raw", "true") 702 + baseURL.RawQuery = query.Encode() 703 + blobURL := baseURL.String() 704 705 contentSrc = blobURL 706 if !rp.config.Core.Dev { ··· 755 } 756 757 ref := chi.URLParam(r, "ref") 758 + ref, _ = url.PathUnescape(ref) 759 + 760 filePath := chi.URLParam(r, "*") 761 + filePath, _ = url.PathUnescape(filePath) 762 763 scheme := "http" 764 if !rp.config.Core.Dev { ··· 766 } 767 768 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Repo.Name) 769 + baseURL := &url.URL{ 770 + Scheme: scheme, 771 + Host: f.Knot, 772 + Path: "/xrpc/sh.tangled.repo.blob", 773 + } 774 + query := baseURL.Query() 775 + query.Set("repo", repo) 776 + query.Set("ref", ref) 777 + query.Set("path", filePath) 778 + query.Set("raw", "true") 779 + baseURL.RawQuery = query.Encode() 780 + blobURL := baseURL.String() 781 782 req, err := http.NewRequest("GET", blobURL, nil) 783 if err != nil { ··· 1366 1367 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 1368 xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 1369 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1370 + log.Println("failed to call XRPC repo.branches", xrpcerr) 0 0 0 0 1371 rp.pages.Error503(w) 1372 return 1373 } ··· 1469 1470 func (rp *Repo) SyncRepoFork(w http.ResponseWriter, r *http.Request) { 1471 ref := chi.URLParam(r, "ref") 1472 + ref, _ = url.PathUnescape(ref) 1473 1474 user := rp.oauth.GetUser(r) 1475 f, err := rp.repoResolver.Resolve(r) ··· 1758 1759 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 1760 branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 1761 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1762 + log.Println("failed to call XRPC repo.branches", xrpcerr) 1763 + rp.pages.Error503(w) 0 0 0 0 1764 return 1765 } 1766 ··· 1795 } 1796 1797 tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 1798 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1799 + log.Println("failed to call XRPC repo.tags", xrpcerr) 1800 + rp.pages.Error503(w) 0 0 0 0 1801 return 1802 } 1803 ··· 1868 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 1869 1870 branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 1871 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1872 + log.Println("failed to call XRPC repo.branches", xrpcerr) 1873 + rp.pages.Error503(w) 0 0 0 0 1874 return 1875 } 1876 ··· 1882 } 1883 1884 tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 1885 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1886 + log.Println("failed to call XRPC repo.tags", xrpcerr) 1887 + rp.pages.Error503(w) 0 0 0 0 1888 return 1889 } 1890 ··· 1896 } 1897 1898 compareBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, base, head) 1899 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1900 + log.Println("failed to call XRPC repo.compare", xrpcerr) 1901 + rp.pages.Error503(w) 0 0 0 0 1902 return 1903 } 1904

+11 -27

appview/serververify/verify.go

··· 4 "context" 5 "errors" 6 "fmt" 7 - "io" 8 - "net/http" 9 - "strings" 10 - "time" 11 0 0 12 "tangled.sh/tangled.sh/core/appview/db" 0 13 "tangled.sh/tangled.sh/core/rbac" 14 ) 15 ··· 24 scheme = "http" 25 } 26 27 - url := fmt.Sprintf("%s://%s/owner", scheme, domain) 28 - req, err := http.NewRequest("GET", url, nil) 29 - if err != nil { 30 - return "", err 31 - } 32 - 33 - client := &http.Client{ 34 - Timeout: 1 * time.Second, 35 - } 36 - 37 - resp, err := client.Do(req.WithContext(ctx)) 38 - if err != nil || resp.StatusCode != 200 { 39 - return "", fmt.Errorf("failed to fetch /owner") 40 } 41 42 - body, err := io.ReadAll(io.LimitReader(resp.Body, 1024)) // read atmost 1kb of data 43 - if err != nil { 44 - return "", fmt.Errorf("failed to read /owner response: %w", err) 45 } 46 47 - did := strings.TrimSpace(string(body)) 48 - if did == "" { 49 - return "", fmt.Errorf("empty DID in /owner response") 50 - } 51 - 52 - return did, nil 53 } 54 55 type OwnerMismatch struct { ··· 65 func RunVerification(ctx context.Context, domain, expectedOwner string, dev bool) error { 66 observedOwner, err := fetchOwner(ctx, domain, dev) 67 if err != nil { 68 - return fmt.Errorf("%w: %w", FetchError, err) 69 } 70 71 if observedOwner != expectedOwner {

··· 4 "context" 5 "errors" 6 "fmt" 0 0 0 0 7 8 + indigoxrpc "github.com/bluesky-social/indigo/xrpc" 9 + "tangled.sh/tangled.sh/core/api/tangled" 10 "tangled.sh/tangled.sh/core/appview/db" 11 + "tangled.sh/tangled.sh/core/appview/xrpcclient" 12 "tangled.sh/tangled.sh/core/rbac" 13 ) 14 ··· 23 scheme = "http" 24 } 25 26 + host := fmt.Sprintf("%s://%s", scheme, domain) 27 + xrpcc := &indigoxrpc.Client{ 28 + Host: host, 0 0 0 0 0 0 0 0 0 0 29 } 30 31 + res, err := tangled.Owner(ctx, xrpcc) 32 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 33 + return "", xrpcerr 34 } 35 36 + return res.Owner, nil 0 0 0 0 0 37 } 38 39 type OwnerMismatch struct { ··· 49 func RunVerification(ctx context.Context, domain, expectedOwner string, dev bool) error { 50 observedOwner, err := fetchOwner(ctx, domain, dev) 51 if err != nil { 52 + return err 53 } 54 55 if observedOwner != expectedOwner {

+4 -3

appview/spindles/spindles.go

··· 16 "tangled.sh/tangled.sh/core/appview/oauth" 17 "tangled.sh/tangled.sh/core/appview/pages" 18 "tangled.sh/tangled.sh/core/appview/serververify" 0 19 "tangled.sh/tangled.sh/core/idresolver" 20 "tangled.sh/tangled.sh/core/rbac" 21 "tangled.sh/tangled.sh/core/tid" ··· 404 if err != nil { 405 l.Error("verification failed", "err", err) 406 407 - if errors.Is(err, serververify.FetchError) { 408 - s.Pages.Notice(w, noticeId, "Failed to verify knot, unable to fetch owner.") 409 return 410 } 411 ··· 442 } 443 444 w.Header().Set("HX-Reswap", "outerHTML") 445 - s.Pages.SpindleListing(w, pages.SpindleListingParams{verifiedSpindle[0]}) 446 } 447 448 func (s *Spindles) addMember(w http.ResponseWriter, r *http.Request) {

··· 16 "tangled.sh/tangled.sh/core/appview/oauth" 17 "tangled.sh/tangled.sh/core/appview/pages" 18 "tangled.sh/tangled.sh/core/appview/serververify" 19 + "tangled.sh/tangled.sh/core/appview/xrpcclient" 20 "tangled.sh/tangled.sh/core/idresolver" 21 "tangled.sh/tangled.sh/core/rbac" 22 "tangled.sh/tangled.sh/core/tid" ··· 405 if err != nil { 406 l.Error("verification failed", "err", err) 407 408 + if errors.Is(err, xrpcclient.ErrXrpcUnsupported) { 409 + s.Pages.Notice(w, noticeId, "Failed to verify spindle, XRPC queries are unsupported on this spindle, consider upgrading!") 410 return 411 } 412 ··· 443 } 444 445 w.Header().Set("HX-Reswap", "outerHTML") 446 + s.Pages.SpindleListing(w, pages.SpindleListingParams{Spindle: verifiedSpindle[0]}) 447 } 448 449 func (s *Spindles) addMember(w http.ResponseWriter, r *http.Request) {

+14 -13

appview/state/profile.go

··· 17 "github.com/gorilla/feeds" 18 "tangled.sh/tangled.sh/core/api/tangled" 19 "tangled.sh/tangled.sh/core/appview/db" 20 - // "tangled.sh/tangled.sh/core/appview/oauth" 21 "tangled.sh/tangled.sh/core/appview/pages" 22 ) 23 ··· 284 l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle) 285 286 loggedInUser := s.oauth.GetUser(r) 0 0 0 287 288 follows, err := fetchFollows(s.db, profile.UserDid) 289 if err != nil { 290 l.Error("failed to fetch follows", "err", err) 291 - return nil, err 292 } 293 294 if len(follows) == 0 { 295 - return nil, nil 296 } 297 298 followDids := make([]string, 0, len(follows)) ··· 303 profiles, err := db.GetProfiles(s.db, db.FilterIn("did", followDids)) 304 if err != nil { 305 l.Error("failed to get profiles", "followDids", followDids, "err", err) 306 - return nil, err 307 } 308 309 followStatsMap, err := db.GetFollowerFollowingCounts(s.db, followDids) ··· 316 following, err := db.GetFollowing(s.db, loggedInUser.Did) 317 if err != nil { 318 l.Error("failed to get follow list", "err", err, "loggedInUser", loggedInUser.Did) 319 - return nil, err 320 } 321 loggedInUserFollowing = make(map[string]struct{}, len(following)) 322 for _, follow := range following { ··· 350 } 351 } 352 353 - return &FollowsPageParams{ 354 - Follows: followCards, 355 - Card: profile, 356 - }, nil 357 } 358 359 func (s *State) followersPage(w http.ResponseWriter, r *http.Request) { ··· 467 468 func (s *State) addIssueItems(ctx context.Context, feed *feeds.Feed, issues []*db.Issue, author *feeds.Author) error { 469 for _, issue := range issues { 470 - owner, err := s.idResolver.ResolveIdent(ctx, issue.Metadata.Repo.Did) 471 if err != nil { 472 return err 473 } ··· 499 500 func (s *State) createIssueItem(issue *db.Issue, owner *identity.Identity, author *feeds.Author) *feeds.Item { 501 return &feeds.Item{ 502 - Title: fmt.Sprintf("%s created issue '%s' in @%s/%s", author.Name, issue.Title, owner.Handle, issue.Metadata.Repo.Name), 503 - Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s/issues/%d", s.config.Core.AppviewHost, owner.Handle, issue.Metadata.Repo.Name, issue.IssueId), Type: "text/html", Rel: "alternate"}, 504 Created: issue.Created, 505 Author: author, 506 } ··· 701 log.Printf("getting profile data for %s: %s", user.Did, err) 702 } 703 704 - repos, err := db.GetAllReposByDid(s.db, user.Did) 705 if err != nil { 706 log.Printf("getting repos for %s: %s", user.Did, err) 707 }

··· 17 "github.com/gorilla/feeds" 18 "tangled.sh/tangled.sh/core/api/tangled" 19 "tangled.sh/tangled.sh/core/appview/db" 0 20 "tangled.sh/tangled.sh/core/appview/pages" 21 ) 22 ··· 283 l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle) 284 285 loggedInUser := s.oauth.GetUser(r) 286 + params := FollowsPageParams{ 287 + Card: profile, 288 + } 289 290 follows, err := fetchFollows(s.db, profile.UserDid) 291 if err != nil { 292 l.Error("failed to fetch follows", "err", err) 293 + return &params, err 294 } 295 296 if len(follows) == 0 { 297 + return &params, nil 298 } 299 300 followDids := make([]string, 0, len(follows)) ··· 305 profiles, err := db.GetProfiles(s.db, db.FilterIn("did", followDids)) 306 if err != nil { 307 l.Error("failed to get profiles", "followDids", followDids, "err", err) 308 + return &params, err 309 } 310 311 followStatsMap, err := db.GetFollowerFollowingCounts(s.db, followDids) ··· 318 following, err := db.GetFollowing(s.db, loggedInUser.Did) 319 if err != nil { 320 l.Error("failed to get follow list", "err", err, "loggedInUser", loggedInUser.Did) 321 + return &params, err 322 } 323 loggedInUserFollowing = make(map[string]struct{}, len(following)) 324 for _, follow := range following { ··· 352 } 353 } 354 355 + params.Follows = followCards 356 + 357 + return &params, nil 0 358 } 359 360 func (s *State) followersPage(w http.ResponseWriter, r *http.Request) { ··· 468 469 func (s *State) addIssueItems(ctx context.Context, feed *feeds.Feed, issues []*db.Issue, author *feeds.Author) error { 470 for _, issue := range issues { 471 + owner, err := s.idResolver.ResolveIdent(ctx, issue.Repo.Did) 472 if err != nil { 473 return err 474 } ··· 500 501 func (s *State) createIssueItem(issue *db.Issue, owner *identity.Identity, author *feeds.Author) *feeds.Item { 502 return &feeds.Item{ 503 + Title: fmt.Sprintf("%s created issue '%s' in @%s/%s", author.Name, issue.Title, owner.Handle, issue.Repo.Name), 504 + Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s/issues/%d", s.config.Core.AppviewHost, owner.Handle, issue.Repo.Name, issue.IssueId), Type: "text/html", Rel: "alternate"}, 505 Created: issue.Created, 506 Author: author, 507 } ··· 702 log.Printf("getting profile data for %s: %s", user.Did, err) 703 } 704 705 + repos, err := db.GetRepos(s.db, 0, db.FilterEq("did", user.Did)) 706 if err != nil { 707 log.Printf("getting repos for %s: %s", user.Did, err) 708 }

+2 -1

appview/state/router.go

··· 113 114 r.Get("/", s.HomeOrTimeline) 115 r.Get("/timeline", s.Timeline) 0 116 117 r.Route("/repo", func(r chi.Router) { 118 r.Route("/new", func(r chi.Router) { ··· 231 } 232 233 func (s *State) IssuesRouter(mw *middleware.Middleware) http.Handler { 234 - issues := issues.New(s.oauth, s.repoResolver, s.pages, s.idResolver, s.db, s.config, s.notifier) 235 return issues.Router(mw) 236 } 237

··· 113 114 r.Get("/", s.HomeOrTimeline) 115 r.Get("/timeline", s.Timeline) 116 + r.With(middleware.AuthMiddleware(s.oauth)).Get("/upgradeBanner", s.UpgradeBanner) 117 118 r.Route("/repo", func(r chi.Router) { 119 r.Route("/new", func(r chi.Router) { ··· 232 } 233 234 func (s *State) IssuesRouter(mw *middleware.Middleware) http.Handler { 235 + issues := issues.New(s.oauth, s.repoResolver, s.pages, s.idResolver, s.db, s.config, s.notifier, s.validator) 236 return issues.Router(mw) 237 } 238

+46 -6

appview/state/state.go

··· 28 "tangled.sh/tangled.sh/core/appview/pages" 29 posthogService "tangled.sh/tangled.sh/core/appview/posthog" 30 "tangled.sh/tangled.sh/core/appview/reporesolver" 0 31 xrpcclient "tangled.sh/tangled.sh/core/appview/xrpcclient" 32 "tangled.sh/tangled.sh/core/eventconsumer" 33 "tangled.sh/tangled.sh/core/idresolver" ··· 53 knotstream *eventconsumer.Consumer 54 spindlestream *eventconsumer.Consumer 55 logger *slog.Logger 0 56 } 57 58 func Make(ctx context.Context, config *config.Config) (*State, error) { ··· 73 } 74 75 pgs := pages.NewPages(config, res) 76 - 77 cache := cache.New(config.Redis.Addr) 78 sess := session.New(cache) 79 - 80 oauth := oauth.NewOAuth(config, sess) 0 81 82 posthog, err := posthog.NewWithConfig(config.Posthog.ApiKey, posthog.Config{Endpoint: config.Posthog.Endpoint}) 83 if err != nil { ··· 121 IdResolver: res, 122 Config: config, 123 Logger: tlog.New("ingester"), 0 124 } 125 err = jc.StartJetstream(ctx, ingester.Ingest()) 126 if err != nil { ··· 160 knotstream, 161 spindlestream, 162 slog.Default(), 0 163 } 164 165 return state, nil 166 } 167 0 0 0 0 0 168 func (s *State) Favicon(w http.ResponseWriter, r *http.Request) { 169 w.Header().Set("Content-Type", "image/svg+xml") 170 w.Header().Set("Cache-Control", "public, max-age=31536000") // one year ··· 223 }) 224 } 225 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 226 func (s *State) Home(w http.ResponseWriter, r *http.Request) { 227 - timeline, err := db.MakeTimeline(s.db, 15) 228 if err != nil { 229 log.Println(err) 230 s.pages.Notice(w, "timeline", "Uh oh! Failed to load timeline.") ··· 237 s.pages.Notice(w, "topstarredrepos", "Unable to load.") 238 return 239 } 240 - 241 - timeline = timeline[:5] 242 243 s.pages.Home(w, pages.TimelineParams{ 244 LoggedInUser: nil, ··· 275 276 for _, k := range pubKeys { 277 key := strings.TrimRight(k.Key, "\n") 278 - w.Write([]byte(fmt.Sprintln(key))) 279 } 280 } 281

··· 28 "tangled.sh/tangled.sh/core/appview/pages" 29 posthogService "tangled.sh/tangled.sh/core/appview/posthog" 30 "tangled.sh/tangled.sh/core/appview/reporesolver" 31 + "tangled.sh/tangled.sh/core/appview/validator" 32 xrpcclient "tangled.sh/tangled.sh/core/appview/xrpcclient" 33 "tangled.sh/tangled.sh/core/eventconsumer" 34 "tangled.sh/tangled.sh/core/idresolver" ··· 54 knotstream *eventconsumer.Consumer 55 spindlestream *eventconsumer.Consumer 56 logger *slog.Logger 57 + validator *validator.Validator 58 } 59 60 func Make(ctx context.Context, config *config.Config) (*State, error) { ··· 75 } 76 77 pgs := pages.NewPages(config, res) 0 78 cache := cache.New(config.Redis.Addr) 79 sess := session.New(cache) 0 80 oauth := oauth.NewOAuth(config, sess) 81 + validator := validator.New(d) 82 83 posthog, err := posthog.NewWithConfig(config.Posthog.ApiKey, posthog.Config{Endpoint: config.Posthog.Endpoint}) 84 if err != nil { ··· 122 IdResolver: res, 123 Config: config, 124 Logger: tlog.New("ingester"), 125 + Validator: validator, 126 } 127 err = jc.StartJetstream(ctx, ingester.Ingest()) 128 if err != nil { ··· 162 knotstream, 163 spindlestream, 164 slog.Default(), 165 + validator, 166 } 167 168 return state, nil 169 } 170 171 + func (s *State) Close() error { 172 + // other close up logic goes here 173 + return s.db.Close() 174 + } 175 + 176 func (s *State) Favicon(w http.ResponseWriter, r *http.Request) { 177 w.Header().Set("Content-Type", "image/svg+xml") 178 w.Header().Set("Cache-Control", "public, max-age=31536000") // one year ··· 231 }) 232 } 233 234 + func (s *State) UpgradeBanner(w http.ResponseWriter, r *http.Request) { 235 + user := s.oauth.GetUser(r) 236 + l := s.logger.With("handler", "UpgradeBanner") 237 + l = l.With("did", user.Did) 238 + l = l.With("handle", user.Handle) 239 + 240 + regs, err := db.GetRegistrations( 241 + s.db, 242 + db.FilterEq("did", user.Did), 243 + db.FilterEq("needs_upgrade", 1), 244 + ) 245 + if err != nil { 246 + l.Error("non-fatal: failed to get registrations", "err", err) 247 + } 248 + 249 + spindles, err := db.GetSpindles( 250 + s.db, 251 + db.FilterEq("owner", user.Did), 252 + db.FilterEq("needs_upgrade", 1), 253 + ) 254 + if err != nil { 255 + l.Error("non-fatal: failed to get spindles", "err", err) 256 + } 257 + 258 + if regs == nil && spindles == nil { 259 + return 260 + } 261 + 262 + s.pages.UpgradeBanner(w, pages.UpgradeBannerParams{ 263 + Registrations: regs, 264 + Spindles: spindles, 265 + }) 266 + } 267 + 268 func (s *State) Home(w http.ResponseWriter, r *http.Request) { 269 + timeline, err := db.MakeTimeline(s.db, 5) 270 if err != nil { 271 log.Println(err) 272 s.pages.Notice(w, "timeline", "Uh oh! Failed to load timeline.") ··· 279 s.pages.Notice(w, "topstarredrepos", "Unable to load.") 280 return 281 } 0 0 282 283 s.pages.Home(w, pages.TimelineParams{ 284 LoggedInUser: nil, ··· 315 316 for _, k := range pubKeys { 317 key := strings.TrimRight(k.Key, "\n") 318 + fmt.Fprintln(w, key) 319 } 320 } 321

+8

appview/strings/strings.go

··· 12 "tangled.sh/tangled.sh/core/appview/config" 13 "tangled.sh/tangled.sh/core/appview/db" 14 "tangled.sh/tangled.sh/core/appview/middleware" 0 15 "tangled.sh/tangled.sh/core/appview/oauth" 16 "tangled.sh/tangled.sh/core/appview/pages" 17 "tangled.sh/tangled.sh/core/appview/pages/markup" ··· 36 IdResolver *idresolver.Resolver 37 Logger *slog.Logger 38 Knotstream *eventconsumer.Consumer 0 39 } 40 41 func (s *Strings) Router(mw *middleware.Middleware) http.Handler { ··· 284 return 285 } 286 0 0 287 // if that went okay, redir to the string 288 s.Pages.HxRedirect(w, "/strings/"+user.Handle+"/"+entry.Rkey) 289 } ··· 358 return 359 } 360 0 0 361 // successful 362 s.Pages.HxRedirect(w, "/strings/"+user.Handle+"/"+string.Rkey) 363 } ··· 399 fail("Failed to delete string.", err) 400 return 401 } 0 0 402 403 s.Pages.HxRedirect(w, "/strings/"+user.Handle) 404 }

··· 12 "tangled.sh/tangled.sh/core/appview/config" 13 "tangled.sh/tangled.sh/core/appview/db" 14 "tangled.sh/tangled.sh/core/appview/middleware" 15 + "tangled.sh/tangled.sh/core/appview/notify" 16 "tangled.sh/tangled.sh/core/appview/oauth" 17 "tangled.sh/tangled.sh/core/appview/pages" 18 "tangled.sh/tangled.sh/core/appview/pages/markup" ··· 37 IdResolver *idresolver.Resolver 38 Logger *slog.Logger 39 Knotstream *eventconsumer.Consumer 40 + Notifier notify.Notifier 41 } 42 43 func (s *Strings) Router(mw *middleware.Middleware) http.Handler { ··· 286 return 287 } 288 289 + s.Notifier.EditString(r.Context(), &entry) 290 + 291 // if that went okay, redir to the string 292 s.Pages.HxRedirect(w, "/strings/"+user.Handle+"/"+entry.Rkey) 293 } ··· 362 return 363 } 364 365 + s.Notifier.NewString(r.Context(), &string) 366 + 367 // successful 368 s.Pages.HxRedirect(w, "/strings/"+user.Handle+"/"+string.Rkey) 369 } ··· 405 fail("Failed to delete string.", err) 406 return 407 } 408 + 409 + s.Notifier.DeleteString(r.Context(), user.Did, rkey) 410 411 s.Pages.HxRedirect(w, "/strings/"+user.Handle) 412 }

+53

appview/validator/issue.go

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + package validator 2 + 3 + import ( 4 + "fmt" 5 + "strings" 6 + 7 + "tangled.sh/tangled.sh/core/appview/db" 8 + ) 9 + 10 + func (v *Validator) ValidateIssueComment(comment *db.IssueComment) error { 11 + // if comments have parents, only ingest ones that are 1 level deep 12 + if comment.ReplyTo != nil { 13 + parents, err := db.GetIssueComments(v.db, db.FilterEq("at_uri", *comment.ReplyTo)) 14 + if err != nil { 15 + return fmt.Errorf("failed to fetch parent comment: %w", err) 16 + } 17 + if len(parents) != 1 { 18 + return fmt.Errorf("incorrect number of parent comments returned: %d", len(parents)) 19 + } 20 + 21 + // depth check 22 + parent := parents[0] 23 + if parent.ReplyTo != nil { 24 + return fmt.Errorf("incorrect depth, this comment is replying at depth >1") 25 + } 26 + } 27 + 28 + if sb := strings.TrimSpace(v.sanitizer.SanitizeDefault(comment.Body)); sb == "" { 29 + return fmt.Errorf("body is empty after HTML sanitization") 30 + } 31 + 32 + return nil 33 + } 34 + 35 + func (v *Validator) ValidateIssue(issue *db.Issue) error { 36 + if issue.Title == "" { 37 + return fmt.Errorf("issue title is empty") 38 + } 39 + 40 + if issue.Body == "" { 41 + return fmt.Errorf("issue body is empty") 42 + } 43 + 44 + if st := strings.TrimSpace(v.sanitizer.SanitizeDescription(issue.Title)); st == "" { 45 + return fmt.Errorf("title is empty after HTML sanitization") 46 + } 47 + 48 + if sb := strings.TrimSpace(v.sanitizer.SanitizeDefault(issue.Body)); sb == "" { 49 + return fmt.Errorf("body is empty after HTML sanitization") 50 + } 51 + 52 + return nil 53 + }

+18

appview/validator/validator.go

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + package validator 2 + 3 + import ( 4 + "tangled.sh/tangled.sh/core/appview/db" 5 + "tangled.sh/tangled.sh/core/appview/pages/markup" 6 + ) 7 + 8 + type Validator struct { 9 + db *db.DB 10 + sanitizer markup.Sanitizer 11 + } 12 + 13 + func New(db *db.DB) *Validator { 14 + return &Validator{ 15 + db: db, 16 + sanitizer: markup.NewSanitizer(), 17 + } 18 + }

+3

cmd/appview/main.go

··· 23 } 24 25 state, err := state.Make(ctx, c) 0 0 0 26 27 if err != nil { 28 log.Fatal(err)

··· 23 } 24 25 state, err := state.Make(ctx, c) 26 + defer func() { 27 + log.Println(state.Close()) 28 + }() 29 30 if err != nil { 31 log.Fatal(err)

+44

contrib/Tiltfile

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + common_env = { 2 + "TANGLED_VM_SPINDLE_OWNER": os.getenv("TANGLED_VM_SPINDLE_OWNER", default=""), 3 + "TANGLED_VM_KNOT_OWNER": os.getenv("TANGLED_VM_KNOT_OWNER", default=""), 4 + "TANGLED_DB_PATH": os.getenv("TANGLED_DB_PATH", default="dev.db"), 5 + "TANGLED_DEV": os.getenv("TANGLED_DEV", default="true"), 6 + } 7 + 8 + nix_globs = ["nix/**", "flake.nix", "flake.lock"] 9 + 10 + local_resource( 11 + name="appview", 12 + serve_cmd="nix run .#watch-appview", 13 + serve_dir="..", 14 + deps=nix_globs, 15 + env=common_env, 16 + allow_parallel=True, 17 + ) 18 + 19 + local_resource( 20 + name="tailwind", 21 + serve_cmd="nix run .#watch-tailwind", 22 + serve_dir="..", 23 + deps=nix_globs, 24 + env=common_env, 25 + allow_parallel=True, 26 + ) 27 + 28 + local_resource( 29 + name="redis", 30 + serve_cmd="redis-server", 31 + serve_dir="..", 32 + deps=nix_globs, 33 + env=common_env, 34 + allow_parallel=True, 35 + ) 36 + 37 + local_resource( 38 + name="vm", 39 + serve_cmd="nix run --impure .#vm", 40 + serve_dir="..", 41 + deps=nix_globs, 42 + env=common_env, 43 + allow_parallel=True, 44 + )

+16

default.nix

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + # Default setup from https://git.lix.systems/lix-project/flake-compat 2 + let 3 + lockFile = builtins.fromJSON (builtins.readFile ./flake.lock); 4 + flake-compat-node = lockFile.nodes.${lockFile.nodes.root.inputs.flake-compat}; 5 + flake-compat = builtins.fetchTarball { 6 + inherit (flake-compat-node.locked) url; 7 + sha256 = flake-compat-node.locked.narHash; 8 + }; 9 + 10 + flake = ( 11 + import flake-compat { 12 + src = ./.; 13 + } 14 + ); 15 + in 16 + flake.defaultNix

-35

docs/migrations/knot-1.7.0.md

··· 1 - # Upgrading from v1.7.0 2 - 3 - After v1.7.0, knot secrets have been deprecated. You no 4 - longer need a secret from the appview to run a knot. All 5 - authorized commands to knots are managed via [Inter-Service 6 - Authentication](https://atproto.com/specs/xrpc#inter-service-authentication-jwt). 7 - Knots will be read-only until upgraded. 8 - 9 - Upgrading is quite easy, in essence: 10 - 11 - - `KNOT_SERVER_SECRET` is no more, you can remove this 12 - environment variable entirely 13 - - `KNOT_SERVER_OWNER` is now required on boot, set this to 14 - your DID. You can find your DID in the 15 - [settings](https://tangled.sh/settings) page. 16 - - Restart your knot once you have replaced the environment 17 - variable 18 - - Head to the [knot dashboard](https://tangled.sh/knots) and 19 - hit the "retry" button to verify your knot. This simply 20 - writes a `sh.tangled.knot` record to your PDS. 21 - 22 - ## Nix 23 - 24 - If you use the nix module, simply bump the flake to the 25 - latest revision, and change your config block like so: 26 - 27 - ```diff 28 - services.tangled-knot = { 29 - enable = true; 30 - server = { 31 - - secretFile = /path/to/secret; 32 - + owner = "did:plc:foo"; 33 - }; 34 - }; 35 - ```

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

+60

docs/migrations.md

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + # Migrations 2 + 3 + This document is laid out in reverse-chronological order. 4 + Newer migration guides are listed first, and older guides 5 + are further down the page. 6 + 7 + ## Upgrading from v1.8.x 8 + 9 + After v1.8.2, the HTTP API for knot and spindles have been 10 + deprecated and replaced with XRPC. Repositories on outdated 11 + knots will not be viewable from the appview. Upgrading is 12 + straightforward however. 13 + 14 + For knots: 15 + 16 + - Upgrade to latest tag (v1.9.0 or above) 17 + - Head to the [knot dashboard](https://tangled.sh/knots) and 18 + hit the "retry" button to verify your knot 19 + 20 + For spindles: 21 + 22 + - Upgrade to latest tag (v1.9.0 or above) 23 + - Head to the [spindle 24 + dashboard](https://tangled.sh/spindles) and hit the 25 + "retry" button to verify your spindle 26 + 27 + ## Upgrading from v1.7.x 28 + 29 + After v1.7.0, knot secrets have been deprecated. You no 30 + longer need a secret from the appview to run a knot. All 31 + authorized commands to knots are managed via [Inter-Service 32 + Authentication](https://atproto.com/specs/xrpc#inter-service-authentication-jwt). 33 + Knots will be read-only until upgraded. 34 + 35 + Upgrading is quite easy, in essence: 36 + 37 + - `KNOT_SERVER_SECRET` is no more, you can remove this 38 + environment variable entirely 39 + - `KNOT_SERVER_OWNER` is now required on boot, set this to 40 + your DID. You can find your DID in the 41 + [settings](https://tangled.sh/settings) page. 42 + - Restart your knot once you have replaced the environment 43 + variable 44 + - Head to the [knot dashboard](https://tangled.sh/knots) and 45 + hit the "retry" button to verify your knot. This simply 46 + writes a `sh.tangled.knot` record to your PDS. 47 + 48 + If you use the nix module, simply bump the flake to the 49 + latest revision, and change your config block like so: 50 + 51 + ```diff 52 + services.tangled-knot = { 53 + enable = true; 54 + server = { 55 + - secretFile = /path/to/secret; 56 + + owner = "did:plc:foo"; 57 + }; 58 + }; 59 + ``` 60 +

+15

flake.lock

··· 1 { 2 "nodes": { 0 0 0 0 0 0 0 0 0 0 0 0 0 0 3 "flake-utils": { 4 "inputs": { 5 "systems": "systems" ··· 136 }, 137 "root": { 138 "inputs": { 0 139 "gomod2nix": "gomod2nix", 140 "htmx-src": "htmx-src", 141 "htmx-ws-src": "htmx-ws-src",

··· 1 { 2 "nodes": { 3 + "flake-compat": { 4 + "flake": false, 5 + "locked": { 6 + "lastModified": 1751685974, 7 + "narHash": "sha256-NKw96t+BgHIYzHUjkTK95FqYRVKB8DHpVhefWSz/kTw=", 8 + "rev": "549f2762aebeff29a2e5ece7a7dc0f955281a1d1", 9 + "type": "tarball", 10 + "url": "https://git.lix.systems/api/v1/repos/lix-project/flake-compat/archive/549f2762aebeff29a2e5ece7a7dc0f955281a1d1.tar.gz?rev=549f2762aebeff29a2e5ece7a7dc0f955281a1d1" 11 + }, 12 + "original": { 13 + "type": "tarball", 14 + "url": "https://git.lix.systems/lix-project/flake-compat/archive/main.tar.gz" 15 + } 16 + }, 17 "flake-utils": { 18 "inputs": { 19 "systems": "systems" ··· 150 }, 151 "root": { 152 "inputs": { 153 + "flake-compat": "flake-compat", 154 "gomod2nix": "gomod2nix", 155 "htmx-src": "htmx-src", 156 "htmx-ws-src": "htmx-ws-src",

+7 -1

flake.nix

··· 7 url = "github:nix-community/gomod2nix"; 8 inputs.nixpkgs.follows = "nixpkgs"; 9 }; 0 0 0 0 10 indigo = { 11 url = "github:oppiliappan/indigo"; 12 flake = false; ··· 50 inter-fonts-src, 51 sqlite-lib-src, 52 ibm-plex-mono-src, 0 53 }: let 54 supportedSystems = ["x86_64-linux" "x86_64-darwin" "aarch64-linux" "aarch64-darwin"]; 55 forAllSystems = nixpkgs.lib.genAttrs supportedSystems; ··· 146 nativeBuildInputs = [ 147 pkgs.go 148 pkgs.air 0 149 pkgs.gopls 150 pkgs.httpie 151 pkgs.litecli ··· 182 tailwind-watcher = 183 pkgs.writeShellScriptBin "run" 184 '' 185 - ${pkgs.tailwindcss}/bin/tailwindcss -w -i input.css -o ./appview/pages/static/tw.css 186 ''; 187 in { 188 fmt = {

··· 7 url = "github:nix-community/gomod2nix"; 8 inputs.nixpkgs.follows = "nixpkgs"; 9 }; 10 + flake-compat = { 11 + url = "https://git.lix.systems/lix-project/flake-compat/archive/main.tar.gz"; 12 + flake = false; 13 + }; 14 indigo = { 15 url = "github:oppiliappan/indigo"; 16 flake = false; ··· 54 inter-fonts-src, 55 sqlite-lib-src, 56 ibm-plex-mono-src, 57 + ... 58 }: let 59 supportedSystems = ["x86_64-linux" "x86_64-darwin" "aarch64-linux" "aarch64-darwin"]; 60 forAllSystems = nixpkgs.lib.genAttrs supportedSystems; ··· 151 nativeBuildInputs = [ 152 pkgs.go 153 pkgs.air 154 + pkgs.tilt 155 pkgs.gopls 156 pkgs.httpie 157 pkgs.litecli ··· 188 tailwind-watcher = 189 pkgs.writeShellScriptBin "run" 190 '' 191 + ${pkgs.tailwindcss}/bin/tailwindcss --watch=always -i input.css -o ./appview/pages/static/tw.css 192 ''; 193 in { 194 fmt = {

+3 -6

input.css

··· 90 } 91 92 label { 93 - @apply block mb-2 text-gray-900 text-sm font-bold py-2 uppercase dark:text-gray-100; 94 } 95 input { 96 @apply border border-gray-400 block rounded bg-gray-50 focus:ring-black p-3 dark:bg-gray-800 dark:border-gray-600 dark:text-white dark:focus:ring-gray-400; ··· 228 } 229 /* LineHighlight */ 230 .chroma .hl { 231 - background-color: #bcc0cc; 232 } 0 233 /* LineNumbersTable */ 234 .chroma .lnt { 235 white-space: pre; ··· 864 text-decoration: underline; 865 } 866 } 867 - 868 - .chroma .line:has(.ln:target) { 869 - @apply bg-amber-400/30 dark:bg-amber-500/20; 870 - }

··· 90 } 91 92 label { 93 + @apply block text-gray-900 text-sm font-bold py-2 uppercase dark:text-gray-100; 94 } 95 input { 96 @apply border border-gray-400 block rounded bg-gray-50 focus:ring-black p-3 dark:bg-gray-800 dark:border-gray-600 dark:text-white dark:focus:ring-gray-400; ··· 228 } 229 /* LineHighlight */ 230 .chroma .hl { 231 + @apply bg-amber-400/30 dark:bg-amber-500/20; 232 } 233 + 234 /* LineNumbersTable */ 235 .chroma .lnt { 236 white-space: pre; ··· 865 text-decoration: underline; 866 } 867 } 0 0 0 0

+4 -1

knotserver/git/language.go

··· 3 import ( 4 "context" 5 "path" 0 6 7 "github.com/go-enry/go-enry/v2" 8 "github.com/go-git/go-git/v5/plumbing/object" ··· 20 return nil 21 } 22 23 - if enry.IsGenerated(filepath, content) { 0 0 24 return nil 25 } 26

··· 3 import ( 4 "context" 5 "path" 6 + "strings" 7 8 "github.com/go-enry/go-enry/v2" 9 "github.com/go-git/go-git/v5/plumbing/object" ··· 21 return nil 22 } 23 24 + if enry.IsGenerated(filepath, content) || 25 + enry.IsBinary(content) || 26 + strings.HasSuffix(filepath, "bun.lock") { 27 return nil 28 } 29

+1 -60

knotserver/router.go

··· 5 "fmt" 6 "log/slog" 7 "net/http" 8 - "runtime/debug" 9 10 "github.com/go-chi/chi/v5" 11 "tangled.sh/tangled.sh/core/idresolver" ··· 72 w.Write([]byte("This is a knot server. More info at https://tangled.sh")) 73 }) 74 75 - owner := func(w http.ResponseWriter, r *http.Request) { 76 - w.Write([]byte(h.c.Server.Owner)) 77 - } 78 - // Deprecated: the sh.tangled.knot.owner xrpc call should be used instead 79 - r.Get("/owner", owner) 80 - 81 r.Route("/{did}", func(r chi.Router) { 82 r.Route("/{name}", func(r chi.Router) { 83 // routes for git operations ··· 88 }) 89 90 // xrpc apis 91 - r.Route("/xrpc", func(r chi.Router) { 92 - r.Get("/_health", h.Version) 93 - r.Get("/sh.tangled.knot.owner", owner) 94 - r.Mount("/", h.XrpcRouter()) 95 - }) 96 97 // Socket that streams git oplogs 98 r.Get("/events", h.Events) ··· 116 ServiceAuth: serviceAuth, 117 } 118 return xrpc.Router() 119 - } 120 - 121 - // version is set during build time. 122 - var version string 123 - 124 - func (h *Knot) Version(w http.ResponseWriter, r *http.Request) { 125 - if version == "" { 126 - info, ok := debug.ReadBuildInfo() 127 - if !ok { 128 - http.Error(w, "failed to read build info", http.StatusInternalServerError) 129 - return 130 - } 131 - 132 - var modVer string 133 - var sha string 134 - var modified bool 135 - 136 - for _, mod := range info.Deps { 137 - if mod.Path == "tangled.sh/tangled.sh/knotserver" { 138 - modVer = mod.Version 139 - break 140 - } 141 - } 142 - 143 - for _, setting := range info.Settings { 144 - switch setting.Key { 145 - case "vcs.revision": 146 - sha = setting.Value 147 - case "vcs.modified": 148 - modified = setting.Value == "true" 149 - } 150 - } 151 - 152 - if modVer == "" { 153 - modVer = "unknown" 154 - } 155 - 156 - if sha == "" { 157 - version = modVer 158 - } else if modified { 159 - version = fmt.Sprintf("%s (%s with modifications)", modVer, sha) 160 - } else { 161 - version = fmt.Sprintf("%s (%s)", modVer, sha) 162 - } 163 - } 164 - 165 - w.Header().Set("Content-Type", "text/plain; charset=utf-8") 166 - fmt.Fprintf(w, "knotserver/%s", version) 167 } 168 169 func (h *Knot) configureOwner() error {

··· 5 "fmt" 6 "log/slog" 7 "net/http" 0 8 9 "github.com/go-chi/chi/v5" 10 "tangled.sh/tangled.sh/core/idresolver" ··· 71 w.Write([]byte("This is a knot server. More info at https://tangled.sh")) 72 }) 73 0 0 0 0 0 0 74 r.Route("/{did}", func(r chi.Router) { 75 r.Route("/{name}", func(r chi.Router) { 76 // routes for git operations ··· 81 }) 82 83 // xrpc apis 84 + r.Mount("/xrpc", h.XrpcRouter()) 0 0 0 0 85 86 // Socket that streams git oplogs 87 r.Get("/events", h.Events) ··· 105 ServiceAuth: serviceAuth, 106 } 107 return xrpc.Router() 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 108 } 109 110 func (h *Knot) configureOwner() error {

+1 -10

knotserver/xrpc/list_keys.go

··· 1 package xrpc 2 3 import ( 4 - "encoding/json" 5 "net/http" 6 "strconv" 7 ··· 46 response.Cursor = &nextCursor 47 } 48 49 - w.Header().Set("Content-Type", "application/json") 50 - if err := json.NewEncoder(w).Encode(response); err != nil { 51 - x.Logger.Error("failed to encode response", "error", err) 52 - writeError(w, xrpcerr.NewXrpcError( 53 - xrpcerr.WithTag("InternalServerError"), 54 - xrpcerr.WithMessage("failed to encode response"), 55 - ), http.StatusInternalServerError) 56 - return 57 - } 58 }

··· 1 package xrpc 2 3 import ( 0 4 "net/http" 5 "strconv" 6 ··· 45 response.Cursor = &nextCursor 46 } 47 48 + writeJson(w, response) 0 0 0 0 0 0 0 0 49 }

+22

knotserver/xrpc/owner.go

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + package xrpc 2 + 3 + import ( 4 + "net/http" 5 + 6 + "tangled.sh/tangled.sh/core/api/tangled" 7 + xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors" 8 + ) 9 + 10 + func (x *Xrpc) Owner(w http.ResponseWriter, r *http.Request) { 11 + owner := x.Config.Server.Owner 12 + if owner == "" { 13 + writeError(w, xrpcerr.OwnerNotFoundError, http.StatusInternalServerError) 14 + return 15 + } 16 + 17 + response := tangled.Owner_Output{ 18 + Owner: owner, 19 + } 20 + 21 + writeJson(w, response) 22 + }

+8 -7

knotserver/xrpc/repo_archive.go

··· 13 ) 14 15 func (x *Xrpc) RepoArchive(w http.ResponseWriter, r *http.Request) { 16 - repo, repoPath, unescapedRef, err := x.parseStandardParams(r) 0 17 if err != nil { 18 writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest) 19 return 20 } 0 0 0 21 22 format := r.URL.Query().Get("format") 23 if format == "" { ··· 34 return 35 } 36 37 - gr, err := git.Open(repoPath, unescapedRef) 38 if err != nil { 39 - writeError(w, xrpcerr.NewXrpcError( 40 - xrpcerr.WithTag("RefNotFound"), 41 - xrpcerr.WithMessage("repository or ref not found"), 42 - ), http.StatusNotFound) 43 return 44 } 45 46 repoParts := strings.Split(repo, "/") 47 repoName := repoParts[len(repoParts)-1] 48 49 - safeRefFilename := strings.ReplaceAll(plumbing.ReferenceName(unescapedRef).Short(), "/", "-") 50 51 var archivePrefix string 52 if prefix != "" {

··· 13 ) 14 15 func (x *Xrpc) RepoArchive(w http.ResponseWriter, r *http.Request) { 16 + repo := r.URL.Query().Get("repo") 17 + repoPath, err := x.parseRepoParam(repo) 18 if err != nil { 19 writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest) 20 return 21 } 22 + 23 + ref := r.URL.Query().Get("ref") 24 + // ref can be empty (git.Open handles this) 25 26 format := r.URL.Query().Get("format") 27 if format == "" { ··· 38 return 39 } 40 41 + gr, err := git.Open(repoPath, ref) 42 if err != nil { 43 + writeError(w, xrpcerr.RefNotFoundError, http.StatusNotFound) 0 0 0 44 return 45 } 46 47 repoParts := strings.Split(repo, "/") 48 repoName := repoParts[len(repoParts)-1] 49 50 + safeRefFilename := strings.ReplaceAll(plumbing.ReferenceName(ref).Short(), "/", "-") 51 52 var archivePrefix string 53 if prefix != "" {

+8 -15

knotserver/xrpc/repo_blob.go

··· 3 import ( 4 "crypto/sha256" 5 "encoding/base64" 6 - "encoding/json" 7 "fmt" 8 "net/http" 9 "path/filepath" ··· 16 ) 17 18 func (x *Xrpc) RepoBlob(w http.ResponseWriter, r *http.Request) { 19 - _, repoPath, ref, err := x.parseStandardParams(r) 0 20 if err != nil { 21 writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest) 22 return 23 } 24 0 0 0 25 treePath := r.URL.Query().Get("path") 26 if treePath == "" { 27 writeError(w, xrpcerr.NewXrpcError( ··· 35 36 gr, err := git.Open(repoPath, ref) 37 if err != nil { 38 - writeError(w, xrpcerr.NewXrpcError( 39 - xrpcerr.WithTag("RefNotFound"), 40 - xrpcerr.WithMessage("repository or ref not found"), 41 - ), http.StatusNotFound) 42 return 43 } 44 ··· 69 return 70 } 71 w.Header().Set("ETag", eTag) 0 72 73 case strings.HasPrefix(mimeType, "text/"): 74 w.Header().Set("Cache-Control", "public, no-cache") ··· 122 response.MimeType = &mimeType 123 } 124 125 - w.Header().Set("Content-Type", "application/json") 126 - if err := json.NewEncoder(w).Encode(response); err != nil { 127 - x.Logger.Error("failed to encode response", "error", err) 128 - writeError(w, xrpcerr.NewXrpcError( 129 - xrpcerr.WithTag("InternalServerError"), 130 - xrpcerr.WithMessage("failed to encode response"), 131 - ), http.StatusInternalServerError) 132 - return 133 - } 134 } 135 136 // isTextualMimeType returns true if the MIME type represents textual content

··· 3 import ( 4 "crypto/sha256" 5 "encoding/base64" 0 6 "fmt" 7 "net/http" 8 "path/filepath" ··· 15 ) 16 17 func (x *Xrpc) RepoBlob(w http.ResponseWriter, r *http.Request) { 18 + repo := r.URL.Query().Get("repo") 19 + repoPath, err := x.parseRepoParam(repo) 20 if err != nil { 21 writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest) 22 return 23 } 24 25 + ref := r.URL.Query().Get("ref") 26 + // ref can be empty (git.Open handles this) 27 + 28 treePath := r.URL.Query().Get("path") 29 if treePath == "" { 30 writeError(w, xrpcerr.NewXrpcError( ··· 38 39 gr, err := git.Open(repoPath, ref) 40 if err != nil { 41 + writeError(w, xrpcerr.RefNotFoundError, http.StatusNotFound) 0 0 0 42 return 43 } 44 ··· 69 return 70 } 71 w.Header().Set("ETag", eTag) 72 + w.Header().Set("Content-Type", mimeType) 73 74 case strings.HasPrefix(mimeType, "text/"): 75 w.Header().Set("Cache-Control", "public, no-cache") ··· 123 response.MimeType = &mimeType 124 } 125 126 + writeJson(w, response) 0 0 0 0 0 0 0 0 127 } 128 129 // isTextualMimeType returns true if the MIME type represents textual content

+5 -16

knotserver/xrpc/repo_branch.go

··· 1 package xrpc 2 3 import ( 4 - "encoding/json" 5 "net/http" 6 "net/url" 0 7 8 "tangled.sh/tangled.sh/core/api/tangled" 9 "tangled.sh/tangled.sh/core/knotserver/git" ··· 31 32 gr, err := git.PlainOpen(repoPath) 33 if err != nil { 34 - writeError(w, xrpcerr.NewXrpcError( 35 - xrpcerr.WithTag("RepoNotFound"), 36 - xrpcerr.WithMessage("repository not found"), 37 - ), http.StatusNotFound) 38 return 39 } 40 ··· 70 Name: ref.Name().Short(), 71 Hash: ref.Hash().String(), 72 ShortHash: &[]string{ref.Hash().String()[:7]}[0], 73 - When: commit.Author.When.Format("2006-01-02T15:04:05.000Z"), 74 IsDefault: &isDefault, 75 } 76 ··· 81 response.Author = &tangled.RepoBranch_Signature{ 82 Name: commit.Author.Name, 83 Email: commit.Author.Email, 84 - When: commit.Author.When.Format("2006-01-02T15:04:05.000Z"), 85 } 86 87 - w.Header().Set("Content-Type", "application/json") 88 - if err := json.NewEncoder(w).Encode(response); err != nil { 89 - x.Logger.Error("failed to encode response", "error", err) 90 - writeError(w, xrpcerr.NewXrpcError( 91 - xrpcerr.WithTag("InternalServerError"), 92 - xrpcerr.WithMessage("failed to encode response"), 93 - ), http.StatusInternalServerError) 94 - return 95 - } 96 }

··· 1 package xrpc 2 3 import ( 0 4 "net/http" 5 "net/url" 6 + "time" 7 8 "tangled.sh/tangled.sh/core/api/tangled" 9 "tangled.sh/tangled.sh/core/knotserver/git" ··· 31 32 gr, err := git.PlainOpen(repoPath) 33 if err != nil { 34 + writeError(w, xrpcerr.RepoNotFoundError, http.StatusNoContent) 0 0 0 35 return 36 } 37 ··· 67 Name: ref.Name().Short(), 68 Hash: ref.Hash().String(), 69 ShortHash: &[]string{ref.Hash().String()[:7]}[0], 70 + When: commit.Author.When.Format(time.RFC3339), 71 IsDefault: &isDefault, 72 } 73 ··· 78 response.Author = &tangled.RepoBranch_Signature{ 79 Name: commit.Author.Name, 80 Email: commit.Author.Email, 81 + When: commit.Author.When.Format(time.RFC3339), 82 } 83 84 + writeJson(w, response) 0 0 0 0 0 0 0 0 85 }

+11 -25

knotserver/xrpc/repo_branches.go

··· 1 package xrpc 2 3 import ( 4 - "encoding/json" 5 "net/http" 6 "strconv" 7 ··· 20 21 cursor := r.URL.Query().Get("cursor") 22 23 - limit := 50 // default 24 - if limitStr := r.URL.Query().Get("limit"); limitStr != "" { 25 - if l, err := strconv.Atoi(limitStr); err == nil && l > 0 && l <= 100 { 26 - limit = l 27 - } 28 - } 0 0 29 30 gr, err := git.PlainOpen(repoPath) 31 if err != nil { 32 - writeError(w, xrpcerr.NewXrpcError( 33 - xrpcerr.WithTag("RepoNotFound"), 34 - xrpcerr.WithMessage("repository not found"), 35 - ), http.StatusNotFound) 36 return 37 } 38 ··· 45 } 46 } 47 48 - end := offset + limit 49 - if end > len(branches) { 50 - end = len(branches) 51 - } 52 53 paginatedBranches := branches[offset:end] 54 ··· 57 Branches: paginatedBranches, 58 } 59 60 - // Write JSON response directly 61 - w.Header().Set("Content-Type", "application/json") 62 - if err := json.NewEncoder(w).Encode(response); err != nil { 63 - x.Logger.Error("failed to encode response", "error", err) 64 - writeError(w, xrpcerr.NewXrpcError( 65 - xrpcerr.WithTag("InternalServerError"), 66 - xrpcerr.WithMessage("failed to encode response"), 67 - ), http.StatusInternalServerError) 68 - return 69 - } 70 }

··· 1 package xrpc 2 3 import ( 0 4 "net/http" 5 "strconv" 6 ··· 19 20 cursor := r.URL.Query().Get("cursor") 21 22 + // limit := 50 // default 23 + // if limitStr := r.URL.Query().Get("limit"); limitStr != "" { 24 + // if l, err := strconv.Atoi(limitStr); err == nil && l > 0 && l <= 100 { 25 + // limit = l 26 + // } 27 + // } 28 + 29 + limit := 500 30 31 gr, err := git.PlainOpen(repoPath) 32 if err != nil { 33 + writeError(w, xrpcerr.RepoNotFoundError, http.StatusNoContent) 0 0 0 34 return 35 } 36 ··· 43 } 44 } 45 46 + end := min(offset+limit, len(branches)) 0 0 0 47 48 paginatedBranches := branches[offset:end] 49 ··· 52 Branches: paginatedBranches, 53 } 54 55 + writeJson(w, response) 0 0 0 0 0 0 0 0 0 56 }

+7 -23

knotserver/xrpc/repo_compare.go

··· 1 package xrpc 2 3 import ( 4 - "encoding/json" 5 "fmt" 6 "net/http" 7 - "net/url" 8 9 "tangled.sh/tangled.sh/core/knotserver/git" 10 "tangled.sh/tangled.sh/core/types" ··· 19 return 20 } 21 22 - rev1Param := r.URL.Query().Get("rev1") 23 - if rev1Param == "" { 24 writeError(w, xrpcerr.NewXrpcError( 25 xrpcerr.WithTag("InvalidRequest"), 26 xrpcerr.WithMessage("missing rev1 parameter"), ··· 28 return 29 } 30 31 - rev2Param := r.URL.Query().Get("rev2") 32 - if rev2Param == "" { 33 writeError(w, xrpcerr.NewXrpcError( 34 xrpcerr.WithTag("InvalidRequest"), 35 xrpcerr.WithMessage("missing rev2 parameter"), ··· 37 return 38 } 39 40 - rev1, _ := url.PathUnescape(rev1Param) 41 - rev2, _ := url.PathUnescape(rev2Param) 42 - 43 gr, err := git.PlainOpen(repoPath) 44 if err != nil { 45 - writeError(w, xrpcerr.NewXrpcError( 46 - xrpcerr.WithTag("RepoNotFound"), 47 - xrpcerr.WithMessage("repository not found"), 48 - ), http.StatusNotFound) 49 return 50 } 51 ··· 79 return 80 } 81 82 - resp := types.RepoFormatPatchResponse{ 83 Rev1: commit1.Hash.String(), 84 Rev2: commit2.Hash.String(), 85 FormatPatch: formatPatch, 86 Patch: rawPatch, 87 } 88 89 - w.Header().Set("Content-Type", "application/json") 90 - if err := json.NewEncoder(w).Encode(resp); err != nil { 91 - x.Logger.Error("failed to encode response", "error", err) 92 - writeError(w, xrpcerr.NewXrpcError( 93 - xrpcerr.WithTag("InternalServerError"), 94 - xrpcerr.WithMessage("failed to encode response"), 95 - ), http.StatusInternalServerError) 96 - return 97 - } 98 }

··· 1 package xrpc 2 3 import ( 0 4 "fmt" 5 "net/http" 0 6 7 "tangled.sh/tangled.sh/core/knotserver/git" 8 "tangled.sh/tangled.sh/core/types" ··· 17 return 18 } 19 20 + rev1 := r.URL.Query().Get("rev1") 21 + if rev1 == "" { 22 writeError(w, xrpcerr.NewXrpcError( 23 xrpcerr.WithTag("InvalidRequest"), 24 xrpcerr.WithMessage("missing rev1 parameter"), ··· 26 return 27 } 28 29 + rev2 := r.URL.Query().Get("rev2") 30 + if rev2 == "" { 31 writeError(w, xrpcerr.NewXrpcError( 32 xrpcerr.WithTag("InvalidRequest"), 33 xrpcerr.WithMessage("missing rev2 parameter"), ··· 35 return 36 } 37 0 0 0 38 gr, err := git.PlainOpen(repoPath) 39 if err != nil { 40 + writeError(w, xrpcerr.RepoNotFoundError, http.StatusNoContent) 0 0 0 41 return 42 } 43 ··· 71 return 72 } 73 74 + response := types.RepoFormatPatchResponse{ 75 Rev1: commit1.Hash.String(), 76 Rev2: commit2.Hash.String(), 77 FormatPatch: formatPatch, 78 Patch: rawPatch, 79 } 80 81 + writeJson(w, response) 0 0 0 0 0 0 0 0 82 }

+6 -30

knotserver/xrpc/repo_diff.go

··· 1 package xrpc 2 3 import ( 4 - "encoding/json" 5 "net/http" 6 - "net/url" 7 8 "tangled.sh/tangled.sh/core/knotserver/git" 9 "tangled.sh/tangled.sh/core/types" ··· 18 return 19 } 20 21 - refParam := r.URL.Query().Get("ref") 22 - if refParam == "" { 23 - writeError(w, xrpcerr.NewXrpcError( 24 - xrpcerr.WithTag("InvalidRequest"), 25 - xrpcerr.WithMessage("missing ref parameter"), 26 - ), http.StatusBadRequest) 27 - return 28 - } 29 - 30 - ref, _ := url.QueryUnescape(refParam) 31 32 gr, err := git.Open(repoPath, ref) 33 if err != nil { 34 - writeError(w, xrpcerr.NewXrpcError( 35 - xrpcerr.WithTag("RefNotFound"), 36 - xrpcerr.WithMessage("repository or ref not found"), 37 - ), http.StatusNotFound) 38 return 39 } 40 41 diff, err := gr.Diff() 42 if err != nil { 43 x.Logger.Error("getting diff", "error", err.Error()) 44 - writeError(w, xrpcerr.NewXrpcError( 45 - xrpcerr.WithTag("RefNotFound"), 46 - xrpcerr.WithMessage("failed to generate diff"), 47 - ), http.StatusInternalServerError) 48 return 49 } 50 51 - resp := types.RepoCommitResponse{ 52 Ref: ref, 53 Diff: diff, 54 } 55 56 - w.Header().Set("Content-Type", "application/json") 57 - if err := json.NewEncoder(w).Encode(resp); err != nil { 58 - x.Logger.Error("failed to encode response", "error", err) 59 - writeError(w, xrpcerr.NewXrpcError( 60 - xrpcerr.WithTag("InternalServerError"), 61 - xrpcerr.WithMessage("failed to encode response"), 62 - ), http.StatusInternalServerError) 63 - return 64 - } 65 }

··· 1 package xrpc 2 3 import ( 0 4 "net/http" 0 5 6 "tangled.sh/tangled.sh/core/knotserver/git" 7 "tangled.sh/tangled.sh/core/types" ··· 16 return 17 } 18 19 + ref := r.URL.Query().Get("ref") 20 + // ref can be empty (git.Open handles this) 0 0 0 0 0 0 0 0 21 22 gr, err := git.Open(repoPath, ref) 23 if err != nil { 24 + writeError(w, xrpcerr.RefNotFoundError, http.StatusNotFound) 0 0 0 25 return 26 } 27 28 diff, err := gr.Diff() 29 if err != nil { 30 x.Logger.Error("getting diff", "error", err.Error()) 31 + writeError(w, xrpcerr.RefNotFoundError, http.StatusInternalServerError) 0 0 0 32 return 33 } 34 35 + response := types.RepoCommitResponse{ 36 Ref: ref, 37 Diff: diff, 38 } 39 40 + writeJson(w, response) 0 0 0 0 0 0 0 0 41 }

+4 -19

knotserver/xrpc/repo_get_default_branch.go

··· 1 package xrpc 2 3 import ( 4 - "encoding/json" 5 "net/http" 0 6 7 "tangled.sh/tangled.sh/core/api/tangled" 8 "tangled.sh/tangled.sh/core/knotserver/git" ··· 17 return 18 } 19 20 - gr, err := git.Open(repoPath, "") 21 - if err != nil { 22 - writeError(w, xrpcerr.NewXrpcError( 23 - xrpcerr.WithTag("RepoNotFound"), 24 - xrpcerr.WithMessage("repository not found"), 25 - ), http.StatusNotFound) 26 - return 27 - } 28 29 branch, err := gr.FindMainBranch() 30 if err != nil { ··· 39 response := tangled.RepoGetDefaultBranch_Output{ 40 Name: branch, 41 Hash: "", 42 - When: "1970-01-01T00:00:00.000Z", 43 } 44 45 - w.Header().Set("Content-Type", "application/json") 46 - if err := json.NewEncoder(w).Encode(response); err != nil { 47 - x.Logger.Error("failed to encode response", "error", err) 48 - writeError(w, xrpcerr.NewXrpcError( 49 - xrpcerr.WithTag("InternalServerError"), 50 - xrpcerr.WithMessage("failed to encode response"), 51 - ), http.StatusInternalServerError) 52 - return 53 - } 54 }

··· 1 package xrpc 2 3 import ( 0 4 "net/http" 5 + "time" 6 7 "tangled.sh/tangled.sh/core/api/tangled" 8 "tangled.sh/tangled.sh/core/knotserver/git" ··· 17 return 18 } 19 20 + gr, err := git.PlainOpen(repoPath) 0 0 0 0 0 0 0 21 22 branch, err := gr.FindMainBranch() 23 if err != nil { ··· 32 response := tangled.RepoGetDefaultBranch_Output{ 33 Name: branch, 34 Hash: "", 35 + When: time.UnixMicro(0).Format(time.RFC3339), 36 } 37 38 + writeJson(w, response) 0 0 0 0 0 0 0 0 39 }

+4 -21

knotserver/xrpc/repo_languages.go

··· 2 3 import ( 4 "context" 5 - "encoding/json" 6 "math" 7 "net/http" 8 - "net/url" 9 "time" 10 11 "tangled.sh/tangled.sh/core/api/tangled" ··· 14 ) 15 16 func (x *Xrpc) RepoLanguages(w http.ResponseWriter, r *http.Request) { 17 - refParam := r.URL.Query().Get("ref") 18 - if refParam == "" { 19 - refParam = "HEAD" // default 20 - } 21 - ref, _ := url.PathUnescape(refParam) 22 - 23 repo := r.URL.Query().Get("repo") 24 repoPath, err := x.parseRepoParam(repo) 25 if err != nil { ··· 27 return 28 } 29 0 0 30 gr, err := git.Open(repoPath, ref) 31 if err != nil { 32 x.Logger.Error("opening repo", "error", err.Error()) 33 - writeError(w, xrpcerr.NewXrpcError( 34 - xrpcerr.WithTag("RefNotFound"), 35 - xrpcerr.WithMessage("repository or ref not found"), 36 - ), http.StatusNotFound) 37 return 38 } 39 ··· 81 response.TotalFiles = &totalFiles 82 } 83 84 - w.Header().Set("Content-Type", "application/json") 85 - if err := json.NewEncoder(w).Encode(response); err != nil { 86 - x.Logger.Error("failed to encode response", "error", err) 87 - writeError(w, xrpcerr.NewXrpcError( 88 - xrpcerr.WithTag("InternalServerError"), 89 - xrpcerr.WithMessage("failed to encode response"), 90 - ), http.StatusInternalServerError) 91 - return 92 - } 93 }

··· 2 3 import ( 4 "context" 0 5 "math" 6 "net/http" 0 7 "time" 8 9 "tangled.sh/tangled.sh/core/api/tangled" ··· 12 ) 13 14 func (x *Xrpc) RepoLanguages(w http.ResponseWriter, r *http.Request) { 0 0 0 0 0 0 15 repo := r.URL.Query().Get("repo") 16 repoPath, err := x.parseRepoParam(repo) 17 if err != nil { ··· 19 return 20 } 21 22 + ref := r.URL.Query().Get("ref") 23 + 24 gr, err := git.Open(repoPath, ref) 25 if err != nil { 26 x.Logger.Error("opening repo", "error", err.Error()) 27 + writeError(w, xrpcerr.RefNotFoundError, http.StatusNotFound) 0 0 0 28 return 29 } 30 ··· 72 response.TotalFiles = &totalFiles 73 } 74 75 + writeJson(w, response) 0 0 0 0 0 0 0 0 76 }

+14 -34

knotserver/xrpc/repo_log.go

··· 1 package xrpc 2 3 import ( 4 - "encoding/json" 5 "net/http" 6 - "net/url" 7 "strconv" 8 9 "tangled.sh/tangled.sh/core/knotserver/git" ··· 19 return 20 } 21 22 - refParam := r.URL.Query().Get("ref") 23 - if refParam == "" { 24 - writeError(w, xrpcerr.NewXrpcError( 25 - xrpcerr.WithTag("InvalidRequest"), 26 - xrpcerr.WithMessage("missing ref parameter"), 27 - ), http.StatusBadRequest) 28 - return 29 - } 30 31 path := r.URL.Query().Get("path") 32 cursor := r.URL.Query().Get("cursor") ··· 38 } 39 } 40 41 - ref, err := url.QueryUnescape(refParam) 42 - if err != nil { 43 - writeError(w, xrpcerr.NewXrpcError( 44 - xrpcerr.WithTag("InvalidRequest"), 45 - xrpcerr.WithMessage("invalid ref parameter"), 46 - ), http.StatusBadRequest) 47 - return 48 - } 49 - 50 gr, err := git.Open(repoPath, ref) 51 if err != nil { 52 - writeError(w, xrpcerr.NewXrpcError( 53 - xrpcerr.WithTag("RefNotFound"), 54 - xrpcerr.WithMessage("repository or ref not found"), 55 - ), http.StatusNotFound) 56 return 57 } 58 ··· 73 return 74 } 75 0 0 0 0 0 0 0 0 0 0 76 // Create response using existing types.RepoLogResponse 77 response := types.RepoLogResponse{ 78 Commits: commits, 79 Ref: ref, 80 Page: (offset / limit) + 1, 81 PerPage: limit, 82 - Total: len(commits), // This is not accurate for pagination, but matches existing behavior 83 } 84 85 if path != "" { ··· 88 89 response.Log = true 90 91 - // Write JSON response directly 92 - w.Header().Set("Content-Type", "application/json") 93 - if err := json.NewEncoder(w).Encode(response); err != nil { 94 - x.Logger.Error("failed to encode response", "error", err) 95 - writeError(w, xrpcerr.NewXrpcError( 96 - xrpcerr.WithTag("InternalServerError"), 97 - xrpcerr.WithMessage("failed to encode response"), 98 - ), http.StatusInternalServerError) 99 - return 100 - } 101 }

··· 1 package xrpc 2 3 import ( 0 4 "net/http" 0 5 "strconv" 6 7 "tangled.sh/tangled.sh/core/knotserver/git" ··· 17 return 18 } 19 20 + ref := r.URL.Query().Get("ref") 0 0 0 0 0 0 0 21 22 path := r.URL.Query().Get("path") 23 cursor := r.URL.Query().Get("cursor") ··· 29 } 30 } 31 0 0 0 0 0 0 0 0 0 32 gr, err := git.Open(repoPath, ref) 33 if err != nil { 34 + writeError(w, xrpcerr.RefNotFoundError, http.StatusNotFound) 0 0 0 35 return 36 } 37 ··· 52 return 53 } 54 55 + total, err := gr.TotalCommits() 56 + if err != nil { 57 + x.Logger.Error("fetching total commits", "error", err.Error()) 58 + writeError(w, xrpcerr.NewXrpcError( 59 + xrpcerr.WithTag("InternalServerError"), 60 + xrpcerr.WithMessage("failed to fetch total commits"), 61 + ), http.StatusNotFound) 62 + return 63 + } 64 + 65 // Create response using existing types.RepoLogResponse 66 response := types.RepoLogResponse{ 67 Commits: commits, 68 Ref: ref, 69 Page: (offset / limit) + 1, 70 PerPage: limit, 71 + Total: total, 72 } 73 74 if path != "" { ··· 77 78 response.Log = true 79 80 + writeJson(w, response) 0 0 0 0 0 0 0 0 0 81 }

+3 -16

knotserver/xrpc/repo_tags.go

··· 1 package xrpc 2 3 import ( 4 - "encoding/json" 5 "net/http" 6 "strconv" 7 ··· 30 } 31 } 32 33 - gr, err := git.Open(repoPath, "") 34 if err != nil { 35 x.Logger.Error("failed to open", "error", err) 36 - writeError(w, xrpcerr.NewXrpcError( 37 - xrpcerr.WithTag("RepoNotFound"), 38 - xrpcerr.WithMessage("repository not found"), 39 - ), http.StatusNotFound) 40 return 41 } 42 ··· 86 Tags: paginatedTags, 87 } 88 89 - // Write JSON response directly 90 - w.Header().Set("Content-Type", "application/json") 91 - if err := json.NewEncoder(w).Encode(response); err != nil { 92 - x.Logger.Error("failed to encode response", "error", err) 93 - writeError(w, xrpcerr.NewXrpcError( 94 - xrpcerr.WithTag("InternalServerError"), 95 - xrpcerr.WithMessage("failed to encode response"), 96 - ), http.StatusInternalServerError) 97 - return 98 - } 99 }

··· 1 package xrpc 2 3 import ( 0 4 "net/http" 5 "strconv" 6 ··· 29 } 30 } 31 32 + gr, err := git.PlainOpen(repoPath) 33 if err != nil { 34 x.Logger.Error("failed to open", "error", err) 35 + writeError(w, xrpcerr.RepoNotFoundError, http.StatusNoContent) 0 0 0 36 return 37 } 38 ··· 82 Tags: paginatedTags, 83 } 84 85 + writeJson(w, response) 0 0 0 0 0 0 0 0 0 86 }

+6 -33

knotserver/xrpc/repo_tree.go

··· 1 package xrpc 2 3 import ( 4 - "encoding/json" 5 "net/http" 6 - "net/url" 7 "path/filepath" 0 8 9 "tangled.sh/tangled.sh/core/api/tangled" 10 "tangled.sh/tangled.sh/core/knotserver/git" ··· 21 return 22 } 23 24 - refParam := r.URL.Query().Get("ref") 25 - if refParam == "" { 26 - writeError(w, xrpcerr.NewXrpcError( 27 - xrpcerr.WithTag("InvalidRequest"), 28 - xrpcerr.WithMessage("missing ref parameter"), 29 - ), http.StatusBadRequest) 30 - return 31 - } 32 33 path := r.URL.Query().Get("path") 34 // path can be empty (defaults to root) 35 36 - ref, err := url.QueryUnescape(refParam) 37 - if err != nil { 38 - writeError(w, xrpcerr.NewXrpcError( 39 - xrpcerr.WithTag("InvalidRequest"), 40 - xrpcerr.WithMessage("invalid ref parameter"), 41 - ), http.StatusBadRequest) 42 - return 43 - } 44 - 45 gr, err := git.Open(repoPath, ref) 46 if err != nil { 47 x.Logger.Error("failed to open git repository", "error", err, "path", repoPath, "ref", ref) 48 - writeError(w, xrpcerr.NewXrpcError( 49 - xrpcerr.WithTag("RefNotFound"), 50 - xrpcerr.WithMessage("repository or ref not found"), 51 - ), http.StatusNotFound) 52 return 53 } 54 ··· 77 entry.Last_commit = &tangled.RepoTree_LastCommit{ 78 Hash: file.LastCommit.Hash.String(), 79 Message: file.LastCommit.Message, 80 - When: file.LastCommit.When.Format("2006-01-02T15:04:05.000Z"), 81 } 82 } 83 ··· 104 Files: treeEntries, 105 } 106 107 - w.Header().Set("Content-Type", "application/json") 108 - if err := json.NewEncoder(w).Encode(response); err != nil { 109 - x.Logger.Error("failed to encode response", "error", err) 110 - writeError(w, xrpcerr.NewXrpcError( 111 - xrpcerr.WithTag("InternalServerError"), 112 - xrpcerr.WithMessage("failed to encode response"), 113 - ), http.StatusInternalServerError) 114 - return 115 - } 116 }

··· 1 package xrpc 2 3 import ( 0 4 "net/http" 0 5 "path/filepath" 6 + "time" 7 8 "tangled.sh/tangled.sh/core/api/tangled" 9 "tangled.sh/tangled.sh/core/knotserver/git" ··· 20 return 21 } 22 23 + ref := r.URL.Query().Get("ref") 24 + // ref can be empty (git.Open handles this) 0 0 0 0 0 0 25 26 path := r.URL.Query().Get("path") 27 // path can be empty (defaults to root) 28 0 0 0 0 0 0 0 0 0 29 gr, err := git.Open(repoPath, ref) 30 if err != nil { 31 x.Logger.Error("failed to open git repository", "error", err, "path", repoPath, "ref", ref) 32 + writeError(w, xrpcerr.RefNotFoundError, http.StatusNotFound) 0 0 0 33 return 34 } 35 ··· 58 entry.Last_commit = &tangled.RepoTree_LastCommit{ 59 Hash: file.LastCommit.Hash.String(), 60 Message: file.LastCommit.Message, 61 + When: file.LastCommit.When.Format(time.RFC3339), 62 } 63 } 64 ··· 85 Files: treeEntries, 86 } 87 88 + writeJson(w, response) 0 0 0 0 0 0 0 0 89 }

+60

knotserver/xrpc/version.go

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + package xrpc 2 + 3 + import ( 4 + "fmt" 5 + "net/http" 6 + "runtime/debug" 7 + 8 + "tangled.sh/tangled.sh/core/api/tangled" 9 + ) 10 + 11 + // version is set during build time. 12 + var version string 13 + 14 + func (x *Xrpc) Version(w http.ResponseWriter, r *http.Request) { 15 + if version == "" { 16 + info, ok := debug.ReadBuildInfo() 17 + if !ok { 18 + http.Error(w, "failed to read build info", http.StatusInternalServerError) 19 + return 20 + } 21 + 22 + var modVer string 23 + var sha string 24 + var modified bool 25 + 26 + for _, mod := range info.Deps { 27 + if mod.Path == "tangled.sh/tangled.sh/knotserver/xrpc" { 28 + modVer = mod.Version 29 + break 30 + } 31 + } 32 + 33 + for _, setting := range info.Settings { 34 + switch setting.Key { 35 + case "vcs.revision": 36 + sha = setting.Value 37 + case "vcs.modified": 38 + modified = setting.Value == "true" 39 + } 40 + } 41 + 42 + if modVer == "" { 43 + modVer = "unknown" 44 + } 45 + 46 + if sha == "" { 47 + version = modVer 48 + } else if modified { 49 + version = fmt.Sprintf("%s (%s with modifications)", modVer, sha) 50 + } else { 51 + version = fmt.Sprintf("%s (%s)", modVer, sha) 52 + } 53 + } 54 + 55 + response := tangled.KnotVersion_Output{ 56 + Version: version, 57 + } 58 + 59 + writeJson(w, response) 60 + }

+18 -35

knotserver/xrpc/xrpc.go

··· 4 "encoding/json" 5 "log/slog" 6 "net/http" 7 - "net/url" 8 "strings" 9 10 securejoin "github.com/cyphar/filepath-securejoin" ··· 69 70 // knot query endpoints (no auth required) 71 r.Get("/"+tangled.KnotListKeysNSID, x.ListKeys) 0 0 0 0 72 73 return r 74 } ··· 84 } 85 86 // Parse repo string (did/repoName format) 87 - parts := strings.Split(repo, "/") 88 - if len(parts) < 2 { 89 return "", xrpcerr.NewXrpcError( 90 xrpcerr.WithTag("InvalidRequest"), 91 xrpcerr.WithMessage("invalid repo format, expected 'did/repoName'"), 92 ) 93 } 94 95 - did := strings.Join(parts[:len(parts)-1], "/") 96 - repoName := parts[len(parts)-1] 97 98 // Construct repository path using the same logic as didPath 99 didRepoPath, err := securejoin.SecureJoin(did, repoName) 100 if err != nil { 101 - return "", xrpcerr.NewXrpcError( 102 - xrpcerr.WithTag("RepoNotFound"), 103 - xrpcerr.WithMessage("failed to access repository"), 104 - ) 105 } 106 107 repoPath, err := securejoin.SecureJoin(x.Config.Repo.ScanPath, didRepoPath) 108 if err != nil { 109 - return "", xrpcerr.NewXrpcError( 110 - xrpcerr.WithTag("RepoNotFound"), 111 - xrpcerr.WithMessage("failed to access repository"), 112 - ) 113 } 114 115 return repoPath, nil 116 } 117 118 - // parseStandardParams parses common query parameters used by most handlers 119 - func (x *Xrpc) parseStandardParams(r *http.Request) (repo, repoPath, ref string, err error) { 120 - // Parse repo parameter 121 - repo = r.URL.Query().Get("repo") 122 - repoPath, err = x.parseRepoParam(repo) 123 - if err != nil { 124 - return "", "", "", err 125 - } 126 - 127 - // Parse and unescape ref parameter 128 - refParam := r.URL.Query().Get("ref") 129 - if refParam == "" { 130 - return "", "", "", xrpcerr.NewXrpcError( 131 - xrpcerr.WithTag("InvalidRequest"), 132 - xrpcerr.WithMessage("missing ref parameter"), 133 - ) 134 - } 135 - 136 - ref, _ = url.QueryUnescape(refParam) 137 - return repo, repoPath, ref, nil 138 - } 139 - 140 func writeError(w http.ResponseWriter, e xrpcerr.XrpcError, status int) { 141 w.Header().Set("Content-Type", "application/json") 142 w.WriteHeader(status) 143 json.NewEncoder(w).Encode(e) 144 } 0 0 0 0 0 0 0 0

··· 4 "encoding/json" 5 "log/slog" 6 "net/http" 0 7 "strings" 8 9 securejoin "github.com/cyphar/filepath-securejoin" ··· 68 69 // knot query endpoints (no auth required) 70 r.Get("/"+tangled.KnotListKeysNSID, x.ListKeys) 71 + r.Get("/"+tangled.KnotVersionNSID, x.Version) 72 + 73 + // service query endpoints (no auth required) 74 + r.Get("/"+tangled.OwnerNSID, x.Owner) 75 76 return r 77 } ··· 87 } 88 89 // Parse repo string (did/repoName format) 90 + parts := strings.SplitN(repo, "/", 2) 91 + if len(parts) != 2 { 92 return "", xrpcerr.NewXrpcError( 93 xrpcerr.WithTag("InvalidRequest"), 94 xrpcerr.WithMessage("invalid repo format, expected 'did/repoName'"), 95 ) 96 } 97 98 + did := parts[0] 99 + repoName := parts[1] 100 101 // Construct repository path using the same logic as didPath 102 didRepoPath, err := securejoin.SecureJoin(did, repoName) 103 if err != nil { 104 + return "", xrpcerr.RepoNotFoundError 0 0 0 105 } 106 107 repoPath, err := securejoin.SecureJoin(x.Config.Repo.ScanPath, didRepoPath) 108 if err != nil { 109 + return "", xrpcerr.RepoNotFoundError 0 0 0 110 } 111 112 return repoPath, nil 113 } 114 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 115 func writeError(w http.ResponseWriter, e xrpcerr.XrpcError, status int) { 116 w.Header().Set("Content-Type", "application/json") 117 w.WriteHeader(status) 118 json.NewEncoder(w).Encode(e) 119 } 120 + 121 + func writeJson(w http.ResponseWriter, response any) { 122 + w.Header().Set("Content-Type", "application/json") 123 + if err := json.NewEncoder(w).Encode(response); err != nil { 124 + writeError(w, xrpcerr.GenericError(err), http.StatusInternalServerError) 125 + return 126 + } 127 + }

+9 -9

lexicons/issue/comment.json

··· 9 "key": "tid", 10 "record": { 11 "type": "object", 12 - "required": ["issue", "body", "createdAt"], 0 0 0 0 13 "properties": { 14 "issue": { 15 "type": "string", 16 "format": "at-uri" 17 }, 18 - "repo": { 19 - "type": "string", 20 - "format": "at-uri" 21 - }, 22 - "owner": { 23 - "type": "string", 24 - "format": "did" 25 - }, 26 "body": { 27 "type": "string" 28 }, 29 "createdAt": { 30 "type": "string", 31 "format": "datetime" 0 0 0 0 32 } 33 } 34 }

··· 9 "key": "tid", 10 "record": { 11 "type": "object", 12 + "required": [ 13 + "issue", 14 + "body", 15 + "createdAt" 16 + ], 17 "properties": { 18 "issue": { 19 "type": "string", 20 "format": "at-uri" 21 }, 0 0 0 0 0 0 0 0 22 "body": { 23 "type": "string" 24 }, 25 "createdAt": { 26 "type": "string", 27 "format": "datetime" 28 + }, 29 + "replyTo": { 30 + "type": "string", 31 + "format": "at-uri" 32 } 33 } 34 }

+25

lexicons/knot/version.json

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + { 2 + "lexicon": 1, 3 + "id": "sh.tangled.knot.version", 4 + "defs": { 5 + "main": { 6 + "type": "query", 7 + "description": "Get the version of a knot", 8 + "output": { 9 + "encoding": "application/json", 10 + "schema": { 11 + "type": "object", 12 + "required": [ 13 + "version" 14 + ], 15 + "properties": { 16 + "version": { 17 + "type": "string" 18 + } 19 + } 20 + } 21 + }, 22 + "errors": [] 23 + } 24 + } 25 + }

+31

lexicons/owner.json

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + { 2 + "lexicon": 1, 3 + "id": "sh.tangled.owner", 4 + "defs": { 5 + "main": { 6 + "type": "query", 7 + "description": "Get the owner of a service", 8 + "output": { 9 + "encoding": "application/json", 10 + "schema": { 11 + "type": "object", 12 + "required": [ 13 + "owner" 14 + ], 15 + "properties": { 16 + "owner": { 17 + "type": "string", 18 + "format": "did" 19 + } 20 + } 21 + } 22 + }, 23 + "errors": [ 24 + { 25 + "name": "OwnerNotFound", 26 + "description": "Owner is not set for this service" 27 + } 28 + ] 29 + } 30 + } 31 + }

-1

lexicons/repo/repo.json

··· 34 }, 35 "description": { 36 "type": "string", 37 - "format": "datetime", 38 "minGraphemes": 1, 39 "maxGraphemes": 140 40 },

··· 34 }, 35 "description": { 36 "type": "string", 0 37 "minGraphemes": 1, 38 "maxGraphemes": 140 39 },

+8 -2

nix/gomod2nix.toml

··· 425 [mod."github.com/whyrusleeping/cbor-gen"] 426 version = "v0.3.1" 427 hash = "sha256-PAd8M2Z8t6rVRBII+Rg8Bz+QaJIwbW64bfyqsv31kgc=" 0 0 0 0 0 0 428 [mod."github.com/yuin/goldmark"] 429 - version = "v1.4.15" 430 - hash = "sha256-MvSOT6dwf5hVYkIg4MnqMpsy5ZtWZ7amAE7Zo9HkEa0=" 431 [mod."github.com/yuin/goldmark-highlighting/v2"] 432 version = "v2.0.0-20230729083705-37449abec8cc" 433 hash = "sha256-HpiwU7jIeDUAg2zOpTIiviQir8dpRPuXYh2nqFFccpg="

··· 425 [mod."github.com/whyrusleeping/cbor-gen"] 426 version = "v0.3.1" 427 hash = "sha256-PAd8M2Z8t6rVRBII+Rg8Bz+QaJIwbW64bfyqsv31kgc=" 428 + [mod."github.com/wyatt915/goldmark-treeblood"] 429 + version = "v0.0.0-20250825231212-5dcbdb2f4b57" 430 + hash = "sha256-IZEsUXTBTsNgWoD7vqRUc9aFCCHNjzk1IUmI9O+NCnM=" 431 + [mod."github.com/wyatt915/treeblood"] 432 + version = "v0.1.15" 433 + hash = "sha256-hb99exdkoY2Qv8WdDxhwgPXGbEYimUr6wFtPXEvcO9g=" 434 [mod."github.com/yuin/goldmark"] 435 + version = "v1.7.12" 436 + hash = "sha256-thLYBS4woL2X5qRdo7vP+xCvjlGRDU0jXtDCUt6vvWM=" 437 [mod."github.com/yuin/goldmark-highlighting/v2"] 438 version = "v2.0.0-20230729083705-37449abec8cc" 439 hash = "sha256-HpiwU7jIeDUAg2zOpTIiviQir8dpRPuXYh2nqFFccpg="

+17 -12

nix/pkgs/knot-unwrapped.nix

··· 3 modules, 4 sqlite-lib, 5 src, 6 - }: 7 - buildGoApplication { 8 - pname = "knot"; 9 - version = "0.1.0"; 10 - inherit src modules; 0 0 0 11 12 - doCheck = false; 0 13 14 - subPackages = ["cmd/knot"]; 15 - tags = ["libsqlite3"]; 0 16 17 - env.CGO_CFLAGS = "-I ${sqlite-lib}/include "; 18 - env.CGO_LDFLAGS = "-L ${sqlite-lib}/lib"; 19 - CGO_ENABLED = 1; 20 - }

··· 3 modules, 4 sqlite-lib, 5 src, 6 + }: let 7 + version = "1.9.0-alpha"; 8 + in 9 + buildGoApplication { 10 + pname = "knot"; 11 + inherit src version modules; 12 + 13 + doCheck = false; 14 15 + subPackages = ["cmd/knot"]; 16 + tags = ["libsqlite3"]; 17 18 + ldflags = [ 19 + "-X tangled.sh/tangled.sh/core/knotserver/xrpc.version=${version}" 20 + ]; 21 22 + env.CGO_CFLAGS = "-I ${sqlite-lib}/include "; 23 + env.CGO_LDFLAGS = "-L ${sqlite-lib}/lib"; 24 + CGO_ENABLED = 1; 25 + }

-3

spindle/server.go

··· 203 w.Write(motd) 204 }) 205 mux.HandleFunc("/events", s.Events) 206 - mux.HandleFunc("/owner", func(w http.ResponseWriter, r *http.Request) { 207 - w.Write([]byte(s.cfg.Server.Owner)) 208 - }) 209 mux.HandleFunc("/logs/{knot}/{rkey}/{name}", s.Logs) 210 211 mux.Mount("/xrpc", s.XrpcRouter())

··· 203 w.Write(motd) 204 }) 205 mux.HandleFunc("/events", s.Events) 0 0 0 206 mux.HandleFunc("/logs/{knot}/{rkey}/{name}", s.Logs) 207 208 mux.Mount("/xrpc", s.XrpcRouter())

+31

spindle/xrpc/owner.go

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + package xrpc 2 + 3 + import ( 4 + "encoding/json" 5 + "net/http" 6 + 7 + "tangled.sh/tangled.sh/core/api/tangled" 8 + xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors" 9 + ) 10 + 11 + func (x *Xrpc) Owner(w http.ResponseWriter, r *http.Request) { 12 + owner := x.Config.Server.Owner 13 + if owner == "" { 14 + writeError(w, xrpcerr.OwnerNotFoundError, http.StatusInternalServerError) 15 + return 16 + } 17 + 18 + response := tangled.Owner_Output{ 19 + Owner: owner, 20 + } 21 + 22 + w.Header().Set("Content-Type", "application/json") 23 + if err := json.NewEncoder(w).Encode(response); err != nil { 24 + x.Logger.Error("failed to encode response", "error", err) 25 + writeError(w, xrpcerr.NewXrpcError( 26 + xrpcerr.WithTag("InternalServerError"), 27 + xrpcerr.WithMessage("failed to encode response"), 28 + ), http.StatusInternalServerError) 29 + return 30 + } 31 + }

+10 -3

spindle/xrpc/xrpc.go

··· 35 func (x *Xrpc) Router() http.Handler { 36 r := chi.NewRouter() 37 38 - r.With(x.ServiceAuth.VerifyServiceAuth).Post("/"+tangled.RepoAddSecretNSID, x.AddSecret) 39 - r.With(x.ServiceAuth.VerifyServiceAuth).Post("/"+tangled.RepoRemoveSecretNSID, x.RemoveSecret) 40 - r.With(x.ServiceAuth.VerifyServiceAuth).Get("/"+tangled.RepoListSecretsNSID, x.ListSecrets) 0 0 0 0 0 0 0 41 42 return r 43 }

··· 35 func (x *Xrpc) Router() http.Handler { 36 r := chi.NewRouter() 37 38 + r.Group(func(r chi.Router) { 39 + r.Use(x.ServiceAuth.VerifyServiceAuth) 40 + 41 + r.Post("/"+tangled.RepoAddSecretNSID, x.AddSecret) 42 + r.Post("/"+tangled.RepoRemoveSecretNSID, x.RemoveSecret) 43 + r.Get("/"+tangled.RepoListSecretsNSID, x.ListSecrets) 44 + }) 45 + 46 + // service query endpoints (no auth required) 47 + r.Get("/"+tangled.OwnerNSID, x.Owner) 48 49 return r 50 }

+15

xrpc/errors/errors.go

··· 51 WithMessage("actor DID not supplied"), 52 ) 53 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 54 var AuthError = func(err error) XrpcError { 55 return NewXrpcError( 56 WithTag("Auth"),

··· 51 WithMessage("actor DID not supplied"), 52 ) 53 54 + var OwnerNotFoundError = NewXrpcError( 55 + WithTag("OwnerNotFound"), 56 + WithMessage("owner not set for this service"), 57 + ) 58 + 59 + var RepoNotFoundError = NewXrpcError( 60 + WithTag("RepoNotFound"), 61 + WithMessage("failed to access repository"), 62 + ) 63 + 64 + var RefNotFoundError = NewXrpcError( 65 + WithTag("RefNotFound"), 66 + WithMessage("failed to access ref"), 67 + ) 68 + 69 var AuthError = func(err error) XrpcError { 70 return NewXrpcError( 71 WithTag("Auth"),