ParseSwift

4.16.2

The original Swift SDK for Parse Platform (iOS, macOS, watchOS, tvOS, Linux, Android, Windows). This repo is maintained by Parse-Swift's original developer and is BETTER than the Parse-Platform Parse-Swift repo in every way (features, bug fixes, and architecture)
netreconlab/Parse-Swift

What's New

4.16.2

2022-11-23T06:51:40Z

Full Changelog, Documentation

Fixes

  • Callback async calls return to correct callbackQueue (#19), thanks to @cbaker6.

parse-repository-header-sdk-swift

iOS · macOS · watchOS · tvOS · Linux · Android · Windows


Build Status CI Build Status Release Coverage Carthage

Swift Versions Platforms

License


A pure Swift library that gives you access to the powerful Parse Server backend from your Swift applications.

For more information about the Parse Platform and its features, see the public documentation. The ParseSwift SDK is not a port of the Parse-SDK-iOS-OSX SDK and though some of it may feel familiar, it is not backwards compatible and is designed using protocol oriented programming (POP) and value types instead of OOP and reference types. You can learn more about POP by watching Protocol-Oriented Programming in Swift or Protocol and Value Oriented Programming in UIKit Apps videos from previous WWDC's. For more details about ParseSwift, visit the api documentation.

To learn how to use or experiment with ParseSwift, you can run and edit the ParseSwift.playground. You can use the parse-server in this repo which has docker compose files (docker-compose up gives you a working server) configured to connect with the playground files, has Parse Dashboard, and can be used with MongoDB or PostgreSQL. You can also configure the Swift Playgrounds to work with your own Parse Server by editing the configuation in Common.swift. To learn more, check out CONTRIBUTING.md.

Use Parse-Swift from NetReconLab

This repo is maintained by Corey E. Baker, 1 of 2 of the original developers of Parse-Swift. Corey was responsible for the direction and development of all releases from 1.0.0 to 4.14.2. This repo will remain aligned with the original core principals of a swifty framework that contains zero dependencies and takes advantage of all of the features the parse-server has to offer. The reason for the bifurcation from the parse-community version of Parse-Swift is due to interference and a number of disagreements with the Parse Project Management Committee (PMC) about the future of ParseSwift along with the PMC member ignoring code reviews and comments, marking relevant comments as off-topic, merging commits directly to main branch, lack-of-understanding of Swift fundamentals, client-side development, and lack of knowledge about how the Parse-Swift framework is designed. It is important to emphasize that no member of the Parse PMC participated in the design, release, and direction of Parse-Swift from its first commit to version 4.14.2. The Parse PMC also does not properly show attribution or appreciation to Corey as the lead developer of Parse-Swift. In addition, no funding or support from the parse-community funds has ever been offered to Corey for any of his contributions to Parse, though a number of payments have been offered and made to other contributors. If you benefit from Parse-Swift and would like to show monetary support, feel free to Buy Me A Coffee


Installation

Swift Package Manager

You can use The Swift Package Manager (SPM) to install ParseSwift by adding the following description to your Package.swift file:

// swift-tools-version:5.5
import PackageDescription

let package = Package(
    name: "YOUR_PROJECT_NAME",
    dependencies: [
        .package(url: "https://github.com/netreconlab/Parse-Swift", .upToNextMajor(from: "4.15.0")),
    ]
)

Then run swift build.

You can also install using SPM in your Xcode project by going to "Project->NameOfYourProject->Swift Packages" and placing https://github.com/netreconlab/Parse-Swift.git in the search field.

Carthage

Add the following line to your Cartfile:

github "netreconlab/Parse-Swift"

Run carthage update, and you should now have the latest version of ParseSwift SDK in your Carthage folder.

Example Apps and Frameworks

Below is a list of apps and frameworks that use Parse-Swift to help developers take advantage of the framework:

  • ParseServerSwift - Write Parse Cloud Code in Swift using Parse-Swift
  • ParseServerAnyAnalytics - Analytics adapter to connect Parse Server analytics to any 3rd party analytics tool
  • CarekitSampe-ParseCareKit - An example application of CareKit's OCKSample synchronizing CareKit data to the Cloud via ParseCareKit
  • ParseCareKit - Synchronize CareKit 2.1+ data with a parse-server using Parse-Swift
  • SnapCat - SnapCat is a social media application for posting pictures, comments, and finding friends. SnapCat is designed using SwiftUI and the ParseSwift SDK
  • ParseMigrateKeychain - A sample app that demonstrates how to migrate an app written with the Parse Objective-C SDK to the Parse-Swift SDK

Usage Guide

After installing ParseSwift, to use it first import ParseSwift in your AppDelegate.swift and then add the following code in your application:didFinishLaunchingWithOptions: method:

ParseSwift.initialize(applicationId: "xxxxxxxxxx", clientKey: "xxxxxxxxxx", serverURL: URL(string: "https://example.com")!)

Please checkout the Swift Playground for more usage information.

LiveQuery

Query is one of the key concepts on the Parse Platform. It allows you to retrieve ParseObjects by specifying some conditions, making it easy to build apps such as a dashboard, a todo list or even some strategy games. However, Query is based on a pull model, which is not suitable for apps that need real-time support.

Suppose you are building an app that allows multiple users to edit the same file at the same time. Query would not be an ideal tool since you can not know when to query from the server to get the updates.

To solve this problem, we introduce Parse LiveQuery. This tool allows you to subscribe to a Query you are interested in. Once subscribed, the server will notify clients whenever a ParseObject that matches the Query is created or updated, in real-time.

Setup Server

Parse LiveQuery contains two parts, the LiveQuery server and the LiveQuery clients (this SDK). In order to use live queries, you need to at least setup the server.

The easiest way to setup the LiveQuery server is to make it run with the Open Source Parse Server.

Use Client

SwiftUI View Models Using Combine

The LiveQuery client interface is based around the concept of Subscriptions. You can register any Query for live updates from the associated live query server and use the query as a view model for a SwiftUI view by simply using the subscribe property of a query:

let myQuery = GameScore.query("points" > 9)

struct ContentView: View {

    //: A LiveQuery subscription can be used as a view model in SwiftUI
    @StateObject var subscription = myQuery.subscribe!
    
    var body: some View {
        VStack {

            if subscription.subscribed != nil {
                Text("Subscribed to query!")
            } else if subscription.unsubscribed != nil {
                Text("Unsubscribed from query!")
            } else if let event = subscription.event {

                //: This is how you register to receive notificaitons of events related to your LiveQuery.
                switch event.event {

                case .entered(let object):
                    Text("Entered with points: \(object.points)")
                case .left(let object):
                    Text("Left with points: \(object.points)")
                case .created(let object):
                    Text("Created with points: \(object.points)")
                case .updated(let object):
                    Text("Updated with points: \(object.points)")
                case .deleted(let object):
                    Text("Deleted with points: \(object.points)")
                }
            } else {
                Text("Not subscribed to a query")
            }

            Spacer()

            Text("Update GameScore in Parse Dashboard to see changes here")

            Button(action: {
                try? query.unsubscribe()
            }, label: {
                Text("Unsubscribe")
                    .font(.headline)
                    .background(Color.red)
                    .foregroundColor(.white)
                    .padding()
                    .cornerRadius(20.0)
                    .frame(width: 300, height: 50)
            })
        }
    }
}

or by calling the subscribe(_ client: ParseLiveQuery) method of a query. If you want to customize your view model more you can subclass Subscription or add the subscription to your own view model. You can test out LiveQuery subscriptions in Swift Playgrounds.

Traditional Callbacks

You can also use asynchronous call backs to subscribe to a LiveQuery:

let myQuery = Message.query("from" == "parse")
guard let subscription = myQuery.subscribeCallback else {
    print("Error subscribing...")
    return
}

or by calling the subscribeCallback(_ client: ParseLiveQuery) method of a query.

Where Message is a ParseObject.

Once you've subscribed to a query, you can handle events on them, like so:

subscription.handleSubscribe { subscribedQuery, isNew in

    //Handle the subscription however you like.
    if isNew {
        print("Successfully subscribed to new query \(subscribedQuery)")
    } else {
        print("Successfully updated subscription to new query \(subscribedQuery)")
    }
}

You can handle any event listed in the LiveQuery spec:

subscription.handleEvent { _, event in
    // Called whenever an object was created
    switch event {

    case .entered(let object):
        print("Entered: \(object)")
    case .left(let object):
        print("Left: \(object)")
    case .created(let object):
        print("Created: \(object)")
    case .updated(let object):
        print("Updated: \(object)")
    case .deleted(let object):
        print("Deleted: \(object)")
    }
}

Similiarly, you can unsubscribe and register to be notified when it occurs:

subscription.handleUnsubscribe { query in
    print("Unsubscribed from \(query)")
}

//: To unsubscribe from your query.
do {
    try query.unsubscribe()
} catch {
    print(error)
}

Handling errors is and other events is similar, take a look at the Subscription class for more information. You can test out LiveQuery subscriptions in Swift Playgrounds.

Advanced Usage

You are not limited to a single Live Query Client - you can create multiple instances of ParseLiveQuery, use certificate authentication and pinning, receive metrics about each client connection, connect to individual server URLs, and more.

Migration from Parse ObjC SDK

An example application that demonstrates how to convert from the Objective-C SDK to the Swift SDK can be found at ParseMigrateKeychain. Specifically, look at ContentViewModel.swift for code examples. The basic steps are below:

  1. Add the ParseSwift framework to your project using SPM
  2. Remove the Objective-C SDK from your project
  3. Add the Objective-C SDK to your project using SPM. You can use this repo as you will only need PFUser and PFInstallation
  4. Convert your app from using the Objective-C SDK to the Swift SDK
  5. Create a User and Installation model that conform to ParseObject
  6. Migrate PFUser->User using loginusingobjckeychain
  7. Migrate PFInstallation->Installation using become
  8. Remove the Objective-C SDK from your project after you have migrated all users

Description

  • Swift Tools 5.5.0
View More Packages from this Author

Dependencies

  • None
Last updated: Wed Dec 07 2022 19:42:11 GMT-0500 (GMT-05:00)