API Method

Author: sam-gc

packages-exp/auth-exp/src/api/index.ts

@@ -16,16 +16,12 @@
  */
 
 import { FirebaseError, querystring } from '@firebase/util';
-import { AuthErrorCode, AUTH_ERROR_FACTORY } from '../core/errors';
+
+import { AUTH_ERROR_FACTORY, AuthErrorCode } from '../core/errors';
+import { Delay } from '../core/util/delay';
 import { Auth } from '../model/auth';
 import { IdTokenResponse } from '../model/id_token';
-import {
-  JsonError,
-  ServerError,
-  ServerErrorMap,
-  SERVER_ERROR_MAP
-} from './errors';
-import { Delay } from '../core/util/delay';
+import { JsonError, SERVER_ERROR_MAP, ServerError, ServerErrorMap } from './errors';
 
 export enum HttpMethod {
   POST = 'POST',
@@ -61,10 +57,9 @@ export async function _performApiRequest<T, V>(
   method: HttpMethod,
   path: Endpoint,
   request?: T,
-  customErrorMap: Partial<ServerErrorMap<ServerError>> = {}
+  customErrorMap: Partial<ServerErrorMap<ServerError>> = {},
 ): Promise<V> {
-  const errorMap = { ...SERVER_ERROR_MAP, ...customErrorMap };
-  try {
+  return performFetchWithErrorHandling(auth, customErrorMap, () => {
     let body = {};
     let params = {};
     if (request) {
@@ -82,8 +77,7 @@ export async function _performApiRequest<T, V>(
       ...params
     }).slice(1);
 
-    const response: Response = await Promise.race<Promise<Response>>([
-      fetch(
+   return fetch(
         `${auth.config.apiScheme}://${auth.config.apiHost}${path}?${query}`,
         {
           method,
@@ -94,16 +88,20 @@ export async function _performApiRequest<T, V>(
           referrerPolicy: 'no-referrer',
           ...body
         }
-      ),
-      new Promise((_, reject) =>
-        setTimeout(() => {
-          return reject(
-            AUTH_ERROR_FACTORY.create(AuthErrorCode.TIMEOUT, {
-              appName: auth.name
-            })
-          );
-        }, DEFAULT_API_TIMEOUT_MS.get())
-      )
+      );
+      });
+}
+
+export async function performFetchWithErrorHandling<V>(
+  auth: Auth,
+  customErrorMap: Partial<ServerErrorMap<ServerError>>,
+  fetchFn: () => Promise<Response>,
+): Promise<V> {
+  const errorMap = { ...SERVER_ERROR_MAP, ...customErrorMap };
+  try {
+    const response: Response = await Promise.race<Promise<Response>>([
+      fetchFn(),
+      makeNetworkTimeout(auth.name),
     ]);
     if (response.ok) {
       return response.json();
@@ -154,3 +152,15 @@ export async function _performSignInRequest<T, V extends IdTokenResponse>(
 
   return serverResponse;
 }
+
+function makeNetworkTimeout<T>(appName: string): Promise<T> {
+  return new Promise((_, reject) =>
+  setTimeout(() => {
+    return reject(
+      AUTH_ERROR_FACTORY.create(AuthErrorCode.TIMEOUT, {
+        appName,
+      })
+    );
+  }, DEFAULT_API_TIMEOUT_MS.get())
+)
+}

packages-exp/auth-exp/src/core/user/token_manager.ts

@@ -15,7 +15,10 @@
  * limitations under the License.
  */
 
+import { requestStsToken } from '../../api/authentication/token';
+import { Auth } from '../../model/auth';
 import { IdTokenResponse } from '../../model/id_token';
+import { AUTH_ERROR_FACTORY, AuthErrorCode } from '../errors';
 import { PersistedBlob } from '../persistence';
 import { assert } from '../util/assert';
 
@@ -52,15 +55,23 @@ export class StsTokenManager {
     this.expirationTime = Date.now() + Number(expiresInSec) * 1000;
   }
 
-  async getToken(forceRefresh = false): Promise<Tokens> {
+  async getToken(auth: Auth, forceRefresh = false): Promise<Tokens|null> {
     if (!forceRefresh && this.accessToken && !this.isExpired) {
-      return {
-        accessToken: this.accessToken,
-        refreshToken: this.refreshToken
-      };
+      return this.tokens;
     }
 
-    throw new Error('StsTokenManager: token refresh not implemented');
+    if (this.accessToken && !this.refreshToken) {
+      throw AUTH_ERROR_FACTORY.create(AuthErrorCode.TOKEN_EXPIRED, {
+        appName: auth.name,
+      });
+    }
+
+    if (!this.refreshToken) {
+      return null;
+    }
+
+    await this.refresh(auth, this.refreshToken);
+    return this.tokens;
   }
 
   toPlainObject(): object {
@@ -71,6 +82,21 @@ export class StsTokenManager {
     };
   }
 
+  private get tokens(): Tokens {
+    return {
+      accessToken: this.accessToken!,
+      refreshToken: this.refreshToken,
+    };
+  }
+
+  private async refresh(auth: Auth, refreshToken: string) {
+    const {access_token, refresh_token, expires_in} = await requestStsToken(auth, refreshToken);
+    
+    this.accessToken = access_token || null;
+    this.refreshToken = refresh_token || null;
+    this.expirationTime = expires_in ? Date.now() + Number(expires_in) * 1000 : null;
+  }
+
   static fromPlainObject(
     appName: string,
     object: PersistedBlob