Codable support for PredicateExpressions.EvaluatePredicate

Author: jmschonfeld

Sources/FoundationEssentials/Predicate/Archiving/ExpressionArchiving.swift

@@ -19,23 +19,54 @@ import ReflectionInternal
 enum PredicateCodableError : Error, CustomStringConvertible {
     case disallowedType(typeName: String, path: String)
     case disallowedIdentifier(String, path: String)
-    case reconstructionFailure(PartialType, [Type])
+    case reconstructionFailure(PartialType, [GenericArgument])
     case variadicType(typeName: String, path: String)
 
     var description: String {
         switch self {
         case .disallowedType(let typeName, let path): return "The '\(typeName)' type is not in the provided allowlist (required by \(path))"
         case .disallowedIdentifier(let id, let path): return "The '\(id)' identifier is not in the provided allowlist (required by \(path))"
-        case .reconstructionFailure(let partial, let args): return "Reconstruction of '\(partial.name)' with the arguments \(args.map(\.swiftType)) failed"
+        case .reconstructionFailure(let partial, let args):
+            let types = args.map {
+                switch $0 {
+                case .type(let type): _typeName(type.swiftType)
+                case .pack(let types): "Pack{\(types.map({ _typeName($0.swiftType) }).joined(separator: ", "))}"
+                }
+            }
+            return "Reconstruction of '\(partial.name)' with the arguments [\(types.joined(separator: ", "))] failed"
         case .variadicType(let typeName, let path): return "The '\(typeName)' type is not allowed because it contains type pack parameters (required by \(path))"
         }
     }
 }
 
 @available(FoundationPredicate 0.1, *)
 private struct ExpressionStructure : Codable {
-    let identifier: String
-    let args: [ExpressionStructure]
+    private enum Argument : Codable {
+        case scalar(ExpressionStructure)
+        case pack([ExpressionStructure])
+        
+        init(from decoder: any Decoder) throws {
+            let container = try decoder.singleValueContainer()
+            if let scalarArg = try? container.decode(ExpressionStructure.self) {
+                self = .scalar(scalarArg)
+            } else {
+                self = .pack(try container.decode([ExpressionStructure].self))
+            }
+        }
+        
+        func encode(to encoder: any Encoder) throws {
+            switch self {
+            case let .scalar(arg):
+                var container = encoder.singleValueContainer()
+                try container.encode(arg)
+            case let .pack(args):
+                var container = encoder.singleValueContainer()
+                try container.encode(args)
+            }
+        }
+    }
+    private let identifier: String
+    private let args: [Argument]
 
     private enum CodingKeys: CodingKey {
         case identifier
@@ -56,7 +87,7 @@ private struct ExpressionStructure : Codable {
     init(from decoder: Decoder) throws {
         if let keyedContainer = try? decoder.container(keyedBy: CodingKeys.self) {
             identifier = try keyedContainer.decode(String.self, forKey: .identifier)
-            args = try keyedContainer.decode([ExpressionStructure].self, forKey: .args)
+            args = try keyedContainer.decode([Argument].self, forKey: .args)
             return
         }
 
@@ -65,20 +96,20 @@ private struct ExpressionStructure : Codable {
     }
 
     init(_ type: Type, with configuration: PredicateCodableConfiguration, path: [String] = []) throws {
-#if canImport(ReflectionInternal, _version: "18")
-        if type.partial?.hasParameterPacks ?? false {
-            throw PredicateCodableError.variadicType(typeName: _typeName(type.swiftType), path: "/\(path.joined(separator: "/"))")
-        }
-#endif
         guard let result = configuration._identifier(for: type) else {
             throw PredicateCodableError.disallowedType(typeName: _typeName(type.swiftType), path: "/\(path.joined(separator: "/"))")
         }
 
         self.identifier = result.identifier
 
         if !result.isConcrete {
-            self.args = try type.genericArguments.map {
-                try .init($0, with: configuration, path: path + [result.identifier])
+            self.args = try type.genericArguments2.map {
+                switch $0 {
+                case .type(let type):
+                    .scalar(try .init(type, with: configuration, path: path + [result.identifier]))
+                case .pack(let types):
+                    .pack(try types.map { try .init($0, with: configuration, path: path + [result.identifier]) })
+                }
             }
         } else {
             self.args = []
@@ -98,17 +129,16 @@ private struct ExpressionStructure : Codable {
             partial = partialType
         }
 
-#if canImport(ReflectionInternal, _version: "18")
-        if partial.hasParameterPacks {
-            throw PredicateCodableError.variadicType(typeName: partial.name, path: "/\(path.joined(separator: "/"))")
-        }
-#endif
-        
-        let argTypes = try args.map {
-            try $0.reconstruct(with: configuration, path: path + [identifier])
+        let argTypes: [GenericArgument] = try args.map {
+            switch $0 {
+            case let .scalar(arg):
+                .type(try arg.reconstruct(with: configuration, path: path + [identifier]))
+            case let .pack(args):
+                .pack(try args.map { try $0.reconstruct(with: configuration, path: path + [identifier]) })
+            }
         }
 
-        guard let created = partial.create(with: argTypes) else {
+        guard let created = partial.create2(with: argTypes) else {
             throw PredicateCodableError.reconstructionFailure(partial, argTypes)
         }
         return created
@@ -117,7 +147,7 @@ private struct ExpressionStructure : Codable {
 
 @available(FoundationPredicate 0.1, *)
 class PredicateArchivingState {
-    let configuration: PredicateCodableConfiguration
+    var configuration: PredicateCodableConfiguration
 
     private var variableMap: [UInt : PredicateExpressions.VariableID]
 
@@ -150,6 +180,7 @@ enum PredicateExpressionCodingKeys : CodingKey {
 @available(FoundationPredicate 0.1, *)
 fileprivate extension PredicateCodableConfiguration {
     mutating func allowInputs<each Input>(_ input: repeat (each Input).Type) {
+        guard self.shouldAddInputTypes else { return }
         var inputTypes = [Any.Type]()
         repeat inputTypes.append((each Input).self)
         for (index, type) in inputTypes.enumerated() {
@@ -158,16 +189,29 @@ fileprivate extension PredicateCodableConfiguration {
     }
 }
 
+private func _withPredicateArchivingState<R>(_ configuration: PredicateCodableConfiguration, _ block: () throws -> R) rethrows -> R {
+    if let currentState = _ThreadLocal[.predicateArchivingState] {
+        // Store the new configuration and reset it after encoding the subtree
+        let oldConfiguration = currentState.configuration
+        defer { currentState.configuration = oldConfiguration }
+        
+        currentState.configuration = configuration
+        return try block()
+    } else {
+        var state = PredicateArchivingState(configuration: configuration)
+        return try _ThreadLocal.withValue(&state, for: .predicateArchivingState, block)
+    }
+}
+
 @available(FoundationPredicate 0.1, *)
 extension KeyedEncodingContainer where Key == PredicateExpressionCodingKeys {
     mutating func _encode<T: PredicateExpression & Encodable, each Input>(_ expression: T, variable: repeat PredicateExpressions.Variable<each Input>, predicateConfiguration: PredicateCodableConfiguration) throws where T.Output == Bool {
         var predicateConfiguration = predicateConfiguration
         predicateConfiguration.allowInputs(repeat (each Input).self)
         let structure = try ExpressionStructure(Type(expression), with: predicateConfiguration)
-        var state = PredicateArchivingState(configuration: predicateConfiguration)
         var variableContainer = self.nestedUnkeyedContainer(forKey: .variable)
         repeat try variableContainer.encode(each variable)
-        try _ThreadLocal.withValue(&state, for: .predicateArchivingState) {
+        try _withPredicateArchivingState(predicateConfiguration) {
             try self.encode(structure, forKey: .structure)
             try self.encode(expression, forKey: .expression)
         }
@@ -188,9 +232,8 @@ extension KeyedDecodingContainer where Key == PredicateExpressionCodingKeys {
         guard let exprType = try structure.reconstruct(with: predicateConfiguration).swiftType as? any (Decodable & PredicateExpression<Bool>).Type else {
             throw DecodingError.dataCorruptedError(forKey: .structure, in: self, debugDescription: "This expression is unsupported by this predicate")
         }
-        var state = PredicateArchivingState(configuration: predicateConfiguration)
         var container = try self.nestedUnkeyedContainer(forKey: .variable)
-        return try _ThreadLocal.withValue(&state, for: .predicateArchivingState) {
+        return try _withPredicateArchivingState(predicateConfiguration) {
             let variable = (repeat try container.decode(PredicateExpressions.Variable<each Input>.self))
             return (try decode(exprType), variable)
         }

Sources/FoundationEssentials/Predicate/Archiving/Predicate+Codable.swift

@@ -12,14 +12,28 @@
 
 #if FOUNDATION_FRAMEWORK
 
+extension PredicateCodableConfiguration {
+    fileprivate static var `default`: Self {
+        // If we're encoding this predicate inside of another one, use the parent predicate's configuration since the "default" was specified here
+        if var parent = _ThreadLocal[.predicateArchivingState]?.configuration {
+            // When decoding sub-predicates, we don't want to overwrite inputs since they by definition must already be in the parent predicate's configuration
+            parent.shouldAddInputTypes = false
+            return parent
+        } else {
+            // Otherwise, the default is the standardConfiguration
+            return .standardConfiguration
+        }
+    }
+}
+
 @available(FoundationPredicate 0.1, *)
 extension Predicate : Codable {
     public func encode(to encoder: Encoder) throws {
-        try self.encode(to: encoder, configuration: .standardConfiguration)
+        try self.encode(to: encoder, configuration: .default)
     }
 
     public init(from decoder: Decoder) throws {
-        try self.init(from: decoder, configuration: .standardConfiguration)
+        try self.init(from: decoder, configuration: .default)
     }
 }
 

Sources/FoundationEssentials/Predicate/Archiving/PredicateCodableConfiguration.swift

@@ -77,6 +77,7 @@ public struct PredicateCodableConfiguration: Sendable, CustomDebugStringConverti
 
     private var allowedKeyPaths: [String : AllowListKeyPath] = [:]
     private var allowedTypes: [String : AllowListType] = [:]
+    internal var shouldAddInputTypes = true
 
     public init() {}
 

Sources/FoundationEssentials/Predicate/Expressions/PredicateEvaluation.swift

@@ -56,11 +56,15 @@ extension PredicateExpressions.PredicateEvaluate : StandardPredicateExpression w
 @available(FoundationPredicate 0.3, *)
 extension PredicateExpressions.PredicateEvaluate : Codable where Condition : Codable, repeat each Input : Codable {
     public func encode(to encoder: Encoder) throws {
-        throw EncodingError.invalidValue(self, EncodingError.Context(codingPath: encoder.codingPath, debugDescription: "Encoding the PredicateEvaluate operator is not yet supported"))
+        var container = encoder.unkeyedContainer()
+        try container.encode(predicate)
+        repeat try container.encode(each input)
     }
 
     public init(from decoder: Decoder) throws {
-        throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Decoding the PredicateEvaluate operator is not yet supported"))
+        var container = try decoder.unkeyedContainer()
+        self.predicate = try container.decode(Condition.self)
+        self.input = (repeat try container.decode((each Input).self))
     }
 }
 

Tests/FoundationEssentialsTests/PredicateCodableTests.swift

@@ -468,64 +468,85 @@ final class PredicateCodableTests: XCTestCase {
         let predicate = #Predicate<Int> { _ in
             a == a
         }
+        
 
-        let encoder = JSONEncoder()
-        var config = PredicateCodableConfiguration.standardConfiguration
-        config.allowPartialType(A< >.self, identifier: "PredicateCodableTests.A")
-        XCTAssertThrowsError(try encoder.encode(predicate, configuration: config)) {
-            XCTAssertTrue(String(describing: $0).contains("type is not allowed because it contains type pack parameters"))
-        }
-        
-        let json = """
-        [
-          {
-            "expression" : [
-              null,
-              null
-            ],
-            "structure" : {
-              "identifier" : "PredicateExpressions.Equal",
-              "args" : [
-                {
-                  "identifier" : "PredicateExpressions.Value",
-                  "args" : [
-                    {
-                      "identifier": "PredicateCodableTests.A",
-                      "args": [
-                        "Swift.String",
-                        "Swift.Int"
-                      ]
-                    }
-                  ]
-                },
-                {
-                  "args" : [
-                    {
-                      "identifier": "PredicateCodableTests.A",
-                      "args": [
-                        "Swift.String",
-                        "Swift.Int"
-                      ]
-                    }
-                  ],
-                  "identifier" : "PredicateExpressions.Value"
-                }
-              ]
-            },
-            "variable" : [
-              {
-                "key" : 0
-              }
-            ]
-          }
+        struct CustomConfig : PredicateCodingConfigurationProviding {
+            static let config = {
+                var configuration = PredicateCodableConfiguration.standardConfiguration
+                configuration.allowPartialType(A< >.self, identifier: "PredicateCodableTests.A")
+                return configuration
+            }()
+        }
+        
+        let decoded = try _encodeDecode(predicate, for: CustomConfig.self)
+        XCTAssertEqual(try decoded.evaluate(2), try predicate.evaluate(2))
+    }
+    
+    func testNestedPredicates() throws {
+        let predicateA = #Predicate<Object> {
+            $0.a == 3
+        }
+        
+        let predicateB = #Predicate<Object> {
+            predicateA.evaluate($0) && $0.a > 2
+        }
+        
+        let decoded = try _encodeDecode(predicateB, for: StandardConfig.self)
+        
+        let objects = [
+            Object(a: 3, b: "abc", c: 0.0, d: 0, e: "c", f: true, g: [1, 3], h: Object2(a: 1, b: "Foo")),
+            Object(a: 2, b: "abc", c: 0.0, d: 0, e: "c", f: true, g: [1, 3], h: Object2(a: 1, b: "Foo")),
+            Object(a: 3, b: "abc", c: 0.0, d: 0, e: "c", f: true, g: [1, 3], h: Object2(a: 1, b: "Foo")),
+            Object(a: 2, b: "abc", c: 0.0, d: 0, e: "c", f: true, g: [1, 3], h: Object2(a: 1, b: "Foo")),
+            Object(a: 4, b: "abc", c: 0.0, d: 0, e: "c", f: true, g: [1, 3], h: Object2(a: 1, b: "Foo"))
         ]
-        """
 
-        let decoder = JSONDecoder()
-        XCTAssertThrowsError(try decoder.decode(Predicate<Int>.self, from: json.data(using: .utf8)!, configuration: config)) {
-            XCTAssertTrue(String(describing: $0).contains("type is not allowed because it contains type pack parameters"))
+        for object in objects {
+            XCTAssertEqual(try decoded.evaluate(object), try predicateB.evaluate(object), "Evaluation failed to produce equal results for \(object)")
         }
     }
+    
+    func testNestedPredicateRestrictedConfiguration() throws {
+        struct RestrictedBox<each T> : Codable {
+            let predicate: Predicate<repeat each T>
+            
+            func encode(to encoder: any Encoder) throws {
+                var container = encoder.unkeyedContainer()
+                // Restricted empty configuration
+                try container.encode(predicate, configuration: PredicateCodableConfiguration())
+            }
+            
+            init(_ predicate: Predicate<repeat each T>) {
+                self.predicate = predicate
+            }
+            
+            init(from decoder: any Decoder) throws {
+                var container = try decoder.unkeyedContainer()
+                self.predicate = try container.decode(Predicate<repeat each T>.self, configuration: PredicateCodableConfiguration())
+            }
+        }
+        
+        let predicateA = #Predicate<Object> {
+            $0.a == 3
+        }
+        let box = RestrictedBox(predicateA)
+        
+        let predicateB = #Predicate<Object> {
+            box.predicate.evaluate($0) && $0.a > 2
+        }
+        
+        struct CustomConfig : PredicateCodingConfigurationProviding {
+            static let config = {
+                var configuration = PredicateCodableConfiguration.standardConfiguration
+                configuration.allowKeyPathsForPropertiesProvided(by: PredicateCodableTests.Object.self)
+                configuration.allowKeyPath(\RestrictedBox<Object>.predicate, identifier: "RestrictedBox.Predicate")
+                return configuration
+            }()
+        }
+        
+        // Throws an error because the sub-predicate's configuration won't contain anything in the allowlist
+        XCTAssertThrowsError(try _encodeDecode(predicateB, for: CustomConfig.self))
+    }
 }
 
 #endif // FOUNDATION_FRAMEWORK