appview: use Repo::AsRecord() in all put-record operations

this helps with consistency as we introduce more fields to the repo
lexicon.

Signed-off-by: oppiliappan <[e-mail]>

appview/db/repos.go

···
 }
 
 func (r *Repo) AsRecord() tangled.Repo {
-	return tangled.Repo{}
+	var source, spindle, description *string
+
+	if r.Source != "" {
+		source = &r.Source
+	}
+
+	if r.Spindle != "" {
+		spindle = &r.Spindle
+	}
+
+	if r.Description != "" {
+		description = &r.Description
+	}
+
+	return tangled.Repo{
+		Knot:        r.Knot,
+		Name:        r.Name,
+		Description: description,
+		CreatedAt:   r.Created.Format(time.RFC3339),
+		Source:      source,
+		Spindle:     spindle,
+	}
 }
 
 func (r Repo) RepoAt() syntax.ATURI {

appview/repo/repo.go

···
 			return
 		}
 
+		newRepo := f.Repo
+		newRepo.Description = newDescription
+		record := newRepo.AsRecord()
+
 		// this is a bit of a pain because the golang atproto impl does not allow nil SwapRecord field
 		//
 		// SwapRecord is optional and should happen automagically, but given that it does not, we have to perform two requests
-		ex, err := client.RepoGetRecord(r.Context(), "", tangled.RepoNSID, user.Did, rkey)
+		ex, err := client.RepoGetRecord(r.Context(), "", tangled.RepoNSID, newRepo.Did, newRepo.Rkey)
 		if err != nil {
 			// failed to get record
 			rp.pages.Notice(w, "repo-notice", "Failed to update description, no record found on PDS.")
···
 		}
 		_, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
 			Collection: tangled.RepoNSID,
-			Repo:       user.Did,
-			Rkey:       rkey,
+			Repo:       newRepo.Did,
+			Rkey:       newRepo.Rkey,
 			SwapRecord: ex.Cid,
 			Record: &lexutil.LexiconTypeDecoder{
-				Val: &tangled.Repo{
-					Knot:        f.Knot,
-					Name:        f.Name,
-					CreatedAt:   f.Created.Format(time.RFC3339),
-					Description: &newDescription,
-					Spindle:     &f.Spindle,
-				},
+				Val: &record,
 			},
 		})
 
···
 		return
 	}
 
-	repoAt := f.RepoAt()
-	rkey := repoAt.RecordKey().String()
-	if rkey == "" {
-		fail("Failed to resolve repo. Try again later", err)
-		return
-	}
-
 	newSpindle := r.FormValue("spindle")
 	removingSpindle := newSpindle == "[[none]]" // see pages/templates/repo/settings/pipelines.html for more info on why we use this value
 	client, err := rp.oauth.AuthorizedClient(r)
···
 		}
 	}
 
+	newRepo := f.Repo
+	newRepo.Spindle = newSpindle
+	record := newRepo.AsRecord()
+
 	spindlePtr := &newSpindle
 	if removingSpindle {
 		spindlePtr = nil
+		newRepo.Spindle = ""
 	}
 
 	// optimistic update
-	err = db.UpdateSpindle(rp.db, string(repoAt), spindlePtr)
+	err = db.UpdateSpindle(rp.db, newRepo.RepoAt().String(), spindlePtr)
 	if err != nil {
 		fail("Failed to update spindle. Try again later.", err)
 		return
 	}
 
-	ex, err := client.RepoGetRecord(r.Context(), "", tangled.RepoNSID, user.Did, rkey)
+	ex, err := client.RepoGetRecord(r.Context(), "", tangled.RepoNSID, newRepo.Did, newRepo.Rkey)
 	if err != nil {
 		fail("Failed to update spindle, no record found on PDS.", err)
 		return
 	}
 	_, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
 		Collection: tangled.RepoNSID,
-		Repo:       user.Did,
-		Rkey:       rkey,
+		Repo:       newRepo.Did,
+		Rkey:       newRepo.Rkey,
 		SwapRecord: ex.Cid,
 		Record: &lexutil.LexiconTypeDecoder{
-			Val: &tangled.Repo{
-				Knot:        f.Knot,
-				Name:        f.Name,
-				CreatedAt:   f.Created.Format(time.RFC3339),
-				Description: &f.Description,
-				Spindle:     spindlePtr,
-			},
+			Val: &record,
 		},
 	})
 
···
 		return
 	}
 
-	err = db.AddCollaborator(rp.db, db.Collaborator{
+	err = db.AddCollaborator(tx, db.Collaborator{
 		Did:        syntax.DID(currentUser.Did),
 		Rkey:       rkey,
 		SubjectDid: collaboratorIdent.DID,
···
 		// create an atproto record for this fork
 		rkey := tid.TID()
 		repo := &db.Repo{
-			Did:    user.Did,
-			Name:   forkName,
-			Knot:   targetKnot,
-			Rkey:   rkey,
-			Source: sourceAt,
+			Did:         user.Did,
+			Name:        forkName,
+			Knot:        targetKnot,
+			Rkey:        rkey,
+			Source:      sourceAt,
+			Description: existingRepo.Description,
+			Created:     time.Now(),
 		}
+		record := repo.AsRecord()
 
 		xrpcClient, err := rp.oauth.AuthorizedClient(r)
 		if err != nil {
···
 			return
 		}
 
-		createdAt := time.Now().Format(time.RFC3339)
 		atresp, err := xrpcClient.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
 			Collection: tangled.RepoNSID,
 			Repo:       user.Did,
 			Rkey:       rkey,
 			Record: &lexutil.LexiconTypeDecoder{
-				Val: &tangled.Repo{
-					Knot:      repo.Knot,
-					Name:      repo.Name,
-					CreatedAt: createdAt,
-					Source:    &sourceAt,
-				}},
+				Val: &record,
+			},
 		})
 		if err != nil {
 			l.Error("failed to write to PDS", "err", err)

appview/state/state.go

···
 			Knot:        domain,
 			Rkey:        rkey,
 			Description: description,
+			Created:     time.Now(),
 		}
+		record := repo.AsRecord()
 
 		xrpcClient, err := s.oauth.AuthorizedClient(r)
 		if err != nil {
···
 			return
 		}
 
-		createdAt := time.Now().Format(time.RFC3339)
 		atresp, err := xrpcClient.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
 			Collection: tangled.RepoNSID,
 			Repo:       user.Did,
 			Rkey:       rkey,
 			Record: &lexutil.LexiconTypeDecoder{
-				Val: &tangled.Repo{
-					Knot:      repo.Knot,
-					Name:      repoName,
-					CreatedAt: createdAt,
-				}},
+				Val: &record,
+			},
 		})
 		if err != nil {
 			l.Info("PDS write failed", "err", err)