tessl/maven-io-ktor--ktor-client-core-macosarm64

Ktor HTTP client core library providing asynchronous HTTP client functionality for multiplatform applications with macOS ARM64 support.

—

Pending

Overview

Eval results

Files

HTTP Client Operations

Name: tessl/maven-io-ktor--ktor-client-core-macosarm64
Author: tessl

Core HTTP client functionality for making requests, handling responses, and managing client lifecycle with multiplatform support and coroutine-based API.

Capabilities

HttpClient Class

Main HTTP client class providing HTTP operations with configurable engines and plugins.

/**
 * A multiplatform asynchronous HTTP client for making requests and handling responses
 * @param engine HTTP client engine for platform-specific implementation
 * @param userConfig Configuration for the client
 */
class HttpClient(
    public val engine: HttpClientEngine,
    private val userConfig: HttpClientConfig<out HttpClientEngineConfig> = HttpClientConfig()
) : CoroutineScope, Closeable {
    
    /** Pipeline for processing outgoing requests */
    public val requestPipeline: HttpRequestPipeline
    
    /** Pipeline for processing incoming responses */
    public val responsePipeline: HttpResponsePipeline
    
    /** Pipeline for sending requests */
    public val sendPipeline: HttpSendPipeline
    
    /** Pipeline for receiving responses */
    public val receivePipeline: HttpReceivePipeline
    
    /** Client attributes for storing custom data */
    public val attributes: Attributes
    
    /** Engine configuration access */
    public val engineConfig: HttpClientEngineConfig
    
    /** Event monitoring for client lifecycle */
    public val monitor: Events
    
    /** Check if engine supports a specific capability */
    public fun isSupported(capability: HttpClientEngineCapability<*>): Boolean
    
    /** Create a new client with additional configuration */
    public fun config(block: HttpClientConfig<*>.() -> Unit): HttpClient
    
    /** Close the client and release resources */
    override fun close()
}

Usage Examples:

import io.ktor.client.*
import io.ktor.client.engine.cio.*

// Create client with default engine
val client = HttpClient()

// Create client with specific engine
val cioClient = HttpClient(CIO) {
    expectSuccess = false
    followRedirects = true
}

// Check engine capabilities
if (client.isSupported(HttpTimeout)) {
    println("Timeout supported")
}

// Create configured client
val configuredClient = client.config {
    install(HttpTimeout) {
        requestTimeoutMillis = 10000
    }
}

// Always close clients
client.close()
configuredClient.close()

HttpClient Factory Function

Platform-specific factory function for creating HTTP clients with configuration.

/**
 * Creates an HttpClient with platform-appropriate default engine
 * @param block Configuration block for the client
 * @return Configured HttpClient instance
 */
expect fun HttpClient(
    block: HttpClientConfig<*>.() -> Unit = {}
): HttpClient

Usage Examples:

import io.ktor.client.*
import io.ktor.client.plugins.*

// Simple client creation
val client = HttpClient()

// Client with configuration
val configuredClient = HttpClient {
    install(UserAgent) {
        agent = "MyApp/1.0"
    }
    
    expectSuccess = false
    followRedirects = true
    
    engine {
        // Engine-specific configuration
        threadsCount = 4
        pipelining = true
    }
}

HTTP Method Extensions

Convenient extension functions for common HTTP methods.

/**
 * Perform GET request
 * @param urlString Target URL
 * @param block Request configuration
 * @return HTTP response
 */
suspend fun HttpClient.get(
    urlString: String,
    block: HttpRequestBuilder.() -> Unit = {}
): HttpResponse

/**
 * Perform POST request
 * @param urlString Target URL  
 * @param block Request configuration
 * @return HTTP response
 */
suspend fun HttpClient.post(
    urlString: String,
    block: HttpRequestBuilder.() -> Unit = {}
): HttpResponse

/**
 * Perform PUT request
 * @param urlString Target URL
 * @param block Request configuration  
 * @return HTTP response
 */
suspend fun HttpClient.put(
    urlString: String,
    block: HttpRequestBuilder.() -> Unit = {}
): HttpResponse

/**
 * Perform PATCH request
 * @param urlString Target URL
 * @param block Request configuration
 * @return HTTP response
 */
suspend fun HttpClient.patch(
    urlString: String,
    block: HttpRequestBuilder.() -> Unit = {}
): HttpResponse

/**
 * Perform DELETE request
 * @param urlString Target URL
 * @param block Request configuration
 * @return HTTP response
 */
suspend fun HttpClient.delete(
    urlString: String,
    block: HttpRequestBuilder.() -> Unit = {}
): HttpResponse

/**
 * Perform HEAD request
 * @param urlString Target URL
 * @param block Request configuration
 * @return HTTP response
 */
suspend fun HttpClient.head(
    urlString: String,
    block: HttpRequestBuilder.() -> Unit = {}
): HttpResponse

/**
 * Perform OPTIONS request
 * @param urlString Target URL
 * @param block Request configuration
 * @return HTTP response
 */
suspend fun HttpClient.options(
    urlString: String,
    block: HttpRequestBuilder.() -> Unit = {}
): HttpResponse

Usage Examples:

import io.ktor.client.*
import io.ktor.client.request.*
import io.ktor.client.statement.*

val client = HttpClient()

// GET request
val getResponse = client.get("https://api.example.com/users")
val users = getResponse.bodyAsText()

// POST request with JSON body
val postResponse = client.post("https://api.example.com/users") {
    setBody("""{"name": "John", "email": "john@example.com"}""")
    headers {
        append("Content-Type", "application/json")
    }
}

// PUT request with authentication
val putResponse = client.put("https://api.example.com/users/123") {
    setBody("""{"name": "John Updated"}""")
    headers {
        append("Authorization", "Bearer $token")
        append("Content-Type", "application/json")
    }
}

// DELETE request
val deleteResponse = client.delete("https://api.example.com/users/123") {
    headers {
        append("Authorization", "Bearer $token")
    }
}

Generic Request Function

Generic request function for custom HTTP methods and advanced configurations.

/**
 * Perform generic HTTP request
 * @param block Request configuration including method, URL, headers, body
 * @return HTTP response
 */
suspend fun HttpClient.request(block: HttpRequestBuilder.() -> Unit): HttpResponse

Usage Examples:

import io.ktor.client.*
import io.ktor.client.request.*
import io.ktor.http.*

val client = HttpClient()

// Custom HTTP method
val response = client.request {
    method = HttpMethod("PATCH")
    url("https://api.example.com/resource")
    setBody("""{"op": "replace", "path": "/status", "value": "active"}""")
    headers {
        append("Content-Type", "application/json-patch+json")
    }
}

// Complex request configuration
val complexResponse = client.request {
    method = HttpMethod.Post
    url {
        protocol = URLProtocol.HTTPS
        host = "api.example.com"
        path("v1", "users")
        parameter("include", "profile")
    }
    headers {
        append("Authorization", "Bearer $token")
        append("Accept", "application/vnd.api+json")
    }
    setBody(requestData)
    timeout {
        requestTimeoutMillis = 30000
    }
}

Request Preparation Functions

Functions for preparing requests without immediate execution.

/**
 * Prepare GET request for later execution
 * @param urlString Target URL
 * @param block Request configuration
 * @return Prepared HttpStatement
 */
suspend fun HttpClient.prepareGet(
    urlString: String,
    block: HttpRequestBuilder.() -> Unit = {}
): HttpStatement

/**
 * Prepare POST request for later execution
 * @param urlString Target URL
 * @param block Request configuration
 * @return Prepared HttpStatement
 */
suspend fun HttpClient.preparePost(
    urlString: String,
    block: HttpRequestBuilder.() -> Unit = {}
): HttpStatement

/**
 * Prepare PUT request for later execution
 * @param urlString Target URL
 * @param block Request configuration
 * @return Prepared HttpStatement
 */
suspend fun HttpClient.preparePut(
    urlString: String,
    block: HttpRequestBuilder.() -> Unit = {}
): HttpStatement

/**
 * Prepare DELETE request for later execution
 * @param urlString Target URL
 * @param block Request configuration
 * @return Prepared HttpStatement
 */
suspend fun HttpClient.prepareDelete(
    urlString: String,
    block: HttpRequestBuilder.() -> Unit = {}
): HttpStatement

/**
 * Prepare HEAD request for later execution
 * @param urlString Target URL
 * @param block Request configuration
 * @return Prepared HttpStatement
 */
suspend fun HttpClient.prepareHead(
    urlString: String,
    block: HttpRequestBuilder.() -> Unit = {}
): HttpStatement

/**
 * Prepare OPTIONS request for later execution
 * @param urlString Target URL
 * @param block Request configuration
 * @return Prepared HttpStatement
 */
suspend fun HttpClient.prepareOptions(
    urlString: String,
    block: HttpRequestBuilder.() -> Unit = {}
): HttpStatement

Usage Examples:

import io.ktor.client.*
import io.ktor.client.statement.*

val client = HttpClient()

// Prepare request for reuse
val statement = client.prepareGet("https://api.example.com/data") {
    headers {
        append("Accept", "application/json")
    }
}

// Execute multiple times
val response1 = statement.execute()
val data1 = response1.bodyAsText()

val response2 = statement.execute()
val data2 = response2.bodyAsText()

// Execute with custom handling
statement.execute { response ->
    if (response.status.isSuccess()) {
        response.bodyAsText()
    } else {
        "Error: ${response.status}"
    }
}

Types

Core Client Types

interface HttpClientCall {
    val client: HttpClient
    val request: HttpRequest
    val response: HttpResponse
    val attributes: Attributes
    
    suspend inline fun <reified T> body(): T
    suspend inline fun <reified T> bodyNullable(): T?
    fun save(): SavedHttpCall
}

class SavedHttpCall(
    override val client: HttpClient,
    override val request: SavedHttpRequest,
    override val response: SavedHttpResponse,
    override val attributes: Attributes
) : HttpClientCall

interface HttpRequest {
    val call: HttpClientCall
    val method: HttpMethod
    val url: Url
    val attributes: Attributes
    val headers: Headers
    val body: OutgoingContent
}

Pipeline Types

class HttpRequestPipeline : Pipeline<Any, HttpRequestBuilder> {
    companion object {
        val Before = PipelinePhase("Before")
        val State = PipelinePhase("State")
        val Transform = PipelinePhase("Transform")
        val Render = PipelinePhase("Render")
        val Send = PipelinePhase("Send")
    }
}

class HttpResponsePipeline : Pipeline<HttpResponseContainer, HttpClientCall> {
    companion object {
        val Receive = PipelinePhase("Receive")
        val Parse = PipelinePhase("Parse")
        val Transform = PipelinePhase("Transform")
    }
}

class HttpSendPipeline : Pipeline<Any, HttpClientCall> {
    companion object {
        val Before = PipelinePhase("Before")
        val State = PipelinePhase("State")
        val Monitoring = PipelinePhase("Monitoring")
        val Engine = PipelinePhase("Engine")
        val Receive = PipelinePhase("Receive")
    }
}

class HttpReceivePipeline : Pipeline<HttpResponseContainer, HttpClientCall> {
    companion object {
        val Before = PipelinePhase("Before")
        val State = PipelinePhase("State")
        val After = PipelinePhase("After")
    }
}

Install with Tessl CLI

npx tessl i tessl/maven-io-ktor--ktor-client-core-macosarm64

docs

built-in-plugins.md

engine-configuration.md

tessl/maven-io-ktor--ktor-client-core-macosarm64

http-client.md.css-3qkkll{font-size:var(--chakra-font-sizes-sm);font-weight:var(--chakra-font-weights-normal);color:var(--chakra-colors-gray-300);}docs/

HTTP Client Operations

Capabilities

HttpClient Class

HttpClient Factory Function

HTTP Method Extensions

Generic Request Function

Request Preparation Functions

Types

Core Client Types

Pipeline Types

http-client.mddocs/