Codable records: JSON encoding and decoding of codable record properties

GRDB/Record/FetchableRecord+Decodable.swift

@@ -1,3 +1,5 @@
+import Foundation
+
 private struct RowKeyedDecodingContainer<Key: CodingKey>: KeyedDecodingContainerProtocol {
     let decoder: RowDecoder
 
@@ -79,7 +81,30 @@ private struct RowKeyedDecodingContainer<Key: CodingKey>: KeyedDecodingContainer
             } else if dbValue.isNull {
                 return nil
             } else {
-                return try T(from: RowDecoder(row: row, codingPath: codingPath + [key]))
+                do {
+                    // This decoding will fail for types that need a keyed container,
+                    // because we're decoding a database value here (string, int, double, data, null)
+                    // if we find a nested Decodable type then pass the string to JSON decoder
+                    let value = try T(from: RowDecoder(row: row, codingPath: codingPath + [key]))
+                    if let _ = value as? Codable {
+                        // Support for nested ( Codable )
+                        return try JSONDecoder().decode(type.self, from: row.dataNoCopy(named: key.stringValue)!)
+                    } else {
+                        return value
+                    }
+                } catch {
+                    switch error as! DecodingError {
+                    case .typeMismatch(_, let context):
+                        if context.debugDescription == "unkeyed decoding is not supported" {
+                            // Support for nested keyed containers ( [Codable] )
+                            return try JSONDecoder().decode(type.self, from: row.dataNoCopy(named: key.stringValue)!)
+                        } else {
+                            throw(error)
+                        }
+                    default:
+                        throw(error)
+                    }
+                }
             }
         }
 
@@ -116,7 +141,30 @@ private struct RowKeyedDecodingContainer<Key: CodingKey>: KeyedDecodingContainer
                 // This allows decoding Date from String, or DatabaseValue from NULL.
                 return type.fromDatabaseValue(dbValue) as! T
             } else {
-                return try T(from: RowDecoder(row: row, codingPath: codingPath + [key]))
+                do {
+                    // This decoding will fail for types that need a keyed container,
+                    // because we're decoding a database value here (string, int, double, data, null)
+                    // if we find a nested Decodable type then pass the string to JSON decoder
+                    let value = try T(from: RowDecoder(row: row, codingPath: codingPath + [key]))
+                    if let _ = value as? Codable {
+                        // Support for nested ( Codable )
+                        return try JSONDecoder().decode(type.self, from: row.dataNoCopy(named: key.stringValue)!)
+                    } else {
+                        return value
+                    }
+                } catch {
+                    switch error as! DecodingError {
+                    case .typeMismatch(_, let context):
+                        if context.debugDescription == "unkeyed decoding is not supported" {
+                            // Support for nested keyed containers ( [Codable] )
+                            return try JSONDecoder().decode(type.self, from: row.dataNoCopy(named: key.stringValue)!)
+                        } else {
+                            throw(error)
+                        }
+                    default:
+                        throw(error)
+                    }
+                }
             }
         }
 

GRDB/Record/PersistableRecord+Encodable.swift

@@ -1,3 +1,5 @@
+import Foundation
+
 private struct PersistableRecordKeyedEncodingContainer<Key: CodingKey> : KeyedEncodingContainerProtocol {
     let encode: (_ value: DatabaseValueConvertible?, _ key: String) -> Void
 
@@ -40,7 +42,23 @@ private struct PersistableRecordKeyedEncodingContainer<Key: CodingKey> : KeyedEn
             // This allows us to encode Date as String, for example.
             encode((value as! DatabaseValueConvertible), key.stringValue)
         } else {
-            try value.encode(to: PersistableRecordEncoder(codingPath: [key], encode: encode))
+            do {
+                 try value.encode(to: PersistableRecordEncoder(codingPath: [key], encode: encode))
+            } catch {
+                // If value.encode does not work e.g. "unkeyed encoding is not supported" then see if model can be stored as JSON
+                do {
+                    let encoder = JSONEncoder()
+                    if #available(watchOS 4.0, OSX 10.13, iOS 11.0, *) {
+                        encoder.outputFormatting = .sortedKeys
+                    }
+                    let json = try encoder.encode(value)
+                    //the Data from the encoder is guaranteed to convert to String
+                    let modelAsString = String(data: json, encoding: .utf8)!
+                    return encode(modelAsString, key.stringValue)
+                } catch {
+                    throw(error)
+                }
+            }
         }
     }
 
@@ -169,7 +187,8 @@ private struct PersistableRecordEncoder : Encoder {
     func container<Key>(keyedBy type: Key.Type) -> KeyedEncodingContainer<Key> {
         // Asked for a keyed type: top level required
         guard codingPath.isEmpty else {
-            fatalError("unkeyed encoding is not supported")
+            let error = EncodingError.invalidValue(encode, EncodingError.Context(codingPath: codingPath, debugDescription: "unkeyed encoding is not supported"))
+            return KeyedEncodingContainer(ThrowingKeyedContainer(error: error))
         }
         return KeyedEncodingContainer(PersistableRecordKeyedEncodingContainer<Key>(encode: encode))
     }
@@ -180,7 +199,8 @@ private struct PersistableRecordEncoder : Encoder {
     /// - precondition: May not be called after a prior `self.container(keyedBy:)` call.
     /// - precondition: May not be called after a value has been encoded through a previous `self.singleValueContainer()` call.
     func unkeyedContainer() -> UnkeyedEncodingContainer {
-        fatalError("unkeyed encoding is not supported")
+        let error = EncodingError.invalidValue(encode, EncodingError.Context(codingPath: [], debugDescription: "unkeyed encoding is not supported"))
+        return ThrowingUnkeyedContainer(error: error)
     }
 
     /// Returns an encoding container appropriate for holding a single primitive value.
@@ -194,6 +214,92 @@ private struct PersistableRecordEncoder : Encoder {
     }
 }
 
+class ThrowingKeyedContainer<KeyType: CodingKey>: KeyedEncodingContainerProtocol {
+    let errorMessage: Error
+    var codingPath: [CodingKey] = []
+
+    init(error: Error) {
+        errorMessage = error
+    }
+
+    func encodeNil(forKey key: KeyType) throws { throw errorMessage }
+    func encode(_ value: Bool, forKey key: KeyType) throws { throw errorMessage }
+    func encode(_ value: Int, forKey key: KeyType) throws { throw errorMessage }
+    func encode(_ value: Int8, forKey key: KeyType) throws { throw errorMessage }
+    func encode(_ value: Int16, forKey key: KeyType) throws { throw errorMessage }
+    func encode(_ value: Int32, forKey key: KeyType) throws { throw errorMessage }
+    func encode(_ value: Int64, forKey key: KeyType) throws { throw errorMessage }
+    func encode(_ value: UInt, forKey key: KeyType) throws { throw errorMessage }
+    func encode(_ value: UInt8, forKey key: KeyType) throws { throw errorMessage }
+    func encode(_ value: UInt16, forKey key: KeyType) throws { throw errorMessage }
+    func encode(_ value: UInt32, forKey key: KeyType) throws { throw errorMessage }
+    func encode(_ value: UInt64, forKey key: KeyType) throws { throw errorMessage }
+    func encode(_ value: Float, forKey key: KeyType) throws { throw errorMessage }
+    func encode(_ value: Double, forKey key: KeyType) throws { throw errorMessage }
+    func encode(_ value: String, forKey key: KeyType) throws { throw errorMessage }
+    func encode<T>(_ value: T, forKey key: KeyType) throws where T : Encodable { throw errorMessage }
+
+    func nestedContainer<NestedKey>(keyedBy keyType: NestedKey.Type, forKey key: KeyType) -> KeyedEncodingContainer<NestedKey> where NestedKey : CodingKey {
+        fatalError("Not implemented")
+    }
+    func nestedUnkeyedContainer(forKey key: KeyType) -> UnkeyedEncodingContainer {
+        fatalError("Not implemented")
+    }
+    func superEncoder() -> Encoder {
+        fatalError("Not implemented")
+    }
+
+    func superEncoder(forKey key: KeyType) -> Encoder {
+        fatalError("Not implemented")
+    }
+}
+
+class ThrowingUnkeyedContainer: UnkeyedEncodingContainer {
+    let errorMessage: Error
+    var codingPath: [CodingKey] = []
+    var count: Int = 0
+
+    init(error: Error) {
+        errorMessage = error
+    }
+
+    func encode(_ value: Int) throws { throw errorMessage }
+    func encode(_ value: Int8) throws { throw errorMessage }
+    func encode(_ value: Int16) throws { throw errorMessage }
+    func encode(_ value: Int32) throws { throw errorMessage }
+    func encode(_ value: Int64) throws { throw errorMessage }
+    func encode(_ value: UInt) throws { throw errorMessage }
+    func encode(_ value: UInt8) throws { throw errorMessage }
+    func encode(_ value: UInt16) throws { throw errorMessage }
+    func encode(_ value: UInt32) throws { throw errorMessage }
+    func encode(_ value: UInt64) throws { throw errorMessage }
+    func encode(_ value: Float) throws { throw errorMessage }
+    func encode(_ value: Double) throws { throw errorMessage }
+    func encode(_ value: String) throws { throw errorMessage }
+    func encode<T>(_ value: T) throws where T : Encodable { throw errorMessage }
+    func encode(_ value: Bool) throws { throw errorMessage }
+    func encodeNil() throws { throw errorMessage }
+
+    func nestedContainer<NestedKey>(keyedBy keyType: NestedKey.Type) -> KeyedEncodingContainer<NestedKey> where NestedKey : CodingKey {
+        fatalError("Not implemented")
+
+    }
+
+    func nestedUnkeyedContainer() -> UnkeyedEncodingContainer {
+        fatalError("Not implemented")
+
+    }
+
+    func superEncoder() -> Encoder {
+        fatalError("Not implemented")
+
+    }
+}
+
+enum JsonStringError: Error {
+    case covertStringError(String)
+}
+
 extension MutablePersistableRecord where Self: Encodable {
     public func encode(to container: inout PersistenceContainer) {
         // The inout container parameter won't enter an escaping closure since