forked from tangled.org/core
Monorepo for Tangled — https://tangled.org

appview: reporesolver: pass entire `Repo` object through context

There is no reason for `ResolvedRepo` to not directly inherit `Repo`

Signed-off-by: Seongmin Lee <boltlessengineer@proton.me>

Changed files
+123 -162
appview
issues
middleware
pulls
repo
reporesolver
+18 -18
appview/issues/issues.go
···
return
}
-
issue, comments, err := db.GetIssueWithComments(rp.db, f.RepoAt, issueIdInt)
+
issue, comments, err := db.GetIssueWithComments(rp.db, f.RepoAt(), issueIdInt)
if err != nil {
log.Println("failed to get issue and comments", err)
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
···
return
}
-
issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
+
issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
if err != nil {
log.Println("failed to get issue", err)
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
return
}
-
err = db.CloseIssue(rp.db, f.RepoAt, issueIdInt)
+
err = db.CloseIssue(rp.db, f.RepoAt(), issueIdInt)
if err != nil {
log.Println("failed to close issue", err)
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
return
}
-
issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
+
issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
if err != nil {
log.Println("failed to get issue", err)
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
isIssueOwner := user.Did == issue.OwnerDid
if isCollaborator || isIssueOwner {
-
err := db.ReopenIssue(rp.db, f.RepoAt, issueIdInt)
+
err := db.ReopenIssue(rp.db, f.RepoAt(), issueIdInt)
if err != nil {
log.Println("failed to reopen issue", err)
rp.pages.Notice(w, "issue-action", "Failed to reopen issue. Try again later.")
···
err := db.NewIssueComment(rp.db, &db.Comment{
OwnerDid: user.Did,
-
RepoAt: f.RepoAt,
+
RepoAt: f.RepoAt(),
Issue: issueIdInt,
CommentId: commentId,
Body: body,
···
createdAt := time.Now().Format(time.RFC3339)
commentIdInt64 := int64(commentId)
ownerDid := user.Did
-
issueAt, err := db.GetIssueAt(rp.db, f.RepoAt, issueIdInt)
+
issueAt, err := db.GetIssueAt(rp.db, f.RepoAt(), issueIdInt)
if err != nil {
log.Println("failed to get issue at", err)
rp.pages.Notice(w, "issue-comment", "Failed to create comment.")
return
}
-
atUri := f.RepoAt.String()
+
atUri := f.RepoAt().String()
client, err := rp.oauth.AuthorizedClient(r)
if err != nil {
log.Println("failed to get authorized client", err)
···
return
}
-
issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
+
issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
if err != nil {
log.Println("failed to get issue", err)
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
return
}
-
comment, err := db.GetComment(rp.db, f.RepoAt, issueIdInt, commentIdInt)
+
comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt)
if err != nil {
http.Error(w, "bad comment id", http.StatusBadRequest)
return
···
return
}
-
issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
+
issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
if err != nil {
log.Println("failed to get issue", err)
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
return
}
-
comment, err := db.GetComment(rp.db, f.RepoAt, issueIdInt, commentIdInt)
+
comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt)
if err != nil {
http.Error(w, "bad comment id", http.StatusBadRequest)
return
···
return
}
-
issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
+
issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
if err != nil {
log.Println("failed to get issue", err)
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
···
return
}
-
comment, err := db.GetComment(rp.db, f.RepoAt, issueIdInt, commentIdInt)
+
comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt)
if err != nil {
http.Error(w, "bad comment id", http.StatusBadRequest)
return
···
// optimistic deletion
deleted := time.Now()
-
err = db.DeleteComment(rp.db, f.RepoAt, issueIdInt, commentIdInt)
+
err = db.DeleteComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt)
if err != nil {
log.Println("failed to delete comment")
rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "failed to delete comment")
···
return
}
-
issues, err := db.GetIssues(rp.db, f.RepoAt, isOpen, page)
+
issues, err := db.GetIssues(rp.db, f.RepoAt(), isOpen, page)
if err != nil {
log.Println("failed to get issues", err)
rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.")
···
}
issue := &db.Issue{
-
RepoAt: f.RepoAt,
+
RepoAt: f.RepoAt(),
Rkey: tid.TID(),
Title: title,
Body: body,
···
rp.pages.Notice(w, "issues", "Failed to create issue.")
return
}
-
atUri := f.RepoAt.String()
+
atUri := f.RepoAt().String()
_, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
Collection: tangled.RepoIssueNSID,
Repo: user.Did,
+3 -8
appview/middleware/middleware.go
···
"slices"
"strconv"
"strings"
-
"time"
"github.com/bluesky-social/indigo/atproto/identity"
"github.com/go-chi/chi/v5"
···
return
}
-
ctx := context.WithValue(req.Context(), "knot", repo.Knot)
-
ctx = context.WithValue(ctx, "repoAt", repo.AtUri)
-
ctx = context.WithValue(ctx, "repoDescription", repo.Description)
-
ctx = context.WithValue(ctx, "repoSpindle", repo.Spindle)
-
ctx = context.WithValue(ctx, "repoAddedAt", repo.Created.Format(time.RFC3339))
+
ctx := context.WithValue(req.Context(), "repo", repo)
next.ServeHTTP(w, req.WithContext(ctx))
})
}
···
return
}
-
pr, err := db.GetPull(mw.db, f.RepoAt, prIdInt)
+
pr, err := db.GetPull(mw.db, f.RepoAt(), prIdInt)
if err != nil {
log.Println("failed to get pull and comments", err)
return
···
return
}
-
fullName := f.OwnerHandle() + "/" + f.RepoName
+
fullName := f.OwnerHandle() + "/" + f.Name
if r.Header.Get("User-Agent") == "Go-http-client/1.1" {
if r.URL.Query().Get("go-get") == "1" {
+21 -21
appview/pulls/pulls.go
···
patch = mergeable.CombinedPatch()
}
-
resp, err := ksClient.MergeCheck([]byte(patch), f.OwnerDid(), f.RepoName, pull.TargetBranch)
+
resp, err := ksClient.MergeCheck([]byte(patch), f.OwnerDid(), f.Name, pull.TargetBranch)
if err != nil {
log.Println("failed to check for mergeability:", err)
return types.MergeCheckResponse{
···
// pulls within the same repo
knot = f.Knot
ownerDid = f.OwnerDid()
-
repoName = f.RepoName
+
repoName = f.Name
}
us, err := knotclient.NewUnsignedClient(knot, s.config.Core.Dev)
···
pulls, err := db.GetPulls(
s.db,
-
db.FilterEq("repo_at", f.RepoAt),
+
db.FilterEq("repo_at", f.RepoAt()),
db.FilterEq("state", state),
)
if err != nil {
···
createdAt := time.Now().Format(time.RFC3339)
ownerDid := user.Did
-
pullAt, err := db.GetPullAt(s.db, f.RepoAt, pull.PullId)
+
pullAt, err := db.GetPullAt(s.db, f.RepoAt(), pull.PullId)
if err != nil {
log.Println("failed to get pull at", err)
s.pages.Notice(w, "pull-comment", "Failed to create comment.")
return
}
-
atUri := f.RepoAt.String()
+
atUri := f.RepoAt().String()
client, err := s.oauth.AuthorizedClient(r)
if err != nil {
log.Println("failed to get authorized client", err)
···
comment := &db.PullComment{
OwnerDid: user.Did,
-
RepoAt: f.RepoAt.String(),
+
RepoAt: f.RepoAt().String(),
PullId: pull.PullId,
Body: body,
CommentAt: atResp.Uri,
···
return
}
-
result, err := us.Branches(f.OwnerDid(), f.RepoName)
+
result, err := us.Branches(f.OwnerDid(), f.Name)
if err != nil {
log.Println("failed to fetch branches", err)
return
···
return
}
-
comparison, err := ksClient.Compare(f.OwnerDid(), f.RepoName, targetBranch, sourceBranch)
+
comparison, err := ksClient.Compare(f.OwnerDid(), f.Name, targetBranch, sourceBranch)
if err != nil {
log.Println("failed to compare", err)
s.pages.Notice(w, "pull", err.Error())
···
Body: body,
TargetBranch: targetBranch,
OwnerDid: user.Did,
-
RepoAt: f.RepoAt,
+
RepoAt: f.RepoAt(),
Rkey: rkey,
Submissions: []*db.PullSubmission{
&initialSubmission,
···
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
return
-
pullId, err := db.NextPullId(tx, f.RepoAt)
+
pullId, err := db.NextPullId(tx, f.RepoAt())
if err != nil {
log.Println("failed to get pull id", err)
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
···
Val: &tangled.RepoPull{
Title: title,
PullId: int64(pullId),
-
TargetRepo: string(f.RepoAt),
+
TargetRepo: string(f.RepoAt()),
TargetBranch: targetBranch,
Patch: patch,
Source: recordPullSource,
···
return
-
result, err := us.Branches(f.OwnerDid(), f.RepoName)
+
result, err := us.Branches(f.OwnerDid(), f.Name)
if err != nil {
log.Println("failed to reach knotserver", err)
return
···
return
-
targetResult, err := targetBranchesClient.Branches(f.OwnerDid(), f.RepoName)
+
targetResult, err := targetBranchesClient.Branches(f.OwnerDid(), f.Name)
if err != nil {
log.Println("failed to reach knotserver for target branches", err)
return
···
return
-
comparison, err := ksClient.Compare(f.OwnerDid(), f.RepoName, pull.TargetBranch, pull.PullSource.Branch)
+
comparison, err := ksClient.Compare(f.OwnerDid(), f.Name, pull.TargetBranch, pull.PullSource.Branch)
if err != nil {
log.Printf("compare request failed: %s", err)
s.pages.Notice(w, "resubmit-error", err.Error())
···
Val: &tangled.RepoPull{
Title: pull.Title,
PullId: int64(pull.PullId),
-
TargetRepo: string(f.RepoAt),
+
TargetRepo: string(f.RepoAt()),
TargetBranch: pull.TargetBranch,
Patch: patch, // new patch
Source: recordPullSource,
···
// Merge the pull request
-
resp, err := ksClient.Merge([]byte(patch), f.OwnerDid(), f.RepoName, pull.TargetBranch, pull.Title, pull.Body, ident.Handle.String(), email.Address)
+
resp, err := ksClient.Merge([]byte(patch), f.OwnerDid(), f.Name, pull.TargetBranch, pull.Title, pull.Body, ident.Handle.String(), email.Address)
if err != nil {
log.Printf("failed to merge pull request: %s", err)
s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
···
defer tx.Rollback()
for _, p := range pullsToMerge {
-
err := db.MergePull(tx, f.RepoAt, p.PullId)
+
err := db.MergePull(tx, f.RepoAt(), p.PullId)
if err != nil {
log.Printf("failed to update pull request status in database: %s", err)
s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
···
return
-
s.pages.HxLocation(w, fmt.Sprintf("/@%s/%s/pulls/%d", f.OwnerHandle(), f.RepoName, pull.PullId))
+
s.pages.HxLocation(w, fmt.Sprintf("/@%s/%s/pulls/%d", f.OwnerHandle(), f.Name, pull.PullId))
func (s *Pulls) ClosePull(w http.ResponseWriter, r *http.Request) {
···
for _, p := range pullsToClose {
// Close the pull in the database
-
err = db.ClosePull(tx, f.RepoAt, p.PullId)
+
err = db.ClosePull(tx, f.RepoAt(), p.PullId)
if err != nil {
log.Println("failed to close pull", err)
s.pages.Notice(w, "pull-close", "Failed to close pull.")
···
for _, p := range pullsToReopen {
// Close the pull in the database
-
err = db.ReopenPull(tx, f.RepoAt, p.PullId)
+
err = db.ReopenPull(tx, f.RepoAt(), p.PullId)
if err != nil {
log.Println("failed to close pull", err)
s.pages.Notice(w, "pull-close", "Failed to close pull.")
···
Body: body,
TargetBranch: targetBranch,
OwnerDid: user.Did,
-
RepoAt: f.RepoAt,
+
RepoAt: f.RepoAt(),
Rkey: rkey,
Submissions: []*db.PullSubmission{
&initialSubmission,
+6 -6
appview/repo/artifact.go
···
Artifact: uploadBlobResp.Blob,
CreatedAt: createdAt.Format(time.RFC3339),
Name: handler.Filename,
-
Repo: f.RepoAt.String(),
+
Repo: f.RepoAt().String(),
Tag: tag.Tag.Hash[:],
},
},
···
artifact := db.Artifact{
Did: user.Did,
Rkey: rkey,
-
RepoAt: f.RepoAt,
+
RepoAt: f.RepoAt(),
Tag: tag.Tag.Hash,
CreatedAt: createdAt,
BlobCid: cid.Cid(uploadBlobResp.Blob.Ref),
···
artifacts, err := db.GetArtifact(
rp.db,
-
db.FilterEq("repo_at", f.RepoAt),
+
db.FilterEq("repo_at", f.RepoAt()),
db.FilterEq("tag", tag.Tag.Hash[:]),
db.FilterEq("name", filename),
)
···
artifacts, err := db.GetArtifact(
rp.db,
-
db.FilterEq("repo_at", f.RepoAt),
+
db.FilterEq("repo_at", f.RepoAt()),
db.FilterEq("tag", tag[:]),
db.FilterEq("name", filename),
)
···
defer tx.Rollback()
err = db.DeleteArtifact(tx,
-
db.FilterEq("repo_at", f.RepoAt),
+
db.FilterEq("repo_at", f.RepoAt()),
db.FilterEq("tag", artifact.Tag[:]),
db.FilterEq("name", filename),
)
···
return nil, err
}
-
result, err := us.Tags(f.OwnerDid(), f.RepoName)
+
result, err := us.Tags(f.OwnerDid(), f.Name)
if err != nil {
log.Println("failed to reach knotserver", err)
return nil, err
+5 -5
appview/repo/index.go
···
return
}
-
result, err := us.Index(f.OwnerDid(), f.RepoName, ref)
+
result, err := us.Index(f.OwnerDid(), f.Name, ref)
if err != nil {
rp.pages.Error503(w)
log.Println("failed to reach knotserver", err)
···
// first attempt to fetch from db
langs, err := db.GetRepoLanguages(
rp.db,
-
db.FilterEq("repo_at", f.RepoAt),
+
db.FilterEq("repo_at", f.RepoAt()),
db.FilterEq("ref", f.Ref),
)
if err != nil || langs == nil {
// non-fatal, fetch langs from ks
-
ls, err := signedClient.RepoLanguages(f.OwnerDid(), f.RepoName, f.Ref)
+
ls, err := signedClient.RepoLanguages(f.OwnerDid(), f.Name, f.Ref)
if err != nil {
return nil, err
}
···
for l, s := range ls.Languages {
langs = append(langs, db.RepoLanguage{
-
RepoAt: f.RepoAt,
+
RepoAt: f.RepoAt(),
Ref: f.Ref,
IsDefaultRef: isDefaultRef,
Language: l,
···
hiddenRef := fmt.Sprintf("hidden/%s/%s", f.Ref, f.Ref)
var status types.AncestorCheckResponse
-
forkSyncableResp, err := signedClient.RepoForkAheadBehind(user.Did, string(f.RepoAt), repoInfo.Name, f.Ref, hiddenRef)
+
forkSyncableResp, err := signedClient.RepoForkAheadBehind(user.Did, string(f.RepoAt()), repoInfo.Name, f.Ref, hiddenRef)
if err != nil {
log.Printf("failed to check if fork is ahead/behind: %s", err)
return nil, err
+45 -46
appview/repo/repo.go
···
} else {
uri = "https"
}
-
url := fmt.Sprintf("%s://%s/%s/%s/archive/%s.tar.gz", uri, f.Knot, f.OwnerDid(), f.RepoName, url.PathEscape(refParam))
+
url := fmt.Sprintf("%s://%s/%s/%s/archive/%s.tar.gz", uri, f.Knot, f.OwnerDid(), f.Name, url.PathEscape(refParam))
http.Redirect(w, r, url, http.StatusFound)
}
···
return
}
-
repolog, err := us.Log(f.OwnerDid(), f.RepoName, ref, page)
+
repolog, err := us.Log(f.OwnerDid(), f.Name, ref, page)
if err != nil {
log.Println("failed to reach knotserver", err)
return
}
-
tagResult, err := us.Tags(f.OwnerDid(), f.RepoName)
+
tagResult, err := us.Tags(f.OwnerDid(), f.Name)
if err != nil {
log.Println("failed to reach knotserver", err)
return
···
tagMap[hash] = append(tagMap[hash], tag.Name)
}
-
branchResult, err := us.Branches(f.OwnerDid(), f.RepoName)
+
branchResult, err := us.Branches(f.OwnerDid(), f.Name)
if err != nil {
log.Println("failed to reach knotserver", err)
return
···
return
}
-
repoAt := f.RepoAt
+
repoAt := f.RepoAt()
rkey := repoAt.RecordKey().String()
if rkey == "" {
log.Println("invalid aturi for repo", err)
···
Record: &lexutil.LexiconTypeDecoder{
Val: &tangled.Repo{
Knot: f.Knot,
-
Name: f.RepoName,
+
Name: f.Name,
Owner: user.Did,
-
CreatedAt: f.CreatedAt,
+
CreatedAt: f.Created.Format(time.RFC3339),
Description: &newDescription,
Spindle: &f.Spindle,
},
···
return
}
-
resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/commit/%s", protocol, f.Knot, f.OwnerDid(), f.RepoName, ref))
+
resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/commit/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref))
if err != nil {
log.Println("failed to reach knotserver", err)
return
···
if !rp.config.Core.Dev {
protocol = "https"
}
-
resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/tree/%s/%s", protocol, f.Knot, f.OwnerDid(), f.RepoName, ref, treePath))
+
resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/tree/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref, treePath))
if err != nil {
log.Println("failed to reach knotserver", err)
return
···
user := rp.oauth.GetUser(r)
var breadcrumbs [][]string
-
breadcrumbs = append(breadcrumbs, []string{f.RepoName, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), ref)})
+
breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), ref)})
if treePath != "" {
for idx, elem := range strings.Split(treePath, "/") {
breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], elem)})
···
return
}
-
result, err := us.Tags(f.OwnerDid(), f.RepoName)
+
result, err := us.Tags(f.OwnerDid(), f.Name)
if err != nil {
log.Println("failed to reach knotserver", err)
return
}
-
artifacts, err := db.GetArtifact(rp.db, db.FilterEq("repo_at", f.RepoAt))
+
artifacts, err := db.GetArtifact(rp.db, db.FilterEq("repo_at", f.RepoAt()))
if err != nil {
log.Println("failed grab artifacts", err)
return
···
return
}
-
result, err := us.Branches(f.OwnerDid(), f.RepoName)
+
result, err := us.Branches(f.OwnerDid(), f.Name)
if err != nil {
log.Println("failed to reach knotserver", err)
return
···
if !rp.config.Core.Dev {
protocol = "https"
}
-
resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/blob/%s/%s", protocol, f.Knot, f.OwnerDid(), f.RepoName, ref, filePath))
+
resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/blob/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref, filePath))
if err != nil {
log.Println("failed to reach knotserver", err)
return
···
}
var breadcrumbs [][]string
-
breadcrumbs = append(breadcrumbs, []string{f.RepoName, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), ref)})
+
breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), ref)})
if filePath != "" {
for idx, elem := range strings.Split(filePath, "/") {
breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], elem)})
···
// fetch the actual binary content like in RepoBlobRaw
-
blobURL := fmt.Sprintf("%s://%s/%s/%s/raw/%s/%s", protocol, f.Knot, f.OwnerDid(), f.RepoName, ref, filePath)
+
blobURL := fmt.Sprintf("%s://%s/%s/%s/raw/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Name, ref, filePath)
contentSrc = blobURL
if !rp.config.Core.Dev {
contentSrc = markup.GenerateCamoURL(rp.config.Camo.Host, rp.config.Camo.SharedSecret, blobURL)
···
if !rp.config.Core.Dev {
protocol = "https"
}
-
blobURL := fmt.Sprintf("%s://%s/%s/%s/raw/%s/%s", protocol, f.Knot, f.OwnerDid(), f.RepoName, ref, filePath)
+
blobURL := fmt.Sprintf("%s://%s/%s/%s/raw/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref, filePath)
resp, err := http.Get(blobURL)
if err != nil {
log.Println("failed to reach knotserver:", err)
···
return
}
-
repoAt := f.RepoAt
+
repoAt := f.RepoAt()
rkey := repoAt.RecordKey().String()
if rkey == "" {
fail("Failed to resolve repo. Try again later", err)
···
Record: &lexutil.LexiconTypeDecoder{
Val: &tangled.Repo{
Knot: f.Knot,
-
Name: f.RepoName,
+
Name: f.Name,
Owner: user.Did,
-
CreatedAt: f.CreatedAt,
+
CreatedAt: f.Created.Format(time.RFC3339),
Description: &f.Description,
Spindle: spindlePtr,
},
···
Record: &lexutil.LexiconTypeDecoder{
Val: &tangled.RepoCollaborator{
Subject: collaboratorIdent.DID.String(),
-
Repo: string(f.RepoAt),
+
Repo: string(f.RepoAt()),
CreatedAt: createdAt.Format(time.RFC3339),
}},
})
···
return
}
-
ksResp, err := ksClient.AddCollaborator(f.OwnerDid(), f.RepoName, collaboratorIdent.DID.String())
+
ksResp, err := ksClient.AddCollaborator(f.OwnerDid(), f.Name, collaboratorIdent.DID.String())
if err != nil {
fail("Knot was unreachable.", err)
return
···
Did: syntax.DID(currentUser.Did),
Rkey: rkey,
SubjectDid: collaboratorIdent.DID,
-
RepoAt: f.RepoAt,
+
RepoAt: f.RepoAt(),
Created: createdAt,
})
if err != nil {
···
log.Println("failed to get authorized client", err)
return
}
-
repoRkey := f.RepoAt.RecordKey().String()
_, err = xrpcClient.RepoDeleteRecord(r.Context(), &comatproto.RepoDeleteRecord_Input{
Collection: tangled.RepoNSID,
Repo: user.Did,
-
Rkey: repoRkey,
+
Rkey: f.Rkey,
})
if err != nil {
log.Printf("failed to delete record: %s", err)
rp.pages.Notice(w, "settings-delete", "Failed to delete repository from PDS.")
return
}
-
log.Println("removed repo record ", f.RepoAt.String())
+
log.Println("removed repo record ", f.RepoAt().String())
secret, err := db.GetRegistrationKey(rp.db, f.Knot)
if err != nil {
···
return
}
-
ksResp, err := ksClient.RemoveRepo(f.OwnerDid(), f.RepoName)
+
ksResp, err := ksClient.RemoveRepo(f.OwnerDid(), f.Name)
if err != nil {
log.Printf("failed to make request to %s: %s", f.Knot, err)
return
···
}
// remove repo from db
-
err = db.RemoveRepo(tx, f.OwnerDid(), f.RepoName)
+
err = db.RemoveRepo(tx, f.OwnerDid(), f.Name)
if err != nil {
rp.pages.Notice(w, "settings-delete", "Failed to update appview")
return
···
return
-
ksResp, err := ksClient.SetDefaultBranch(f.OwnerDid(), f.RepoName, branch)
+
ksResp, err := ksClient.SetDefaultBranch(f.OwnerDid(), f.Name, branch)
if err != nil {
log.Printf("failed to make request to %s: %s", f.Knot, err)
return
···
r.Context(),
spindleClient,
&tangled.RepoAddSecret_Input{
-
Repo: f.RepoAt.String(),
+
Repo: f.RepoAt().String(),
Key: key,
Value: value,
},
···
r.Context(),
spindleClient,
&tangled.RepoRemoveSecret_Input{
-
Repo: f.RepoAt.String(),
+
Repo: f.RepoAt().String(),
Key: key,
},
···
// return
// }
-
// result, err := us.Branches(f.OwnerDid(), f.RepoName)
+
// result, err := us.Branches(f.OwnerDid(), f.Name)
// if err != nil {
// log.Println("failed to reach knotserver", err)
// return
···
// oauth.WithDev(rp.config.Core.Dev),
// ); err != nil {
// log.Println("failed to create spindle client", err)
-
// } else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt.String()); err != nil {
+
// } else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt().String()); err != nil {
// log.Println("failed to fetch secrets", err)
// } else {
// secrets = resp.Secrets
···
return
-
result, err := us.Branches(f.OwnerDid(), f.RepoName)
+
result, err := us.Branches(f.OwnerDid(), f.Name)
if err != nil {
log.Println("failed to reach knotserver", err)
return
···
oauth.WithDev(rp.config.Core.Dev),
); err != nil {
log.Println("failed to create spindle client", err)
-
} else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt.String()); err != nil {
+
} else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt().String()); err != nil {
log.Println("failed to fetch secrets", err)
} else {
secrets = resp.Secrets
···
} else {
uri = "https"
-
forkName := fmt.Sprintf("%s", f.RepoName)
-
forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.RepoName)
+
forkName := fmt.Sprintf("%s", f.Name)
+
forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.Repo.Name)
_, err = client.SyncRepoFork(user.Did, forkSourceUrl, forkName, f.Ref)
if err != nil {
···
return
-
forkName := fmt.Sprintf("%s", f.RepoName)
+
forkName := fmt.Sprintf("%s", f.Name)
// this check is *only* to see if the forked repo name already exists
// in the user's account.
-
existingRepo, err := db.GetRepo(rp.db, user.Did, f.RepoName)
+
existingRepo, err := db.GetRepo(rp.db, user.Did, f.Name)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
// no existing repo with this name found, we can use the name as is
···
} else {
uri = "https"
-
forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.RepoName)
-
sourceAt := f.RepoAt.String()
+
forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.Repo.Name)
+
sourceAt := f.RepoAt().String()
rkey := tid.TID()
repo := &db.Repo{
···
return
-
result, err := us.Branches(f.OwnerDid(), f.RepoName)
+
result, err := us.Branches(f.OwnerDid(), f.Name)
if err != nil {
rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
log.Println("failed to reach knotserver", err)
···
head = queryHead
-
tags, err := us.Tags(f.OwnerDid(), f.RepoName)
+
tags, err := us.Tags(f.OwnerDid(), f.Name)
if err != nil {
rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
log.Println("failed to reach knotserver", err)
···
return
-
branches, err := us.Branches(f.OwnerDid(), f.RepoName)
+
branches, err := us.Branches(f.OwnerDid(), f.Name)
if err != nil {
rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
log.Println("failed to reach knotserver", err)
return
-
tags, err := us.Tags(f.OwnerDid(), f.RepoName)
+
tags, err := us.Tags(f.OwnerDid(), f.Name)
if err != nil {
rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
log.Println("failed to reach knotserver", err)
return
-
formatPatch, err := us.Compare(f.OwnerDid(), f.RepoName, base, head)
+
formatPatch, err := us.Compare(f.OwnerDid(), f.Name, base, head)
if err != nil {
rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
log.Println("failed to compare", err)
+25 -58
appview/reporesolver/resolver.go
···
"strings"
"github.com/bluesky-social/indigo/atproto/identity"
-
"github.com/bluesky-social/indigo/atproto/syntax"
securejoin "github.com/cyphar/filepath-securejoin"
"github.com/go-chi/chi/v5"
"tangled.sh/tangled.sh/core/appview/config"
···
)
type ResolvedRepo struct {
-
Knot string
+
db.Repo
OwnerId identity.Identity
-
RepoName string
-
RepoAt syntax.ATURI
-
Description string
-
Spindle string
-
CreatedAt string
Ref string
CurrentDir string
···
}
func (rr *RepoResolver) Resolve(r *http.Request) (*ResolvedRepo, error) {
-
repoName := chi.URLParam(r, "repo")
-
knot, ok := r.Context().Value("knot").(string)
+
repo, ok := r.Context().Value("repo").(*db.Repo)
if !ok {
-
log.Println("malformed middleware")
+
log.Println("malformed middleware: `repo` not exist in context")
return nil, fmt.Errorf("malformed middleware")
}
id, ok := r.Context().Value("resolvedId").(identity.Identity)
···
return nil, fmt.Errorf("malformed middleware")
}
-
repoAt, ok := r.Context().Value("repoAt").(string)
-
if !ok {
-
log.Println("malformed middleware")
-
return nil, fmt.Errorf("malformed middleware")
-
}
-
-
parsedRepoAt, err := syntax.ParseATURI(repoAt)
-
if err != nil {
-
log.Println("malformed repo at-uri")
-
return nil, fmt.Errorf("malformed middleware")
-
}
-
ref := chi.URLParam(r, "ref")
if ref == "" {
-
us, err := knotclient.NewUnsignedClient(knot, rr.config.Core.Dev)
+
us, err := knotclient.NewUnsignedClient(repo.Knot, rr.config.Core.Dev)
if err != nil {
return nil, err
}
-
defaultBranch, err := us.DefaultBranch(id.DID.String(), repoName)
+
defaultBranch, err := us.DefaultBranch(id.DID.String(), repo.Name)
if err != nil {
return nil, err
}
···
currentDir := path.Dir(extractPathAfterRef(r.URL.EscapedPath(), ref))
-
// pass through values from the middleware
-
description, ok := r.Context().Value("repoDescription").(string)
-
addedAt, ok := r.Context().Value("repoAddedAt").(string)
-
spindle, ok := r.Context().Value("repoSpindle").(string)
-
return &ResolvedRepo{
-
Knot: knot,
-
OwnerId: id,
-
RepoName: repoName,
-
RepoAt: parsedRepoAt,
-
Description: description,
-
CreatedAt: addedAt,
-
Ref: ref,
-
CurrentDir: currentDir,
-
Spindle: spindle,
+
Repo: *repo,
+
OwnerId: id,
+
Ref: ref,
+
CurrentDir: currentDir,
rr: rr,
}, nil
···
var p string
if handle != "" && !handle.IsInvalidHandle() {
-
p, _ = securejoin.SecureJoin(fmt.Sprintf("@%s", handle), f.RepoName)
+
p, _ = securejoin.SecureJoin(fmt.Sprintf("@%s", handle), f.Name)
} else {
-
p, _ = securejoin.SecureJoin(f.OwnerDid(), f.RepoName)
+
p, _ = securejoin.SecureJoin(f.OwnerDid(), f.Name)
}
-
return p
-
}
-
-
func (f *ResolvedRepo) DidSlashRepo() string {
-
p, _ := securejoin.SecureJoin(f.OwnerDid(), f.RepoName)
return p
}
···
// this function is a bit weird since it now returns RepoInfo from an entirely different
// package. we should refactor this or get rid of RepoInfo entirely.
func (f *ResolvedRepo) RepoInfo(user *oauth.User) repoinfo.RepoInfo {
+
repoAt := f.RepoAt()
isStarred := false
if user != nil {
-
isStarred = db.GetStarStatus(f.rr.execer, user.Did, syntax.ATURI(f.RepoAt))
+
isStarred = db.GetStarStatus(f.rr.execer, user.Did, repoAt)
}
-
starCount, err := db.GetStarCount(f.rr.execer, f.RepoAt)
+
starCount, err := db.GetStarCount(f.rr.execer, repoAt)
if err != nil {
-
log.Println("failed to get star count for ", f.RepoAt)
+
log.Println("failed to get star count for ", repoAt)
}
-
issueCount, err := db.GetIssueCount(f.rr.execer, f.RepoAt)
+
issueCount, err := db.GetIssueCount(f.rr.execer, repoAt)
if err != nil {
-
log.Println("failed to get issue count for ", f.RepoAt)
+
log.Println("failed to get issue count for ", repoAt)
}
-
pullCount, err := db.GetPullCount(f.rr.execer, f.RepoAt)
+
pullCount, err := db.GetPullCount(f.rr.execer, repoAt)
if err != nil {
-
log.Println("failed to get issue count for ", f.RepoAt)
+
log.Println("failed to get issue count for ", repoAt)
}
-
source, err := db.GetRepoSource(f.rr.execer, f.RepoAt)
+
source, err := db.GetRepoSource(f.rr.execer, repoAt)
if errors.Is(err, sql.ErrNoRows) {
source = ""
} else if err != nil {
-
log.Println("failed to get repo source for ", f.RepoAt, err)
+
log.Println("failed to get repo source for ", repoAt, err)
}
var sourceRepo *db.Repo
···
if err != nil {
log.Printf("failed to create unsigned client for %s: %v", knot, err)
} else {
-
result, err := us.Branches(f.OwnerDid(), f.RepoName)
+
result, err := us.Branches(f.OwnerDid(), f.Name)
if err != nil {
-
log.Printf("failed to get branches for %s/%s: %v", f.OwnerDid(), f.RepoName, err)
+
log.Printf("failed to get branches for %s/%s: %v", f.OwnerDid(), f.Name, err)
}
if len(result.Branches) == 0 {
···
repoInfo := repoinfo.RepoInfo{
OwnerDid: f.OwnerDid(),
OwnerHandle: f.OwnerHandle(),
-
Name: f.RepoName,
-
RepoAt: f.RepoAt,
+
Name: f.Name,
+
RepoAt: repoAt,
Description: f.Description,
Ref: f.Ref,
IsStarred: isStarred,