Renaming, Reorganization, PrimitiveObjectStore, new ParseEncoder

Parse.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>

Sources/ParseSwift/API/API+Commands.swift

@@ -18,7 +18,7 @@ internal extension API {
         let params: [String: String?]?
 
         internal var data: Data? {
-            return try? getJSONEncoder().encode(body)
+            return try? ParseCoding.jsonEncoder().encode(body)
         }
 
         init(method: API.Method,
@@ -34,24 +34,32 @@ internal extension API {
         }
 
         public func execute(options: API.Options) throws -> U {
+            let url = ParseConfiguration.serverURL.appendingPathComponent(path.urlComponent)
+
+            guard var components = URLComponents(url: url, resolvingAgainstBaseURL: false),
+                  let componentsURL = components.url else {
+                throw ParseError(code: .unknownError, message: "Invalid URL.")
+            }
+
             let params = self.params?.getQueryItems()
             let headers = API.getHeaders(options: options)
-            let url = ParseConfiguration.serverURL.appendingPathComponent(path.urlComponent)
 
-            var components = URLComponents(url: url, resolvingAgainstBaseURL: false)!
             components.queryItems = params
 
-            var urlRequest = URLRequest(url: components.url!)
+            var urlRequest = URLRequest(url: componentsURL)
             urlRequest.allHTTPHeaderFields = headers
+
             if let body = data {
                 urlRequest.httpBody = body
             }
+
             urlRequest.httpMethod = method.rawValue
+
             let responseData = try URLSession.shared.syncDataTask(with: urlRequest)
             do {
                 return try mapper(responseData)
             } catch _ {
-                throw try getDecoder().decode(ParseError.self, from: responseData)
+                throw try ParseCoding.jsonDecoder().decode(ParseError.self, from: responseData)
             }
         }
 
@@ -63,27 +71,27 @@ internal extension API {
 
 internal extension API.Command {
     // MARK: Saving
-    static func saveCommand<T>(_ object: T) -> API.Command<T, T> where T: ObjectType {
+    static func saveCommand<T>(_ object: T) -> API.Command<T, T> where T: ParseObject {
         if object.isSaved {
             return updateCommand(object)
         }
         return createCommand(object)
     }
 
     // MARK: Saving - private
-    private static func createCommand<T>(_ object: T) -> API.Command<T, T> where T: ObjectType {
+    private static func createCommand<T>(_ object: T) -> API.Command<T, T> where T: ParseObject {
         let mapper = { (data) -> T in
-            try getDecoder().decode(SaveResponse.self, from: data).apply(object)
+            try ParseCoding.jsonDecoder().decode(SaveResponse.self, from: data).apply(object)
         }
         return API.Command<T, T>(method: .POST,
                                  path: object.endpoint,
                                  body: object,
                                  mapper: mapper)
     }
 
-    private static func updateCommand<T>(_ object: T) -> API.Command<T, T> where T: ObjectType {
+    private static func updateCommand<T>(_ object: T) -> API.Command<T, T> where T: ParseObject {
         let mapper = { (data: Data) -> T in
-            try getDecoder().decode(UpdateResponse.self, from: data).apply(object)
+            try ParseCoding.jsonDecoder().decode(UpdateResponse.self, from: data).apply(object)
         }
         return API.Command<T, T>(method: .PUT,
                                  path: object.endpoint,
@@ -92,18 +100,18 @@ internal extension API.Command {
     }
 
     // MARK: Fetching
-    static func fetchCommand<T>(_ object: T) throws -> API.Command<T, T> where T: ObjectType {
+    static func fetchCommand<T>(_ object: T) throws -> API.Command<T, T> where T: ParseObject {
         guard object.isSaved else {
             throw ParseError(code: .unknownError, message: "Cannot Fetch an object without id")
         }
         return API.Command<T, T>(method: .GET,
                                  path: object.endpoint) { (data) -> T in
-                                    try getDecoder().decode(T.self, from: data)
+                                    try ParseCoding.jsonDecoder().decode(T.self, from: data)
         }
     }
 }
 
-extension API.Command where T: ObjectType {
+extension API.Command where T: ParseObject {
 
     internal var data: Data? {
         guard let body = body else { return nil }
@@ -124,7 +132,7 @@ extension API.Command where T: ObjectType {
         }
         let mapper = { (data: Data) -> [(T, ParseError?)] in
             let decodingType = [BatchResponseItem<SaveOrUpdateResponse>].self
-            let responses = try getDecoder().decode(decodingType, from: data)
+            let responses = try ParseCoding.jsonDecoder().decode(decodingType, from: data)
             return bodies.enumerated().map({ (object) -> (T, ParseError?) in
                 let response = responses[object.0]
                 if let success = response.success {

Sources/ParseSwift/API/API.swift

@@ -75,7 +75,7 @@ public struct API {
             headers["X-Parse-Client-Key"] = clientKey
         }
 
-        if let token = CurrentUserInfo.currentSessionToken {
+        if let token = BaseParseUser.currentUserContainer?.sessionToken {
             headers["X-Parse-Session-Token"] = token
         }
 

Sources/ParseSwift/API/BatchUtils.swift

@@ -8,10 +8,10 @@
 
 import Foundation
 
-typealias ParseObjectBatchCommand<T> = BatchCommand<T, T> where T: ObjectType
+typealias ParseObjectBatchCommand<T> = BatchCommand<T, T> where T: ParseObject
 typealias ParseObjectBatchResponse<T> = [(T, ParseError?)]
 // swiftlint:disable line_length
-typealias RESTBatchCommandType<T> = API.Command<ParseObjectBatchCommand<T>, ParseObjectBatchResponse<T>> where T: ObjectType
+typealias RESTBatchCommandType<T> = API.Command<ParseObjectBatchCommand<T>, ParseObjectBatchResponse<T>> where T: ParseObject
 // swiftlint:enable line_length
 
 public struct BatchCommand<T, U>: Encodable where T: Encodable {
@@ -46,7 +46,7 @@ struct SaveOrUpdateResponse: Decodable {
         return UpdateResponse(updatedAt: updatedAt)
     }
 
-    func apply<T>(_ object: T) -> T where T: ObjectType {
+    func apply<T>(_ object: T) -> T where T: ParseObject {
         if isCreate {
             return asSaveResponse().apply(object)
         } else {

Sources/ParseSwift/API/Responses.swift

@@ -15,7 +15,7 @@ internal struct SaveResponse: Decodable {
         return createdAt
     }
 
-    func apply<T>(_ object: T) -> T where T: ObjectType {
+    func apply<T>(_ object: T) -> T where T: ParseObject {
         var object = object
         object.objectId = objectId
         object.createdAt = createdAt
@@ -27,7 +27,7 @@ internal struct SaveResponse: Decodable {
 internal struct UpdateResponse: Decodable {
     var updatedAt: Date
 
-    func apply<T>(_ object: T) -> T where T: ObjectType {
+    func apply<T>(_ object: T) -> T where T: ParseObject {
         var object = object
         object.updatedAt = updatedAt
         return object

Sources/ParseSwift/Asynchronous.swift

@@ -22,19 +22,22 @@ private func runAsync<T>(options: API.Options,
     }
 }
 
-extension Saving {
+// MARK: Saveable
+extension Saveable {
     public func save(options: API.Options = [], callback: @escaping (Self.SavingType?, Error?) -> Void) {
         runAsync(options: options, function: self.save, callback: callback)
     }
 }
 
-extension Fetching {
+// MARK: Fetchable
+extension Fetchable {
     public func fetch(options: API.Options = [], callback: @escaping (Self.FetchingType?, Error?) -> Void) {
         runAsync(options: options, function: self.fetch, callback: callback)
     }
 }
 
-extension Querying {
+// MARK: Queryable
+extension Queryable {
     public func find(options: API.Options = [], callback: @escaping ([ResultType]?, Error?) -> Void) {
         runAsync(options: options, function: self.find, callback: callback)
     }
@@ -46,15 +49,16 @@ extension Querying {
     }
 }
 
-public extension ObjectType {
+// MARK: Batch Support
+public extension ParseObject {
     static func saveAll(options: API.Options = [],
                         _ objects: Self...,
                         callback: @escaping ([(Self, ParseError?)]?, Error?) -> Void) {
         objects.saveAll(options: options, callback: callback)
     }
 }
 
-public extension Sequence where Element: ObjectType {
+public extension Sequence where Element: ParseObject {
     func saveAll(options: API.Options = [],
                  callback: @escaping ([(Element, ParseError?)]?, Error?) -> Void) {
         runAsync(options: options, function: self.saveAll, callback: callback)

Sources/ParseSwift/Coding/Extensions.swift

@@ -0,0 +1,37 @@
+//
+//  File.swift
+//  
+//
+//  Created by Pranjal Satija on 7/19/20.
+//
+
+import Foundation
+
+// MARK: Date
+internal extension Date {
+    func parseFormatted() -> String {
+        return ParseCoding.dateFormatter.string(from: self)
+    }
+
+    var parseRepresentation: [String: String] {
+        return ["__type": "Date", "iso": parseFormatted()]
+    }
+}
+
+// MARK: JSONEncoder
+extension JSONEncoder {
+    func encodeAsString<T>(_ value: T) throws -> String where T: Encodable {
+        guard let string = String(data: try encode(value), encoding: .utf8) else {
+            throw ParseError(code: .unknownError, message: "Unable to encode object...")
+        }
+
+        return string
+    }
+}
+
+// MARK: ParseObject
+internal extension ParseObject {
+    func getEncoder() -> ParseEncoder {
+        return ParseCoding.parseEncoder()
+    }
+}

Sources/ParseSwift/Coding/ParseCoding.swift

@@ -0,0 +1,80 @@
+//
+//  ParseObjectType.swift
+//  ParseSwift
+//
+//  Created by Florent Vilmart on 17-07-24.
+//  Copyright © 2017 Parse. All rights reserved.
+//
+
+import Foundation
+
+// MARK: ParseCoding
+internal enum ParseCoding {}
+
+// MARK: Coders
+extension ParseCoding {
+    private static let forbiddenKeys = Set(["createdAt", "updatedAt", "objectId", "className"])
+
+    static func jsonEncoder() -> JSONEncoder {
+        let encoder = JSONEncoder()
+        encoder.dateEncodingStrategy = dateEncodingStrategy
+        return encoder
+    }
+
+    static func jsonDecoder() -> JSONDecoder {
+        let encoder = JSONDecoder()
+        encoder.dateDecodingStrategy = dateDecodingStrategy
+        return encoder
+    }
+
+    static func parseEncoder() -> ParseEncoder {
+        let encoder = ParseEncoder()
+        encoder.dateEncodingStrategy = dateEncodingStrategy
+        encoder.shouldEncodeKey = { (key, path) -> Bool in
+            if path.count == 0 // top level
+                && Self.forbiddenKeys.contains(key) {
+                return false
+            }
+            return true
+        }
+
+        return encoder
+    }
+}
+
+// MARK: Dates
+extension ParseCoding {
+    enum DateEncodingKeys: String, CodingKey {
+        case iso
+        case type = "__type"
+    }
+
+    static let dateFormatter: DateFormatter = {
+        var dateFormatter = DateFormatter()
+        dateFormatter.locale = Locale(identifier: "")
+        dateFormatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"
+        return dateFormatter
+    }()
+
+    static let dateEncodingStrategy: JSONEncoder.DateEncodingStrategy = .custom({ (date, enc) in
+        var container = enc.container(keyedBy: DateEncodingKeys.self)
+        try container.encode("Date", forKey: .type)
+        let dateString = dateFormatter.string(from: date)
+        try container.encode(dateString, forKey: .iso)
+    })
+
+    static let dateDecodingStrategy: JSONDecoder.DateDecodingStrategy = .custom({ (dec) -> Date in
+        do {
+            let container = try dec.singleValueContainer()
+            let decodedString = try container.decode(String.self)
+            return dateFormatter.date(from: decodedString)!
+        } catch let error {
+            let container = try dec.container(keyedBy: DateEncodingKeys.self)
+            if let decoded = try container.decodeIfPresent(String.self, forKey: .iso) {
+                return dateFormatter.date(from: decoded)!
+            }
+        }
+
+        throw ParseError(code: .unknownError, message: "unable to decode")
+    })
+}