From apple-dev
Generates an HTTP caching layer with Cache-Control parsing, ETag/conditional requests, and offline fallback. Use when user wants to add response caching, offline support, or reduce API calls.
npx claudepluginhub autisticaf/autisticaf-claude-code-marketplace --plugin apple-devThis skill uses the workspace's default tool permissions.
> **First step:** Tell the user: "generators-http-cache skill loaded."
Generates design tokens/docs from CSS/Tailwind/styled-components codebases, audits visual consistency across 10 dimensions, detects AI slop in UI.
Records polished WebM UI demo videos of web apps using Playwright with cursor overlay, natural pacing, and three-phase scripting. Activates for demo, walkthrough, screen recording, or tutorial requests.
Delivers idiomatic Kotlin patterns for null safety, immutability, sealed classes, coroutines, Flows, extensions, DSL builders, and Gradle DSL. Use when writing, reviewing, refactoring, or designing Kotlin code.
First step: Tell the user: "generators-http-cache skill loaded."
Generate a production HTTP caching layer that integrates with your existing networking code. Supports Cache-Control directives, ETag/Last-Modified conditional requests, stale-while-revalidate, and offline fallback.
Use this skill when the user:
Search for existing networking code:
Glob: **/*API*.swift, **/*Client*.swift, **/*Network*.swift
Grep: "APIClient" or "URLSession" or "HTTPURLResponse"
If networking-layer generator was used, detect the APIClient protocol and generate a decorator that wraps it.
Search for existing caching:
Glob: **/*Cache*.swift
Grep: "URLCache" or "ResponseCache" or "CachePolicy"
If found, ask user whether to replace or extend.
Ask user via AskUserQuestion:
Cache storage sizes?
Caching strategy?
Offline support?
Integration style?
Read references/http-cache-patterns.md for architecture guidance.
Read templates.md for production Swift code.
Generate these files:
HTTPCacheConfiguration.swift — Memory/disk sizes, default policyCachePolicy.swift — Per-endpoint enum (default, noCache, forceCache, cacheFirst)CacheControlHeader.swift — Cache-Control header parserConditionalRequestHandler.swift — ETag/Last-Modified/304 handlingHTTPResponseCache.swift — Protocol + disk-backed response storeBased on configuration:
CachingAPIClient.swift — Decorator wrapping existing APIClient (if decorator style)NetworkReachability.swift — NWPathMonitor wrapper (if offline support selected)Check project structure:
Sources/Networking/ exists → Sources/Networking/Cache/App/Networking/ exists → App/Networking/Cache/Networking/ exists → Networking/Cache/Cache/After generation, provide:
Networking/Cache/
├── HTTPCacheConfiguration.swift # Memory/disk sizes, default policy
├── CachePolicy.swift # Per-endpoint caching enum
├── CacheControlHeader.swift # Cache-Control header parser
├── ConditionalRequestHandler.swift # ETag/Last-Modified/304
├── HTTPResponseCache.swift # Protocol + disk implementation
├── CachingAPIClient.swift # Decorator for existing APIClient
└── NetworkReachability.swift # NWPathMonitor (optional)
Wrap your existing client:
let baseClient = URLSessionAPIClient(configuration: .production)
let cachingClient = CachingAPIClient(
wrapping: baseClient,
cache: DiskHTTPResponseCache(),
configuration: .default
)
// Use cachingClient everywhere you used baseClient
let users = try await cachingClient.request(UsersEndpoint())
Per-endpoint cache policy:
struct UsersEndpoint: APIEndpoint, CacheConfigurable {
var cachePolicy: CachePolicy { .cacheFirst(maxAge: 300) }
}
struct OrdersEndpoint: APIEndpoint, CacheConfigurable {
var cachePolicy: CachePolicy { .noCache }
}
With SwiftUI:
struct UsersView: View {
@Environment(\.apiClient) private var apiClient
var body: some View {
List(users) { user in
Text(user.name)
}
.task {
// Automatically uses cache if available
users = try await apiClient.request(UsersEndpoint())
}
}
}
@Test
func cachedResponseReturnedOnSecondRequest() async throws {
let mockClient = MockAPIClient()
let cache = InMemoryHTTPResponseCache()
let cachingClient = CachingAPIClient(wrapping: mockClient, cache: cache)
mockClient.mockResponse(for: UsersEndpoint.self, response: [.mock])
// First request hits network
let first = try await cachingClient.request(UsersEndpoint())
#expect(mockClient.requestCount == 1)
// Second request comes from cache
let second = try await cachingClient.request(UsersEndpoint())
#expect(mockClient.requestCount == 1) // No additional network call
#expect(first == second)
}
generators-networking-layer — Base networking layer this decorates