Cache implementation

Sources/Cache/Cache.swift

@@ -113,7 +113,6 @@ actor Cache {
 
       let hydratedTree = ResultTree(
         data: hydratedResults,
-        ttl: dehydratedTree.ttl,
         cachedAt: dehydratedTree.cachedAt,
         lastAccessed: dehydratedTree.lastAccessed,
         rootObject: rootObj
@@ -147,7 +146,6 @@ actor Cache {
           queryId: queryId,
           tree: .init(
             data: dehydratedResults,
-            ttl: response.ttl,
             cachedAt: Date(),
             lastAccessed: Date(),
             rootObject: rootObj

Sources/Cache/CacheSettings.swift

@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+import Foundation
+
 /// Specifies the cache configuration for a `DataConnect` instance.
 ///
 /// You can configure the cache's storage policy and its maximum size.
@@ -33,13 +35,22 @@ public struct CacheSettings: Sendable {
   /// to trigger cleanup procedures. The default is 100MB (100,000,000 bytes).
   public let maxSizeBytes: UInt64
 
+  /// Max time interval before a queries cache is considered stale and refreshed from the server
+  /// This interval does not imply that cached data is evicted and it can still be accessed using
+  /// the `cacheOnly` fetch policy
+  public let maxAge: TimeInterval
+
   /// Creates a new cache settings configuration.
   ///
   /// - Parameters:
   ///   - storage: The storage mechanism to use. Defaults to `.persistent`.
   ///   - maxSize: The maximum desired size of the cache in bytes. Defaults to 100MB.
-  public init(storage: Storage = .persistent, maxSize: UInt64 = 100_000_000) {
+  ///   - maxAge: The max time interval before a queries cache is considered stale and refreshed
+  /// from the server
+  public init(storage: Storage = .persistent, maxSize: UInt64 = 100_000_000,
+              maxAge: TimeInterval = 0) {
     self.storage = storage
     maxSizeBytes = maxSize
+    self.maxAge = maxAge
   }
 }

Sources/Cache/ResultTree.swift

@@ -19,9 +19,6 @@ struct ResultTree: Codable {
   // tree data - could be hydrated or dehydrated.
   let data: String
 
-  // interval during which query results are considered fresh
-  let ttl: TimeInterval
-
   // Local time when the entry was cached / updated
   let cachedAt: Date
 
@@ -38,7 +35,6 @@ struct ResultTree: Codable {
   enum CodingKeys: String, CodingKey {
     case cachedAt = "ca" // cached at
     case lastAccessed = "la" // last accessed
-    case ttl = "ri" // revalidation interval
     case data = "d" // data cached
   }
 }

Sources/Internal/GrpcClient.swift

@@ -159,8 +159,8 @@ actor GrpcClient: CustomStringConvertible {
        If we have Partial Errors, we follow the partial error route below.
        */
       guard !errorInfoList.isEmpty else {
-        // TODO: Extract ttl, server timestamp
-        return ServerResponse(jsonResults: resultsString, ttl: 10.0)
+        // TODO: Extract ttl, server timestamp when available
+        return ServerResponse(jsonResults: resultsString, maxAge: nil)
       }
 
       // We have partial errors returned

Sources/Internal/ServerResponse.swift

@@ -16,5 +16,5 @@ import Foundation
 
 struct ServerResponse {
   let jsonResults: String
-  let ttl: TimeInterval
+  let maxAge: TimeInterval?
 }

Sources/Queries/GenericQueryRef.swift

@@ -30,7 +30,24 @@ actor GenericQueryRef<ResultData: Decodable & Sendable, Variable: OperationVaria
 
   private let cache: Cache?
 
-  private var ttl: TimeInterval? = 10.0 //
+  // maxAge received from server in query response
+  private var serverMaxAge: TimeInterval? = nil
+
+  // maxAge computed based on server or cache settings
+  // server is given priority over cache settings
+  private var maxAge: TimeInterval {
+    if let serverMaxAge {
+      DataConnectLogger.debug("Using maxAge specified from server \(serverMaxAge)")
+      return serverMaxAge
+    }
+
+    if let ma = cache?.config.maxAge {
+      DataConnectLogger.debug("Using maxAge specified from cache settings \(ma)")
+      return ma
+    }
+
+    return 0
+  }
 
   // Ideally we would like this to be part of the QueryRef protocol
   // Not adding for now since the protocol is Public
@@ -94,6 +111,7 @@ actor GenericQueryRef<ResultData: Decodable & Sendable, Variable: OperationVaria
 
     do {
       if let cache {
+        serverMaxAge = response.maxAge
         await cache.update(queryId: operationId, response: response, requestor: self)
       }
     }
@@ -112,15 +130,14 @@ actor GenericQueryRef<ResultData: Decodable & Sendable, Variable: OperationVaria
   }
 
   private func fetchCachedResults(allowStale: Bool) async throws -> OperationResult<ResultData> {
-    guard let cache,
-          let ttl,
-          ttl > 0 else {
-      DataConnectLogger.info("No cache provider configured or ttl is not set \(ttl)")
+    guard let cache
+    else {
+      DataConnectLogger.info("No cache provider configured")
       return OperationResult(data: nil, source: .cache)
     }
 
     if let cacheEntry = await cache.resultTree(queryId: request.requestId),
-       (cacheEntry.isStale(ttl) && allowStale) || !cacheEntry.isStale(ttl) {
+       (cacheEntry.isStale(maxAge) && allowStale) || !cacheEntry.isStale(maxAge) {
       let decoder = JSONDecoder()
       let decodedData = try decoder.decode(
         ResultData.self,