docsnapshot.FromJSON prototype

Author: DellaBitta

common/api-review/firestore.api.md

@@ -174,6 +174,8 @@ export class DocumentSnapshot<AppModelType = DocumentData, DbModelType extends D
     protected constructor();
     data(options?: SnapshotOptions): AppModelType | undefined;
     exists(): this is QueryDocumentSnapshot<AppModelType, DbModelType>;
+    // (undocumented)
+    static fromJSON(db: Firestore, json: object): object;
     get(fieldPath: string | FieldPath, options?: SnapshotOptions): any;
     get id(): string;
     readonly metadata: SnapshotMetadata;

packages/firestore/src/api/snapshot.ts

@@ -15,6 +15,8 @@
  * limitations under the License.
  */
 
+import { BundleConverterImpl } from '../core/bundle_impl';
+import { createBundleReaderSync } from '../core/firestore_client';
 import { newQueryComparator } from '../core/query';
 import { ChangeType, ViewSnapshot } from '../core/view_snapshot';
 import { FieldPath } from '../lite-api/field_path';
@@ -33,8 +35,10 @@ import {
 } from '../lite-api/snapshot';
 import { UntypedFirestoreDataConverter } from '../lite-api/user_data_reader';
 import { AbstractUserDataWriter } from '../lite-api/user_data_writer';
+import { LiteUserDataWriter } from '../lite-api/reference_impl';
 import { Document } from '../model/document';
 import { DocumentKey } from '../model/document_key';
+import { newSerializer } from '../platform/serializer';
 import { debugAssert, fail } from '../util/assert';
 import {
   BundleBuilder,
@@ -543,6 +547,88 @@ export class DocumentSnapshot<
     result['bundle'] = builder.build();
     return result;
   }
+
+  static fromJSON(db: Firestore, json: object): object {
+    const requiredFields = ['bundle', 'bundleName', 'bundleSource'];
+    let error: string | undefined = undefined;
+    let bundleString: string = '';
+    for (const key of requiredFields) {
+      if (!(key in json)) {
+        error = `json missing required field: ${key}`;
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const value = (json as any)[key];
+      if (key === 'bundleSource') {
+        if (typeof value !== 'string') {
+          error = `json field 'bundleSource' must be a string.`;
+          break;
+        } else if (value !== 'DocumentSnapshot') {
+          error = "Expected 'bundleSource' field to equal 'DocumentSnapshot'";
+          break;
+        }
+      } else if (key === 'bundle') {
+        if (typeof value !== 'string') {
+          error = `json field 'bundle' must be a string.`;
+          break;
+        }
+        bundleString = value;
+      }
+    }
+    if(error) {
+      throw new FirestoreError(
+        Code.INVALID_ARGUMENT,
+        error
+      );
+    }
+    const serializer = newSerializer(db._databaseId);
+    const reader = createBundleReaderSync(bundleString, serializer);
+    const elements = reader.getElements();
+    if (elements.length === 0) {
+      throw new FirestoreError(
+        Code.INVALID_ARGUMENT,
+        'No snapshat data was found in the bundle.'
+      );
+    }
+    if (
+      elements.length !== 2 ||
+      !elements[0].payload.documentMetadata ||
+      !elements[1].payload.document
+    ) {
+      throw new FirestoreError(
+        Code.INVALID_ARGUMENT,
+        'DocumentSnapshot bundle data must contain one document metadata and then one document'
+      );
+    }
+    const docMetadata = elements[0].payload!.documentMetadata!;
+    const docData = elements[1].payload.document!;
+    if (docMetadata.name! !== docData.name) {
+      throw new FirestoreError(
+        Code.INVALID_ARGUMENT,
+        'The document data is not related to the document metadata in the bundle'
+      );
+    }
+    const bundleConverter = new BundleConverterImpl(serializer);
+    const bundledDoc = {
+      metadata: docMetadata,
+      document: docData
+    };
+    const documentSnapshotData = bundleConverter.toDocumentSnapshotData(
+      docMetadata,
+      bundledDoc
+    );
+    const liteUserDataWriter = new LiteUserDataWriter(db);
+    return new DocumentSnapshot(
+      db,
+      liteUserDataWriter,
+      documentSnapshotData.documentKey,
+      documentSnapshotData.mutableDoc,
+      new SnapshotMetadata(
+        /* hasPendingWrites= */ false,
+        /* fromCache= */ false
+      ),
+      null
+    );
+  }
 }
 
 /**

packages/firestore/src/core/bundle_impl.ts

@@ -27,6 +27,7 @@ import { MutableDocument } from '../model/document';
 import { DocumentKey } from '../model/document_key';
 import { ResourcePath } from '../model/path';
 import {
+  BundledDocumentMetadata,
   BundleMetadata as ProtoBundleMetadata,
   NamedQuery as ProtoNamedQuery
 } from '../protos/firestore_bundle_proto';
@@ -76,6 +77,23 @@ export class BundleConverterImpl implements BundleConverter {
     }
   }
 
+  toDocumentSnapshotData(docMetadata: BundledDocumentMetadata, bundledDoc: BundledDocument) : {
+    documentKey: DocumentKey,
+    mutableDoc: MutableDocument,
+  } {
+    const bundleConverter = new BundleConverterImpl(this.serializer);
+    const documentKey = bundleConverter.toDocumentKey(docMetadata.name!);
+    const mutableDoc = bundleConverter.toMutableDocument(bundledDoc);
+    mutableDoc.setReadTime(
+      bundleConverter.toSnapshotVersion(docMetadata.readTime!)
+    );
+
+    return {
+      documentKey,
+      mutableDoc
+    };
+  }
+
   toSnapshotVersion(time: ApiTimestamp): SnapshotVersion {
     return fromVersion(time);
   }

packages/firestore/src/core/firestore_client.ts

@@ -53,8 +53,9 @@ import { JsonProtoSerializer } from '../remote/serializer';
 import { debugAssert } from '../util/assert';
 import { AsyncObserver } from '../util/async_observer';
 import { AsyncQueue, wrapInUserErrorIfRecoverable } from '../util/async_queue';
-import { BundleReader } from '../util/bundle_reader';
+import { BundleReader, BundleReaderSync } from '../util/bundle_reader';
 import { newBundleReader } from '../util/bundle_reader_impl';
+import { newBundleReaderSync } from '../util/bundle_reader_sync_impl';
 import { Code, FirestoreError } from '../util/error';
 import { logDebug, logWarn } from '../util/log';
 import { AutoId } from '../util/misc';
@@ -97,6 +98,8 @@ import { TransactionRunner } from './transaction_runner';
 import { View } from './view';
 import { ViewSnapshot } from './view_snapshot';
 
+import { ExpUserDataWriter } from '../api/reference_impl';
+
 const LOG_TAG = 'FirestoreClient';
 export const MAX_CONCURRENT_LIMBO_RESOLUTIONS = 100;
 
@@ -799,16 +802,6 @@ export function firestoreClientLoadBundle(
   });
 }
 
-export function firestoreClientLoadDodcumentSnapshotBundle(
-  client: FirestoreClient,
-  databaseId: DatabaseId,
-  data: string
-): object {
-  const reader = createBundleReader(data, newSerializer(databaseId));
-  const encodedContent: Uint8Array = newTextEncoder().encode(data);
-  return {};
-}
-
 export function firestoreClientGetNamedQuery(
   client: FirestoreClient,
   queryName: string
@@ -831,6 +824,13 @@ export function createBundleReader(
   return newBundleReader(toByteStreamReader(content), serializer);
 }
 
+export function createBundleReaderSync(
+  bundleData: string,
+  serializer: JsonProtoSerializer
+): BundleReaderSync {
+  return newBundleReaderSync(bundleData, serializer);
+}
+
 export function firestoreClientSetIndexConfiguration(
   client: FirestoreClient,
   indexes: FieldIndex[]

packages/firestore/src/util/bundle_reader.ts

@@ -30,11 +30,7 @@ export class SizedBundleElement {
     public readonly payload: BundleElement,
     // How many bytes this element takes to store in the bundle.
     public readonly byteLength: number
-  ) {
-    console.log("DEDB new sizedBundle element.");
-    console.log("payload: ", payload);
-    console.log("byteLength: ", byteLength);
-  }
+  ) {}
 
   isBundleMetadata(): boolean {
     return 'metadata' in this.payload;
@@ -73,8 +69,8 @@ export interface BundleReader {
 /**
  * A class representing a bundle.
  *
- * Takes a bundle stream or buffer, and presents abstractions to read bundled
- * elements out of the underlying content.
+ * Takes a bundle string buffer, parses the data, and provides accessors to the data contained
+ * within it.
  */
 export interface BundleReaderSync {
   serializer: JsonProtoSerializer;
@@ -85,9 +81,8 @@ export interface BundleReaderSync {
   getMetadata(): BundleMetadata;
 
   /**
-   * Returns the next BundleElement (together with its byte size in the bundle)
-   * that has not been read from underlying ReadableStream. Returns null if we
-   * have reached the end of the stream.
+   * Returns BundleElements parsed from the bundle. Returns an empty array if no bundle elements
+   * exist.
    */
   getElements(): Array<SizedBundleElement>;
 }

packages/firestore/src/util/bundle_reader_sync_impl.ts

@@ -23,7 +23,7 @@ import { BundleReaderSync, SizedBundleElement } from './bundle_reader';
 /**
  * A class that can parse a bundle form the string serialization of a bundle.
  */
-class BundleReaderSyncImpl implements BundleReaderSync { 
+export class BundleReaderSyncImpl implements BundleReaderSync {
   private metadata: BundleMetadata;
   private elements: Array<SizedBundleElement>;
   private cursor: number;
@@ -35,78 +35,78 @@ class BundleReaderSyncImpl implements BundleReaderSync {
     this.elements = new Array<SizedBundleElement>();
 
     let element = this.nextElement();
+    console.error('DEEDB Element (metadata): ', element);
     if (element && element.isBundleMetadata()) {
       this.metadata = element as BundleMetadata;
     } else {
       throw new Error(`The first element of the bundle is not a metadata, it is
          ${JSON.stringify(element?.payload)}`);
     }
 
-    element = this.nextElement();
-    while(element !== null) {
-      this.elements.push(element);
-    }
+    do {
+      element = this.nextElement();
+      if (element !== null) {
+        console.error('DEDB parsed element: ', element);
+        this.elements.push(element);
+      } else {
+        console.error('DEDB no more elements.');
+      }
+    } while (element !== null);
   }
-  
+
   /* Returns the parsed metadata of the bundle. */
-  getMetadata() : BundleMetadata {
+  getMetadata(): BundleMetadata {
     return this.metadata;
   }
 
   /* Returns the DocumentSnapshot or NamedQuery elements of the bundle. */
-  getElements() : Array<SizedBundleElement> {
+  getElements(): Array<SizedBundleElement> {
     return this.elements;
   }
 
   /**
    * Parses the next element of the bundle.
    *
-   * @returns a SizedBundleElement representation of the next element in the bundle, or null if 
+   * @returns a SizedBundleElement representation of the next element in the bundle, or null if
    * no more elements exist.
    */
-  private nextElement() : SizedBundleElement | null {
-    if(this.cursor === this.bundleData.length) {
+  private nextElement(): SizedBundleElement | null {
+    if (this.cursor === this.bundleData.length) {
       return null;
     }
-    
-    const length = this.readLength();
+    const length: number = this.readLength();
     const jsonString = this.readJsonString(length);
-
-    return new SizedBundleElement(
-      JSON.parse(jsonString),
-      length
-    );
+    return new SizedBundleElement(JSON.parse(jsonString), length);
   }
 
   /**
    * Reads from a specified position from the bundleData string, for a specified
    * number of bytes.
-   * 
+   *
    * @param length how many characters to read.
    * @returns a string parsed from the bundle.
    */
   private readJsonString(length: number): string {
-    if(this.cursor + length > this.bundleData.length) {
+    if (this.cursor + length > this.bundleData.length) {
       throw new Error('Reached the end of bundle when more is expected.');
     }
-    const result = this.bundleData.slice(this.cursor, length);
-    this.cursor += length;
+    const result = this.bundleData.slice(this.cursor, (this.cursor += length));
     return result;
   }
 
   /**
-   * Reads from the current cursor until the first '{'. 
-   * 
+   * Reads from the current cursor until the first '{'.
+   *
    * @returns  A string to integer represention of the parsed value.
    * @throws An {@link Error} if the cursor has reached the end of the stream, since lengths
    * prefix bundle objects.
    */
-  private readLength(): number { 
+  private readLength(): number {
     const startIndex = this.cursor;
     let curIndex = this.cursor;
-    while(curIndex < this.bundleData.length) {
-      if(this.bundleData[curIndex] === '{') {
-        if(curIndex === startIndex) {
+    while (curIndex < this.bundleData.length) {
+      if (this.bundleData[curIndex] === '{') {
+        if (curIndex === startIndex) {
           throw new Error('First character is a bracket and not a number');
         }
         this.cursor = curIndex;