Squashed 'apollo-ios/' changes from 9e4bad9cc..c5a0eef72

c5a0eef72 feature: @fieldPolicy directive (#735)

git-subtree-dir: apollo-ios
git-subtree-split: c5a0eef72972927864af6bda056095b0ba615dd0

Author: gh-action-runner

Sources/Apollo/ExecutionSources/CacheDataExecutionSource.swift

@@ -34,8 +34,9 @@ struct CacheDataExecutionSource: GraphQLExecutionSource {
     with info: FieldExecutionInfo,
     on object: Record
   ) -> PossiblyDeferred<AnyHashable?> {
-    PossiblyDeferred {      
-      let value = try object[info.cacheKeyForField()]
+    PossiblyDeferred {
+      
+      let value = try resolveCacheKey(with: info, on: object)
 
       switch value {
       case let reference as CacheReference:
@@ -67,6 +68,73 @@ struct CacheDataExecutionSource: GraphQLExecutionSource {
       }
     }
   }
+  
+  private func resolveCacheKey(
+    with info: FieldExecutionInfo,
+    on object: Record
+  ) throws -> AnyHashable? {
+    if let fieldPolicyResult = resolveProgrammaticFieldPolicy(with: info, and: info.field.type) ??
+        FieldPolicyDirectiveEvaluator(field: info.field, variables: info.parentInfo.variables)?.resolveFieldPolicy(),
+       let returnTypename = typename(for: info.field) {
+      
+      switch fieldPolicyResult {
+      case .single(let key):
+        return object[formatCacheKey(withInfo: key, andTypename: returnTypename)]
+      case .list(let keys):
+        return keys.map { object[formatCacheKey(withInfo: $0, andTypename: returnTypename)] }
+      }
+    }
+    
+    let key = try info.cacheKeyForField()
+    return object[key]
+  }
+  
+  private func resolveProgrammaticFieldPolicy(
+    with info: FieldExecutionInfo,
+    and type: Selection.Field.OutputType
+  ) -> FieldPolicyResult? {
+    guard let provider = info.parentInfo.schema.configuration.self as? (any FieldPolicyProvider.Type) else {
+      return nil
+    }
+    
+    switch type {
+    case .nonNull(let innerType):
+      return resolveProgrammaticFieldPolicy(with: info, and: innerType)
+    case .list(_):
+      if let keys = provider.cacheKeyList(
+        for: info.field,
+        variables: info.parentInfo.variables,
+        path: info.responsePath
+      ) {
+        return .list(keys)
+      }
+    default:
+      if let key = provider.cacheKey(
+        for: info.field,
+        variables: info.parentInfo.variables,
+        path: info.responsePath
+      ) {
+        return .single(key)
+      }
+    }
+    return nil
+  }
+  
+  private func formatCacheKey(
+    withInfo info: CacheKeyInfo,
+    andTypename typename: String
+  ) -> String {
+    return "\(info.uniqueKeyGroup ?? typename):\(info.id)"
+  }
+  
+  private func typename(for field: Selection.Field) -> String? {
+    switch field.type.namedType {
+    case .object(let selectionSetType):
+      return selectionSetType.__parentType.__typename
+    default:
+      return nil
+    }
+  }
 
   private func deferredResolve(reference: CacheReference) -> PossiblyDeferred<Record> {
     guard let transaction else {
@@ -102,5 +170,3 @@ struct CacheDataExecutionSource: GraphQLExecutionSource {
     }
   }
 }
-
-

Sources/Apollo/FieldPolicyDirectiveEvaluator.swift

@@ -0,0 +1,234 @@
+import Foundation
+#if !COCOAPODS
+import ApolloAPI
+#endif
+
+enum FieldPolicyResult {
+  case single(CacheKeyInfo)
+  case list([CacheKeyInfo])
+}
+
+struct FieldPolicyDirectiveEvaluator {
+  let field: Selection.Field
+  let fieldPolicy: Selection.FieldPolicy
+  let arguments: [String: InputValue]
+  let variables: GraphQLOperation.Variables?
+  
+  init?(
+    field: Selection.Field,
+    variables: GraphQLOperation.Variables?
+  ) {
+    self.field = field
+    self.variables = variables
+    
+    guard let fieldPolicy = field.fieldPolicy else {
+      return nil
+    }
+    self.fieldPolicy = fieldPolicy
+    
+    guard let arguments = field.arguments else {
+      return nil
+    }
+    self.arguments = arguments
+  }
+  
+  func resolveFieldPolicy() -> FieldPolicyResult? {   
+    let keyArgs = parseKeyArgs(for: fieldPolicy)
+
+    var singleValueArgs = [String?](repeating: nil, count: keyArgs.count)
+    var listArgIndex: Int? = nil
+    var listArgValues: [String] = []
+
+    for (index, arg) in keyArgs.enumerated() {
+      guard let argVal = arguments[arg.name] else {
+        return nil
+      }
+
+      guard let resolved = argVal.resolveValue(
+        keyPath: arg.path,
+        variables: variables
+      ), !resolved.isEmpty else {
+        return nil
+      }
+      
+      if resolved.count > 1 {
+        listArgIndex = index
+        listArgValues = resolved
+      } else {
+        guard let value = resolved.first else {
+          return nil
+        }
+        singleValueArgs[index] = value
+      }
+    }
+
+    if let listArgIndex = listArgIndex {
+      guard let cacheKeyList = processKeyList(
+        listArgIndex: listArgIndex,
+        listArgValues: listArgValues,
+        singleValueArgs: singleValueArgs,
+        keyArgs: keyArgs
+      ) else {
+        return nil
+      }
+      return .list(cacheKeyList)
+    } else {
+      let parts = singleValueArgs.compactMap { $0 }
+      return .single(CacheKeyInfo(id: parts.joined(separator: "+")))
+    }
+  }
+  
+  private func processKeyList(
+    listArgIndex: Int,
+    listArgValues: [String],
+    singleValueArgs: [String?],
+    keyArgs: [ParsedKey]
+  ) -> [CacheKeyInfo]? {
+    var keys: [CacheKeyInfo] = []
+    keys.reserveCapacity(listArgValues.count)
+    for value in listArgValues {
+      var parts = [String]()
+      parts.reserveCapacity(keyArgs.count)
+      for keyIndex in 0..<keyArgs.count {
+        if keyIndex == listArgIndex {
+          parts.append(value)
+        } else if let singleValue = singleValueArgs[keyIndex] {
+          parts.append(singleValue)
+        } else {
+          return nil
+        }
+      }
+      keys.append(CacheKeyInfo(id: parts.joined(separator: "+")))
+    }
+    return keys
+  }
+  
+  private func parseKeyArgs(for fieldPolicy: Selection.FieldPolicy) -> [ParsedKey] {
+    fieldPolicy.keyArgs.map { key in
+      if let dot = key.firstIndex(of: ".") {
+        let name = String(key[..<dot])
+        let rest = key[key.index(after: dot)...]
+        return ParsedKey(name: name, path: rest.split(separator: ".").map(String.init))
+      } else {
+        return ParsedKey(name: key, path: nil)
+      }
+    }
+  }
+  
+  private struct ParsedKey {
+    let name: String
+    let path: [String]?
+  }
+}
+
+extension ScalarType {
+  fileprivate var cacheKeyComponentStringValue: String {
+    switch self {
+    case let strVal as String:
+      return strVal
+      
+    case let boolVal as Bool:
+      return boolVal ? "true" : "false"
+      
+    case let intVal as Int:
+      return String(intVal)
+      
+    case let doubleVal as Double:
+      return String(doubleVal)
+      
+    case let floatVal as Float:
+      return String(floatVal)
+      
+    default:
+      return String(describing: self)
+    }
+  }
+}
+
+extension JSONValue {
+  fileprivate func cacheKeyComponentStringValue(keyPath: [String]? = nil) -> [String]? {
+    switch self {
+    case let strVal as String:
+      return [strVal]
+      
+    case let boolVal as Bool:
+      return boolVal ? ["true"] : ["false"]
+      
+    case let intVal as Int:
+      return [String(intVal)]
+      
+    case let doubleVal as Double:
+      return [String(doubleVal)]
+      
+    case let floatVal as Float:
+      return [String(floatVal)]
+      
+    case let arrVal as [JSONValue]:
+      let values: [String] = arrVal.compactMap { $0.cacheKeyComponentStringValue()?.first }
+      guard !values.isEmpty else { return nil }
+      return values
+      
+    case let objVal as JSONObject:
+      guard let keyPath, !keyPath.isEmpty else { return nil }
+      guard let targetValue = objVal.traverse(to: keyPath[...]) else { return nil }
+      return targetValue.cacheKeyComponentStringValue()
+      
+    default:
+      return [String(describing: self)]
+    }
+  }
+}
+
+extension JSONObject {
+  fileprivate func traverse(
+    to path: ArraySlice<String>
+  ) -> JSONValue? {
+    guard let head = path.first else { return self }
+    guard let next = self[head] else { return nil }
+    if path.count == 1 { return next }
+    if let nested = next as? JSONObject {
+      return nested.traverse(to: path.dropFirst())
+    }
+    return nil
+  }
+}
+
+extension InputValue {
+  fileprivate func resolveValue(keyPath: [String]? = nil, variables: [String: (any GraphQLOperationVariableValue)]? = nil) -> [String]? {
+    switch self {
+    case .scalar(let scalar):
+      return [scalar.cacheKeyComponentStringValue]
+    case .variable(let varName):
+      guard let varValue = variables?[varName] else {
+        return nil
+      }
+      return varValue._jsonEncodableValue?._jsonValue.cacheKeyComponentStringValue(keyPath: keyPath)
+    case .list(let list):
+      if list.contains(where: { if case .list = $0 { return true } else { return false } }) {
+        return nil
+      }
+      let values = list.compactMap { $0.resolveValue()?.first }
+      guard !values.isEmpty else { return nil }
+      return values
+    case .object(let dict):
+      guard let keyPath, !keyPath.isEmpty else { return nil }
+      guard let targetValue = self.traverse(through: dict, to: keyPath[...]) else { return nil }
+      return targetValue.resolveValue()
+    default:
+      return nil
+    }
+  }
+  
+  fileprivate func traverse(
+    through dict: [String: InputValue],
+    to path: ArraySlice<String>
+  ) -> InputValue? {
+    guard let head = path.first else { return .object(dict) }
+    guard let next = dict[head] else { return nil }
+    if path.count == 1 { return next }
+    if case .object(let nested) = next {
+      return traverse(through: nested, to: path.dropFirst())
+    }
+    return nil
+  }
+}

Sources/ApolloAPI/FieldPolicyProvider.swift

@@ -0,0 +1,25 @@
+/// A protocol that can be added to the ``SchemaConfiguration`` in order to provide custom field policy configuration.
+///
+/// This protocol should be applied to your existing ``SchemaConfiguration`` and provides a way to provide custom
+/// field policy cache keys in lieu of using the @fieldPolicy directive.
+public protocol FieldPolicyProvider {
+  /// The entry point for resolving a cache key to read an object from the `NormalizedCache` for a field
+  /// that returns a single object.
+  /// 
+  /// - Parameters:
+  ///   - field: The ``Selection.Field`` of the operation being executed.
+  ///   - variables: Optional ``GraphQLOperation.Variables`` input values provided to the operation.
+  ///   - path: The ``ResponsePath`` representing the path within operation to get to the given field.
+  /// - Returns: A ``CacheKeyInfo`` describing the computed cache key.
+  static func cacheKey(for field: Selection.Field, variables: GraphQLOperation.Variables?, path: ResponsePath) -> CacheKeyInfo?
+  
+  /// The entry point for resolving cache keys to read objects from the `NormalizedCache` for a field
+  /// that returns a list of objects.
+  ///
+  /// - Parameters:
+  ///   - field: The ``Selection.Field`` of the operation being executed.
+  ///   - variables: Optional ``GraphQLOperation.Variables`` input values provided to the operation.
+  ///   - path: The ``ResponsePath`` representing the path within operation to get to the given field.
+  /// - Returns: An array of ``CacheKeyInfo`` describing the computed cache keys.
+  static func cacheKeyList(for listField: Selection.Field, variables: GraphQLOperation.Variables?, path: ResponsePath) -> [CacheKeyInfo]?
+}

Sources/Apollo/ResponsePath.swift renamed to Sources/ApolloAPI/ResponsePath.swift

@@ -39,5 +39,4 @@ public protocol SchemaConfiguration {
   ///     Represented as a ``ObjectData`` dictionary.
   /// - Returns: A ``CacheKeyInfo`` describing the computed cache key for the response object.
   static func cacheKeyInfo(for type: Object, object: ObjectData) -> CacheKeyInfo?
-
 }