Merge firestore bundles implementation without exposing public APIs

.changeset/lemon-steaks-draw.md

@@ -0,0 +1,5 @@
+---
+"@firebase/firestore": feature
+---
+
+Add support for loading Firestore Bundle Files.

packages-exp/auth-exp/index.webworker.ts

@@ -37,7 +37,10 @@ registerAuth(ClientPlatform.WORKER);
 export function getAuth(app = getApp()): Auth {
   // Unlike the other environments, we need to explicitly check if indexedDb is
   // available. That means doing the whole rigamarole
-  const auth = _getProvider(app, _ComponentName.AUTH).getImmediate() as AuthImpl;
+  const auth = _getProvider(
+    app,
+    _ComponentName.AUTH
+  ).getImmediate() as AuthImpl;
 
   // This promise is intended to float; auth initialization happens in the
   // background, meanwhile the auth object may be used by the app.

packages/database/src/api/Database.ts

@@ -157,14 +157,17 @@ export class Database implements FirebaseService {
     validateUrl(apiName, 1, parsedURL);
 
     const repoInfo = parsedURL.repoInfo;
-    if (!repoInfo.isCustomHost() && repoInfo.host !== this.repo_.repoInfo_.host) {
+    if (
+      !repoInfo.isCustomHost() &&
+      repoInfo.host !== this.repo_.repoInfo_.host
+    ) {
       fatal(
         apiName +
           ': Host name does not match the current database: ' +
           '(found ' +
           repoInfo.host +
           ' but expected ' +
-          this.repo_.repoInfo_.host+
+          this.repo_.repoInfo_.host +
           ')'
       );
     }

packages/firebase/index.d.ts

@@ -8285,6 +8285,43 @@ declare namespace firebase.firestore {
     INTERNAL: { delete: () => Promise<void> };
   }
 
+  export function loadBundle(
+    db: Firestore,
+    bundleData: ArrayBuffer | ReadableStream<ArrayBuffer> | string
+  ): LoadBundleTask;
+
+  export function namedQuery(
+    db: Firestore,
+    name: string
+  ): Promise<Query<DocumentData> | null>;
+
+  export interface LoadBundleTask {
+    onProgress(
+      next?: (progress: LoadBundleTaskProgress) => any,
+      error?: (error: Error) => any,
+      complete?: () => void
+    ): void;
+
+    then<T, R>(
+      onFulfilled?: (a: LoadBundleTaskProgress) => T | PromiseLike<T>,
+      onRejected?: (a: Error) => R | PromiseLike<R>
+    ): Promise<T | R>;
+
+    catch<R>(
+      onRejected: (a: Error) => R | PromiseLike<R>
+    ): Promise<R | LoadBundleTaskProgress>;
+  }
+
+  export interface LoadBundleTaskProgress {
+    documentsLoaded: number;
+    totalDocuments: number;
+    bytesLoaded: number;
+    totalBytes: number;
+    taskState: TaskState;
+  }
+
+  export type TaskState = 'Error' | 'Running' | 'Success';
+
   /**
    * An immutable object representing a geo point in Firestore. The geo point
    * is represented as latitude/longitude pair.

packages/firestore-types/index.d.ts

@@ -99,6 +99,33 @@ export class FirebaseFirestore {
   INTERNAL: { delete: () => Promise<void> };
 }
 
+export interface LoadBundleTask {
+  onProgress(
+    next?: (progress: LoadBundleTaskProgress) => any,
+    error?: (error: Error) => any,
+    complete?: () => void
+  ): void;
+
+  then<T, R>(
+    onFulfilled?: (a: LoadBundleTaskProgress) => T | PromiseLike<T>,
+    onRejected?: (a: Error) => R | PromiseLike<R>
+  ): Promise<T | R>;
+
+  catch<R>(
+    onRejected: (a: Error) => R | PromiseLike<R>
+  ): Promise<R | LoadBundleTaskProgress>;
+}
+
+export interface LoadBundleTaskProgress {
+  documentsLoaded: number;
+  totalDocuments: number;
+  bytesLoaded: number;
+  totalBytes: number;
+  taskState: TaskState;
+}
+
+export type TaskState = 'Error' | 'Running' | 'Success';
+
 export class GeoPoint {
   constructor(latitude: number, longitude: number);
 

packages/firestore/exp-types/index.d.ts

@@ -516,6 +516,43 @@ export function snapshotEqual<T>(
   right: DocumentSnapshot<T> | QuerySnapshot<T>
 ): boolean;
 
+export interface LoadBundleTask {
+  onProgress(
+    next?: (progress: LoadBundleTaskProgress) => any,
+    error?: (error: Error) => any,
+    complete?: () => void
+  ): void;
+
+  then<T, R>(
+    onFulfilled?: (a: LoadBundleTaskProgress) => T | PromiseLike<T>,
+    onRejected?: (a: Error) => R | PromiseLike<R>
+  ): Promise<T | R>;
+
+  catch<R>(
+    onRejected: (a: Error) => R | PromiseLike<R>
+  ): Promise<R | LoadBundleTaskProgress>;
+}
+
+export interface LoadBundleTaskProgress {
+  documentsLoaded: number;
+  totalDocuments: number;
+  bytesLoaded: number;
+  totalBytes: number;
+  taskState: TaskState;
+}
+
+export type TaskState = 'Error' | 'Running' | 'Success';
+
+export function loadBundle(
+  firestore: FirebaseFirestore,
+  bundleData: ArrayBuffer | ReadableStream<Uint8Array> | string
+): LoadBundleTask;
+
+export function namedQuery(
+  firestore: FirebaseFirestore,
+  name: string
+): Promise<Query<DocumentData> | null>;
+
 export type FirestoreErrorCode =
   | 'cancelled'
   | 'unknown'

packages/firestore/exp/index.ts

@@ -31,8 +31,7 @@ export {
   waitForPendingWrites,
   disableNetwork,
   enableNetwork,
-  terminate,
-  Settings
+  terminate
 } from './src/api/database';
 
 export {

packages/firestore/externs.json

@@ -28,6 +28,7 @@
     "packages/webchannel-wrapper/src/index.d.ts",
     "packages/util/dist/src/crypt.d.ts",
     "packages/util/dist/src/environment.d.ts",
+    "packages/firestore/src/protos/firestore_bundle_proto.ts",
     "packages/firestore/src/protos/firestore_proto_api.d.ts",
     "packages/firestore/src/util/error.ts",
     "packages/firestore/src/local/indexeddb_schema.ts",

packages/firestore/rollup.shared.js

@@ -129,7 +129,75 @@ const manglePrivatePropertiesOptions = {
   },
   mangle: {
     properties: {
-      regex: /^__PRIVATE_/
+      regex: /^__PRIVATE_/,
+      // All JS Keywords are reserved. Although this should be taken cared of by
+      // Terser, we have seen issues with `do`, hence the extra caution.
+      reserved: [
+        'abstract',
+        'arguments',
+        'await',
+        'boolean',
+        'break',
+        'byte',
+        'case',
+        'catch',
+        'char',
+        'class',
+        'const',
+        'continue',
+        'debugger',
+        'default',
+        'delete',
+        'do',
+        'double',
+        'else',
+        'enum',
+        'eval',
+        'export',
+        'extends',
+        'false',
+        'final',
+        'finally',
+        'float',
+        'for',
+        'function',
+        'goto',
+        'if',
+        'implements',
+        'import',
+        'in',
+        'instanceof',
+        'int',
+        'interface',
+        'let',
+        'long',
+        'native',
+        'new',
+        'null',
+        'package',
+        'private',
+        'protected',
+        'public',
+        'return',
+        'short',
+        'static',
+        'super',
+        'switch',
+        'synchronized',
+        'this',
+        'throw',
+        'throws',
+        'transient',
+        'true',
+        'try',
+        'typeof',
+        'var',
+        'void',
+        'volatile',
+        'while',
+        'with',
+        'yield'
+      ]
     }
   }
 };

packages/firestore/src/api/bundle.ts

@@ -0,0 +1,118 @@
+/**
+ * @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 '@firebase/firestore-types';
+import { Deferred } from '../util/promise';
+import { PartialObserver } from './observer';
+import { debugAssert } from '../util/assert';
+import { FirestoreError } from '../util/error';
+
+export class LoadBundleTask
+  implements
+    firestore.LoadBundleTask,
+    PromiseLike<firestore.LoadBundleTaskProgress> {
+  private _progressObserver: PartialObserver<
+    firestore.LoadBundleTaskProgress
+  > = {};
+  private _taskCompletionResolver = new Deferred<
+    firestore.LoadBundleTaskProgress
+  >();
+
+  private _lastProgress: firestore.LoadBundleTaskProgress = {
+    taskState: 'Running',
+    totalBytes: 0,
+    totalDocuments: 0,
+    bytesLoaded: 0,
+    documentsLoaded: 0
+  };
+
+  onProgress(
+    next?: (progress: firestore.LoadBundleTaskProgress) => unknown,
+    error?: (err: Error) => unknown,
+    complete?: () => void
+  ): void {
+    this._progressObserver = {
+      next,
+      error,
+      complete
+    };
+  }
+
+  catch<R>(
+    onRejected: (a: Error) => R | PromiseLike<R>
+  ): Promise<R | firestore.LoadBundleTaskProgress> {
+    return this._taskCompletionResolver.promise.catch(onRejected);
+  }
+
+  then<T, R>(
+    onFulfilled?: (a: firestore.LoadBundleTaskProgress) => T | PromiseLike<T>,
+    onRejected?: (a: Error) => R | PromiseLike<R>
+  ): Promise<T | R> {
+    return this._taskCompletionResolver.promise.then(onFulfilled, onRejected);
+  }
+
+  /**
+   * Notifies all observers that bundle loading has completed, with a provided
+   * `LoadBundleTaskProgress` object.
+   */
+  _completeWith(progress: firestore.LoadBundleTaskProgress): void {
+    debugAssert(
+      progress.taskState === 'Success',
+      'Task is not completed with Success.'
+    );
+    this._updateProgress(progress);
+    if (this._progressObserver.complete) {
+      this._progressObserver.complete();
+    }
+
+    this._taskCompletionResolver.resolve(progress);
+  }
+
+  /**
+   * Notifies all observers that bundle loading has failed, with a provided
+   * `Error` as the reason.
+   */
+  _failWith(error: FirestoreError): void {
+    this._lastProgress.taskState = 'Error';
+
+    if (this._progressObserver.next) {
+      this._progressObserver.next(this._lastProgress);
+    }
+
+    if (this._progressObserver.error) {
+      this._progressObserver.error(error);
+    }
+
+    this._taskCompletionResolver.reject(error);
+  }
+
+  /**
+   * Notifies a progress update of loading a bundle.
+   * @param progress The new progress.
+   */
+  _updateProgress(progress: firestore.LoadBundleTaskProgress): void {
+    debugAssert(
+      this._lastProgress.taskState === 'Running',
+      'Cannot update progress on a completed or failed task'
+    );
+
+    this._lastProgress = progress;
+    if (this._progressObserver.next) {
+      this._progressObserver.next(progress);
+    }
+  }
+}