netreconlab/parse-swift

Contributors

Developers who dedicate their time and effort are who make this repo possible!

<a href="https://github.com/netreconlab/Parse-Swift/graphs/contributors"> <img src="https://contrib.rocks/image?repo=netreconlab/Parse-Swift" /> </a>

• Why use ParseSwift^OG from NetReconLab?
• Contributors
• Example Apps and Frameworks
• Test Drive Parse-Swift
• Installation

- Swift Package Manager - CocoaPods

• Usage Guide
• LiveQuery

- Setup Server - Use Client - SwiftUI View Models Using Combine - Traditional Callbacks - Advanced Usage

• Migrating from Older Versions and SDKs

Example Apps and Frameworks

Below is a list of apps and frameworks that use ParseSwift^OG to help developers take advantage of the framework:

• ParseServerSwift - Write Parse Cloud Code in Swift using ParseSwift^OG
• ParseServerAnyAnalytics - Analytics adapter to connect Parse Server analytics to any 3rd party analytics tool
• CareKitSample-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 ParseSwift^OG
• SnapCat - SnapCat is a social media application for posting pictures, comments, and finding friends. SnapCat is designed using SwiftUI and the ParseSwift^OG SDK
• ParseMigrateKeychain - A sample app that demonstrates how to migrate an app written with the Parse Objective-C SDK to the ParseSwift^OG SDK. Learn more, see the discussion.

Test Drive Parse-Swift

To learn how to use or experiment with ParseSwift^OG, 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 configuration in Common.swift. To learn more, see this discussion or CONTRIBUTING.md.

Installation

Swift Package Manager

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

// swift-tools-version:6.0
import PackageDescription

let package = Package(
    name: "YOUR_PROJECT_NAME",
    dependencies: [
        .package(url: "https://github.com/netreconlab/Parse-Swift", .upToNextMajor(from: "6.0.4"))
    ],
    targets: [
        .target(
            name: "YOUR_PROJECT_NAME",
            dependencies: [
                .product(name: "ParseSwift", package: "Parse-Swift")
            ]
        ),
        .testTarget(
            name: "YOUR_PROJECT_NAMETests",
            dependencies: ["YOUR_PROJECT_NAME"]
        )
    ]
)

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.

CocoaPods

Add the following line to your Podfile:

pod 'ParseSwiftOG'

To link to the latest updates on the main branch, add the following line to your Podfile:

pod 'ParseSwiftOG', :git => 'https://github.com/netreconlab/Parse-Swift.git', :branch => 'main'

In your projects, use:

import ParseSwiftOG

Usage Guide

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

try await 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: https://github.com/netreconlab/Parse-Swift/blob/0c17c781a211299f324753fa9bcbb6845c22fad2/ParseSwift.playground/Pages/19%20-%20SwiftUI%20-%20LiveQuery.xcplaygroundpage/Contents.swift#L66-L125

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")
do {
  let subscription = try await myQuery.subscribeCallback()
} catch {
    print("Error subscribing...")
}

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 for LiveQuery docs:

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)")
    }
}

Similarly, 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 await query.unsubscribe()
} catch {
    print(error)
}

Handling errors and other events are 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.

[license-link]: LICENSE

Migrating from Older Versions and SDKs

1. See the discussion to learn how to migrate from ParseSwift^OG 4.15.0+ to 5.1.1+
2. See the discussion to learn how to migrate from parse-community/Parse-Swift
3. See the discussion to learn how to migrate from Parse-SDK-iOS-OSX

Package Metadata

Repository: netreconlab/parse-swift

Default branch: main

README: README.md