Uploading Files to an API with Swift

Welcome to the next step in your journey of mastering API interactions with Swift! In our previous lesson, you learned how to download files efficiently using an API, enhancing your skills in file management. Today, we will take a look at the reverse process: uploading files to an API. This capability is crucial for creating applications that need to store or share files, such as documents, images, or any other type of data with an external server.

Understanding file uploads will further expand your ability to interact with APIs, equipping you to build more robust and feature-complete applications. By the end of this lesson, you will learn how to send a file to a server using Swift, ensuring that you can manage uploads confidently and efficiently.

To upload files via HTTP, the POST method is commonly used, as it’s designed for submitting data to a server, including files. The key to sending files is using multipart/form-data, a format that allows both text and binary data to be sent together, organized into separate parts. This format ensures the server can properly handle the uploaded file along with any additional data.

In Swift, URLSession and URLRequest make this process seamless. You can configure a URLRequest to use the POST method and set the appropriate headers for multipart/form-data. Swift's networking capabilities allow you to handle file uploads efficiently, focusing on the functionality of your application.

Now, let's delve into the process of uploading a file using Swift. Consider the following code example, which utilizes the "/notes" endpoint to upload a file named meeting_notes.txt.

import Foundation
import FoundationNetworking

// Base URL for the API
let baseURL = URL(string: "http://localhost:8000/notes")!

// Specify the file name to upload
let fileName = "meeting_notes.txt"

// Create a DispatchGroup
let dispatchGroup = DispatchGroup()

do {
    // Get the file URL
    let fileURL = URL(fileURLWithPath: fileName)
    
    // Read the file data
    let fileData = try Data(contentsOf: fileURL)
    
    // Create a URLRequest
    var request = URLRequest(url: baseURL)
    request.httpMethod = "POST"
    
    // Set the content type to multipart/form-data
    let boundary = UUID().uuidString
    request.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")
    
    // Create the multipart form data
    var body = Data()
    body.append("--\(boundary)\r\n".data(using: .utf8)!)
    body.append("Content-Disposition: form-data; name=\"file\"; filename=\"\(fileName)\"\r\n".data(using: .utf8)!)
    body.append("Content-Type: application/octet-stream\r\n\r\n".data(using: .utf8)!)
    body.append(fileData)
    body.append("\r\n--\(boundary)--\r\n".data(using: .utf8)!)
    
    request.httpBody = body
    
    // Enter the DispatchGroup
    dispatchGroup.enter()
    
    // Create a URLSession data task
    let task = URLSession.shared.dataTask(with: request) { data, response, error in
        if let error = error {
            print("Error occurred: \(error)")
        } else if let httpResponse = response as? HTTPURLResponse, (200...299).contains(httpResponse.statusCode) {
            print("File uploaded successfully: \(fileName)")
        } else {
            print("Failed to upload file.")
        }
        
        // Leave the DispatchGroup
        dispatchGroup.leave()
    }
    
    // Start the task
    task.resume()
    
    // Wait for the task to complete
    dispatchGroup.wait()
    
} catch {
    print("File not found or could not be read: \(fileName)")
}

This code example demonstrates how to properly upload a file to an API:

• The Data(contentsOf:) method reads the file data, which is essential for properly handling the file data.
• A URLRequest is configured to send a POST request to the API's /notes endpoint, attaching the file in the request.
• If the upload is successful, a success message is printed to the console.

In this example, requests are encapsulated in a do-catch block to gracefully address potential issues. An error is handled if the file specified for upload cannot be located or read. By managing these exceptions, you can ensure your application behaves predictably, even if something goes wrong during file upload.