Add setDoc() (#3139)

Author: schmidt-sebastian

packages/firestore/lite/index.node.ts

@@ -36,7 +36,8 @@ export {
   doc,
   parent,
   getDoc,
-  deleteDoc
+  deleteDoc,
+  setDoc
 } from './src/api/reference';
 
 // TOOD(firestorelite): Add tests when setDoc() is available

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

@@ -17,53 +17,30 @@
 
 import * as firestore from '../../index';
 
+import { BaseFieldPath } from '../../../src/api/field_path';
 import { cast } from './util';
-import {
-  DOCUMENT_KEY_NAME,
-  FieldPath as InternalFieldPath
-} from '../../../src/model/path';
-import { validateNamedArrayAtLeastNumberOfElements } from '../../../src/util/input_validation';
-import { Code, FirestoreError } from '../../../src/util/error';
+import { DOCUMENT_KEY_NAME } from '../../../src/model/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 implements firestore.FieldPath {
+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.
 
-  /** Internal representation of a Firestore field path. */
-  _internalPath: InternalFieldPath;
-
   /**
    * 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[]) {
-    validateNamedArrayAtLeastNumberOfElements(
-      'FieldPath',
-      fieldNames,
-      'fieldNames',
-      1
-    );
-
-    const emptyElement = fieldNames.indexOf('');
-    if (emptyElement !== -1) {
-      throw new FirestoreError(
-        Code.INVALID_ARGUMENT,
-        `Invalid field name at argument $(i + 1). ` +
-          'Field names must not be empty.'
-      );
-    }
-
-    this._internalPath = new InternalFieldPath(fieldNames);
+    super(fieldNames);
   }
 
   isEqual(other: firestore.FieldPath): boolean {

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

@@ -20,7 +20,10 @@ import * as firestore from '../../index';
 import { Document } from '../../../src/model/document';
 import { DocumentKey } from '../../../src/model/document_key';
 import { Firestore } from './database';
-import { DocumentKeyReference } from '../../../src/api/user_data_reader';
+import {
+  DocumentKeyReference,
+  UserDataReader
+} from '../../../src/api/user_data_reader';
 import { Query as InternalQuery } from '../../../src/core/query';
 import { FirebaseFirestore, FirestoreDataConverter } from '../../index';
 import { ResourcePath } from '../../../src/model/path';
@@ -32,6 +35,9 @@ import {
 } from '../../../src/remote/datastore';
 import { hardAssert } from '../../../src/util/assert';
 import { DeleteMutation, Precondition } from '../../../src/model/mutation';
+import { PlatformSupport } from '../../../src/platform/platform';
+import { applyFirestoreDataConverter } from '../../../src/api/database';
+import { DatabaseId } from '../../../src/core/database_info';
 import { cast } from './util';
 import {
   validateArgType,
@@ -271,6 +277,36 @@ export function getDoc<T>(
   });
 }
 
+export function setDoc<T>(
+  reference: firestore.DocumentReference<T>,
+  data: T,
+  options?: firestore.SetOptions
+): Promise<void> {
+  const ref = cast(reference, DocumentReference);
+
+  const [convertedValue] = applyFirestoreDataConverter(
+    ref._converter,
+    data,
+    'setDoc'
+  );
+
+  // Kick off configuring the client, which freezes the settings.
+  const configureClient = ref.firestore._ensureClientConfigured();
+  const dataReader = newUserDataReader(
+    ref.firestore._databaseId,
+    ref.firestore._settings!
+  );
+
+  const parsed = dataReader.parseSetData('setDoc', convertedValue, options);
+
+  return configureClient.then(datastore =>
+    invokeCommitRpc(
+      datastore,
+      parsed.toMutations(ref._key, Precondition.none())
+    )
+  );
+}
+
 export function deleteDoc(
   reference: firestore.DocumentReference
 ): Promise<void> {
@@ -283,3 +319,15 @@ export function deleteDoc(
       ])
     );
 }
+
+function newUserDataReader(
+  databaseId: DatabaseId,
+  settings: firestore.Settings
+): UserDataReader {
+  const serializer = PlatformSupport.getPlatform().newSerializer(databaseId);
+  return new UserDataReader(
+    databaseId,
+    !!settings.ignoreUndefinedProperties,
+    serializer
+  );
+}

packages/firestore/lite/test/helpers.ts

@@ -20,7 +20,7 @@ import { initializeApp } from '@firebase/app-exp';
 import * as firestore from '../index';
 
 import { initializeFirestore } from '../src/api/database';
-import { doc, collection } from '../src/api/reference';
+import { doc, collection, setDoc } from '../src/api/reference';
 import {
   DEFAULT_PROJECT_ID,
   DEFAULT_SETTINGS
@@ -55,3 +55,14 @@ export function withTestDoc(
     return fn(doc(collection(db, 'test-collection')));
   });
 }
+
+export function withTestDocAndInitialData(
+  data: firestore.DocumentData,
+  fn: (doc: firestore.DocumentReference) => void | Promise<void>
+): Promise<void> {
+  return withTestDb(async db => {
+    const ref = doc(collection(db, 'test-collection'));
+    await setDoc(ref, data);
+    return fn(ref);
+  });
+}

packages/firestore/lite/test/integration.test.ts

@@ -23,16 +23,27 @@ import {
   getFirestore,
   initializeFirestore
 } from '../src/api/database';
-import { withTestDb, withTestDoc } from './helpers';
+import {
+  withTestDb,
+  withTestDbSettings,
+  withTestDoc,
+  withTestDocAndInitialData
+} from './helpers';
 import {
   parent,
   collection,
   CollectionReference,
   doc,
   DocumentReference,
   getDoc,
-  deleteDoc
+  deleteDoc,
+  setDoc
 } from '../src/api/reference';
+import { FieldPath } from '../src/api/field_path';
+import {
+  DEFAULT_PROJECT_ID,
+  DEFAULT_SETTINGS
+} from '../../test/integration/util/settings';
 import { expectEqual, expectNotEqual } from '../../test/util/helpers';
 import { FieldValue } from '../../src/api/field_value';
 
@@ -169,7 +180,127 @@ describe('getDoc()', () => {
     });
   });
 
-  // TODO(firestorelite): Expand test coverage once we can write docs
+  it('can get an existing document', () => {
+    return withTestDocAndInitialData({ val: 1 }, async docRef => {
+      const docSnap = await getDoc(docRef);
+      expect(docSnap.exists()).to.be.true;
+    });
+  });
+});
+
+describe('deleteDoc()', () => {
+  it('can delete a non-existing document', () => {
+    return withTestDoc(docRef => deleteDoc(docRef));
+  });
+
+  it('can delete an existing document', () => {
+    return withTestDoc(async docRef => {
+      await setDoc(docRef, {});
+      await deleteDoc(docRef);
+      const docSnap = await getDoc(docRef);
+      expect(docSnap.exists()).to.be.false;
+    });
+  });
+});
+
+describe('setDoc()', () => {
+  it('can set a new document', () => {
+    return withTestDoc(async docRef => {
+      await setDoc(docRef, { val: 1 });
+      const docSnap = await getDoc(docRef);
+      expect(docSnap.data()).to.deep.equal({ val: 1 });
+    });
+  });
+
+  it('can merge a document', () => {
+    return withTestDocAndInitialData({ foo: 1 }, async docRef => {
+      await setDoc(docRef, { bar: 2 }, { merge: true });
+      const docSnap = await getDoc(docRef);
+      expect(docSnap.data()).to.deep.equal({ foo: 1, bar: 2 });
+    });
+  });
+
+  it('can merge a document with mergeFields', () => {
+    return withTestDocAndInitialData({ foo: 1 }, async docRef => {
+      await setDoc(
+        docRef,
+        { foo: 'ignored', bar: 2, baz: { foobar: 3 } },
+        { mergeFields: ['bar', new FieldPath('baz', 'foobar')] }
+      );
+      const docSnap = await getDoc(docRef);
+      expect(docSnap.data()).to.deep.equal({
+        foo: 1,
+        bar: 2,
+        baz: { foobar: 3 }
+      });
+    });
+  });
+
+  it('throws when user input fails validation', () => {
+    return withTestDoc(async docRef => {
+      expect(() => setDoc(docRef, { val: undefined })).to.throw(
+        'Function setDoc() called with invalid data. Unsupported field value: undefined (found in field val)'
+      );
+    });
+  });
+
+  it("can ignore 'undefined'", () => {
+    return withTestDbSettings(
+      DEFAULT_PROJECT_ID,
+      { ...DEFAULT_SETTINGS, ignoreUndefinedProperties: true },
+      async db => {
+        const docRef = doc(collection(db, 'test-collection'));
+        await setDoc(docRef, { val: undefined });
+        const docSnap = await getDoc(docRef);
+        expect(docSnap.data()).to.deep.equal({});
+      }
+    );
+  });
+});
+
+describe('DocumentSnapshot', () => {
+  it('can represent missing data', () => {
+    return withTestDoc(async docRef => {
+      const docSnap = await getDoc(docRef);
+      expect(docSnap.exists()).to.be.false;
+      expect(docSnap.data()).to.be.undefined;
+    });
+  });
+
+  it('can return data', () => {
+    return withTestDocAndInitialData({ foo: 1 }, async docRef => {
+      const docSnap = await getDoc(docRef);
+      expect(docSnap.exists()).to.be.true;
+      expect(docSnap.data()).to.deep.equal({ foo: 1 });
+    });
+  });
+
+  it('can return single field', () => {
+    return withTestDocAndInitialData({ foo: 1, bar: 2 }, async docRef => {
+      const docSnap = await getDoc(docRef);
+      expect(docSnap.get('foo')).to.equal(1);
+      expect(docSnap.get(new FieldPath('bar'))).to.equal(2);
+    });
+  });
+
+  it('can return nested field', () => {
+    return withTestDocAndInitialData({ foo: { bar: 1 } }, async docRef => {
+      const docSnap = await getDoc(docRef);
+      expect(docSnap.get('foo.bar')).to.equal(1);
+      expect(docSnap.get(new FieldPath('foo', 'bar'))).to.equal(1);
+    });
+  });
+
+  it('is properly typed', () => {
+    return withTestDocAndInitialData({ foo: 1 }, async docRef => {
+      const docSnap = await getDoc(docRef);
+      let documentData = docSnap.data()!; // "data" is typed as nullable
+      if (docSnap.exists()) {
+        documentData = docSnap.data(); // "data" is typed as non-null
+      }
+      expect(documentData).to.deep.equal({ foo: 1 });
+    });
+  });
 });
 
 describe('deleteDoc()', () => {