feat: Add UploadReleaseAssetFromRelease convenience helper

github/repos_releases.go

@@ -12,6 +12,7 @@ import (
 	"io"
 	"mime"
 	"net/http"
+	"net/url"
 	"os"
 	"path/filepath"
 	"strings"
@@ -488,3 +489,71 @@ func (s *RepositoriesService) UploadReleaseAsset(ctx context.Context, owner, rep
 	}
 	return asset, resp, nil
 }
+
+// UploadReleaseAssetFromRelease uploads an asset using the UploadURL that's embedded
+// in a RepositoryRelease object.
+//
+// This is a convenience wrapper that extracts the release.UploadURL (which is usually
+// templated like "https://uploads.github.com/.../assets{?name,label}") and uploads
+// the provided file using the existing upload helpers.
+//
+// GitHub API docs: https://docs.github.com/rest/releases/assets#upload-a-release-asset
+//
+//meta:operation POST /repos/{owner}/{repo}/releases/{release_id}/assets
+func (s *RepositoriesService) UploadReleaseAssetFromRelease(ctx context.Context, release *RepositoryRelease, opts *UploadOptions, file *os.File) (*ReleaseAsset, *Response, error) {
+	if release == nil || release.UploadURL == nil {
+		return nil, nil, errors.New("release UploadURL must be provided")
+	}
+	if file == nil {
+		return nil, nil, errors.New("file must be provided")
+	}
+
+	// Extract upload URL.
+	uploadURL := *release.UploadURL
+
+	// If uploadURL contains a template, strip it (e.g. "{?name,label}").
+	if idx := strings.Index(uploadURL, "{"); idx != -1 {
+		uploadURL = uploadURL[:idx]
+	}
+
+	// If uploadURL is absolute (starts with http/https), parse and use only the path.
+	if strings.HasPrefix(uploadURL, "http://") || strings.HasPrefix(uploadURL, "https://") {
+		if uParsed, err := url.Parse(uploadURL); err == nil {
+			uploadURL = uParsed.Path
+		}
+	}
+
+	// Defensive: always remove any leading '/' so client gets a relative path.
+	uploadURL = strings.TrimPrefix(uploadURL, "/")
+
+	// addOptions will append query params for name/label (same as UploadReleaseAsset)
+	u, err := addOptions(uploadURL, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	stat, err := file.Stat()
+	if err != nil {
+		return nil, nil, err
+	}
+	if stat.IsDir() {
+		return nil, nil, errors.New("the asset to upload can't be a directory")
+	}
+
+	mediaType := mime.TypeByExtension(filepath.Ext(file.Name()))
+	if opts != nil && opts.MediaType != "" {
+		mediaType = opts.MediaType
+	}
+
+	req, err := s.client.NewUploadRequest(u, file, stat.Size(), mediaType)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	asset := new(ReleaseAsset)
+	resp, err := s.client.Do(ctx, req, asset)
+	if err != nil {
+		return nil, resp, err
+	}
+	return asset, resp, nil
+}

github/repos_releases_test.go

@@ -781,6 +781,83 @@ func TestRepositoriesService_UploadReleaseAsset(t *testing.T) {
 	}
 }
 
+func TestRepositoriesService_UploadReleaseAssetFromRelease(t *testing.T) {
+	t.Parallel()
+
+	var (
+		defaultUploadOptions     = &UploadOptions{Name: "n"}
+		defaultExpectedFormValue = values{"name": "n"}
+		mediaTypeTextPlain       = "text/plain; charset=utf-8"
+	)
+
+	client, mux, _ := setup(t)
+
+	// Use the same endpoint path used in other tests.
+	mux.HandleFunc("/repos/o/r/releases/1/assets", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "POST")
+		testHeader(t, r, "Content-Type", mediaTypeTextPlain)
+		testHeader(t, r, "Content-Length", "12")
+		testFormValues(t, r, defaultExpectedFormValue)
+		testBody(t, r, "Upload me !\n")
+
+		fmt.Fprint(w, `{"id":1}`)
+	})
+
+	// Create a file using the test helper that existing tests use.
+	file := openTestFile(t, "upload.txt", "Upload me !\n")
+
+	// Provide a templated upload URL like GitHub returns.
+	uploadURL := "/repos/o/r/releases/1/assets{?name,label}"
+	release := &RepositoryRelease{
+		UploadURL: &uploadURL,
+	}
+
+	ctx := t.Context()
+	asset, _, err := client.Repositories.UploadReleaseAssetFromRelease(ctx, release, defaultUploadOptions, file)
+	if err != nil {
+		t.Fatalf("Repositories.UploadReleaseAssetFromRelease returned error: %v", err)
+	}
+	want := &ReleaseAsset{ID: Ptr(int64(1))}
+	if !cmp.Equal(asset, want) {
+		t.Fatalf("Repositories.UploadReleaseAssetFromRelease returned %+v, want %+v", asset, want)
+	}
+
+	const methodName = "UploadReleaseAssetFromRelease"
+	testBadOptions(t, methodName, func() (err error) {
+		_, _, err = client.Repositories.UploadReleaseAssetFromRelease(ctx, release, defaultUploadOptions, nil)
+		return err
+	})
+}
+
+func TestRepositoriesService_UploadReleaseAssetFromRelease_AbsoluteTemplate(t *testing.T) {
+	t.Parallel()
+	client, mux, _ := setup(t)
+
+	mux.HandleFunc("/repos/o/r/releases/1/assets", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "POST")
+		// Expect name query param created by addOptions after trimming template.
+		if r.URL.Query().Get("name") != "abs.txt" {
+			t.Errorf("Expected name query param 'abs.txt', got %q", r.URL.Query().Get("name"))
+		}
+		fmt.Fprint(w, `{"id":1}`)
+	})
+
+	file := openTestFile(t, "upload.txt", "Upload me !\n")
+
+	uploadURL := "https://uploads.github.com/repos/o/r/releases/1/assets{?name,label}"
+	release := &RepositoryRelease{UploadURL: &uploadURL}
+
+	opts := &UploadOptions{Name: "abs.txt"}
+	asset, _, err := client.Repositories.UploadReleaseAssetFromRelease(t.Context(), release, opts, file)
+	if err != nil {
+		t.Fatalf("UploadReleaseAssetFromRelease returned error: %v", err)
+	}
+	want := &ReleaseAsset{ID: Ptr(int64(1))}
+	if !cmp.Equal(asset, want) {
+		t.Fatalf("UploadReleaseAssetFromRelease returned %+v, want %+v", asset, want)
+	}
+}
+
 func TestRepositoryReleaseRequest_Marshal(t *testing.T) {
 	t.Parallel()
 	testJSONMarshal(t, &repositoryReleaseRequest{}, "{}")