Request Building

For advanced HTTP operations, you can build custom requests with full control over methods, headers, and other request properties. This is essential for complex API integrations and custom protocols.

Custom Request Creation

http.NewRequest(method, url, body)

Creates a new HTTP request object for customization before execution.

Syntax:

NewRequest Syntax
1	`http.NewRequest(method, url, body) (request, error)`

Parameters: - method (string) - HTTP method (GET, POST, PUT, DELETE, PATCH, etc.) - url (string) - Target URL - body (string) - Request body (use empty string for no body)

Returns: - request (map) - Request object for further customization - error - None on success, error on failure

Examples:

Custom HTTP Method:

Custom HTTP Method

package main
import http
import json
import fmt

// PATCH request for partial updates
function patchUser(userId string, updates map) {
    var jsonData, jsonErr = json.Marshal(updates)
    if jsonErr != None {
        return jsonErr
    }

    var url = "https://api.example.com/users/" + userId
    var result = http.NewRequest("PATCH", url, jsonData)
    var request = result[0]
    var err = result[1]

    if err != None {
        return "Failed to create request: " + err
    }

    // Set headers for PATCH request
    var contentRequest = http.SetHeader(request, "Content-Type", "application/json")[0]
    var authRequest = http.SetHeader(contentRequest, "Authorization", "Bearer token123")[0]

    // Execute the request
    var response = http.Do(authRequest)[0]

    if response["status"] == 200 {
        fmt.Printf("✅ User %s patched successfully\n", userId)
        return None
    } else {
        return "Patch failed: " + response["statusText"]
    }
}

// Usage
var updates = {"email": "newemail@example.com"}
var patchErr = patchUser("123", updates)
if patchErr != None {
    fmt.Printf("Patch Error: %s\n", patchErr)
}

Request with Authentication:

Request with Authentication

package main
import http
import json
import fmt

// Authenticated API request builder
function authenticatedRequest(method string, endpoint string, token string, body string) {
    var fullUrl = "https://secure-api.example.com" + endpoint
    var result = http.NewRequest(method, fullUrl, body)
    var request = result[0]
    var err = result[1]

    if err != None {
        return None, "Request creation failed: " + err
    }

    // Add authentication and standard headers
    var authRequest = http.SetHeader(request, "Authorization", "Bearer " + token)[0]
    var contentRequest = http.SetHeader(authRequest, "Content-Type", "application/json")[0]
    var acceptRequest = http.SetHeader(contentRequest, "Accept", "application/json")[0]
    var userAgentRequest = http.SetHeader(acceptRequest, "User-Agent", "HarneetApp/1.0")[0]

    return userAgentRequest, None
}

// Usage
var token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
var userData = {"name": "Alice", "role": "admin"}
var jsonData, _ = json.Marshal(userData)

var request, reqErr = authenticatedRequest("POST", "/api/users", token, jsonData)
if reqErr != None {
    fmt.Printf("Request Error: %s\n", reqErr)
} else {
    var response = http.Do(request)[0]
    fmt.Printf("Response Status: %d\n", response["status"])
}

Header Management

http.SetHeader(request, key, value)

Sets a header on a request object.

Syntax:

SetHeader Syntax
1	`http.SetHeader(request, key, value) (request, error)`

Parameters: - request (map) - Request object from NewRequest - key (string) - Header name - value (string) - Header value

Returns: - request (map) - Updated request object - error - None on success, error on failure

Examples:

Multiple Header Management:

Multiple Headers

package main
import http
import fmt

// Build request with multiple headers
function buildAPIRequest(url string, token string) {
    var result = http.NewRequest("GET", url, "")
    var request = result[0]
    var err = result[1]

    if err != None {
        return None, err
    }

    // Chain multiple headers
    var authRequest = http.SetHeader(request, "Authorization", "Bearer " + token)[0]
    var userAgentRequest = http.SetHeader(authRequest, "User-Agent", "HarneetApp/1.0")[0]
    var acceptRequest = http.SetHeader(userAgentRequest, "Accept", "application/json")[0]
    var cacheRequest = http.SetHeader(acceptRequest, "Cache-Control", "no-cache")[0]
    var langRequest = http.SetHeader(cacheRequest, "Accept-Language", "en-US,en;q=0.9")[0]

    return langRequest, None
}

// Usage
var request, reqErr = buildAPIRequest("https://api.example.com/data", "token123")
if reqErr != None {
    fmt.Printf("Request building failed: %s\n", reqErr)
} else {
    var response = http.Do(request)[0]
    fmt.Printf("API Response Status: %d\n", response["status"])
}

Cookie Management via Headers:

Cookie Management

package main
import http
import fmt

// Set multiple cookies in a request
function setRequestCookies(request map, cookies map) {
    var cookieString = ""
    var first = true

    // Build cookie string from map (simplified)
    for key, value in cookies {
        if !first {
            cookieString = cookieString + "; "
        }
        cookieString = cookieString + key + "=" + value
        first = false
    }

    var cookieRequest = http.SetHeader(request, "Cookie", cookieString)[0]
    return cookieRequest
}

// Usage
var request = http.NewRequest("GET", "https://api.example.com/profile", "")[0]
var cookies = {
    "session_id": "abc123xyz",
    "user_pref": "dark_theme",
    "lang": "en"
}

var cookieRequest = setRequestCookies(request, cookies)
var response = http.Do(cookieRequest)[0]
fmt.Printf("Profile request with cookies - Status: %d\n", response["status"])

Content Negotiation Headers:

Content Negotiation

package main
import http
import fmt

// Set content negotiation headers
function requestWithContentNegotiation(url string, acceptType string, acceptEncoding string) {
    var request = http.NewRequest("GET", url, "")[0]

    // Content negotiation headers
    var acceptRequest = http.SetHeader(request, "Accept", acceptType)[0]
    var encodingRequest = http.SetHeader(acceptRequest, "Accept-Encoding", acceptEncoding)[0]
    var charsetRequest = http.SetHeader(encodingRequest, "Accept-Charset", "utf-8")[0]

    return charsetRequest
}

// Usage examples
var jsonRequest = requestWithContentNegotiation(
    "https://api.example.com/data", 
    "application/json", 
    "gzip, deflate"
)

var xmlRequest = requestWithContentNegotiation(
    "https://api.example.com/data", 
    "application/xml", 
    "gzip"
)

var jsonResponse = http.Do(jsonRequest)[0]
var xmlResponse = http.Do(xmlRequest)[0]

fmt.Printf("JSON Response: %d\n", jsonResponse["status"])
fmt.Printf("XML Response: %d\n", xmlResponse["status"])

Request Execution

http.Do(request)

Executes a custom HTTP request.

Syntax:

Do Syntax
1	`http.Do(request) (response, error)`

Parameters: - request (map) - Request object created with NewRequest

Returns: - response (map) - Response object - error - None on success, error on failure

Request Object Structure

Request objects created with http.NewRequest() have the following structure:

Request Object Structure

package main
{
    "method": "GET",                  // HTTP method
    "url": "https://example.com",     // Target URL
    "headers": {                      // Headers map
        "User-Agent": "Harneet/1.0",
        "Authorization": "Bearer token",
        "Content-Type": "application/json",
        // ... other headers
    }
}

Common Header Types

Authentication Headers

// Bearer token authentication
http.SetHeader(request, "Authorization", "Bearer " + token)

// Basic authentication (base64 encoded username:password)
http.SetHeader(request, "Authorization", "Basic " + encodedCredentials)

// API key authentication
http.SetHeader(request, "X-API-Key", apiKey)

Content Headers

// JSON content
http.SetHeader(request, "Content-Type", "application/json")

// Form data
http.SetHeader(request, "Content-Type", "application/x-www-form-urlencoded")

// File upload
http.SetHeader(request, "Content-Type", "multipart/form-data")

// Plain text
http.SetHeader(request, "Content-Type", "text/plain")

Accept Headers

// Accept JSON responses
http.SetHeader(request, "Accept", "application/json")

// Accept multiple formats
http.SetHeader(request, "Accept", "application/json, application/xml, text/plain")

// Accept with quality values
http.SetHeader(request, "Accept", "application/json;q=0.9, text/plain;q=0.8")

Caching Headers

// Disable caching
http.SetHeader(request, "Cache-Control", "no-cache")

// Force fresh response
http.SetHeader(request, "Cache-Control", "no-store")

// Conditional requests
http.SetHeader(request, "If-Modified-Since", "Wed, 21 Oct 2015 07:28:00 GMT")
http.SetHeader(request, "If-None-Match", "\"33a64df551425fcc55e4d42a148795d9f25f89d4\"")

Custom Headers

// API versioning
http.SetHeader(request, "X-API-Version", "v2")

// Request ID for tracing
http.SetHeader(request, "X-Request-ID", "req-123456")

// Client information
http.SetHeader(request, "User-Agent", "MyApp/1.0 (Platform/Version)")

// Language preferences
http.SetHeader(request, "Accept-Language", "en-US,en;q=0.9,es;q=0.8")

Advanced Request Patterns

Request Builder Pattern

package main
import http

// Request builder function
function buildRequest(method string, url string) {
    return http.NewRequest(method, url, "")[0]
}

function withAuth(request map, token string) {
    return http.SetHeader(request, "Authorization", "Bearer " + token)[0]
}

function withJSON(request map) {
    var contentRequest = http.SetHeader(request, "Content-Type", "application/json")[0]
    return http.SetHeader(contentRequest, "Accept", "application/json")[0]
}

function withUserAgent(request map, userAgent string) {
    return http.SetHeader(request, "User-Agent", userAgent)[0]
}

// Usage
var request = buildRequest("GET", "https://api.example.com/data")
request = withAuth(request, "token123")
request = withJSON(request)
request = withUserAgent(request, "MyApp/1.0")

var response = http.Do(request)[0]

Request Template Function

package main
import http
import json

// Generic API request template
function apiRequest(method string, endpoint string, data map, token string) {
    var baseUrl = "https://api.example.com"
    var fullUrl = baseUrl + endpoint

    var body = ""
    if data != None {
        var jsonData, _ = json.Marshal(data)
        body = jsonData
    }

    var request = http.NewRequest(method, fullUrl, body)[0]

    // Standard headers
    request = http.SetHeader(request, "Content-Type", "application/json")[0]
    request = http.SetHeader(request, "Accept", "application/json")[0]
    request = http.SetHeader(request, "User-Agent", "HarneetApp/1.0")[0]

    // Authentication
    if token != "" {
        request = http.SetHeader(request, "Authorization", "Bearer " + token)[0]
    }

    return http.Do(request)
}

// Usage examples
var users = apiRequest("GET", "/users", None, "token123")
var newUser = apiRequest("POST", "/users", {"name": "Alice"}, "token123")
var updatedUser = apiRequest("PUT", "/users/123", {"name": "Alice Updated"}, "token123")
var deleted = apiRequest("DELETE", "/users/123", None, "token123")

Best Practices

1. Always Set User-Agent

Set User-Agent
1	`http.SetHeader(request, "User-Agent", "MyApp/1.0 (contact@example.com)")`

2. Use Appropriate Content-Type

Set Content-Type
1 2 3 4 5	`// For JSON data http.SetHeader(request, "Content-Type", "application/json") // For form data http.SetHeader(request, "Content-Type", "application/x-www-form-urlencoded")`

3. Handle Authentication Properly

Handle Authentication
1 2 3 4	`// Use Bearer tokens when possible http.SetHeader(request, "Authorization", "Bearer " + token) // Store sensitive tokens securely (not in code)`

4. Set Accept Headers

Set Accept Headers
1 2	`// Be explicit about what you expect http.SetHeader(request, "Accept", "application/json")`

5. Use Request IDs for Tracing

Use Request IDs
1	`http.SetHeader(request, "X-Request-ID", generateRequestId())`

Next Steps

Response Handling - Learn about processing responses and handling different content types
Examples & Patterns - See real-world examples and advanced patterns
HTTP Client - Go back to basic HTTP methods