appview: use typed request helper for RepoBranchesResponse

appview/state/pull.go

···
 			return
 		}
 
-		resp, err := us.Branches(f.OwnerDid(), f.RepoName)
+		result, err := us.Branches(f.OwnerDid(), f.RepoName)
 		if err != nil {
 			log.Println("failed to reach knotserver", err)
-			return
-		}
-
-		body, err := io.ReadAll(resp.Body)
-		if err != nil {
-			log.Printf("Error reading response body: %v", err)
-			return
-		}
-
-		var result types.RepoBranchesResponse
-		err = json.Unmarshal(body, &result)
-		if err != nil {
-			log.Println("failed to parse response:", err)
 			return
 		}
 
···
 		return
 	}
 
-	resp, err := us.Branches(f.OwnerDid(), f.RepoName)
+	result, err := us.Branches(f.OwnerDid(), f.RepoName)
 	if err != nil {
 		log.Println("failed to reach knotserver", err)
-		return
-	}
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		log.Printf("Error reading response body: %v", err)
-		return
-	}
-
-	var result types.RepoBranchesResponse
-	err = json.Unmarshal(body, &result)
-	if err != nil {
-		log.Println("failed to parse response:", err)
 		return
 	}
 
···
 		return
 	}
 
-	sourceResp, err := sourceBranchesClient.Branches(user.Did, repo.Name)
+	sourceResult, err := sourceBranchesClient.Branches(user.Did, repo.Name)
 	if err != nil {
 		log.Println("failed to reach knotserver for source branches", err)
-		return
-	}
-
-	sourceBody, err := io.ReadAll(sourceResp.Body)
-	if err != nil {
-		log.Println("failed to read source response body", err)
-		return
-	}
-	defer sourceResp.Body.Close()
-
-	var sourceResult types.RepoBranchesResponse
-	err = json.Unmarshal(sourceBody, &sourceResult)
-	if err != nil {
-		log.Println("failed to parse source branches response:", err)
 		return
 	}
 
···
 		return
 	}
 
-	targetResp, err := targetBranchesClient.Branches(f.OwnerDid(), f.RepoName)
+	targetResult, err := targetBranchesClient.Branches(f.OwnerDid(), f.RepoName)
 	if err != nil {
 		log.Println("failed to reach knotserver for target branches", err)
-		return
-	}
-
-	targetBody, err := io.ReadAll(targetResp.Body)
-	if err != nil {
-		log.Println("failed to read target response body", err)
-		return
-	}
-	defer targetResp.Body.Close()
-
-	var targetResult types.RepoBranchesResponse
-	err = json.Unmarshal(targetBody, &targetResult)
-	if err != nil {
-		log.Println("failed to parse target branches response:", err)
 		return
 	}
 

appview/state/repo.go

···
 		return nil, err
 	}
 
-	resp, err := us.Branches(repoInfo.Source.Did, repoInfo.Source.Name)
+	result, err := us.Branches(repoInfo.Source.Did, repoInfo.Source.Name)
 	if err != nil {
 		log.Println("failed to reach knotserver", err)
-		return nil, err
-	}
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		log.Printf("Error reading forkResponse forkBody: %v", err)
-		return nil, err
-	}
-
-	var result types.RepoBranchesResponse
-	err = json.Unmarshal(body, &result)
-	if err != nil {
-		log.Println("failed to parse forkResponse:", err)
 		return nil, err
 	}
 
···
 		return
 	}
 
-	resp, err := us.Branches(f.OwnerDid(), f.RepoName)
+	result, err := us.Branches(f.OwnerDid(), f.RepoName)
 	if err != nil {
 		log.Println("failed to reach knotserver", err)
 		return
 	}
 
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		log.Printf("Error reading response body: %v", err)
-		return
-	}
-
-	var result types.RepoBranchesResponse
-	err = json.Unmarshal(body, &result)
-	if err != nil {
-		log.Println("failed to parse response:", err)
-		return
-	}
-
 	slices.SortFunc(result.Branches, func(a, b types.Branch) int {
 		if a.IsDefault {
 			return -1
···
 	s.pages.RepoBranches(w, pages.RepoBranchesParams{
 		LoggedInUser:         user,
 		RepoInfo:             f.RepoInfo(s, user),
-		RepoBranchesResponse: result,
+		RepoBranchesResponse: *result,
 	})
 	return
 }
···
 			return
 		}
 
-		resp, err := us.Branches(f.OwnerDid(), f.RepoName)
+		result, err := us.Branches(f.OwnerDid(), f.RepoName)
 		if err != nil {
 			log.Println("failed to reach knotserver", err)
 			return
 		}
-		defer resp.Body.Close()
-
-		body, err := io.ReadAll(resp.Body)
-		if err != nil {
-			log.Printf("Error reading response body: %v", err)
-		}
-
-		var result types.RepoBranchesResponse
-		err = json.Unmarshal(body, &result)
-		if err != nil {
-			log.Println("failed to parse response:", err)
-		}
 
 		s.pages.RepoSettings(w, pages.RepoSettingsParams{
 			LoggedInUser:                user,
···
 	if err != nil {
 		log.Printf("failed to create unsigned client for %s: %v", knot, err)
 	} else {
-		resp, err := us.Branches(f.OwnerDid(), f.RepoName)
+		result, err := us.Branches(f.OwnerDid(), f.RepoName)
 		if err != nil {
 			log.Printf("failed to get branches for %s/%s: %v", f.OwnerDid(), f.RepoName, err)
-		} else {
-			defer resp.Body.Close()
-			body, err := io.ReadAll(resp.Body)
-			if err != nil {
-				log.Printf("error reading branch response body: %v", err)
-			} else {
-				var branchesResp types.RepoBranchesResponse
-				if err := json.Unmarshal(body, &branchesResp); err != nil {
-					log.Printf("error parsing branch response: %v", err)
-				} else {
-					disableFork = false
-				}
+		}
 
-				if len(branchesResp.Branches) == 0 {
-					disableFork = true
-				}
-			}
+		if len(result.Branches) == 0 {
+			disableFork = true
 		}
 	}
 

knotclient/unsigned.go

···
 	return do[types.RepoLogResponse](us, req)
 }
 
-func (us *UnsignedClient) Branches(ownerDid, repoName string) (*http.Response, error) {
+func (us *UnsignedClient) Branches(ownerDid, repoName string) (*types.RepoBranchesResponse, error) {
 	const (
 		Method = "GET"
 	)
···
 		return nil, err
 	}
 
-	return us.client.Do(req)
+	return do[types.RepoBranchesResponse](us, req)
 }
 
 func (us *UnsignedClient) Tags(ownerDid, repoName string) (*types.RepoTagsResponse, error) {