crossmate

NYTPuzzleFetcher.swift (7114B)

---

 import Foundation
 import SwiftUI
 
 extension EnvironmentValues {
     @Entry var nytPuzzleFetcher: NYTPuzzleFetcher? = nil
 }
 
 actor NYTPuzzleFetcher {
     /// Upper bound on a puzzle response body. Real daily puzzle JSON is well
     /// under 200 KB, so 2 MB rejects nothing genuine while keeping an
     /// unexpected server response from buffering unbounded data. Checked
     /// against `Content-Length` before reading and enforced again while
     /// streaming, since the header is optional.
     static let maxResponseBytes = 2_097_152
 
     /// Upper bound on an overlay asset. The two real examples are 13 KB and
     /// 68 KB — they're mostly transparent — so 1 MB rejects nothing genuine
     /// while capping what a mis-served asset can buffer. Anything larger would
     /// blow the slicer's own payload budget long before it reached the `.xd`.
     static let maxOverlayBytes = 1_048_576
 
     private let cookieProvider: @Sendable () -> NYTCookieLoadResult
 
     init(cookieProvider: @escaping @Sendable () -> NYTCookieLoadResult) {
         self.cookieProvider = cookieProvider
     }
 
     func fetchPuzzle(for date: Date) async throws -> String {
         let cookie = try currentCookie()
 
         let formatter = DateFormatter()
         formatter.dateFormat = "yyyy-MM-dd"
         formatter.timeZone = TimeZone(identifier: "America/New_York")
         let dateString = formatter.string(from: date)
 
         let url = URL(string: "https://www.nytimes.com/svc/crosswords/v6/puzzle/daily/\(dateString).json")!
 
         var request = URLRequest(url: url)
         request.setValue("NYT-S=\(cookie)", forHTTPHeaderField: "Cookie")
 
         let (bytes, response) = try await URLSession.shared.bytes(for: request)
 
         guard let httpResponse = response as? HTTPURLResponse else {
             throw NYTFetchError.invalidResponse
         }
 
         switch httpResponse.statusCode {
         case 200:
             break
         case 401, 403:
             throw NYTFetchError.unauthorized
         case 429:
             throw NYTFetchError.rateLimited
         default:
             throw NYTFetchError.httpError(statusCode: httpResponse.statusCode)
         }
 
         // A success from this endpoint is always JSON; anything else (a
         // captive portal, an HTML error page served with 200) is not a
         // puzzle, so reject it before buffering the body.
         guard Self.isJSONContentType(httpResponse.value(forHTTPHeaderField: "Content-Type")) else {
             throw NYTFetchError.unexpectedContentType
         }
 
         let data = try await Self.boundedResponseData(
             from: bytes,
             limit: Self.maxResponseBytes,
             expectedLength: httpResponse.expectedContentLength
         )
 
         // Convert NYT JSON to .xd format, baking in both overlay phases when
         // the puzzle has them and their assets can be fetched.
         async let beforeStartImage = overlayImage(
             at: try? NYTToXDConverter.beforeStartImageURL(jsonData: data)
         )
         async let afterSolveImage = overlayImage(
             at: try? NYTToXDConverter.afterSolveImageURL(jsonData: data)
         )
         return try await NYTToXDConverter.convert(
             jsonData: data,
             beforeStartImage: beforeStartImage,
             afterSolveImage: afterSolveImage
         )
     }
 
     /// Fetches one puzzle overlay asset, or nil if it has none or the fetch fails.
     ///
     /// Deliberately swallows every error. Letting a CDN hiccup fail the whole
     /// conversion would cost the player the underlying crossword to save its
     /// artwork. Assets are fetched anonymously, so this adds no authenticated
     /// traffic.
     private func overlayImage(at url: URL?) async -> Data? {
         guard let url else { return nil }
         do {
             let (bytes, response) = try await URLSession.shared.bytes(from: url)
             guard let httpResponse = response as? HTTPURLResponse,
                   httpResponse.statusCode == 200 else {
                 return nil
             }
             return try await Self.boundedResponseData(
                 from: bytes,
                 limit: Self.maxOverlayBytes,
                 expectedLength: httpResponse.expectedContentLength
             )
         } catch {
             return nil
         }
     }
 
     /// Whether a response `Content-Type` permits JSON. A missing header is
     /// accepted (the body still has to survive JSON parsing); a supplied
     /// non-JSON type is rejected.
     static func isJSONContentType(_ header: String?) -> Bool {
         guard let header else { return true }
         let mime = header.split(separator: ";").first.map {
             $0.trimmingCharacters(in: .whitespaces).lowercased()
         } ?? ""
         return mime == "application/json" || mime.hasSuffix("+json")
     }
 
     /// Accumulates a response byte stream up to `limit`, failing as soon as
     /// the budget is exceeded (throwing drops the stream, which cancels the
     /// transfer). A known `expectedLength` over the budget fails before
     /// reading at all; an unknown length (-1) streams against the cap.
     static func boundedResponseData<S: AsyncSequence>(
         from bytes: S,
         limit: Int,
         expectedLength: Int64
     ) async throws -> Data where S.Element == UInt8 {
         guard expectedLength <= Int64(limit) else {
             throw NYTFetchError.responseTooLarge
         }
         var data = Data()
         data.reserveCapacity(expectedLength > 0 ? Int(expectedLength) : 0)
         for try await byte in bytes {
             guard data.count < limit else {
                 throw NYTFetchError.responseTooLarge
             }
             data.append(byte)
         }
         return data
     }
 
     private func currentCookie() throws -> String {
         switch cookieProvider() {
         case .available(let cookie):
             cookie
         case .missing:
             throw NYTFetchError.notSignedIn
         case .temporarilyUnavailable:
             throw NYTFetchError.sessionStatusUnavailable
         }
     }
 }
 
 enum NYTFetchError: LocalizedError {
     case notSignedIn
     case sessionStatusUnavailable
     case invalidResponse
     case unexpectedContentType
     case responseTooLarge
     case unauthorized
     case rateLimited
     case httpError(statusCode: Int)
 
     var errorDescription: String? {
         switch self {
         case .notSignedIn:
             "Not signed in to NYT."
         case .sessionStatusUnavailable:
             "Crossmate could not determine whether you are signed in to NYT. Unlock the device and try again."
         case .invalidResponse:
             "Received an invalid response."
         case .unexpectedContentType:
             "Received an unexpected response type."
         case .responseTooLarge:
             "Received an unexpectedly large response."
         case .unauthorized:
             "Your NYT session has expired. Sign in again from Settings."
         case .rateLimited:
             "Too many requests. Wait a moment and try again."
         case .httpError(let statusCode):
             "Fetch failed (HTTP \(statusCode))."
         }
     }
 }