Switch DoltHub fork from REST API to GraphQL createFork mutation

Replace the v1alpha1 REST fork endpoint with the DoltHub GraphQL API
at /graphql, using the createFork mutation with cookie-based auth
(dolthubToken). The GraphQL API is more reliable and is the same
approach used by hosted.doltdb.com per DoltHub team guidance.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: julianknutsen

internal/remote/dolthub.go

@@ -4,14 +4,15 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 	"strings"
 	"time"
 )
 
-// dolthubAPIBase is the DoltHub REST API base URL.
+// dolthubGraphQLURL is the DoltHub GraphQL API endpoint.
 // Var so tests can override it.
-var dolthubAPIBase = "https://www.dolthub.com/api/v1alpha1"
+var dolthubGraphQLURL = "https://www.dolthub.com/graphql"
 
 const dolthubRemoteBase = "https://doltremoteapi.dolthub.com"
 
@@ -29,48 +30,77 @@ func (d *DoltHubProvider) DatabaseURL(org, db string) string {
 	return fmt.Sprintf("%s/%s/%s", dolthubRemoteBase, org, db)
 }
 
+// graphqlRequest is the JSON body sent to the GraphQL endpoint.
+type graphqlRequest struct {
+	Query     string         `json:"query"`
+	Variables map[string]any `json:"variables,omitempty"`
+}
+
+// graphqlResponse is the top-level JSON response from GraphQL.
+type graphqlResponse struct {
+	Data   json.RawMessage `json:"data"`
+	Errors []struct {
+		Message string `json:"message"`
+	} `json:"errors"`
+}
+
 func (d *DoltHubProvider) Fork(fromOrg, fromDB, toOrg string) error {
-	body := map[string]string{
-		"owner_name":     toOrg,
-		"new_repo_name":  fromDB,
-		"from_owner":     fromOrg,
-		"from_repo_name": fromDB,
+	query := `mutation CreateFork($ownerName: String!, $parentOwnerName: String!, $parentRepoName: String!) {
+  createFork(ownerName: $ownerName, parentOwnerName: $parentOwnerName, parentRepoName: $parentRepoName) {
+    forkOperationName
+  }
+}`
+	reqBody := graphqlRequest{
+		Query: query,
+		Variables: map[string]any{
+			"ownerName":       toOrg,
+			"parentOwnerName": fromOrg,
+			"parentRepoName":  fromDB,
+		},
 	}
-	payload, err := json.Marshal(body)
+	payload, err := json.Marshal(reqBody)
 	if err != nil {
 		return fmt.Errorf("marshaling fork request: %w", err)
 	}
 
-	url := dolthubAPIBase + "/database/fork"
-	req, err := http.NewRequest("POST", url, bytes.NewReader(payload))
+	req, err := http.NewRequest("POST", dolthubGraphQLURL, bytes.NewReader(payload))
 	if err != nil {
 		return fmt.Errorf("creating fork request: %w", err)
 	}
 	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("authorization", "token "+d.token)
+	req.Header.Set("Cookie", "dolthubToken="+d.token)
 
 	client := &http.Client{Timeout: 60 * time.Second}
 	resp, err := client.Do(req)
 	if err != nil {
-		return fmt.Errorf("DoltHub fork API request failed: %w", err)
+		return fmt.Errorf("DoltHub GraphQL fork request failed: %w", err)
 	}
 	defer func() { _ = resp.Body.Close() }()
 
-	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
-		return nil
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("reading DoltHub GraphQL response: %w", err)
 	}
 
-	var errResp struct {
-		Status  string `json:"status"`
-		Message string `json:"message"`
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return fmt.Errorf("DoltHub GraphQL error (HTTP %d): %s", resp.StatusCode, string(body))
+	}
+
+	var gqlResp graphqlResponse
+	if err := json.Unmarshal(body, &gqlResp); err != nil {
+		return fmt.Errorf("parsing DoltHub GraphQL response: %w", err)
 	}
-	if decErr := json.NewDecoder(resp.Body).Decode(&errResp); decErr == nil {
-		if strings.Contains(strings.ToLower(errResp.Message), "already exists") {
+
+	if len(gqlResp.Errors) > 0 {
+		msg := gqlResp.Errors[0].Message
+		if strings.Contains(strings.ToLower(msg), "already exists") ||
+			strings.Contains(strings.ToLower(msg), "already been forked") {
 			return nil
 		}
-		return fmt.Errorf("DoltHub fork API error (HTTP %d): %s", resp.StatusCode, errResp.Message)
+		return fmt.Errorf("DoltHub GraphQL fork error: %s", msg)
 	}
-	return fmt.Errorf("DoltHub fork API error (HTTP %d)", resp.StatusCode)
+
+	return nil
 }
 
 func (d *DoltHubProvider) Type() string { return "dolthub" }

internal/remote/dolthub_test.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
+	"strings"
 	"testing"
 )
 
@@ -14,9 +15,9 @@ func TestDoltHubProvider_Fork(t *testing.T) {
 		body       string
 		wantError  bool
 	}{
-		{"success", 200, `{"status":"ok"}`, false},
-		{"already exists", 409, `{"message":"already exists"}`, false},
-		{"forbidden", 403, `{"message":"forbidden"}`, true},
+		{"success", 200, `{"data":{"createFork":{"forkOperationName":"op-123"}}}`, false},
+		{"already exists", 200, `{"errors":[{"message":"database has already been forked"}]}`, false},
+		{"forbidden", 200, `{"errors":[{"message":"forbidden"}]}`, true},
 	}
 
 	for _, tt := range tests {
@@ -25,29 +26,40 @@ func TestDoltHubProvider_Fork(t *testing.T) {
 				if r.Method != "POST" {
 					t.Errorf("expected POST, got %s", r.Method)
 				}
-				if r.URL.Path != "/database/fork" {
-					t.Errorf("expected /database/fork, got %s", r.URL.Path)
-				}
-				if r.Header.Get("authorization") != "token test-token" {
-					t.Errorf("expected auth header, got %q", r.Header.Get("authorization"))
+
+				// Verify cookie auth.
+				cookie := r.Header.Get("Cookie")
+				if !strings.Contains(cookie, "dolthubToken=test-token") {
+					t.Errorf("expected dolthubToken cookie, got %q", cookie)
 				}
 
-				var body map[string]string
-				if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+				// Verify GraphQL request body.
+				var gqlReq graphqlRequest
+				if err := json.NewDecoder(r.Body).Decode(&gqlReq); err != nil {
 					t.Errorf("decoding request body: %v", err)
 				}
-				if body["from_owner"] != "steveyegge" {
-					t.Errorf("from_owner = %q, want %q", body["from_owner"], "steveyegge")
+				if !strings.Contains(gqlReq.Query, "createFork") {
+					t.Errorf("query should contain createFork, got %q", gqlReq.Query)
+				}
+				vars := gqlReq.Variables
+				if vars["parentOwnerName"] != "steveyegge" {
+					t.Errorf("parentOwnerName = %q, want %q", vars["parentOwnerName"], "steveyegge")
+				}
+				if vars["parentRepoName"] != "wl-commons" {
+					t.Errorf("parentRepoName = %q, want %q", vars["parentRepoName"], "wl-commons")
+				}
+				if vars["ownerName"] != "alice-dev" {
+					t.Errorf("ownerName = %q, want %q", vars["ownerName"], "alice-dev")
 				}
 
 				w.WriteHeader(tt.statusCode)
 				_, _ = w.Write([]byte(tt.body))
 			}))
 			defer server.Close()
 
-			oldBase := dolthubAPIBase
-			dolthubAPIBase = server.URL
-			defer func() { dolthubAPIBase = oldBase }()
+			oldURL := dolthubGraphQLURL
+			dolthubGraphQLURL = server.URL
+			defer func() { dolthubGraphQLURL = oldURL }()
 
 			provider := NewDoltHubProvider("test-token")
 			err := provider.Fork("steveyegge", "wl-commons", "alice-dev")
@@ -61,6 +73,24 @@ func TestDoltHubProvider_Fork(t *testing.T) {
 	}
 }
 
+func TestDoltHubProvider_Fork_HTTPError(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(500)
+		_, _ = w.Write([]byte("internal server error"))
+	}))
+	defer server.Close()
+
+	oldURL := dolthubGraphQLURL
+	dolthubGraphQLURL = server.URL
+	defer func() { dolthubGraphQLURL = oldURL }()
+
+	provider := NewDoltHubProvider("test-token")
+	err := provider.Fork("org", "db", "fork-org")
+	if err == nil {
+		t.Error("expected error for HTTP 500")
+	}
+}
+
 func TestDoltHubProvider_DatabaseURL(t *testing.T) {
 	provider := NewDoltHubProvider("token")
 	got := provider.DatabaseURL("steveyegge", "wl-commons")