Batch and Transaction Operation in FireStore #667

Author: EddyVerbruggen

demo-ng/app/tabs/firestore/firestore.component.html

@@ -25,5 +25,7 @@
     <Button text="Where, Order, Limit" (tap)="firestoreWhereOrderLimit()" class="button"></Button>
     <Button text="Where array_contains" (tap)="firestoreWhereCityHasALake()" class="button"></Button>
     <Button text="Delete" (tap)="firestoreDelete()" class="button"></Button>
+    <!--<Button text="Transactional update" (tap)="transactionalUpdate()" class="button"></Button>-->
+    <Button text="Write batch" (tap)="writeBatch()" class="button"></Button>
   </StackLayout>
 </ScrollView>

demo-ng/app/tabs/firestore/firestore.component.ts

@@ -45,16 +45,14 @@ export class FirestoreComponent {
         .set({
               name: "Woofie",
               last: "lastofwoofie",
-          // note that this only works on iOS (there's a limitation in the Firestore Android SDK)
+              // note that this only works on iOS (there's a limitation in the Firestore Android SDK)
               // updateTsSet: firebase.firestore().FieldValue().serverTimestamp()
             },
             {
               merge: true
             }
         )
-        .then(() => {
-          console.log("Woofie set");
-        })
+        .then(() => console.log("Woofie set"))
         .catch(err => console.log("Setting Woofie failed, error: " + err));
 
 
@@ -74,23 +72,26 @@ export class FirestoreComponent {
       state: "CA",
       country: "USA",
       capital: false,
-      population: 3900000
+      population: 3900000,
+      landmarks: ["lake", "mountain"]
     });
 
     citiesCollection.doc("SAC").set({
       name: "Sacramento",
       state: "CA",
       country: "USA",
       capital: true,
-      population: 500000
+      population: 500000,
+      landmarks: ["mountain"]
     });
 
     citiesCollection.doc("DC").set({
       name: "Washington, D.C.",
       state: "WA",
       country: "USA",
       capital: true,
-      population: 680000
+      population: 680000,
+      landmarks: ["airport", "lake"]
     });
 
     citiesCollection.doc("TOK").set({
@@ -290,4 +291,41 @@ export class FirestoreComponent {
         })
         .catch(error => console.log("doWebGetValueForCompanies error: " + error));
   }
+
+  /*
+  public transactionalUpdate(): void {
+    const sfDocRef: firestore.DocumentReference = firebase.firestore().collection("cities").doc("SF");
+
+    firebase.firestore().runTransaction(transaction => {
+      const sfDoc = transaction.get(sfDocRef);
+      if (!sfDoc.exists) {
+        console.log("City SF doesn't exist");
+      } else {
+        const newPopulation = sfDoc.data().population + 1;
+        console.log(`Updating city 'SF' to a new population of: ${newPopulation}, and flipping the 'capital' state to ${sfDoc.data().capital}.`);
+
+        // this should fail
+        transaction
+            .set(sfDocRef, {capital: !sfDoc.data().capital}, {merge: true})
+            // .delete(sfDocRef) // with this line enabled, the next line will fail and the entire tx is rolled back 👍
+            .update(sfDocRef, {population: newPopulation})
+      }
+      return null;
+    })
+        .then(() => console.log(`Transaction successfully committed`))
+        .catch(error => console.log("doTransaction error: " + error));
+  }
+  */
+
+  public writeBatch(): void {
+    const sfDocRef: firestore.DocumentReference = firebase.firestore().collection("cities").doc("SF");
+
+    firebase.firestore().batch()
+        .set(sfDocRef, {capital: false}, {merge: true})
+        // .delete(sfDocRef) // Want to verify batches are atomic? With this line enabled, the next line will fail and the entire batch is rolled back correctly 👍
+        .update(sfDocRef, {population: 5})
+        .commit()
+        .then(() => console.log(`Batch successfully committed`))
+        .catch(error => console.log("Batch error: " + error));
+  }
 }

docs/FIRESTORE.md

@@ -237,5 +237,29 @@ query
     });
 ```
 
-## Future work
-Need something else that's not supported yet? Please open an Issue or PR 😚
+### `batch()`
+To perform a (mixed) sequence of `set`, `update`, and/or `delete` operations in an atomic fashion
+(everything is rolled back if 1 operation fails), use the `batch` feature.
+
+```typescript
+const sanFranciscoDocumentReference: firestore.DocumentReference = firebase.firestore().collection("cities").doc("SF");
+
+firebase.firestore().batch()
+    .set(sanFranciscoDocumentReference, {capital: false}, {merge: true})
+    .update(sanFranciscoDocumentReference, {population: 5})
+    .update(sanFranciscoDocumentReference, {population: 6})
+    .commit()
+    .then(() => console.log("Batch successfully committed"))
+    .catch(error => console.log("Batch error: " + error));
+```
+
+Need proof these batches are atomic? Try deleting and then updating a document 😉
+
+```typescript
+firebase.firestore().batch()
+    .delete(sanFranciscoDocumentReference)
+    .update(sanFranciscoDocumentReference, {population: 7})
+    .commit()
+    .then(() => console.log("Batch successfully committed"))
+    .catch(error => console.log("Batch error: " + error));
+```

src/app/firestore/index.ts

@@ -15,5 +15,13 @@ export module firestore {
     GeoPoint(latitude: number, longitude: number): firebase.firestore.GeoPoint {
       return firebase.firestore.GeoPoint(latitude, longitude);
     }
+
+    // runTransaction<T>(updateFunction: (transaction: firebase.firestore.Transaction) => Promise<any>): Promise<void> {
+    //   return firebase.firestore.runTransaction(updateFunction);
+    // }
+
+    batch(): firebase.firestore.WriteBatch {
+      return firebase.firestore.batch();
+    }
   }
 }

src/firebase.android.ts

@@ -2115,6 +2115,159 @@ firebase.invites.getInvitation = () => {
   });
 };
 
+class FirestoreWriteBatch implements firestore.WriteBatch {
+
+  public nativeWriteBatch: com.google.firebase.firestore.WriteBatch;
+
+  public set = (documentRef: firestore.DocumentReference, data: firestore.DocumentData, options?: firestore.SetOptions): firestore.WriteBatch => {
+    if (options && options.merge) {
+      this.nativeWriteBatch.set(documentRef.android, firebase.toValue(data), com.google.firebase.firestore.SetOptions.merge());
+    } else {
+      this.nativeWriteBatch.set(documentRef.android, firebase.toValue(data));
+    }
+    return this;
+  };
+
+  public update = (documentRef: firestore.DocumentReference, data: firestore.UpdateData): firestore.WriteBatch => {
+    this.nativeWriteBatch.update(documentRef.android, firebase.toValue(data));
+    return this;
+  };
+
+  public delete = (documentRef: firestore.DocumentReference): firestore.WriteBatch => {
+    this.nativeWriteBatch.delete(documentRef.android);
+    return this;
+  };
+
+  public commit(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const onCompleteListener = new com.google.android.gms.tasks.OnCompleteListener({
+        onComplete: task => {
+          if (!task.isSuccessful()) {
+            const ex = task.getException();
+            reject(ex && ex.getReason ? ex.getReason() : ex);
+          } else {
+            resolve();
+          }
+        }
+      });
+      this.nativeWriteBatch.commit().addOnCompleteListener(onCompleteListener);
+    });
+  };
+}
+
+firebase.firestore.batch = (): firestore.WriteBatch => {
+  const batch = new FirestoreWriteBatch();
+  batch.nativeWriteBatch = com.google.firebase.firestore.FirebaseFirestore.getInstance().batch();
+  return batch;
+};
+
+/*
+class FirestoreTransaction implements firestore.Transaction {
+
+  public nativeTransaction: com.google.firebase.firestore.Transaction;
+
+  public get = (documentRef: firestore.DocumentReference): DocumentSnapshot => {
+    const docSnapshot: com.google.firebase.firestore.DocumentSnapshot = this.nativeTransaction.get(documentRef.android);
+    return new DocumentSnapshot(docSnapshot ? docSnapshot.getId() : null, docSnapshot.exists(), firebase.toJsObject(docSnapshot.getData()));
+  };
+
+  public set = (documentRef: firestore.DocumentReference, data: firestore.DocumentData, options?: firestore.SetOptions): firestore.Transaction => {
+    console.log(">>> in tx.set");
+    if (options && options.merge) {
+      this.nativeTransaction.set(documentRef.android, firebase.toValue(data), com.google.firebase.firestore.SetOptions.merge());
+    } else {
+      this.nativeTransaction.set(documentRef.android, firebase.toValue(data));
+    }
+    return this;
+  };
+
+  public update = (documentRef: firestore.DocumentReference, data: firestore.UpdateData): firestore.Transaction => {
+    console.log(">>> in tx.update");
+    this.nativeTransaction.update(documentRef.android, firebase.toValue(data));
+    return this;
+  };
+
+  public delete = (documentRef: firestore.DocumentReference): firestore.Transaction => {
+    console.log(">>> in tx.delete");
+    this.nativeTransaction.delete(documentRef.android);
+    return this;
+  }
+};
+
+firebase.firestore.Transaction = (nativeTransaction: com.google.firebase.firestore.Transaction): firestore.Transaction => {
+  const tx = new FirestoreTransaction();
+  tx.nativeTransaction = nativeTransaction;
+  return tx;
+};
+
+firebase.firestore.runTransaction = (updateFunction: (transaction: firestore.Transaction) => Promise<any>): Promise<void> => {
+  return new Promise((resolve, reject) => {
+
+    const onSuccessListenert = new com.google.android.gms.tasks.OnSuccessListener({
+      onSuccess: () => {
+        const i = 1;
+      }
+    });
+
+    const l = new java.util.ArrayList();
+    l.add("foooo");
+    l.add("barrr");
+    org.nativescript.plugins.firebase.FirebaseFirestore.STATE = onSuccessListenert; // for this assignment to 'stick', this needs to be a real Java object
+    org.nativescript.plugins.firebase.FirebaseFirestore.UPDATE_FUNCTION = updateFunction;
+    console.log(">>> STATE: " + org.nativescript.plugins.firebase.FirebaseFirestore.STATE);
+    console.log(">>> UPDATE_FUNCTION: " + org.nativescript.plugins.firebase.FirebaseFirestore.UPDATE_FUNCTION);
+
+    let worker;
+    if (global['TNS_WEBPACK']) {
+      const WorkerScript = require('nativescript-worker-loader!./android-firestoretx-worker.js');
+      worker = new WorkerScript();
+    } else {
+      worker = new Worker('./android-firestoretx-worker.js');
+    }
+
+    (<any>global).theUpdateFunction = updateFunction;
+
+    worker.onmessage = msg => {
+      console.log(">>> msg from worker, stringified: " + JSON.stringify(msg));
+    };
+
+    worker.onerror = err => {
+      console.log(">>> worker err: " + JSON.stringify(err));
+    };
+
+    worker.postMessage({
+      in: "innn",
+      someArray: l,
+      onSuccessListenert: onSuccessListenert
+      // updateFunction: updateFunction
+    });
+
+    const onSuccessListener = new com.google.android.gms.tasks.OnSuccessListener({
+      onSuccess: resolve // TODO does this syntax work? if so: refactor other instances... otherwise use: onSuccess: () => resolve()
+    });
+
+    const onFailureListener = new com.google.android.gms.tasks.OnFailureListener({
+      onFailure: exception => reject(exception.getMessage())
+    });
+
+    // TODO apply is called from java to js, so that makes it run on the main/UI thread.. so doesn't work
+    // .. can we share native objects via appcontext (for a worker)?
+    const txFunction = new com.google.firebase.firestore.Transaction.Function({
+      apply: (nativeTransaction: com.google.firebase.firestore.Transaction) => {
+        const tx = new firebase.firestore.Transaction(nativeTransaction);
+        return updateFunction(tx);
+      }
+    });
+
+    com.google.firebase.firestore.FirebaseFirestore.getInstance().runTransaction(txFunction)
+        .addOnSuccessListener(onSuccessListener)
+        .addOnFailureListener(onFailureListener);
+
+    // org.nativescript.plugins.firebase.FirebaseFirestore.runTransaction(txFunction, onSuccessListener, onFailureListener);
+  });
+};
+*/
+
 firebase.firestore.collection = (collectionPath: string): firestore.CollectionReference => {
   try {
 

src/firebase.d.ts

@@ -753,6 +753,42 @@ export namespace firestore {
     add(data: DocumentData): Promise<DocumentReference>;
   }
 
+  export type UpdateData = { [fieldPath: string]: any };
+
+  export class FieldPath {
+    /**
+     * Creates a FieldPath from the provided field names. If more than one field
+     * name is provided, the path will point to a nested field in a document.
+     *
+     * @param fieldNames A list of field names.
+     */
+    constructor(...fieldNames: string[]);
+
+    /**
+     * Returns a special sentinel FieldPath to refer to the ID of a document.
+     * It can be used in queries to sort or filter by the document ID.
+     */
+    static documentId(): FieldPath;
+  }
+
+  /*
+  export interface Transaction {
+    get(documentRef: DocumentReference): DocumentSnapshot;
+    set(documentRef: DocumentReference, data: DocumentData, options?: SetOptions): Transaction;
+    update(documentRef: DocumentReference, data: UpdateData): Transaction;
+    update(documentRef: DocumentReference, field: string | FieldPath, value: any, ...moreFieldsAndValues: any[]): Transaction;
+    delete(documentRef: DocumentReference): Transaction;
+  }
+  */
+
+  export interface WriteBatch {
+    set(documentRef: DocumentReference, data: DocumentData, options?: SetOptions): WriteBatch;
+    update(documentRef: DocumentReference, data: UpdateData): WriteBatch;
+    update(documentRef: DocumentReference, field: string | FieldPath, value: any, ...moreFieldsAndValues: any[]): WriteBatch;
+    delete(documentRef: DocumentReference): WriteBatch;
+    commit(): Promise<void>;
+  }
+
   export class FieldValue {
     static serverTimestamp: () => "SERVER_TIMESTAMP";
   }
@@ -776,6 +812,10 @@ export namespace firestore {
   function getDocument(collectionPath: string, documentPath: string): Promise<DocumentSnapshot>;
 
   function update(collectionPath: string, documentPath: string, document: any): Promise<void>;
+
+  // function runTransaction(updateFunction: (transaction: firestore.Transaction) => Promise<any>): Promise<void>;
+
+  function batch(): firestore.WriteBatch;
 }
 
 // Auth