feat: add ParseSchema to SDK

.spi.yml

@@ -3,6 +3,7 @@ builder:
   configs:
   - platform: ios
     scheme: "ParseSwift (iOS)"
+    documentation_targets: ["ParseSwift (iOS)"]
   - platform: macos-xcodebuild
     scheme: "ParseSwift (macOS)"
   - platform: macos-xcodebuild-arm

CHANGELOG.md

@@ -5,6 +5,9 @@
 [Full Changelog](https://github.com/parse-community/Parse-Swift/compare/4.5.0...main)
 * _Contributing to this repo? Add info about your change here to be included in the next release_
 
+__New features__
+- Add ParseSchema, ParseCLP, and ParseFieldOptions. Should only be used when using the Swift SDK on a secured server ([#370](https://github.com/parse-community/Parse-Swift/pull/370)), thanks to [Corey Baker](https://github.com/cbaker6).
+
 ### 4.5.0
 [Full Changelog](https://github.com/parse-community/Parse-Swift/compare/4.4.0...4.5.0)
 

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

@@ -0,0 +1,254 @@
+//: [Previous](@previous)
+
+import PlaygroundSupport
+import Foundation
+import ParseSwift
+
+PlaygroundPage.current.needsIndefiniteExecution = true
+initializeParse()
+
+//: Youe specific _User value type.
+struct User: ParseUser {
+    //: These are required by `ParseObject`.
+    var objectId: String?
+    var createdAt: Date?
+    var updatedAt: Date?
+    var ACL: ParseACL?
+    var originalData: Data?
+
+    //: These are required by `ParseUser`.
+    var username: String?
+    var email: String?
+    var emailVerified: Bool?
+    var password: String?
+    var authData: [String: [String: String]?]?
+
+    //: Your custom keys.
+    var customKey: String?
+
+    //: Implement your own version of merge
+    func merge(with object: Self) throws -> Self {
+        var updated = try mergeParse(with: object)
+        if updated.shouldRestoreKey(\.customKey,
+                                     original: object) {
+            updated.customKey = object.customKey
+        }
+        return updated
+    }
+}
+
+//: Create your own value typed `ParseObject`.
+struct GameScore2: ParseObject {
+    //: These are required by ParseObject
+    var objectId: String?
+    var createdAt: Date?
+    var updatedAt: Date?
+    var ACL: ParseACL?
+    var originalData: Data?
+
+    //: 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 {
+        var updated = try mergeParse(with: object)
+        if updated.shouldRestoreKey(\.points,
+                                     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
+        }
+        if updated.shouldRestoreKey(\.owner,
+                                     original: object) {
+            updated.owner = object.owner
+        }
+        if updated.shouldRestoreKey(\.rivals,
+                                     original: object) {
+            updated.rivals = object.rivals
+        }
+        return updated
+    }
+}
+
+//: It's recommended to place custom initializers in an extension
+//: to preserve the memberwise initializer.
+extension GameScore2 {
+
+    init(points: Int) {
+        self.points = points
+    }
+
+    init(objectId: String?) {
+        self.objectId = objectId
+    }
+}
+
+//: First lets create a new CLP for the new schema.
+let clp = ParseCLP(requiresAuthentication: true, publicAccess: false)
+    .setAccessPublic(true, on: .get)
+    .setAccessPublic(true, on: .find)
+
+//: Next we use the CLP to create the new schema and add fields to it.
+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))
+        .addField("rivals",
+                  type: .array,
+                  options: ParseFieldOptions<[User]>(required: false, defauleValue: nil))
+} catch {
+    print("Can't add field: \(gameScoreSchema)")
+}
+
+//: Now lets create the schema on the server.
+gameScoreSchema.create { result in
+    switch result {
+    case .success(let savedSchema):
+        print("Check GameScore2 in Dashboard. \nThe created schema:  \(savedSchema)")
+    case .failure(let error):
+        print("Couldn't save schema: \(error)")
+    }
+}
+
+//: We can update the CLP to only allow access to users specified in the "owner" field.
+let clp2 = clp.setPointerFields(Set(["owner"]), on: .get)
+gameScoreSchema.classLevelPermissions = clp2
+
+//: In addition, we can add an index.
+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
+    switch result {
+    case .success(let updatedSchema):
+        print("Check GameScore2 in Dashboard. \nThe updated schema: \(updatedSchema)")
+        /*:
+         Updated the current gameScoreSchema with the newest.
+         */
+        gameScoreSchema = updatedSchema
+    case .failure(let error):
+        print("Couldn't update schema: \(error)")
+    }
+}
+
+//: Indexes can also be deleted.
+gameScoreSchema = gameScoreSchema.deleteIndex("myIndex")
+
+//: Next, we need to update the schema on the server with the changes.
+gameScoreSchema.update { result in
+    switch result {
+    case .success(let updatedSchema):
+        print("Check GameScore2 in Dashboard. \nThe updated schema: \(updatedSchema)")
+        /*:
+         Updated the current gameScoreSchema with the newest.
+         */
+        gameScoreSchema = updatedSchema
+    case .failure(let error):
+        print("Couldn't update schema: \(error)")
+    }
+}
+
+/*:
+ Fields can also be deleted on a schema. Lets remove
+ the **data** field since it's not going being used.
+*/
+gameScoreSchema = gameScoreSchema.deleteField("data")
+
+//: Next, we need to update the schema on the server with the changes.
+gameScoreSchema.update { result in
+    switch result {
+    case .success(let updatedSchema):
+        print("Check GameScore2 in Dashboard. \nThe updated schema: \(updatedSchema)")
+        /*:
+         Updated the current gameScoreSchema with the newest.
+         */
+        gameScoreSchema = updatedSchema
+    case .failure(let error):
+        print("Couldn't update schema: \(error)")
+    }
+}
+
+/*:
+ Sets of fields can also be protected from access. Lets protect
+ some fields from access.
+*/
+var clp3 = gameScoreSchema.classLevelPermissions
+clp3 = clp3?
+    .setProtectedFieldsPublic(["owner"])
+    .setProtectedFields(["level"], userField: "rivals")
+gameScoreSchema.classLevelPermissions = clp3
+
+//: Next, we need to update the schema on the server with the changes.
+gameScoreSchema.update { result in
+    switch result {
+    case .success(let updatedSchema):
+        print("Check GameScore2 in Dashboard. \nThe updated schema: \(updatedSchema)")
+        /*:
+         Updated the current gameScoreSchema with the newest.
+         */
+        gameScoreSchema = updatedSchema
+    case .failure(let error):
+        print("Couldn't update schema: \(error)")
+    }
+}
+
+//: Now lets save a new object to the new schema.
+var gameScore = GameScore2()
+gameScore.points = 120
+gameScore.owner = User.current
+
+gameScore.save { result in
+    switch result {
+    case .success(let savedGameScore):
+        print("The saved GameScore is: \(savedGameScore)")
+    case .failure(let error):
+        print("Couldn't save schema: \(error)")
+    }
+}
+
+//: You can delete all objects your schema by purging them.
+gameScoreSchema.purge { result in
+    switch result {
+    case .success:
+        print("All objects have been purged from this schema.")
+    case .failure(let error):
+        print("Couldn't purge schema: \(error)")
+    }
+}
+
+/*:
+ As long as there's no data in your `ParseSchema` you can
+ delete the schema.
+*/
+ gameScoreSchema.delete { result in
+    switch result {
+    case .success:
+        print("The schema has been deleted.")
+    case .failure(let error):
+        print("Couldn't delete the schema: \(error)")
+    }
+}
+
+//: [Next](@next)