Remove WebChannelConnection from Lite SDK

Author: schmidt-sebastian

packages/firestore/package.json

@@ -63,6 +63,7 @@
     "@firebase/webchannel-wrapper": "0.2.41",
     "@grpc/grpc-js": "^1.0.0",
     "@grpc/proto-loader": "^0.5.0",
+    "axios": "^0.19.2",
     "tslib": "^1.11.1"
   },
   "peerDependencies": {

packages/firestore/src/platform/browser/webchannel_connection.ts

@@ -35,79 +35,40 @@ import {
 } from '@firebase/util';
 
 import { Token } from '../../api/credentials';
-import { DatabaseId, DatabaseInfo } from '../../core/database_info';
-import { SDK_VERSION } from '../../core/version';
-import { Connection, Stream } from '../../remote/connection';
+import { DatabaseInfo } from '../../core/database_info';
+import { Stream } from '../../remote/connection';
 import {
   mapCodeFromRpcStatus,
   mapCodeFromHttpResponseErrorStatus
 } from '../../remote/rpc_error';
 import { StreamBridge } from '../../remote/stream_bridge';
-import { debugAssert, fail, hardAssert } from '../../util/assert';
+import { fail, hardAssert } from '../../util/assert';
 import { Code, FirestoreError } from '../../util/error';
 import { logDebug, logWarn } from '../../util/log';
-import { Indexable } from '../../util/misc';
 import { Rejecter, Resolver } from '../../util/promise';
 import { StringMap } from '../../util/types';
+import { RestConnection } from '../../remote/rest_connection';
 
 const LOG_TAG = 'Connection';
 
 const RPC_STREAM_SERVICE = 'google.firestore.v1.Firestore';
-const RPC_URL_VERSION = 'v1';
-
-/**
- * Maps RPC names to the corresponding REST endpoint name.
- * Uses Object Literal notation to avoid renaming.
- */
-const RPC_NAME_REST_MAPPING: { [key: string]: string } = {};
-RPC_NAME_REST_MAPPING['BatchGetDocuments'] = 'batchGet';
-RPC_NAME_REST_MAPPING['Commit'] = 'commit';
-RPC_NAME_REST_MAPPING['RunQuery'] = 'runQuery';
-
-// TODO(b/38203344): The SDK_VERSION is set independently from Firebase because
-// we are doing out-of-band releases. Once we release as part of Firebase, we
-// should use the Firebase version instead.
-const X_GOOG_API_CLIENT_VALUE = 'gl-js/ fire/' + SDK_VERSION;
 
 const XHR_TIMEOUT_SECS = 15;
 
-export class WebChannelConnection implements Connection {
-  private readonly databaseId: DatabaseId;
-  private readonly baseUrl: string;
+export class WebChannelConnection extends RestConnection {
   private readonly forceLongPolling: boolean;
 
   constructor(info: DatabaseInfo) {
-    this.databaseId = info.databaseId;
-    const proto = info.ssl ? 'https' : 'http';
-    this.baseUrl = proto + '://' + info.host;
+    super(info);
     this.forceLongPolling = info.forceLongPolling;
   }
 
-  /**
-   * Modifies the headers for a request, adding any authorization token if
-   * present and any additional headers for the request.
-   */
-  private modifyHeadersForRequest(
-    headers: StringMap,
-    token: Token | null
-  ): void {
-    if (token) {
-      for (const header in token.authHeaders) {
-        if (token.authHeaders.hasOwnProperty(header)) {
-          headers[header] = token.authHeaders[header];
-        }
-      }
-    }
-    headers['X-Goog-Api-Client'] = X_GOOG_API_CLIENT_VALUE;
-  }
-
-  invokeRPC<Req, Resp>(
+  protected performRPCRequest<Req, Resp>(
     rpcName: string,
-    request: Req,
-    token: Token | null
+    url: string,
+    headers: StringMap,
+    body: Req
   ): Promise<Resp> {
-    const url = this.makeUrl(rpcName);
-
     return new Promise((resolve: Resolver<Resp>, reject: Rejecter) => {
       const xhr = new XhrIo();
       xhr.listenOnce(EventType.COMPLETE, () => {
@@ -161,7 +122,6 @@ export class WebChannelConnection implements Connection {
               } else {
                 // If we received an HTTP_ERROR but there's no status code,
                 // it's most probably a connection issue
-                logDebug(LOG_TAG, 'RPC "' + rpcName + '" failed');
                 reject(
                   new FirestoreError(Code.UNAVAILABLE, 'Connection failed.')
                 );
@@ -170,51 +130,25 @@ export class WebChannelConnection implements Connection {
             default:
               fail(
                 'RPC "' +
-                  rpcName +
-                  '" failed with unanticipated ' +
-                  'webchannel error ' +
-                  xhr.getLastErrorCode() +
-                  ': ' +
-                  xhr.getLastError() +
-                  ', giving up.'
+                rpcName +
+                '" failed with unanticipated ' +
+                'webchannel error ' +
+                xhr.getLastErrorCode() +
+                ': ' +
+                xhr.getLastError() +
+                ', giving up.'
               );
           }
         } finally {
           logDebug(LOG_TAG, 'RPC "' + rpcName + '" completed.');
         }
       });
 
-      // The database field is already encoded in URL. Specifying it again in
-      // the body is not necessary in production, and will cause duplicate field
-      // errors in the Firestore Emulator. Let's remove it.
-      const jsonObj = ({ ...request } as unknown) as Indexable;
-      delete jsonObj.database;
-
-      const requestString = JSON.stringify(jsonObj);
-      logDebug(LOG_TAG, 'XHR sending: ', url + ' ' + requestString);
-      // Content-Type: text/plain will avoid preflight requests which might
-      // mess with CORS and redirects by proxies. If we add custom headers
-      // we will need to change this code to potentially use the
-      // $httpOverwrite parameter supported by ESF to avoid
-      // triggering preflight requests.
-      const headers: StringMap = { 'Content-Type': 'text/plain' };
-
-      this.modifyHeadersForRequest(headers, token);
-
+      const requestString = JSON.stringify(body);
       xhr.send(url, 'POST', requestString, headers, XHR_TIMEOUT_SECS);
     });
   }
-
-  invokeStreamingRPC<Req, Resp>(
-    rpcName: string,
-    request: Req,
-    token: Token | null
-  ): Promise<Resp[]> {
-    // The REST API automatically aggregates all of the streamed results, so we
-    // can just use the normal invoke() method.
-    return this.invokeRPC<Req, Resp[]>(rpcName, request, token);
-  }
-
+  
   openStream<Req, Resp>(
     rpcName: string,
     token: Token | null
@@ -283,7 +217,7 @@ export class WebChannelConnection implements Connection {
     }
 
     const url = urlParts.join('');
-    logDebug(LOG_TAG, 'Creating WebChannel: ' + url + ' ' + request);
+    logDebug(LOG_TAG, 'Creating WebChannel: ' + url, request);
     const channel = webchannelTransport.createWebChannel(url, request);
 
     // WebChannel supports sending the first message with the handshake - saving
@@ -420,24 +354,4 @@ export class WebChannelConnection implements Connection {
     }, 0);
     return streamBridge;
   }
-
-  // visible for testing
-  makeUrl(rpcName: string): string {
-    const urlRpcName = RPC_NAME_REST_MAPPING[rpcName];
-    debugAssert(
-      urlRpcName !== undefined,
-      'Unknown REST mapping for: ' + rpcName
-    );
-    return (
-      this.baseUrl +
-      '/' +
-      RPC_URL_VERSION +
-      '/projects/' +
-      this.databaseId.projectId +
-      '/databases/' +
-      this.databaseId.database +
-      '/documents:' +
-      urlRpcName
-    );
-  }
 }

packages/firestore/src/platform/browser_lite/base64.ts

@@ -0,0 +1,18 @@
+/**
+ * @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.
+ */
+
+export * from '../browser/base64';

packages/firestore/src/platform/browser_lite/connection.ts

@@ -0,0 +1,27 @@
+/**
+ * @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 { DatabaseInfo } from '../../core/database_info';
+import { Connection } from '../../remote/connection';
+import { FetchConnection } from './fetch_connection';
+
+export { newConnectivityMonitor } from '../browser/connection';
+
+/** Initializes the HTTP connection for the REST API. */
+export function newConnection(databaseInfo: DatabaseInfo): Promise<Connection> {
+  return Promise.resolve(new FetchConnection(databaseInfo));
+}

packages/firestore/src/platform/browser_lite/dom.ts

@@ -0,0 +1,18 @@
+/**
+ * @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.
+ */
+
+export * from '../browser/dom';

packages/firestore/src/platform/browser_lite/fetch_connection.ts

@@ -0,0 +1,57 @@
+/**
+ * @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 { Token } from '../../api/credentials';
+import { Stream } from '../../remote/connection';
+import { mapCodeFromHttpStatus } from '../../remote/rpc_error';
+import { FirestoreError } from '../../util/error';
+import { StringMap } from '../../util/types';
+import { RestConnection } from '../../remote/rest_connection';
+
+export class FetchConnection extends RestConnection {
+  openStream<Req, Resp>(
+    rpcName: string,
+    token: Token | null
+  ): Stream<Req, Resp> {
+    throw new Error('Not supported by FetchConnection');
+  }
+
+  protected async performRPCRequest<Req, Resp>(
+    rpcName: string,
+    url: string,
+    headers: StringMap,
+    body: Req
+  ): Promise<Resp> {
+    const requestJson = JSON.stringify(body);
+    let response: Response;
+
+    try {
+      response = await fetch(url, {
+        method: 'POST',
+        headers,
+        body: requestJson
+      });
+    } catch (err) {
+      throw new FirestoreError(
+        mapCodeFromHttpStatus(err.status),
+        'Request failed with error: ' + err.statusText
+      );
+    }
+
+    return JSON.parse(await response.text());
+  }
+}

packages/firestore/src/platform/browser_lite/format_json.ts

@@ -0,0 +1,18 @@
+/**
+ * @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.
+ */
+
+export * from '../browser/format_json';

packages/firestore/src/platform/browser_lite/random_bytes.ts

@@ -0,0 +1,18 @@
+/**
+ * @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.
+ */
+
+export * from '../browser/random_bytes';

packages/firestore/src/platform/browser_lite/serializer.ts

@@ -0,0 +1,24 @@
+/**
+ * @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.
+ */
+
+/** Return the Platform-specific serializer monitor. */
+import { JsonProtoSerializer } from '../../remote/serializer';
+import { DatabaseId } from '../../core/database_info';
+
+export function newSerializer(databaseId: DatabaseId): JsonProtoSerializer {
+  return new JsonProtoSerializer(databaseId, /* useProto3Json= */ true);
+}