@firebase/firestore 3.3.1 → 3.4.0-2021111174650

package/dist/lite/index.node.cjs.js

@@ -14,7 +14,7 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var nodeFetch__default = /*#__PURE__*/_interopDefaultLegacy(nodeFetch);
 
-const version$1 = "3.3.1";
+const version$1 = "3.4.0-2021111174650";
 
 /**
  * @license
@@ -67,7 +67,7 @@ User.GOOGLE_CREDENTIALS = new User('google-credentials-uid');
 User.FIRST_PARTY = new User('first-party-uid');
 User.MOCK_USER = new User('mock-user');
 
-const version = "9.5.0";
+const version = "9.6.0-2021111174650";
 
 /**
  * @license
@@ -436,16 +436,15 @@ class OAuthToken {
     constructor(value, user) {
         this.user = user;
         this.type = 'OAuth';
-        this.authHeaders = {};
-        // Set the headers using Object Literal notation to avoid minification
-        this.authHeaders['Authorization'] = `Bearer ${value}`;
+        this.headers = new Map();
+        this.headers.set('Authorization', `Bearer ${value}`);
     }
 }
 /**
  * A CredentialsProvider that always yields an empty token.
  * @internal
  */
-class EmptyCredentialsProvider {
+class EmptyAuthCredentialsProvider {
     getToken() {
         return Promise.resolve(null);
     }
@@ -460,7 +459,7 @@ class EmptyCredentialsProvider {
  * A CredentialsProvider that always returns a constant token. Used for
  * emulator token mocking.
  */
-class EmulatorCredentialsProvider {
+class EmulatorAuthCredentialsProvider {
     constructor(token) {
         this.token = token;
         /**
@@ -484,7 +483,7 @@ class EmulatorCredentialsProvider {
     }
 }
 /** Credential provider for the Lite SDK. */
-class LiteCredentialsProvider {
+class LiteAuthCredentialsProvider {
     constructor(authProvider) {
         this.auth = null;
         authProvider.onInit(auth => {
@@ -518,25 +517,17 @@ class LiteCredentialsProvider {
  */
 class FirstPartyToken {
     constructor(gapi, sessionIndex, iamToken) {
-        this.gapi = gapi;
-        this.sessionIndex = sessionIndex;
-        this.iamToken = iamToken;
         this.type = 'FirstParty';
         this.user = User.FIRST_PARTY;
-    }
-    get authHeaders() {
-        const headers = {
-            'X-Goog-AuthUser': this.sessionIndex
-        };
-        // Use array notation to prevent minification
-        const authHeader = this.gapi['auth']['getAuthHeaderValueForFirstParty']([]);
+        this.headers = new Map();
+        this.headers.set('X-Goog-AuthUser', sessionIndex);
+        const authHeader = gapi['auth']['getAuthHeaderValueForFirstParty']([]);
         if (authHeader) {
-            headers['Authorization'] = authHeader;
+            this.headers.set('Authorization', authHeader);
         }
-        if (this.iamToken) {
-            headers['X-Goog-Iam-Authorization-Token'] = this.iamToken;
+        if (iamToken) {
+            this.headers.set('X-Goog-Iam-Authorization-Token', iamToken);
         }
-        return headers;
     }
 }
 /*
@@ -544,7 +535,7 @@ class FirstPartyToken {
  * to authenticate the user, using technique that is only available
  * to applications hosted by Google.
  */
-class FirstPartyCredentialsProvider {
+class FirstPartyAuthCredentialsProvider {
     constructor(gapi, sessionIndex, iamToken) {
         this.gapi = gapi;
         this.sessionIndex = sessionIndex;
@@ -560,13 +551,50 @@ class FirstPartyCredentialsProvider {
     shutdown() { }
     invalidateToken() { }
 }
+class AppCheckToken {
+    constructor(value) {
+        this.value = value;
+        this.type = 'AppCheck';
+        this.headers = new Map();
+        if (value && value.length > 0) {
+            this.headers.set('x-firebase-appcheck', this.value);
+        }
+    }
+}
+/** AppCheck token provider for the Lite SDK. */
+class LiteAppCheckTokenProvider {
+    constructor(appCheckProvider) {
+        this.appCheckProvider = appCheckProvider;
+        this.appCheck = null;
+        appCheckProvider.onInit(appCheck => {
+            this.appCheck = appCheck;
+        });
+    }
+    getToken() {
+        if (!this.appCheck) {
+            return Promise.resolve(null);
+        }
+        return this.appCheck.getToken().then(tokenResult => {
+            if (tokenResult) {
+                hardAssert(typeof tokenResult.token === 'string');
+                return new AppCheckToken(tokenResult.token);
+            }
+            else {
+                return null;
+            }
+        });
+    }
+    invalidateToken() { }
+    start(asyncQueue, changeListener) { }
+    shutdown() { }
+}
 /**
  * Builds a CredentialsProvider depending on the type of
  * the credentials passed in.
  */
-function makeCredentialsProvider(credentials) {
+function makeAuthCredentialsProvider(credentials) {
     if (!credentials) {
-        return new EmptyCredentialsProvider();
+        return new EmptyAuthCredentialsProvider();
     }
     switch (credentials['type']) {
         case 'gapi':
@@ -576,11 +604,11 @@ function makeCredentialsProvider(credentials) {
                 client !== null &&
                 client['auth'] &&
                 client['auth']['getAuthHeaderValueForFirstParty']));
-            return new FirstPartyCredentialsProvider(client, credentials['sessionIndex'] || '0', credentials['iamToken'] || null);
+            return new FirstPartyAuthCredentialsProvider(client, credentials['sessionIndex'] || '0', credentials['iamToken'] || null);
         case 'provider':
             return credentials['client'];
         default:
-            throw new FirestoreError(Code.INVALID_ARGUMENT, 'makeCredentialsProvider failed due to invalid credential type');
+            throw new FirestoreError(Code.INVALID_ARGUMENT, 'makeAuthCredentialsProvider failed due to invalid credential type');
     }
 }
 
@@ -1167,11 +1195,11 @@ class RestConnection {
                 this.databaseId.database +
                 '/documents';
     }
-    invokeRPC(rpcName, path, req, token) {
+    invokeRPC(rpcName, path, req, authToken, appCheckToken) {
         const url = this.makeUrl(rpcName, path);
         logDebug(LOG_TAG$3, 'Sending: ', url, req);
         const headers = {};
-        this.modifyHeadersForRequest(headers, token);
+        this.modifyHeadersForRequest(headers, authToken, appCheckToken);
         return this.performRPCRequest(rpcName, url, headers, req).then(response => {
             logDebug(LOG_TAG$3, 'Received: ', response);
             return response;
@@ -1180,16 +1208,16 @@ class RestConnection {
             throw err;
         });
     }
-    invokeStreamingRPC(rpcName, path, request, token) {
+    invokeStreamingRPC(rpcName, path, request, authToken, appCheckToken) {
         // The REST API automatically aggregates all of the streamed results, so we
         // can just use the normal invoke() method.
-        return this.invokeRPC(rpcName, path, request, token);
+        return this.invokeRPC(rpcName, path, request, authToken, appCheckToken);
     }
     /**
      * Modifies the headers for a request, adding any authorization token if
      * present and any additional headers for the request.
      */
-    modifyHeadersForRequest(headers, token) {
+    modifyHeadersForRequest(headers, authToken, appCheckToken) {
         headers['X-Goog-Api-Client'] = getGoogApiClientValue();
         // Content-Type: text/plain will avoid preflight requests which might
         // mess with CORS and redirects by proxies. If we add custom headers
@@ -1199,12 +1227,11 @@ class RestConnection {
         if (this.databaseInfo.appId) {
             headers['X-Firebase-GMPID'] = this.databaseInfo.appId;
         }
-        if (token) {
-            for (const header in token.authHeaders) {
-                if (token.authHeaders.hasOwnProperty(header)) {
-                    headers[header] = token.authHeaders[header];
-                }
-            }
+        if (authToken) {
+            authToken.headers.forEach((value, key) => (headers[key] = value));
+        }
+        if (appCheckToken) {
+            appCheckToken.headers.forEach((value, key) => (headers[key] = value));
         }
     }
     makeUrl(rpcName, path) {
@@ -4092,9 +4119,10 @@ class Datastore {
  * consumption.
  */
 class DatastoreImpl extends Datastore {
-    constructor(credentials, connection, serializer) {
+    constructor(authCredentials, appCheckCredentials, connection, serializer) {
         super();
-        this.credentials = credentials;
+        this.authCredentials = authCredentials;
+        this.appCheckCredentials = appCheckCredentials;
         this.connection = connection;
         this.serializer = serializer;
         this.terminated = false;
@@ -4104,18 +4132,21 @@ class DatastoreImpl extends Datastore {
             throw new FirestoreError(Code.FAILED_PRECONDITION, 'The client has already been terminated.');
         }
     }
-    /** Gets an auth token and invokes the provided RPC. */
+    /** Invokes the provided RPC with auth and AppCheck tokens. */
     invokeRPC(rpcName, path, request) {
         this.verifyInitialized();
-        return this.credentials
-            .getToken()
-            .then(token => {
-            return this.connection.invokeRPC(rpcName, path, request, token);
+        return Promise.all([
+            this.authCredentials.getToken(),
+            this.appCheckCredentials.getToken()
+        ])
+            .then(([authToken, appCheckToken]) => {
+            return this.connection.invokeRPC(rpcName, path, request, authToken, appCheckToken);
         })
             .catch((error) => {
             if (error.name === 'FirebaseError') {
                 if (error.code === Code.UNAUTHENTICATED) {
-                    this.credentials.invalidateToken();
+                    this.authCredentials.invalidateToken();
+                    this.appCheckCredentials.invalidateToken();
                 }
                 throw error;
             }
@@ -4124,18 +4155,21 @@ class DatastoreImpl extends Datastore {
             }
         });
     }
-    /** Gets an auth token and invokes the provided RPC with streamed results. */
+    /** Invokes the provided RPC with streamed results with auth and AppCheck tokens. */
     invokeStreamingRPC(rpcName, path, request) {
         this.verifyInitialized();
-        return this.credentials
-            .getToken()
-            .then(token => {
-            return this.connection.invokeStreamingRPC(rpcName, path, request, token);
+        return Promise.all([
+            this.authCredentials.getToken(),
+            this.appCheckCredentials.getToken()
+        ])
+            .then(([authToken, appCheckToken]) => {
+            return this.connection.invokeStreamingRPC(rpcName, path, request, authToken, appCheckToken);
         })
             .catch((error) => {
             if (error.name === 'FirebaseError') {
                 if (error.code === Code.UNAUTHENTICATED) {
-                    this.credentials.invalidateToken();
+                    this.authCredentials.invalidateToken();
+                    this.appCheckCredentials.invalidateToken();
                 }
                 throw error;
             }
@@ -4150,8 +4184,8 @@ class DatastoreImpl extends Datastore {
 }
 // TODO(firestorexp): Make sure there is only one Datastore instance per
 // firestore-exp client.
-function newDatastore(credentials, connection, serializer) {
-    return new DatastoreImpl(credentials, connection, serializer);
+function newDatastore(authCredentials, appCheckCredentials, connection, serializer) {
+    return new DatastoreImpl(authCredentials, appCheckCredentials, connection, serializer);
 }
 async function invokeCommitRpc(datastore, mutations) {
     const datastoreImpl = debugCast(datastore);
@@ -4227,7 +4261,7 @@ function getDatastore(firestore) {
         const databaseInfo = makeDatabaseInfo(firestore._databaseId, firestore.app.options.appId || '', firestore._persistenceKey, firestore._freezeSettings());
         const connection = newConnection(databaseInfo);
         const serializer = newSerializer(firestore._databaseId);
-        const datastore = newDatastore(firestore._credentials, connection, serializer);
+        const datastore = newDatastore(firestore._authCredentials, firestore._appCheckCredentials, connection, serializer);
         datastoreInstances.set(firestore, datastore);
     }
     return datastoreInstances.get(firestore);
@@ -4403,8 +4437,9 @@ class FirestoreSettingsImpl {
  */
 class Firestore {
     /** @hideconstructor */
-    constructor(databaseIdOrApp, _credentials) {
-        this._credentials = _credentials;
+    constructor(databaseIdOrApp, _authCredentials, _appCheckCredentials) {
+        this._authCredentials = _authCredentials;
+        this._appCheckCredentials = _appCheckCredentials;
         /**
          * Whether it's a Firestore or Firestore Lite instance.
          */
@@ -4445,7 +4480,7 @@ class Firestore {
         }
         this._settings = new FirestoreSettingsImpl(settings);
         if (settings.credentials !== undefined) {
-            this._credentials = makeCredentialsProvider(settings.credentials);
+            this._authCredentials = makeAuthCredentialsProvider(settings.credentials);
         }
     }
     _getSettings() {
@@ -4556,7 +4591,7 @@ function connectFirestoreEmulator(firestore, host, port, options = {}) {
             }
             user = new User(uid);
         }
-        firestore._credentials = new EmulatorCredentialsProvider(new OAuthToken(token, user));
+        firestore._authCredentials = new EmulatorAuthCredentialsProvider(new OAuthToken(token, user));
     }
 }
 /**
@@ -4605,7 +4640,7 @@ function registerFirestore() {
     setSDKVersion(`${app.SDK_VERSION}_lite`);
     app._registerComponent(new component.Component('firestore/lite', (container, { options: settings }) => {
         const app = container.getProvider('app').getImmediate();
-        const firestoreInstance = new Firestore(app, new LiteCredentialsProvider(container.getProvider('auth-internal')));
+        const firestoreInstance = new Firestore(app, new LiteAuthCredentialsProvider(container.getProvider('auth-internal')), new LiteAppCheckTokenProvider(container.getProvider('app-check-internal')));
         if (settings) {
             firestoreInstance._setSettings(settings);
         }