Add Transaction

integration/firestore/gulpfile.js

@@ -1,6 +1,6 @@
 /**
  * @license
- * Copyright 2017 Google Inc.
+ * Copyright 2017 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -51,6 +51,7 @@ function copyTests() {
         testBase + '/integration/api/*.ts',
         testBase + '/integration/util/events_accumulator.ts',
         testBase + '/integration/util/helpers.ts',
+        testBase + '/integration/util/settings.ts',
         testBase + '/util/equality_matcher.ts',
         testBase + '/util/promise.ts'
       ],

packages/firestore/.eslintrc.js

@@ -1,3 +1,20 @@
+/**
+ * @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.
+ */
+
 module.exports = {
   extends: '../../config/.eslintrc.js',
   parserOptions: {
@@ -35,6 +52,13 @@ module.exports = {
       rules: {
         '@typescript-eslint/no-explicit-any': 'error'
       }
+    },
+    // TODO(firestorelite): Remove this exception when app-exp is published
+    {
+      files: ['lite/**/*.ts'],
+      rules: {
+        'import/no-extraneous-dependencies': 'off'
+      }
     }
   ]
 };

packages/firestore/lite/index.d.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import { FirebaseApp } from '@firebase/app-types';
+import { FirebaseApp } from '@firebase/app-types-exp';
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
@@ -134,10 +134,11 @@ export class Transaction {
 
   get<T>(documentRef: DocumentReference<T>): Promise<DocumentSnapshot<T>>;
 
+  set<T>(documentRef: DocumentReference<T>, data: T): Transaction;
   set<T>(
     documentRef: DocumentReference<T>,
-    data: T,
-    options?: SetOptions
+    data: Partial<T>,
+    options: SetOptions
   ): Transaction;
 
   update(documentRef: DocumentReference<any>, data: UpdateData): Transaction;
@@ -154,10 +155,11 @@ export class Transaction {
 export class WriteBatch {
   private constructor();
 
+  set<T>(documentRef: DocumentReference<T>, data: T): WriteBatch;
   set<T>(
     documentRef: DocumentReference<T>,
-    data: T,
-    options?: SetOptions
+    data: Partial<T>,
+    options: SetOptions
   ): WriteBatch;
 
   update(documentRef: DocumentReference<any>, data: UpdateData): WriteBatch;
@@ -263,7 +265,7 @@ export function getQuery<T>(query: Query<T>): Promise<QuerySnapshot<T>>;
 export function addDoc<T>(
   reference: CollectionReference<T>,
   data: T
-): Promise<DocumentSnapshot<T>>;
+): Promise<DocumentReference<T>>;
 export function setDoc<T>(
   reference: DocumentReference<T>,
   data: T
@@ -274,15 +276,16 @@ export function setDoc<T>(
   options: SetOptions
 ): Promise<void>;
 export function updateDoc(
-  reference: DocumentReference,
+  reference: DocumentReference<unknown>,
   data: UpdateData
 ): Promise<void>;
 export function updateDoc(
+  reference: DocumentReference<unknown>,
   field: string | FieldPath,
   value: any,
   ...moreFieldsAndValues: any[]
 ): Promise<void>;
-export function deleteDoc(reference: DocumentReference): Promise<void>;
+export function deleteDoc(reference: DocumentReference<unknown>): Promise<void>;
 
 export class FieldValue {
   private constructor();

packages/firestore/lite/index.node.ts

@@ -0,0 +1,70 @@
+/**
+ * @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 { registerVersion, _registerComponent } from '@firebase/app-exp';
+import { Firestore } from './src/api/database';
+import { version } from '../package.json';
+import { Component, ComponentType } from '@firebase/component';
+
+import '../src/platform_node/node_init';
+
+export {
+  Firestore,
+  initializeFirestore,
+  getFirestore
+} from './src/api/database';
+
+export {
+  DocumentReference,
+  Query,
+  CollectionReference,
+  collection,
+  doc,
+  parent,
+  getDoc,
+  deleteDoc,
+  setDoc,
+  updateDoc,
+  addDoc
+} from './src/api/reference';
+
+export { FieldPath } from './src/api/field_path';
+
+export { DocumentSnapshot, QueryDocumentSnapshot } from './src/api/snapshot';
+
+export { WriteBatch, writeBatch } from './src/api/write_batch';
+
+export { Transaction, runTransaction } from './src/api/transaction';
+
+export function registerFirestore(): void {
+  _registerComponent(
+    new Component(
+      'firestore/lite',
+      container => {
+        const app = container.getProvider('app-exp').getImmediate()!;
+        return ((app, auth) => new Firestore(app, auth))(
+          app,
+          container.getProvider('auth-internal')
+        );
+      },
+      ComponentType.PUBLIC
+    )
+  );
+  registerVersion('firestore-lite', version, 'node');
+}
+
+registerFirestore();

packages/firestore/lite/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@firebase/firestore/lite",
+  "description": "A lite version of the Firestore SDK",
+  "main": "../dist/lite/index.node.cjs.js",
+  "private": true
+}

packages/firestore/lite/src/api/database.ts

@@ -0,0 +1,139 @@
+/**
+ * @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 '../../';
+
+import { _getProvider } from '@firebase/app-exp';
+import { FirebaseApp } from '@firebase/app-types-exp';
+import { Provider } from '@firebase/component';
+
+import { Code, FirestoreError } from '../../../src/util/error';
+import { DatabaseId, DatabaseInfo } from '../../../src/core/database_info';
+import { FirebaseAuthInternalName } from '@firebase/auth-interop-types';
+import {
+  CredentialsProvider,
+  FirebaseCredentialsProvider
+} from '../../../src/api/credentials';
+import { Datastore, newDatastore } from '../../../src/remote/datastore';
+import { PlatformSupport } from '../../../src/platform/platform';
+import { Deferred } from '../../../src/util/promise';
+
+// settings() defaults:
+const DEFAULT_HOST = 'firestore.googleapis.com';
+const DEFAULT_SSL = true;
+
+// TODO(firestorelite): Depend on FirebaseService once #3112 is merged
+
+/**
+ * The root reference to the Firestore Lite database.
+ */
+export class Firestore implements firestore.FirebaseFirestore {
+  readonly _databaseId: DatabaseId;
+  private readonly _firebaseApp: FirebaseApp;
+  private readonly _credentials: CredentialsProvider;
+
+  // Assigned via _configureClient()/_ensureClientConfigured()
+  _settings?: firestore.Settings;
+  private readonly _datastoreDeferred = new Deferred<Datastore>();
+
+  constructor(
+    app: FirebaseApp,
+    authProvider: Provider<FirebaseAuthInternalName>
+  ) {
+    this._firebaseApp = app;
+    this._databaseId = Firestore.databaseIdFromApp(app);
+    this._credentials = new FirebaseCredentialsProvider(authProvider);
+  }
+
+  get app(): FirebaseApp {
+    return this._firebaseApp;
+  }
+
+  _configureClient(settings: firestore.Settings): void {
+    if (this._settings) {
+      throw new FirestoreError(
+        Code.FAILED_PRECONDITION,
+        'Firestore has already been started and its settings can no longer ' +
+          'be changed. initializeFirestore() cannot be called after calling ' +
+          'getFirestore().'
+      );
+    }
+    this._settings = settings;
+
+    const databaseInfo = this._makeDatabaseInfo(settings);
+
+    // Kick off initializing the datastore but don't actually wait for it.
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    PlatformSupport.getPlatform()
+      .loadConnection(databaseInfo)
+      .then(connection => {
+        const serializer = PlatformSupport.getPlatform().newSerializer(
+          databaseInfo.databaseId
+        );
+        const datastore = newDatastore(
+          connection,
+          this._credentials,
+          serializer
+        );
+        this._datastoreDeferred.resolve(datastore);
+      });
+  }
+
+  _ensureClientConfigured(): Promise<Datastore> {
+    if (!this._settings) {
+      this._settings = {};
+    }
+    return this._datastoreDeferred.promise;
+  }
+
+  private _makeDatabaseInfo(settings: firestore.Settings): DatabaseInfo {
+    return new DatabaseInfo(
+      this._databaseId,
+      /* persistenceKey= */ 'unsupported',
+      settings.host ?? DEFAULT_HOST,
+      settings.ssl ?? DEFAULT_SSL,
+      /* forceLongPolling= */ false
+    );
+  }
+
+  private static databaseIdFromApp(app: FirebaseApp): DatabaseId {
+    if (!Object.prototype.hasOwnProperty.apply(app.options, ['projectId'])) {
+      throw new FirestoreError(
+        Code.INVALID_ARGUMENT,
+        '"projectId" not provided in firebase.initializeApp.'
+      );
+    }
+
+    return new DatabaseId(app.options.projectId!);
+  }
+}
+
+export function initializeFirestore(
+  app: FirebaseApp,
+  settings: firestore.Settings
+): Firestore {
+  const firestore = _getProvider(
+    app,
+    'firestore/lite'
+  ).getImmediate() as Firestore;
+  firestore._configureClient(settings);
+  return firestore;
+}
+
+export function getFirestore(app: FirebaseApp): Firestore {
+  return _getProvider(app, 'firestore/lite').getImmediate() as Firestore;
+}

packages/firestore/lite/src/api/field_path.ts

@@ -0,0 +1,49 @@
+/**
+ * @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 { tryCast } from './util';
+import { BaseFieldPath } from '../../../src/api/field_path';
+
+/**
+ * A FieldPath refers to a field in a document. The path may consist of a single
+ * field name (referring to a top-level field in the document), or a list of
+ * field names (referring to a nested field in the document).
+ */
+export class FieldPath extends BaseFieldPath implements firestore.FieldPath {
+  // Note: This class is stripped down a copy of the FieldPath class in the
+  // legacy SDK. The changes are:
+  // - The `documentId()` static method has been removed
+  // - Input validation is limited to errors that cannot be caught by the
+  //   TypeScript transpiler.
+
+  /**
+   * 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[]) {
+    super(fieldNames);
+  }
+
+  isEqual(other: firestore.FieldPath): boolean {
+    const path = tryCast(other, FieldPath);
+    return this._internalPath.isEqual(path._internalPath);
+  }
+}