appview/pulls: upload patches as blobs

By using blobs we massively increase our maximum patch size. When stored
directly on the record patches can be at most 2 MiB. By moving it to a
blob, we get a minimum of 50 MiB (smaller if the pds has set it but 50
is the default).

Signed-off-by: Samuel Shuert <[e-mail]>
Signed-off-by: Seongmin Lee <[e-mail]>

appview/models/pull.go

···
 	Repo   *Repo
 }
 
+// NOTE: This method does not include patch blob in returned atproto record
 func (p Pull) AsRecord() tangled.RepoPull {
 	var source *tangled.RepoPull_Source
 	if p.PullSource != nil {
···
 			Repo:   p.RepoAt.String(),
 			Branch: p.TargetBranch,
 		},
-		Patch:  p.LatestPatch(),
 		Source: source,
 	}
 	return record

appview/pulls/pulls.go

···
 		return
 	}
 
+	blob, err := comatproto.RepoUploadBlob(r.Context(), client, strings.NewReader(patch))
+	if err != nil {
+		log.Println("failed to upload patch", err)
+		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
+		return
+	}
+
 	_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 		Collection: tangled.RepoPullNSID,
 		Repo:       user.Did,
···
 					Repo:   string(repo.RepoAt()),
 					Branch: targetBranch,
 				},
-				Patch:     patch,
+				Patch:     blob.Blob.Ref.String(),
 				Source:    recordPullSource,
 				CreatedAt: time.Now().Format(time.RFC3339),
 			},
···
 	// apply all record creations at once
 	var writes []*comatproto.RepoApplyWrites_Input_Writes_Elem
 	for _, p := range stack {
+		blob, err := comatproto.RepoUploadBlob(r.Context(), client, strings.NewReader(p.LatestPatch()))
+		if err != nil {
+			log.Println("failed to upload patch blob", err)
+			s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
+			return
+		}
+
 		record := p.AsRecord()
-		write := comatproto.RepoApplyWrites_Input_Writes_Elem{
+		record.Patch = blob.Blob.Ref.String()
+		writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{
 			RepoApplyWrites_Create: &comatproto.RepoApplyWrites_Create{
 				Collection: tangled.RepoPullNSID,
 				Rkey:       &p.Rkey,
···
 					Val: &record,
 				},
 			},
-		}
-		writes = append(writes, &write)
+		})
 	}
 	_, err = comatproto.RepoApplyWrites(r.Context(), client, &comatproto.RepoApplyWrites_Input{
 		Repo:   user.Did,
···
 		return
 	}
 
-	var recordPullSource *tangled.RepoPull_Source
-	if pull.IsBranchBased() {
-		recordPullSource = &tangled.RepoPull_Source{
-			Branch: pull.PullSource.Branch,
-			Sha:    sourceRev,
-		}
+	blob, err := comatproto.RepoUploadBlob(r.Context(), client, strings.NewReader(patch))
+	if err != nil {
+		log.Println("failed to upload patch blob", err)
+		s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
+		return
 	}
-	if pull.IsForkBased() {
-		repoAt := pull.PullSource.RepoAt.String()
-		recordPullSource = &tangled.RepoPull_Source{
-			Branch: pull.PullSource.Branch,
-			Repo:   &repoAt,
-			Sha:    sourceRev,
-		}
-	}
+	record := pull.AsRecord()
+	record.Patch = blob.Blob.Ref.String()
+	record.CreatedAt = time.Now().Format(time.RFC3339)
 
 	_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 		Collection: tangled.RepoPullNSID,
···
 		Rkey:       pull.Rkey,
 		SwapRecord: ex.Cid,
 		Record: &lexutil.LexiconTypeDecoder{
-			Val: &tangled.RepoPull{
-				Title: pull.Title,
-				Target: &tangled.RepoPull_Target{
-					Repo:   string(repo.RepoAt()),
-					Branch: pull.TargetBranch,
-				},
-				Patch:     patch, // new patch
-				Source:    recordPullSource,
-				CreatedAt: time.Now().Format(time.RFC3339),
-			},
+			Val: &record,
 		},
 	})
 	if err != nil {
···
 	}
 	defer tx.Rollback()
 
+	client, err := s.oauth.AuthorizedClient(r)
+	if err != nil {
+		log.Println("failed to authorize client")
+		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
+		return
+	}
+
 	// pds updates to make
 	var writes []*comatproto.RepoApplyWrites_Input_Writes_Elem
 
···
 			return
 		}
 
+		blob, err := comatproto.RepoUploadBlob(r.Context(), client, strings.NewReader(patch))
+		if err != nil {
+			log.Println("failed to upload patch blob", err)
+			s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
+			return
+		}
 		record := p.AsRecord()
+		record.Patch = blob.Blob.Ref.String()
 		writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{
 			RepoApplyWrites_Create: &comatproto.RepoApplyWrites_Create{
 				Collection: tangled.RepoPullNSID,
···
 			return
 		}
 
+		blob, err := comatproto.RepoUploadBlob(r.Context(), client, strings.NewReader(patch))
+		if err != nil {
+			log.Println("failed to upload patch blob", err)
+			s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
+			return
+		}
 		record := np.AsRecord()
-
+		record.Patch = blob.Blob.Ref.String()
 		writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{
 			RepoApplyWrites_Update: &comatproto.RepoApplyWrites_Update{
 				Collection: tangled.RepoPullNSID,
···
 	if err != nil {
 		log.Println("failed to resubmit pull", err)
 		s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
-		return
-	}
-
-	client, err := s.oauth.AuthorizedClient(r)
-	if err != nil {
-		log.Println("failed to authorize client")
-		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
 		return
 	}