Merge remote-tracking branch 'origin/master'

Author: EddyVerbruggen

docs/DATABASE.md

@@ -416,7 +416,9 @@ same time.
 You can look at the [docs](https://firebase.google.com/docs/reference/js/firebase.database.Reference#transaction) for more information.
 
 Note that a return value of `null` will delete the value at this location whereas returning
-undefined will abort the transaction. On success a promise is returned containing
+undefined will not modify the data at this location. Firebase web aborts the transaction when
+given an undefined, but due to technically difficulties we just return transaction success which
+results in committed = true. On transaction complete a promise is returned containing
 {committed:boolean, snapshot: DataSnapshot} and an error will be returned if the transaciton
 failed.
 
@@ -463,6 +465,25 @@ firebaseWebApi.database().ref(path).transaction(currentValue => {
         return ++currentValue; // increment the value
       }
     })
+
+// Based off Firebase simple blog post. You can also treat the
+// data as an object and return an updated version of post
+firebaseWebApi.database().ref(path).transaction(function(post) {
+      if (post) {
+        console.log("Post Object looks like: " +  JSON.stringify(post));
+        if (post.stars && post.stars[uid]) {
+          post.starCount--;
+          post.stars[uid] = null;
+        } else {
+          post.starCount++;
+          if (!post.stars) {
+            post.stars = {};
+          }
+          post.stars[uid] = true;
+        }
+      }
+      return post;
+    });
 ```
 </details>
 

src/firebase.android.ts

@@ -1807,14 +1807,22 @@ firebase.transaction = (path: string, transactionUpdate: (currentState) => any,
     const dbRef: com.google.firebase.database.DatabaseReference = firebase.instance.child(path);
     const handler: com.google.firebase.database.Transaction.Handler = new com.google.firebase.database.Transaction.Handler({
       doTransaction: (mutableData: com.google.firebase.database.MutableData) => {
-        const desiredValue = transactionUpdate(mutableData.getValue());
+        const desiredValue = transactionUpdate(firebase.toJsObject(mutableData.getValue()));
         // Java does not have undefined, but web transactions use undefined to detect if an abort() is desired.
         if (desiredValue === undefined) {
-          return com.google.firebase.database.Transaction.abort();
-        } else {
-          mutableData.setValue(firebase.toValue(desiredValue));
+          // Same problem as iOS. The very first call to runTransaction will see that we get undefined
+          // and immediately abort the transaction which results in us failing to update the value. Subsequent
+          // calls are working fine unlike in iOS which always fail.
+
+          // TLDR: Abort would be ideal, but atm it can result in a failed update (when it shouln't)
+          // Returning success fixes this but makes our { committed: always true }...
+
+          // return com.google.firebase.database.Transaction.abort();
           return com.google.firebase.database.Transaction.success(mutableData);
         }
+        mutableData.setValue(firebase.toValue(desiredValue));
+        return com.google.firebase.database.Transaction.success(mutableData);
+
       },
       onComplete: (databaseError: com.google.firebase.database.DatabaseError, commited: boolean, snapshot: com.google.firebase.database.DataSnapshot) => {
         databaseError !== null ? reject(databaseError.getMessage()) :

src/firebase.ios.ts

@@ -9,7 +9,7 @@ import * as firebaseMessaging from "./messaging/messaging";
 import * as application from "tns-core-modules/application/application";
 import { ios as iOSUtils } from "tns-core-modules/utils/utils";
 import * as firebaseFunctions from './functions/functions';
-import { firestore, User, OnDisconnect as OnDisconnectBase, transaction, DataSnapshot } from "./firebase";
+import { firestore, User, OnDisconnect as OnDisconnectBase, DataSnapshot } from "./firebase";
 import { firebaseUtils } from "./utils";
 
 firebase._gIDAuthentication = null;
@@ -1546,9 +1546,23 @@ firebase.transaction = (path: string, transactionUpdate: (currentState) => any,
 
     dbRef.runTransactionBlockAndCompletionBlock(
       (mutableData: FIRMutableData): FIRTransactionResult => {
-        const desiredValue = transactionUpdate(mutableData.value);
+        const desiredValue = transactionUpdate(firebaseUtils.toJsObject(mutableData.value));
         if (desiredValue === undefined) {
-          return FIRTransactionResult.abort();
+          // The problem case : user returns undefined when the the value we give them (mutableData) is null.
+          // This is a valid case as the user will want to abort if he thinks theres no data, BUT mutualData
+          // is usually null when runTransaction is called the first time(which is why its called multiple times).
+          // Result: we would abort and the transaction terminates, but the real data didn't have a chance to come in
+          // for the function to be called a second time.
+          // Even in the ios simple blog example their complete block is called twice with committed first being false
+          // followed by a second one saying committed is true... So with this implementation I favored having an "incorrect"
+          // committed boolean, but have the correct updated value
+
+          // TLDR: if user returns undefined then we may never execute his function with the correct input
+          // For now the way to resolve this is to call success with the original value (so we don't modify anything)
+          // And then the user will get his expected value, but { committed: always true }....
+
+          // return FIRTransactionResult.abort();
+          return FIRTransactionResult.successWithValue(mutableData);
         } else {
           mutableData.value = desiredValue;
           return FIRTransactionResult.successWithValue(mutableData);