AzureData

AzureData is an iOS client SDK for Microsoft's Azure Cosmos DB DocumentDB API written in Swift.

Configure

Before making calls to AzureData, you'll need to call AzureData.configure. We recommend doing this in application(_:didFinishLaunchingWithOptions:).

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
    
    AzureData.configure (forAccountNamed: "cosmosDb name", withKey: "read-write key", ofType: .master)
    
    // uncomment to enable verbose logging
    // AzureData.verboseLogging = true

    // ...

    return true
}

Usage

Resource	Create	List	Get	Delete	Replace	Query	Execute
Databases	Create	List	Get	Delete	*	*	*
Collections	Create	List	Get	Delete	Replace	*	*
Documents	Create	List	Get	Delete	Replace	Query	*
Attachments	Create	List	*	Delete	Replace	*	*
Stored Procedures	Create	List	*	Delete	Replace	*	Execute
User Defined Functions	Create	List	*	Delete	Replace	*	*
Triggers	Create	List	*	Delete	Replace	*	*
Users	Create	List	Get	Delete	Replace	*	*
Permissions	Create	List	Get	Delete	Replace	*	*
Offers	*	List	Get	*	Replace	Query	*

* not applicable to resource type

Databases

Create

AzureData.create (databaseWithId: id) { r in
    // database = r.resource
}

List

AzureData.databases () { r in
    // databases = r.resource?.items
}

Get

AzureData.get (databaseWithId: id) { r in
    // database = r.resource
}

Delete

AzureData.delete (database) { s in
    // s == successfully deleted
}

Collections

Create

AzureData.create (collectionWithId: id, inDatabase: databaseId) { r in
    // collection = r.resource
}

database.create (collectionWithId: id) { r in
    // collection = r.resource
}

List

AzureData.get (collectionsIn: databaseId) { r in
    // collections = r.resource?.items
}

database.getCollections () { r in
    // collections = r.resource?.items
}

Get

AzureData.get (collectionWithId: id, inDatabase: databaseId) { r in
    // collection = r.resource
}

database.get (collectionWithId: id) { r in
    // collection = r.resource
}

Delete

AzureData.delete (collection, from: databaseId) { s in
    // s == successfully deleted
}

database.delete (collection) { s in
    // s == successfully deleted
}

Replace

// TODO...

Documents

There are two different classes you can use to interact with documents:

Document

The Document type is intended to be inherited by your custom model types. Subclasses must conform to the Codable protocal and require minimal boilerplate code for successful serialization/deserialization.

Here is an example of a class CustomDocument that inherits from Document:

class CustomDocument: Document {
    
    var testDate:   Date?
    var testNumber: Double?
    
    public override init () { super.init() }
    public override init (_ id: String) { super.init(id) }
    
    public required init(from decoder: Decoder) throws {
        try super.init(from: decoder)
        
        let container = try decoder.container(keyedBy: CodingKeys.self)
        
        testDate    = try container.decode(Date.self,   forKey: .testDate)
        testNumber  = try container.decode(Double.self, forKey: .testNumber)
    }
    
    public override func encode(to encoder: Encoder) throws {
        try super.encode(to: encoder)

        var container = encoder.container(keyedBy: CodingKeys.self)
        
        try container.encode(testDate,      forKey: .testDate)
        try container.encode(testNumber,    forKey: .testNumber)
    }

    private enum CodingKeys: String, CodingKey {
        case testDate
        case testNumber
    }
}

DictionaryDocument

The DictionaryDocument type behaves very much like a [String:Any] dictionary while handling all properties required by the database. This allows you to interact with the document directly using subscript syntax. DictionaryDocument cannot be subclassed.

Here is an example of using DictionaryDocument to create a document with the same properties as the CustomDocument above:

let document = DictionaryDocument()

document["testDate"]   = Date(timeIntervalSince1970: 1510865595)         
document["testNumber"] = 1_000_000

Create

let document = CustomDocument()

document.testDate   = Date(timeIntervalSince1970: 1510865595)
document.testNumber = 1_000_000

// or

let document = DictionaryDocument()

document["testDate"]   = Date(timeIntervalSince1970: 1510865595)         
document["testNumber"] = 1_000_000


AzureData.create (document, inCollection: collectionId, inDatabase: databaseId) { r in
    // document = r.resource
}

AzureData.create (document, in: collection) { r in
    // document = r.resource
}

collection.create (document) { r in
    // document = r.resource
}

List

AzureData.get (documentsAs: CustomDocument.self, inCollection: collectionId, inDatabase: databaseId) { r in
    // documents = r.resource?.items
}

AzureData.get (documentsAs: CustomDocument.self, in: collection) { r in
    // documents = r.resource?.items
}

collection.get (documentsAs: CustomDocument.self) { r in
    // documents in r.resource?.list
}

Get

AzureData.get (documentWithId: id, as: CustomDocument.self, inCollection: collectionId, inDatabase: databaseId) { r in
    // document = r.resource
}

AzureData.get (documentWithId: id, as: CustomDocument.self, in: collection) { r in
    // document = r.resource
}

collection.get (documentWithResourceId: id: as: CustomDocument.self) { r in
    // document = r.resource
}

Delete

AzureData.delete (document, fromCollection: collectionId, inDatabase: databaseId) { r in
    // document = r.resource
}

AzureData.delete (document, from: collection) { r in
    // document = r.resource
}

collection.delete (document) { s in
    // s == successfully deleted
}

Replace

AzureData.replace (document, inCollection: collectionId, inDatabase: databaseId) { r in
    // document = r.resource
}

AzureData.replace (document, in: collection) { r in
    // document = r.resource
}

collection.replace (document) { r in
    // document = r.resource
}

Query

let query = ADQuery.select("firstName", "lastName", ...)
                   .from("People")
                   .where("firstName", is: "Colby")
                   .and("lastName", is: "Williams")
                   .and("age", isGreaterThanOrEqualTo: 20)
                   .orderBy("_etag", descending: true)

AzureData.query(documentsIn: collectionId, inDatabase: databaseId, with: query) { r in
    // documents = r.resource?.items
}

AzureData.query(documentsIn: collection, with: query) { r in
    // documents = r.resource?.items
}

collection.query (documentsWith: query) { r in
    // documents in r.resource?.list
}

Attachments

Create

// link to existing media asset:
AzureData.create (attachmentWithId: id, contentType: "image/png", andMediaUrl: url, onDocument: documentId, inCollection: collectionId, inDatabase: databaseId) { r in
    // attachment = r.resource
}

//or upload the media directly:
AzureData.create (attachmentWithId: id, contentType: "image/png", name: "file.png", with: media, onDocument: documentId, inCollection: collectionId, inDatabase: databaseId) { r in
    // attachment = r.resource
}

List

AzureData.get (attachmentsOn: documentId, inCollection: collectionId, inDatabase: databaseId) { r in
    // attachments = r.resource
}

Delete

AzureData.delete (attachment, onDocument: documentId, inCollection: collectionId, inDatabase: databaseId) { s in
    // s == successfully deleted
}

Replace

// link to existing media asset:
AzureData.replace(attachmentWithId: id, contentType: "image/png", andMediaUrl: url, onDocument: documentId, inCollection: collectionId, inDatabase: databaseId) { r in
    // attachment = r.resource
}


AzureData.replace(attachmentWithId: id, contentType: "image/png", name: "file.png", with: media, onDocument: documentId, inCollection: collectionId, inDatabase: databaseId) { r in
    // attachment = r.resource
}

Stored Procedures

Create

AzureData.create (storedProcedureWithId: id, andBody: body, inCollection: collectionId, inDatabase: databaseId) { r in
    // storedProcedure = r.resource
}

AzureData.create (storedProcedureWithId: id, andBody: body, in: collection) { r in
    // storedProcedure = r.resource
}

collection.create (storedProcedureWithId: storedProcedureId, andBody: body) { r in
    // storedProcedure = r.resource
}

List

AzureData.get (storedProceduresIn: collectionId, inDatabase: databaseId) { r in
    // storedProcedures = r.resource?.items
}

AzureData.get (storedProceduresIn: collection) { r in
    // storedProcedures = r.resource?.items
}

collection.getStoredProcedures () { r in
    // storedProcedures in r.resource?.list
}

Delete

AzureData.delete (storedProcedure, fromCollection: collectionId, inDatabase: databaseId) { s in
    // s == successfully deleted
}

AzureData.delete (storedProcedure, from: collection) { s in
    // s == successfully deleted
}

collection.delete (storedProcedure) { s in
    // s == successfully deleted
}

Replace

AzureData.replace (storedProcedureWithId: id, andBody: body, inCollection: collectionId, inDatabase: databaseId) { r in
    // storedProcedure = r.resource
}

AzureData.replace (storedProcedureWithId: id, andBody: body, in: collection) { r in
    // storedProcedure = r.resource
}

collection.replace (storedProcedureWithId: storedProcedureId, andBody: body) { r in
    // storedProcedure = r.resource
}

Execute

AzureData.execute (storedProcedureWithId: id, usingParameters: [], inCollection: collectionId, inDatabase: databaseId) { r in
    // r = raw response data
}

AzureData.execute (storedProcedureWithId: id, usingParameters: [], in: collection) { r in
    // r = raw response data
}

collection.execute (storedProcedureWithId: storedProcedureId, usingParameters: parameters) { data in
    // data = response from stored procedure
}

User Defined Functions

Create

AzureData.create (userDefinedFunctionWithId: id, andBody: body, inCollection: collectionId, inDatabase: databaseId) { r in
    // userDefinedFunction = r.resource
}

AzureData.create (userDefinedFunctionWithId: id, andBody: body, in: collection) { r in
    // userDefinedFunction = r.resource
}

collection.create (userDefinedFunctionWithId: userDefinedFunctionId, andBody: body) { r in
    // userDefinedFunction = r.resource
}

List

AzureData.get (userDefinedFunctionsIn: collectionId, inDatabase: databaseId) { r in
    // userDefinedFunction = r.resource?.items
}

AzureData.get (userDefinedFunctionsIn: collection) { r in
    // userDefinedFunction = r.resource?.items
}

collection.getUserDefinedFunctions () { r in
    // userDefinedFunctions in r.resource?.list
}

Delete

AzureData.delete (userDefinedFunction, fromCollection: collectionId, inDatabase: databaseId) { s in
    // s == successfully deleted
}

AzureData.delete (userDefinedFunction, from: collection) { s in
    // s == successfully deleted
}

collection.delete (userDefinedFunction) { s in
    // s == successfully deleted
}

Replace

AzureData.replace (userDefinedFunctionWithId: id, andBody: body, inCollection: collectionId, inDatabase: databaseId) { r in
    // userDefinedFunction = r.resource
}

AzureData.replace (userDefinedFunctionWithId: id, andBody: body, from: collection) { r in
    // userDefinedFunction = r.resource
}

collection.replace (userDefinedFunctionWithId: userDefinedFunctionId, andBody: body) { r in
    // userDefinedFunction = r.resource
}

Triggers

Create

AzureData.create (triggerWithId: id, operation: .all, type: .pre, andBody: body, inCollection: collectionId, inDatabase: databaseId) { r in
    // trigger = r.resource
}

AzureData.create (triggerWithId: id, operation: .all, type: .pre, andBody: bosy, in: collection) { r in
    // trigger = r.resource
}

collection.create (triggerWithId: triggerId, andBody: body, operation: operation, type: type) { r in
    // trigger = r.resource
}

List

AzureData.get (triggersIn: collectionId, inDatabase: databaseId) { r in
    // triggers = r.resource?.items
}

AzureData.get (triggersIn: collection) { r in
    // triggers = r.resource?.items
}

collection.getTriggers () { r in
    // triggers in r.resource?.list
}

Delete

AzureData.delete (trigger, fromCollection: collectionId, inDatabase: databaseId) { s in
    // s == successfully deleted
}

AzureData.delete (trigger, from: collection) { s in
    // s == successfully deleted
}

collection.delete (trigger) { s in
    // s == successfully deleted
}

Replace

AzureData.replace (triggerWithId: id, operation: .all, type: .pre, andBody: body, inCollection: collectionId, inDatabase: databaseId) { r in
    // trigger = r.resource
}

AzureData.replace (triggerWithId: id, operation: .all, type: .pre, andBody: body, in: collection) { r in
    // trigger = r.resource
}

collection.replace (triggerWithId: triggerId, andBody: body, operation: operation, type: type) { r in
    // trigger = r.resource
}

Users

Create

AzureData.create (userWithId: id, inDatabase: databaseId) { r in
    // user = r.resource
}

database.create (userWithId: userId) { r in
    // user = r.resource
}

List

AzureData.get (usersIn: databaseId) { r in
    // users = r.resource?.items
}

database.getUsers () { r in
    // users = r.resource?.items
}

Get

AzureData.get (userWithId: id, inDatabase: databaseId) { r in
    // user = r.resource
}

database.get (userWithId: userId) { r in
    // user = r.resource
}

Delete

AzureData.delete (user, fromDatabase: databaseId) { s in
    // s == successfully deleted
}

database.delete (user: user) { s in
    // s == successfully deleted
}

Replace

AzureData.replace (userWithId: id, with: newUserId, inDatabase: databaseId) { r in
    // user = r.resource
}

database.replace (userWithId: userId) { r in
    // user = r.resource
}

Permissions

Create

AzureData.create (permissionWithId: id, mode: .read, in: resource, forUser: userId, inDatabase: databaseId) { r in
    // permission = r.resource
}

List

AzureData.get (permissionsFor: userId, inDatabase: databaseId) { r in
    // permissions = r.resource
}

Get

AzureData.get (permissionWithId: id, forUser: userId, inDatabase: databaseId) { r in
    // permission = r.resource
}

Delete

AzureData.delete (permission, forUser: userId, inDatabase: databaseId) { s in
    // s == successfully deleted
}

Replace

AzureData.replace (permissionWithId: id, mode: .read, in: resource, forUser: userId, inDatabase: databaseId) { r in
    // permission = r.resource
}

Offers

List

AzureData.offers() { r in
// offers = r.resource?.items
}

Get

AzureData.get (offerWithId: id) { r in
    // offer = r.resource
}

Replace

// TODO...

Query

// TODO...