add userField to CLP

Author: cbaker6

ParseSwift.playground/Pages/20 - Schema.xcplaygroundpage/Contents.swift

@@ -48,8 +48,10 @@ struct GameScore2: ParseObject {
 
     //: Your own properties.
     var points: Int?
+    var level: Int?
     var data: ParseBytes?
     var owner: User?
+    var rivals: [User]?
 
     //: Implement your own version of merge
     func merge(with object: Self) throws -> Self {
@@ -58,6 +60,10 @@ struct GameScore2: ParseObject {
                                      original: object) {
             updated.points = object.points
         }
+        if updated.shouldRestoreKey(\.level,
+                                     original: object) {
+            updated.level = object.level
+        }
         if updated.shouldRestoreKey(\.data,
                                      original: object) {
             updated.data = object.data
@@ -66,6 +72,10 @@ struct GameScore2: ParseObject {
                                      original: object) {
             updated.owner = object.owner
         }
+        if updated.shouldRestoreKey(\.rivals,
+                                     original: object) {
+            updated.rivals = object.rivals
+        }
         return updated
     }
 }
@@ -93,14 +103,21 @@ var gameScoreSchema = ParseSchema<GameScore2>(classLevelPermissions: clp)
     .addField("points",
               type: .number,
               options: ParseFieldOptions<Int>(required: false, defauleValue: nil))
+    .addField("level",
+              type: .number,
+              options: ParseFieldOptions<Int>(required: false, defauleValue: nil))
     .addField("data",
               type: .bytes,
               options: ParseFieldOptions<String>(required: false, defauleValue: nil))
 
 do {
-    gameScoreSchema = try gameScoreSchema.addField("owner",
-                                                   type: .pointer,
-                                                   options: ParseFieldOptions<User>(required: false, defauleValue: nil))
+    gameScoreSchema = try gameScoreSchema
+        .addField("owner",
+                  type: .pointer,
+                  options: ParseFieldOptions<User>(required: false, defauleValue: nil))
+        .addField("rivals",
+                  type: .array,
+                  options: ParseFieldOptions<[User]>(required: false, defauleValue: nil))
 } catch {
     print("Can't add field: \(gameScoreSchema)")
 }
@@ -120,7 +137,7 @@ let clp2 = clp.setPointerFields(Set(["owner"]), on: .get)
 gameScoreSchema.classLevelPermissions = clp2
 
 //: In addition, we can add an index.
-gameScoreSchema = gameScoreSchema.addIndex("myIndex", field: "points", index: 1)
+gameScoreSchema = gameScoreSchema.addIndex("myIndex", field: "level", index: 1)
 
 //: Next, we need to update the schema on the server with the changes.
 gameScoreSchema.update { result in
@@ -174,11 +191,13 @@ gameScoreSchema.update { result in
 }
 
 /*:
- Fields can also be deleted on a schema. Lets remove
- the **data** field since it's not going being used.
+ Sets of fields can also be protected from access. Lets protect
+ some fields from access.
 */
 var clp3 = gameScoreSchema.classLevelPermissions
-clp3 = clp3?.setProtectedFieldsPublic(["owner"])
+clp3 = clp3?
+    .setProtectedFieldsPublic(["owner"])
+    .setProtectedFields(["level"], userField: "rivals")
 gameScoreSchema.classLevelPermissions = clp3
 
 //: Next, we need to update the schema on the server with the changes.

Sources/ParseSwift/Types/ParseCLP.swift

@@ -122,6 +122,10 @@ public struct ParseCLP: Codable, Equatable {
 
 // MARK: Default Implementation
 extension ParseCLP {
+    static func getUserFieldAccess(_ field: String) -> String {
+        "userField:\(field)"
+    }
+
     func hasAccess(_ keyPath: KeyPath<Self, [String: AnyCodable]?>,
                    for entity: String) -> Bool {
         self[keyPath: keyPath]?[entity]?.value as? Bool ?? false
@@ -801,6 +805,17 @@ public extension ParseCLP {
         getProtectedFields(Access.requiresAuthentication.rawValue)
     }
 
+    /**
+     Get the protected fields either a field of `ParseUser` type or
+     an array of `ParseUser`'s in a Parse class cannot access.
+     - parameter field: A field in a Parse class that is either of `ParseUser` type or
+     an array of `ParseUser`'s.
+     - returns: The set protected fields that cannot be accessed.
+    */
+    func getProtectedFieldsUser(_ field: String) -> Set<String> {
+        getProtectedFields(Self.getUserFieldAccess(field))
+    }
+
     /**
      Get the protected fields the given `ParseUser` objectId cannot access.
      - parameter objectId: The `ParseUser` objectId access to check.
@@ -862,10 +877,25 @@ public extension ParseCLP {
         setProtected(fields, on: \.protectedFields, for: Access.requiresAuthentication.rawValue)
     }
 
+    /**
+     Set whether the given field that is either of `ParseUser` type or an array of `ParseUser`'s
+     should not have access to specific fields of a Parse class.
+     - parameter fields: The set of fields that should be protected from access.
+     - parameter userField: A field in a Parse class that is either of `ParseUser` type or
+     an array of `ParseUser`'s to restrict access to.
+     - returns: A mutated instance of `ParseCLP` for easy chaining.
+     - throws: An error of type `ParseError`.
+    */
+    func setProtectedFields(_ fields: Set<String>, userField: String) -> Self {
+        setProtected(fields,
+                     on: \.protectedFields,
+                     for: Self.getUserFieldAccess(userField))
+    }
+
     /**
      Set whether the given `ParseUser` objectId should not have access to specific fields of a Parse class.
-     - parameter objectId: The `ParseUser` objectId to restrict access to.
      - parameter fields: The set of fields that should be protected from access.
+     - parameter objectId: The `ParseUser` objectId to restrict access to.
      - returns: A mutated instance of `ParseCLP` for easy chaining.
      - throws: An error of type `ParseError`.
     */
@@ -930,6 +960,20 @@ public extension ParseCLP {
         addProtected(fields, on: \.protectedFields, for: Access.requiresAuthentication.rawValue)
     }
 
+    /**
+     Add to the set of specific fields the given field that is either of `ParseUser` type or an array of `ParseUser`'s
+     should not have access to on a Parse class.
+     - parameter fields: The set of fields that should be protected from access.
+     - parameter userField: A field in a Parse class that is either of `ParseUser` type or
+     an array of `ParseUser`'s to restrict access to.
+     - returns: A mutated instance of `ParseCLP` for easy chaining.
+     - throws: An error of type `ParseError`.
+     - note: This method adds on to the current set of `fields` in the CLP.
+    */
+    func addProtectedFieldsUser(_ fields: Set<String>, userField: String) -> Self {
+        addProtected(fields, on: \.protectedFields, for: Self.getUserFieldAccess(userField))
+    }
+
     /**
      Add to the set of specific fields the given `ParseUser` objectId should not have access to on a Parse class.
      - parameter fields: The set of fields that should be protected from access.
@@ -1003,6 +1047,20 @@ public extension ParseCLP {
         removeProtected(fields, on: \.protectedFields, for: Access.requiresAuthentication.rawValue)
     }
 
+    /**
+     Remove fields from the set of specific fields the given field that is either of `ParseUser` type
+     or an array of `ParseUser`'s should not have access to on a Parse class.
+     - parameter fields: The set of fields that should be removed from protected access.
+     - parameter userField: A field in a Parse class that is either of `ParseUser` type or
+     an array of `ParseUser`'s to restrict access to.
+     - returns: A mutated instance of `ParseCLP` for easy chaining.
+     - throws: An error of type `ParseError`.
+     - note: This method removes from the current set of `fields` in the CLP.
+    */
+    func removeProtectedFieldsUser(_ fields: Set<String>, userField: String) -> Self {
+        removeProtected(fields, on: \.protectedFields, for: Self.getUserFieldAccess(userField))
+    }
+
     /**
      Remove fields from the set of specific fields the given `ParseUser` objectId
      should not have access to on a Parse class.

Tests/ParseSwiftTests/ParseCLPTests.swift

@@ -210,6 +210,23 @@ class ParseCLPTests: XCTestCase { // swiftlint:disable:this type_body_length
         XCTAssertEqual(clp4.getProtectedFieldsRequiresAuthentication(), newField)
     }
 
+    func testProtectedFieldsUserField() throws {
+        let fields = Set<String>(["hello", "world"])
+        let userField = "peace"
+        let clp = ParseCLP().setProtectedFields(fields, userField: userField)
+        XCTAssertEqual(clp.getProtectedFieldsUser(userField), fields)
+
+        let newField = Set<String>(["new"])
+        let clp2 = clp.addProtectedFieldsUser(newField, userField: userField)
+        XCTAssertEqual(clp2.getProtectedFieldsUser(userField), fields.union(newField))
+
+        let clp3 = clp2.removeProtectedFieldsUser(newField, userField: userField)
+        XCTAssertEqual(clp3.getProtectedFieldsUser(userField), fields)
+
+        let clp4 = ParseCLP().addProtectedFieldsUser(newField, userField: userField)
+        XCTAssertEqual(clp4.getProtectedFieldsUser(userField), newField)
+    }
+
     func testProtectedFieldsObjectId() throws {
         let fields = Set<String>(["hello", "world"])
         let clp = ParseCLP().setProtectedFields(fields, for: objectId)