Add setDoc()

Author: schmidt-sebastian

packages/firestore/lite/index.node.ts

@@ -36,7 +36,8 @@ export {
   doc,
   parent,
   getDoc,
-  deleteDoc
+  deleteDoc,
+  setDoc
 } from './src/api/reference';
 
 export { FieldPath } from './src/api/field_path';

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

@@ -18,50 +18,28 @@
 import * as firestore from '../../index';
 
 import { tryCast } from './util';
-import { FieldPath as InternalFieldPath } from '../../../src/model/path';
-import { validateNamedArrayAtLeastNumberOfElements } from '../../../src/util/input_validation';
-import { Code, FirestoreError } from '../../../src/util/error';
+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 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
-    );
-
-    for (let i = 0; i < fieldNames.length; ++i) {
-      if (fieldNames[i].length === 0) {
-        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';
@@ -34,6 +37,8 @@ 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';
 
 /**
  * A reference to a particular document in a collection in the database.
@@ -301,6 +306,34 @@ export function getDoc<T>(
   });
 }
 
+export function setDoc<T>(
+  reference: firestore.DocumentReference<T>,
+  data: T,
+  options?: firestore.SetOptions
+): Promise<void> {
+  const ref = tryCast(reference, DocumentReference);
+  return ref.firestore._ensureClientConfigured().then(firestore => {
+    const dataReader = newUserDataReader(firestore);
+
+    const [convertedValue] = applyFirestoreDataConverter(
+      ref._converter,
+      data,
+      'setDoc'
+    );
+
+    const parsed = isMerge(options)
+      ? dataReader.parseMergeData('setDoc', convertedValue)
+      : isMergeFields(options)
+      ? dataReader.parseMergeData('setDoc', convertedValue, options.mergeFields)
+      : dataReader.parseSetData('setDoc', convertedValue);
+
+    return invokeCommitRpc(
+      firestore._datastore,
+      parsed.toMutations(ref._key, Precondition.none())
+    );
+  });
+}
+
 export function deleteDoc(
   reference: firestore.DocumentReference
 ): Promise<void> {
@@ -313,3 +346,30 @@ export function deleteDoc(
       ])
     );
 }
+
+/** Returns true if options.merge is true. */
+function isMerge(options?: firestore.SetOptions): options is { merge: true } {
+  return !!options && (options as { merge: true }).merge;
+}
+
+/** Returns true if options.mergeFields is set. */
+function isMergeFields(
+  options?: firestore.SetOptions
+): options is { mergeFields: Array<string | firestore.FieldPath> } {
+  return (
+    !!options &&
+    !!(options as { mergeFields: Array<string | firestore.FieldPath> })
+      .mergeFields
+  );
+}
+
+function newUserDataReader(firestore: Required<Firestore>): UserDataReader {
+  const serializer = PlatformSupport.getPlatform().newSerializer(
+    firestore._databaseId
+  );
+  return new UserDataReader(
+    firestore._databaseId,
+    !!firestore._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,18 @@ import {
   getFirestore,
   initializeFirestore
 } from '../src/api/database';
-import { withTestDb, withTestDoc } from './helpers';
+import { withTestDb, 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';
 
 describe('Firestore', () => {
   it('can provide setting', () => {
@@ -165,13 +167,104 @@ 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));
   });
 
-  // TODO(firestorelite): Expand test coverage once we can write docs
+  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: 2, 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 }
+      });
+    });
+  });
+});
+
+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 });
+    });
+  });
 });

packages/firestore/src/api/database.ts

@@ -91,6 +91,7 @@ import {
 import {
   DocumentKeyReference,
   fieldPathFromArgument,
+  UntypedFirestoreDataConverter,
   UserDataReader
 } from './user_data_reader';
 import { UserDataWriter } from './user_data_writer';
@@ -2535,8 +2536,8 @@ function resultChangeType(type: ChangeType): firestore.DocumentChangeType {
  * their set() or fails due to invalid data originating from a toFirestore()
  * call.
  */
-function applyFirestoreDataConverter<T>(
-  converter: firestore.FirestoreDataConverter<T> | undefined,
+export function applyFirestoreDataConverter<T>(
+  converter: UntypedFirestoreDataConverter<T> | undefined,
   value: T,
   functionName: string
 ): [firestore.DocumentData, string] {

packages/firestore/src/api/field_path.ts

@@ -30,21 +30,14 @@ import {
 // underscore to discourage their use.
 
 /**
- * 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).
+ * A field class base class that is shared by the lite, full and legacy SDK,
+ * which supports shared code that deals with FieldPaths.
  */
-export class FieldPath implements firestore.FieldPath {
+export abstract class BaseFieldPath {
   /** Internal representation of a Firestore field path. */
-  _internalPath: InternalFieldPath;
+  readonly _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[]) {
+  constructor(fieldNames: string[]) {
     validateNamedArrayAtLeastNumberOfElements(
       'FieldPath',
       fieldNames,
@@ -65,6 +58,22 @@ export class FieldPath implements firestore.FieldPath {
 
     this._internalPath = new InternalFieldPath(fieldNames);
   }
+}
+/**
+ * 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 {
+  /**
+   * 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);
+  }
 
   /**
    * Internal Note: The backend doesn't technically support querying by