Merge pull request #1 from space-squad/develop

Develop

Author: annanna

.github/README.md

@@ -0,0 +1,145 @@
+# FirebaseManager Package
+
+This repository contains all utility functions that simplify transactions with Firebase products like Cloud Firestore, Cloud Storage or Authentication, wrapped in a Swift Package.
+
+It is made by **[SPACE SQUAD](https://www.spacesquad.de)**! We make great software with ♥️ in Berlin.
+
+<img src="assets/README-spacesquad_logo_full.png" width="120">
+
+---
+
+## Content
+- [Features](#features)
+- [Installation](#installation)
+- [How to Use](#how-to-use)
+
+
+## Features
+- [x] CRUD-Transactions for collections and documents stored in Firebase Cloud Firestore 
+- [x] CR-Transactions for documents stored in Firebase Cloud Storage 
+- [ ] Handling Authentication and Authorization using SignInWithApple and Password
+
+---
+
+## Installation
+##### Requirements
+- iOS 14.0+ / macOS 10.14+
+- Xcode 13+
+- Swift 5+
+
+##### Swift Package Manager
+In Xcode, go to `File > Add Packages` and add `https://github.com/space-squad/swift-firebase-manager`. Add the package to all your targets.
+
+
+## How to Use
+
+The package is separated into three targets and you need to import the one that fits your needs:
+
+### FirebaseFirestoreManager
+Target for all transactions with the Firebase Cloud Firestore.
+
+
+##### Status
+- [x] CRUD-Transactions for collections and documents
+- [x] Error Handling
+- [ ] Support for nested collections
+- [ ] Snapshot Listeners
+
+
+In the first step you need to define your collections by implementing the ReferenceProtocol.
+
+Example definition for two top-level collections (countries, notes), where every country-document has a cities-collection associated:
+```Swift
+import FirebaseFirestoreManager
+
+enum FirestoreReference: String, ReferenceProtocol {
+    case country = "countries", city = "cities", notes
+}
+```
+Next you need to define all your model classes, conforming to Codable-protocol.
+
+Example:
+```Swift
+public struct City: Codable {
+
+    let name: String
+    let state: String?
+    let country: String?
+    let isCapital: Bool?
+    let population: Int64?
+
+    enum CodingKeys: String, CodingKey {
+        case name
+        case state
+        case country
+        case isCapital = "capital"
+        case population
+    }
+
+}
+```
+
+Afterwards you can use all FirebaseFirestoreManager-classes for creating, reading, updating or deleting data.
+
+Example:
+```Swift
+// Create new document
+let country = Country(....)
+FirestoreManager.createDocument(country, reference: FirestoreReference.country) { _ in }
+
+// Read all documents from a collection
+FirestoreManager.fetchCollection(FirestoreReference.country) { (result: Result<[Country], FirestoreError>) in
+    switch result {
+    case .success(let countries):
+        // Here you can use the fetched countries!
+        print(countries)
+    case .failure(let error):
+        print(error.localizedDescription)
+    }
+}
+
+// Update document
+country.name = "USA"
+FirestoreManager.updateDocument(country, reference: FirestoreReference.country, with: country.id) { _ in }
+
+// Delete document
+FirestoreManager.deleteDocument(reference: FirestoreReference.country, with: country.id)
+```
+
+### FirebaseStorageManager
+Target for all transactions with the Firebase Cloud Storage, using the Combine-framework.
+
+##### Status
+- [x] Create files
+- [x] Read files
+- [ ] Delete files
+- [x] Error Handling
+- [ ] Hierarchical Organization
+- [ ] Multiple Buckets
+- [ ] Support more file types
+
+Example:
+```Swift
+// Create new file in bucket in folder "directory"
+
+let data = Data(base64Encoded: someString)!        
+FirebaseStorageManager.uploadData(data: data, path: "directory", fileName: "fileName", fileType: .csv)
+    .sink { _ in }
+        receiveValue: { url in
+            print(url.absoluteURL)
+        }
+
+
+// Read File from bucket
+FirebaseStorageManager.fetchFile(path: "directory", fileName: "fileName", fileType: .csv)
+    .tryMap { url in
+        try String(contentsOf: url)
+    }
+    .replaceError(with: "Error")
+    .sink { print($0) }
+```
+
+
+
+### FirebaseAuthenticationManager
+To be completed.

.github/assets/README-spacesquad_logo_full.png

@@ -37,14 +37,14 @@ playground.xcworkspace
 # Swift Package Manager
 #
 # Add this line if you want to avoid checking in source code from Swift Package Manager dependencies.
-# Packages/
-# Package.pins
-# Package.resolved
-# *.xcodeproj
+Packages/
+Package.pins
+Package.resolved
+*.xcodeproj
 #
 # Xcode automatically generates this directory with a .xcworkspacedata file and xcuserdata
 # hence it is not needed unless you have added a package configuration file to your project
-# .swiftpm
+.swiftpm
 
 .build/
 

.gitignore

@@ -0,0 +1,38 @@
+// swift-tools-version:5.5
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "FirebaseManager",
+    platforms: [
+        .iOS(.v14),
+        .macOS(.v10_14)
+    ],
+    products: [
+        .library(
+            name: "FirebaseManagerPackage",
+            targets: [
+                "FirebaseStorageManager"
+            ])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/firebase/firebase-ios-sdk.git", .upToNextMajor(from: "9.0.0"))
+    ],
+    targets: [
+        .target(
+            name: "FirebaseFirestoreManager",
+            dependencies: [
+                .product(name: "FirebaseFirestoreSwift", package: "firebase-ios-sdk")
+            ],
+            path: "Sources/FirestoreManager"
+        ),
+        .target(
+            name: "FirebaseStorageManager",
+            dependencies: [
+                .product(name: "FirebaseStorage", package: "firebase-ios-sdk")
+            ],
+            path: "Sources/StorageManager"
+        )
+    ]
+)

Package.swift

@@ -0,0 +1,35 @@
+//
+//  FirestoreManager+Create.swift
+//  
+//
+//  Created by Anna Münster on 26.08.21.
+//
+
+import Foundation
+
+extension FirestoreManager {
+    /**
+     Create a document in Firebase.
+     
+     - Parameter object: Codable object to be uploaded
+     - Parameter reference: The collection name
+     - Parameter id: ID to be set for the document, if nil it is created by Firebase
+     - Parameter completion: If creating was successful, the documentId is returned, otherwise the error
+     */
+    public static func createDocument<T: Encodable>(_ object: T,
+                                                    reference: ReferenceProtocol,
+                                                    with id: String? = nil,
+                                                    completion: @escaping(Result<String, FirestoreError>) -> Void) {
+        do {
+            if let id = id {
+                try reference.reference().document(id).setData(from: object)
+                completion(.success(id))
+            } else {
+                let reference = try reference.reference().addDocument(from: object)
+                completion(.success(reference.documentID))
+            }
+        } catch {
+            completion(.failure(FirestoreError.create(error: error)))
+        }
+    }
+}

README.md

@@ -0,0 +1,26 @@
+//
+//  FirestoreManager+Delete.swift
+//  
+//
+//  Created by Anna Münster on 26.08.21.
+//
+
+import Foundation
+
+extension FirestoreManager {
+    /**
+     Delete a document in Firebase.
+     
+     - Parameter reference: The collection name
+     - Parameter id: ID to be set for the document
+     */
+    public static func deleteDocument(reference: ReferenceProtocol, with id: String, completion: ((FirestoreError?) -> Void)? = nil) {
+        reference.reference().document(id).delete { error in
+            if let error = error {
+                completion?(FirestoreError.delete(error: error))
+            } else {
+                completion?(nil)
+            }
+        }
+    }
+}

Sources/FirestoreManager/FirestoreCRUD/Create.swift

@@ -0,0 +1,88 @@
+//
+//  FirestoreManager+Fetch.swift
+//  
+//
+//  Created by Anna Münster on 26.08.21.
+//
+
+import Foundation
+import FirebaseFirestore
+
+extension FirestoreManager {
+    /**
+     Fetch and listen to a collection from Firebase.
+     
+     - Parameter reference: The collection name
+     - Parameter filters: Dictionary of the filter key and the value
+     - Parameter orderBy: Key to order objects by
+     - Parameter descending: Whether orderBy key should descend
+     - Parameter limit: Limit number of fetched items
+     */
+    public static func fetchCollection<T>(_ reference: ReferenceProtocol,
+                                   filters: [String: Any]? = nil,
+                                   orderBy: [String]? = nil,
+                                   descending: Bool = false,
+                                   limit: Int? = nil,
+                                   completion: @escaping (Result<[T], FirestoreError>) -> Void) where T: Decodable {
+        
+        
+        var query: Query = reference.reference()
+        
+        filters?.forEach { filter, filterValue in
+            query = query.whereField(filter, isEqualTo: filterValue)
+        }
+        
+        orderBy?.forEach { orderValue in
+            query = query.order(by: orderValue, descending: descending)
+        }
+        
+        if let limit = limit {
+            query = query.limit(to: limit)
+        }
+        
+        query.addSnapshotListener { querySnapshot, error in
+            guard let documents = querySnapshot?.documents else {
+                completion(.failure(.documentNotFound(error: error)))
+                return
+            }
+            do {
+                let objects = try documents.map { queryDocumentSnapshot -> T in
+                    try queryDocumentSnapshot.data(as: T.self)
+                }
+                
+                completion(.success(objects))
+            } catch {
+                completion(.failure(.decoding(error: error)))
+            }
+        }
+    }
+    
+   
+    /**
+     Fetch and listen to a single document in Firebase.
+     
+     - Parameter reference: The parent's collection name
+     - Parameter id: ID of the document
+     */
+    public static func fetchDocument<T>(_ reference: ReferenceProtocol,
+                                 id: String,
+                                 completion: @escaping (Result<T, FirestoreError>) -> Void) where T: Decodable {
+        
+        let reference = reference.reference().document(id)
+        
+        let snapshotBlock = { (document: DocumentSnapshot?, error: Error?) in
+            guard let document = document, document.exists else {
+                completion(.failure(.documentNotFound(error: error)))
+                return
+            }
+            do {
+                let decodedObject = try document.data(as: T.self)
+                completion(.success(decodedObject))
+            } catch {
+                completion(.failure(.decoding(error: error)))
+            }
+        }
+        
+        reference.addSnapshotListener(snapshotBlock)
+    }
+}