Merge branch 'mrschmidt/transactions' into mrschmidt/expshim

schmidt-sebastian · schmidt-sebastian · commit c845490fdfa8 · 2020-07-06T15:12:03.000-07:00
diff --git a/.changeset/gorgeous-beers-build.md b/.changeset/gorgeous-beers-build.md
@@ -0,0 +1,2 @@
+---
+---
diff --git a/packages/firestore/exp/index.node.ts b/packages/firestore/exp/index.node.ts
@@ -54,7 +54,7 @@ export {
   parent
 } from '../lite/src/api/reference';
 
-export { runTransaction, Transaction } from '../lite/src/api/transaction';
+export { runTransaction, Transaction } from './src/api/transaction';
 
 export {
   getDoc,
diff --git a/packages/firestore/exp/src/api/transaction.ts b/packages/firestore/exp/src/api/transaction.ts
@@ -0,0 +1,75 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as firestore from '../../index';
+
+import { BaseTransaction } from '../../../lite/src/api/transaction';
+import { DocumentSnapshot } from './snapshot';
+import { TransactionRunner } from '../../../src/core/transaction_runner';
+import { AsyncQueue } from '../../../src/util/async_queue';
+import { cast } from '../../../lite/src/api/util';
+import { Firestore } from './database';
+import { Deferred } from '../../../src/util/promise';
+import { SnapshotMetadata } from '../../../src/api/database';
+import { Transaction as InternalTransaction } from '../../../src/core/transaction';
+
+export class Transaction extends BaseTransaction
+  implements firestore.Transaction {
+  constructor(
+    protected readonly _firestore: Firestore,
+    _transaction: InternalTransaction
+  ) {
+    super(_firestore, _transaction);
+  }
+
+  get<T>(
+    documentRef: firestore.DocumentReference<T>
+  ): Promise<firestore.DocumentSnapshot<T>> {
+    return this._getHelper<firestore.DocumentSnapshot<T>, T>(
+      documentRef,
+      (ref, doc) =>
+        new DocumentSnapshot<T>(
+          this._firestore,
+          ref._key,
+          doc,
+          new SnapshotMetadata(
+            /* hasPendingWrites= */ false,
+            /* fromCache= */ false
+          ),
+          ref._converter
+        )
+    );
+  }
+}
+
+export function runTransaction<T>(
+  firestore: firestore.FirebaseFirestore,
+  updateFunction: (transaction: firestore.Transaction) => Promise<T>
+): Promise<T> {
+  const firestoreClient = cast(firestore, Firestore);
+  return firestoreClient._getDatastore().then(async datastore => {
+    const deferred = new Deferred<T>();
+    new TransactionRunner<T>(
+      new AsyncQueue(),
+      datastore,
+      internalTransaction =>
+        updateFunction(new Transaction(firestoreClient, internalTransaction)),
+      deferred
+    ).run();
+    return deferred.promise;
+  });
+}
diff --git a/packages/firestore/lite/src/api/transaction.ts b/packages/firestore/lite/src/api/transaction.ts
@@ -33,26 +33,39 @@ import { AsyncQueue } from '../../../src/util/async_queue';
 import { Deferred } from '../../../src/util/promise';
 import { FieldPath as ExternalFieldPath } from '../../../src/api/field_path';
 import { validateReference } from './write_batch';
-import { newUserDataReader } from './reference';
+import { DocumentReference, newUserDataReader } from './reference';
 import { FieldPath } from './field_path';
 import { cast } from './util';
 
-export class Transaction implements firestore.Transaction {
-  // This is the lite version of the Transaction API used in the legacy SDK. The
-  // class is a close copy but takes different input types.
+// TODO(mrschmidt) Consider using `BaseTransaction` as the base class in the
+// legacy SDK.
+export abstract class BaseTransaction {
+  // This is the tree-shakeable version of the Transaction class used in the
+  // legacy SDK. The class is a close copy but takes different input and output
+  // types. The Lite as well as the firestore-exp SDK further extend this class
+  // to provide their appropriate API types.
 
   private readonly _dataReader: UserDataReader;
 
   constructor(
-    private readonly _firestore: Firestore,
+    protected readonly _firestore: Firestore,
     private readonly _transaction: InternalTransaction
   ) {
     this._dataReader = newUserDataReader(_firestore);
   }
 
-  get<T>(
-    documentRef: firestore.DocumentReference<T>
-  ): Promise<firestore.DocumentSnapshot<T>> {
+  /**
+   * Wrapper around the `BatchGetDocuments` RPC that calls the provided
+   * converter with the resulting Document. The converter should return
+   * the QueryDocumentSnapshot type that is expected by the SDK user.
+   *
+   * @param documentRef The document to fetch.
+   * @param converter A function that returns a QueryDocumentSnapshot.
+   */
+  protected _getHelper<DocSnap, T>(
+    documentRef: firestore.DocumentReference<T>,
+    converter: (ref: DocumentReference<T>, doc: Document | null) => DocSnap
+  ): Promise<DocSnap> {
     const ref = validateReference(documentRef, this._firestore);
     return this._transaction
       .lookup([ref._key])
@@ -62,19 +75,9 @@ export class Transaction implements firestore.Transaction {
         }
         const doc = docs[0];
         if (doc instanceof NoDocument) {
-          return new DocumentSnapshot<T>(
-            this._firestore,
-            ref._key,
-            null,
-            ref._converter
-          );
+          return converter(ref, null);
         } else if (doc instanceof Document) {
-          return new DocumentSnapshot<T>(
-            this._firestore,
-            doc.key,
-            doc,
-            ref._converter
-          );
+          return converter(ref, doc);
         } else {
           throw fail(
             `BatchGetDocumentsRequest returned unexpected document type: ${doc.constructor.name}`
@@ -83,17 +86,17 @@ export class Transaction implements firestore.Transaction {
       });
   }
 
-  set<T>(documentRef: firestore.DocumentReference<T>, value: T): Transaction;
+  set<T>(documentRef: firestore.DocumentReference<T>, value: T): this;
   set<T>(
     documentRef: firestore.DocumentReference<T>,
     value: Partial<T>,
     options: firestore.SetOptions
-  ): Transaction;
+  ): this;
   set<T>(
     documentRef: firestore.DocumentReference<T>,
     value: T,
     options?: firestore.SetOptions
-  ): Transaction {
+  ): this {
     const ref = validateReference(documentRef, this._firestore);
     const convertedValue = applyFirestoreDataConverter(
       ref._converter,
@@ -114,19 +117,19 @@ export class Transaction implements firestore.Transaction {
   update(
     documentRef: firestore.DocumentReference<unknown>,
     value: firestore.UpdateData
-  ): Transaction;
+  ): this;
   update(
     documentRef: firestore.DocumentReference<unknown>,
     field: string | ExternalFieldPath,
     value: unknown,
     ...moreFieldsAndValues: unknown[]
-  ): Transaction;
+  ): this;
   update(
     documentRef: firestore.DocumentReference<unknown>,
     fieldOrUpdateData: string | ExternalFieldPath | firestore.UpdateData,
     value?: unknown,
     ...moreFieldsAndValues: unknown[]
-  ): Transaction {
+  ): this {
     const ref = validateReference(documentRef, this._firestore);
 
     let parsed;
@@ -153,13 +156,26 @@ export class Transaction implements firestore.Transaction {
     return this;
   }
 
-  delete(documentRef: firestore.DocumentReference<unknown>): Transaction {
+  delete(documentRef: firestore.DocumentReference<unknown>): this {
     const ref = validateReference(documentRef, this._firestore);
     this._transaction.delete(ref._key);
     return this;
   }
 }
 
+export class Transaction extends BaseTransaction
+  implements firestore.Transaction {
+  get<T>(
+    documentRef: firestore.DocumentReference<T>
+  ): Promise<firestore.DocumentSnapshot<T>> {
+    return this._getHelper<DocumentSnapshot<T>, T>(
+      documentRef,
+      (ref, doc) =>
+        new DocumentSnapshot<T>(this._firestore, ref._key, doc, ref._converter)
+    );
+  }
+}
+
 export function runTransaction<T>(
   firestore: firestore.FirebaseFirestore,
   updateFunction: (transaction: firestore.Transaction) => Promise<T>
diff --git a/packages/firestore/lite/src/api/write_batch.ts b/packages/firestore/lite/src/api/write_batch.ts
@@ -23,10 +23,7 @@ import {
 } from '../../../src/model/mutation';
 import { Code, FirestoreError } from '../../../src/util/error';
 import { applyFirestoreDataConverter } from '../../../src/api/database';
-import {
-  DocumentKeyReference,
-  UserDataReader
-} from '../../../src/api/user_data_reader';
+import { UserDataReader } from '../../../src/api/user_data_reader';
 import { cast } from './util';
 import { DocumentReference, newUserDataReader } from './reference';
 import { Firestore } from './database';
@@ -159,7 +156,7 @@ export class WriteBatch implements firestore.WriteBatch {
 export function validateReference<T>(
   documentRef: firestore.DocumentReference<T>,
   firestore: Firestore
-): DocumentKeyReference<T> {
+): DocumentReference<T> {
   if (documentRef.firestore !== firestore) {
     throw new FirestoreError(
       Code.INVALID_ARGUMENT,
