Add 'everythingBefore' date based cache clearing policy

Author: Mordil

Sources/Apollo/NormalizedCache.swift

@@ -13,6 +13,8 @@ public struct CacheClearingPolicy: Equatable {
   /// Clears the the last (most recent) records in the cache up to the given limit.
   /// - Parameter k: The number of records to remove from the cache.
   public static func last(_ k: Int) -> CacheClearingPolicy { .init(.last(k)) }
+  /// Clears all records from the cache that was pulled in before the date provided.
+  public static func everythingBefore(_ date: Date) -> CacheClearingPolicy { .init(.everythingBefore(date)) }
 
   // actual policy storage
 
@@ -28,13 +30,15 @@ public struct CacheClearingPolicy: Equatable {
     case allMatchingKeyPattern(String)
     case first(Int)
     case last(Int)
+    case everythingBefore(Date)
 
     public static func ==(lhs: _Policy, rhs: _Policy) -> Bool {
       switch (lhs, rhs) {
       case (.allRecords, .allRecords): return true
       case let (.allMatchingKeyPattern(left), .allMatchingKeyPattern(right)): return left == right
       case let (.first(left), .first(right)): return left == right
       case let (.last(left), .last(right)): return left == right
+      case let (.everythingBefore(left), .everythingBefore(right)): return left == right
       default: return false
       }
     }

Sources/Apollo/RecordSet.swift

@@ -31,6 +31,11 @@ public struct RecordSet {
 
     case let .allMatchingKeyPattern(pattern): self.storage = self.storage.filter { !$0.key.contains(pattern) }
 
+    case let .everythingBefore(date): self.storage = self.storage.filter {
+      let comparison = Calendar.current.compare($0.value.lastReceivedAt, to: date, toGranularity: .minute)
+      return comparison != .orderedAscending
+    }
+
     case .allRecords: fallthrough
     default: self.storage.removeAll()
     }

Sources/ApolloSQLite/SQLiteNormalizedCache.swift

@@ -141,6 +141,12 @@ public final class SQLiteNormalizedCache {
       )
       try self.db.run(matchingRecords.delete())
 
+    case let .everythingBefore(date):
+      let oldRecords = records.where(
+        self.lastReceivedAt < Int64(date.timeIntervalSince1970)
+      )
+      try self.db.run(oldRecords.delete())
+
     case .allRecords: fallthrough
     default:
       try self.db.run(records.delete())

Tests/ApolloSQLiteTests/CachePersistenceTests.swift

@@ -94,6 +94,25 @@ extension CachePersistenceTests {
     }
   }
 
+  func testClearByDate() {
+    let emptyCacheExpectation = self.expectation(description: "empty cache")
+
+    self.testCacheClearing(withPolicy: .allMatchingKeyPattern("*hero*")) { client, _ in
+      client.store.withinReadTransaction {
+        $0.loadRecords(forKeys: ["QUERY_ROOT.hero", "QUERY_ROOT.hero(episode:EMPIRE)"]) { result in
+          defer { emptyCacheExpectation.fulfill() }
+
+          do {
+            let results = try result.get()
+            XCTAssertTrue(results.allSatisfy({ $0 == nil }))
+          } catch {
+            XCTFail("Unexpected error: \(error)")
+          }
+        }
+      }
+    }
+  }
+
   private func testCacheClearing(
     withPolicy policy: CacheClearingPolicy,
     validateAssumptions: @escaping (ApolloClient, TwoHeroesQuery) throws -> Void,