Update multipart upload to use upload_id from server

The server now returns an upload_id from the start endpoint, which must be included in chunk and finalize endpoint paths.

Author: LeMikaelF

internal/turso/tursoServer.go

@@ -79,17 +79,17 @@ func (i *TursoServerClient) UploadFileMultipart(filepath string, remoteEncryptio
 	totalSize := stat.Size()
 	startTime := time.Now()
 
-	chunkSize, err := i.startMultipartUpload(totalSize)
+	uploadStart, err := i.startMultipartUpload(totalSize)
 	if err != nil {
 		return err
 	}
 
-	uploadedBytes, err := i.uploadChunks(chunkSize, file, totalSize, startTime, remoteEncryptionCipher, remoteEncryptionKey, onUploadProgress)
+	uploadedBytes, err := i.uploadChunks(uploadStart.UploadID, uploadStart.ChunkSize, file, totalSize, startTime, remoteEncryptionCipher, remoteEncryptionKey, onUploadProgress)
 	if err != nil {
 		return err
 	}
 
-	if err = i.finalizeUpload(); err != nil {
+	if err = i.finalizeUpload(uploadStart.UploadID); err != nil {
 		return err
 	}
 
@@ -99,42 +99,51 @@ func (i *TursoServerClient) UploadFileMultipart(filepath string, remoteEncryptio
 	return nil
 }
 
-func (i *TursoServerClient) startMultipartUpload(dbSize int64) (int64, error) {
+type multipartUploadStart struct {
+	ChunkSize int64
+	UploadID  string
+}
+
+func (i *TursoServerClient) startMultipartUpload(dbSize int64) (multipartUploadStart, error) {
 	requestBody := map[string]int64{
 		"db_size_bytes": dbSize,
 	}
 
 	body, err := marshal(requestBody)
 	if err != nil {
-		return 0, fmt.Errorf("failed to marshal multipart upload request: %w", err)
+		return multipartUploadStart{}, fmt.Errorf("failed to marshal multipart upload request: %w", err)
 	}
 
 	r, err := i.client.Put("/v2/upload/start", body)
 	if err != nil {
-		return 0, fmt.Errorf("failed to initiate multipart upload: %w", err)
+		return multipartUploadStart{}, fmt.Errorf("failed to initiate multipart upload: %w", err)
 	}
 	defer r.Body.Close()
 
 	if r.StatusCode != http.StatusOK {
 		body, err := io.ReadAll(r.Body)
 		if err != nil {
-			return 0, fmt.Errorf("initiate multipart upload failed with status code %d and error reading response: %v", r.StatusCode, err)
+			return multipartUploadStart{}, fmt.Errorf("initiate multipart upload failed with status code %d and error reading response: %v", r.StatusCode, err)
 		}
-		return 0, fmt.Errorf("initiate multipart upload failed with status code %d: %s", r.StatusCode, string(body))
+		return multipartUploadStart{}, fmt.Errorf("initiate multipart upload failed with status code %d: %s", r.StatusCode, string(body))
 	}
 
 	type multipartUploadResponse struct {
-		ChunkSize int64 `json:"chunk_size"`
+		ChunkSize int64  `json:"chunk_size"`
+		UploadID  string `json:"upload_id"`
 	}
 	var uploadResp multipartUploadResponse
 	if err := json.NewDecoder(r.Body).Decode(&uploadResp); err != nil {
-		return 0, fmt.Errorf("failed to decode multipart upload response: %w", err)
+		return multipartUploadStart{}, fmt.Errorf("failed to decode multipart upload response: %w", err)
 	}
 
-	return uploadResp.ChunkSize, nil
+	return multipartUploadStart{
+		ChunkSize: uploadResp.ChunkSize,
+		UploadID:  uploadResp.UploadID,
+	}, nil
 }
 
-func (i *TursoServerClient) uploadChunks(chunkSize int64, file io.Reader, totalSize int64, startTime time.Time, remoteEncryptionCipher, remoteEncryptionKey string, onUploadProgress func(progressPct int, uploadedBytes int64, totalBytes int64, elapsedTime time.Duration, done bool)) (int64, error) {
+func (i *TursoServerClient) uploadChunks(uploadID string, chunkSize int64, file io.Reader, totalSize int64, startTime time.Time, remoteEncryptionCipher, remoteEncryptionKey string, onUploadProgress func(progressPct int, uploadedBytes int64, totalBytes int64, elapsedTime time.Duration, done bool)) (int64, error) {
 	var uploadedBytes int64 = 0
 	chunkID := 0
 	lastProgressPct := -1
@@ -157,7 +166,7 @@ func (i *TursoServerClient) uploadChunks(chunkSize int64, file io.Reader, totalS
 			lastUpdate: lastProgressPct,
 		}
 
-		chunkPath := fmt.Sprintf("/v2/upload/chunk/%d", chunkID)
+		chunkPath := fmt.Sprintf("/v2/upload/%s/chunk/%d", uploadID, chunkID)
 
 		var headers = map[string]string{}
 		if remoteEncryptionCipher != "" && remoteEncryptionKey != "" {
@@ -191,8 +200,8 @@ func (i *TursoServerClient) uploadChunks(chunkSize int64, file io.Reader, totalS
 	return uploadedBytes, nil
 }
 
-func (i *TursoServerClient) finalizeUpload() error {
-	r, err := i.client.Put("/v2/upload/finalize", nil)
+func (i *TursoServerClient) finalizeUpload(uploadID string) error {
+	r, err := i.client.Put(fmt.Sprintf("/v2/upload/%s/finalize", uploadID), nil)
 	if err != nil {
 		return fmt.Errorf("failed to finalize multipart upload: %w", err)
 	}

internal/turso/tursoServer_test.go

@@ -27,6 +27,7 @@ type MockTursoServer struct {
 	receivedHeaders map[string][]string
 	requestCount    int
 	chunkData       map[int][]byte
+	uploadID        string
 
 	// Configurable responses
 	startUploadStatus int
@@ -48,6 +49,7 @@ func NewMockTursoServer() *MockTursoServer {
 		finalizeStatus:    http.StatusOK,
 		chunkSize:         1024 * 1024, // 1MB default
 		failAtChunk:       -1,
+		uploadID:          "test-upload-id",
 	}
 
 	mock.Server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -63,9 +65,9 @@ func NewMockTursoServer() *MockTursoServer {
 		switch {
 		case r.Method == "PUT" && r.URL.Path == "/v2/upload/start":
 			mock.handleMultipartStart(w, r)
-		case r.Method == "PUT" && strings.HasPrefix(r.URL.Path, "/v2/upload/chunk/"):
+		case r.Method == "PUT" && strings.HasPrefix(r.URL.Path, "/v2/upload/"+mock.uploadID+"/chunk/"):
 			mock.handleChunkUpload(w, r)
-		case r.Method == "PUT" && r.URL.Path == "/v2/upload/finalize":
+		case r.Method == "PUT" && r.URL.Path == "/v2/upload/"+mock.uploadID+"/finalize":
 			mock.handleFinalize(w, r)
 		default:
 			w.WriteHeader(http.StatusNotFound)
@@ -83,7 +85,10 @@ func (m *MockTursoServer) handleMultipartStart(w http.ResponseWriter, r *http.Re
 	}
 
 	w.WriteHeader(m.startUploadStatus)
-	json.NewEncoder(w).Encode(map[string]int64{"chunk_size": m.chunkSize})
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"chunk_size": m.chunkSize,
+		"upload_id":  m.uploadID,
+	})
 }
 
 func (m *MockTursoServer) handleChunkUpload(w http.ResponseWriter, r *http.Request) {
@@ -517,22 +522,23 @@ func TestUploadFileMultipart_ProgressCallbackPerChunk(t *testing.T) {
 func TestUploadFileMultipart_ContentLengthHeader(t *testing.T) {
 	var receivedContentLengths []string
 	var mu sync.Mutex
+	uploadID := "test-upload-id"
 
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		mu.Lock()
-		if strings.HasPrefix(r.URL.Path, "/v2/upload/chunk/") {
+		if strings.Contains(r.URL.Path, "/chunk/") {
 			receivedContentLengths = append(receivedContentLengths, r.Header.Get("Content-Length"))
 		}
 		mu.Unlock()
 
 		switch {
 		case r.URL.Path == "/v2/upload/start":
 			w.WriteHeader(http.StatusOK)
-			_ = json.NewEncoder(w).Encode(map[string]int64{"chunk_size": 1024})
-		case strings.HasPrefix(r.URL.Path, "/v2/upload/chunk/"):
+			_ = json.NewEncoder(w).Encode(map[string]interface{}{"chunk_size": int64(1024), "upload_id": uploadID})
+		case strings.HasPrefix(r.URL.Path, "/v2/upload/"+uploadID+"/chunk/"):
 			_, _ = io.ReadAll(r.Body)
 			w.WriteHeader(http.StatusOK)
-		case r.URL.Path == "/v2/upload/finalize":
+		case r.URL.Path == "/v2/upload/"+uploadID+"/finalize":
 			w.WriteHeader(http.StatusOK)
 		default:
 			w.WriteHeader(http.StatusNotFound)