Simplicity Swift HTTP Client Expert

Expert assistant for working with the Simplicity Swift HTTP library - a type-safe HTTP client inspired by swift-openapi-generator's client design.

What This Skill Does

This skill provides deep knowledge of the Simplicity Swift HTTP library architecture, helping you:

Instructions

1. Understanding the Architecture

When exploring the codebase:

- Executes requests through a middleware chain using `URLSession`

- The `send(request:)` method builds middleware chain in **reverse order**

- Middlewares execute in the order they were added (not reversed)

- Defines type-safe requests with associated `RequestBody` and `ResponseBody` types

- Provides default JSON encoding/decoding implementations

- Use `Never?` for `RequestBody` on bodyless requests (GET/DELETE)

- Intercepts requests/responses via `intercept` method

- Receives a `next` closure to continue the chain

- Can modify requests before calling `next`

- Can inspect/modify responses after `next` returns

2. Building and Testing

Use these commands:

```bash

Build the package

swift build

Run all tests

swift test

Run a specific test suite

swift test --filter MiddlewareTests

Run a specific test

swift test --filter "MiddlewareTests/middlewareCallOrder"

```

**IMPORTANT**: When running tests, run them for **all supported platforms**, not just one.

3. Working with Request Bodies

Follow these patterns for request body handling:

- Set `RequestBody` to `Never?`

- Set `httpBody` property to `nil`

- The protocol's private extensions skip body encoding automatically

- Define a concrete `Encodable` type for `RequestBody`

- Default JSON encoding is provided

- Override `encodeBody()` for custom encoding

4. Writing Tests

Use Swift Testing framework patterns:

For network tests:

5. Understanding Middleware Order

Key insight: The middleware chain is built in reverse, but execution is forward:

```swift

// Added in this order:

client.addMiddleware(LoggingMiddleware()) // 1

client.addMiddleware(AuthMiddleware()) // 2

// Chain built: Auth -> Logging -> URLSession

// Execution: Logging executes first, Auth second

```

6. Code Navigation

Key files to reference:

7. Best Practices

When working with this codebase:

1. **Type safety first**: Leverage associated types for compile-time guarantees

2. **Middleware for cross-cutting concerns**: Auth, logging, retry logic

3. **Test with mocks**: Use `MockURLProtocol` for deterministic tests

4. **Run multi-platform tests**: Always test on all supported platforms

5. **Follow the protocol patterns**: Use `Never?` correctly for bodyless requests

Example Usage

**Building and testing:**

```

"Build the package and run all tests"

"Run the middleware tests only"

"Test on all platforms"

```

**Code exploration:**

```

"Show me how middleware chains work"

"Explain the HTTPRequest body handling"

"Where is JSON encoding implemented?"

```

**Implementation:**

```

"Add a new retry middleware"

"Create a request with no body"

"Mock a network response for testing"

```

Constraints