fix(auth): make auth API compatible with new Firebase SDK

Author: jeffbcross

src/providers/auth.spec.ts

@@ -1,20 +1,27 @@
 import {Provider, Inject, provide, Injectable, Optional} from '@angular/core';
+import { Observable } from 'rxjs/Observable';
+import { Observer } from 'rxjs/Observer';
 import {ReplaySubject} from 'rxjs/ReplaySubject';
-import {FirebaseRef, FirebaseAuthConfig} from '../tokens';
+
+import 'rxjs/add/operator/mergeMap';
+import 'rxjs/add/operator/take';
+import 'rxjs/add/operator/concat';
+import 'rxjs/add/operator/skip';
+import 'rxjs/add/observable/of';
+
+import {FirebaseApp, FirebaseAuthConfig} from '../tokens';
 import {isPresent} from '../utils/utils';
 import * as utils from '../utils/utils';
 import {
+  authDataToAuthState,
   AuthBackend,
   AuthProviders,
   AuthMethods,
-  OAuthCredentials,
-  OAuth1Credentials,
-  OAuth2Credentials,
-  AuthCredentials,
-  FirebaseAuthState,
+  EmailPasswordCredentials,
+  OAuthCredential,
   AuthConfiguration,
-  FirebaseAuthDataAllProviders,
-  authDataToAuthState
+  FirebaseAuthState,
+  stripProviderId
 } from './auth_backend';
 
 const kBufferSize = 1;
@@ -26,20 +33,39 @@ export const firebaseAuthConfig = (config: AuthConfiguration): Provider => {
 };
 
 @Injectable()
-export class FirebaseAuth extends ReplaySubject<FirebaseAuthState> {
+export class AngularFireAuth extends ReplaySubject<FirebaseAuthState> {
+  private _credentialCache: {[key:string]: OAuthCredential} = {};
   constructor(private _authBackend: AuthBackend,
     @Optional() @Inject(FirebaseAuthConfig) private _config?: AuthConfiguration) {
     super(kBufferSize);
 
-    this._authBackend.onAuth((authData) => this._emitAuthData(authData));
+    let firstPass = true;
+    this._authBackend.onAuth()
+      .mergeMap((authState: FirebaseAuthState) => {
+        // TODO: get rid of side effect
+        if (firstPass) {
+          firstPass = false;
+          return this._authBackend.getRedirectResult()
+            .map((userCredential: firebase.auth.UserCredential) => {
+              if (userCredential && userCredential.credential) {
+                authState = attachCredentialToAuthState(authState, userCredential.credential, userCredential.credential.provider);
+                this._credentialCache[userCredential.credential.provider] = <OAuthCredential>userCredential.credential;
+              }
+              return authState;
+            })
+        }
+        return Observable.of(authState);
+      })
+      .subscribe((authData: FirebaseAuthState) => this._emitAuthData(authData));
   }
 
-  public login(config?: AuthConfiguration): Promise<FirebaseAuthState>;
-  public login(credentials?: FirebaseCredentials): Promise<FirebaseAuthState>;
-  public login(credentials: AuthCredentials, config?: AuthConfiguration): Promise<FirebaseAuthState>;
-  public login(obj1?: any, obj2?: AuthConfiguration): Promise<FirebaseAuthState> {
+  public login(config?: AuthConfiguration): firebase.Promise<FirebaseAuthState>;
+  // If logging in with email and password
+  public login(credentials?: EmailPasswordCredentials | firebase.auth.AuthCredential | string): firebase.Promise<FirebaseAuthState>;
+  public login(credentials: EmailPasswordCredentials | firebase.auth.AuthCredential | string, config?: AuthConfiguration): firebase.Promise<FirebaseAuthState>;
+  public login(obj1?: any, obj2?: AuthConfiguration): firebase.Promise<FirebaseAuthState> {
     let config: AuthConfiguration = null;
-    let credentials: AuthCredentials = null;
+    let credentials: EmailPasswordCredentials | firebase.auth.AuthCredential | string = null;
     if (arguments.length > 2) {
       return this._reject('Login only accepts a maximum of two arguments.');
     } else if (arguments.length == 2) {
@@ -74,33 +100,37 @@ export class FirebaseAuth extends ReplaySubject<FirebaseAuthState> {
 
     switch (config.method) {
       case AuthMethods.Popup:
-        return this._authBackend.authWithOAuthPopup(config.provider, this._scrubConfig(config));
+        return this._authBackend.authWithOAuthPopup(config.provider, this._scrubConfig(config))
+          .then((userCredential: firebase.auth.UserCredential) => {
+            // Incorrect type information
+            this._credentialCache[userCredential.credential.provider] = <OAuthCredential>userCredential.credential;
+            return authDataToAuthState(userCredential.user, <OAuthCredential>(<any>userCredential).credential);
+          });
       case AuthMethods.Redirect:
-        return this._authBackend.authWithOAuthRedirect(config.provider, this._scrubConfig(config));
+        // Gets around typings issue since this method doesn't resolve with a user.
+        // The method really only does anything with an error, since it redirects.
+        return <Promise<FirebaseAuthState>>(<any>this._authBackend).authWithOAuthRedirect(config.provider, this._scrubConfig(config));
       case AuthMethods.Anonymous:
         return this._authBackend.authAnonymously(this._scrubConfig(config));
       case AuthMethods.Password:
-        return this._authBackend.authWithPassword(<FirebaseCredentials>credentials, this._scrubConfig(config, false));
+        return this._authBackend.authWithPassword(<EmailPasswordCredentials>credentials);
       case AuthMethods.OAuthToken:
-        return this._authBackend.authWithOAuthToken(config.provider, <OAuthCredentials>credentials,
+        return this._authBackend.authWithOAuthToken(<firebase.auth.AuthCredential>credentials,
           this._scrubConfig(config));
       case AuthMethods.CustomToken:
-        return this._authBackend.authWithCustomToken((<OAuth2Credentials>credentials).token,
-          this._scrubConfig(config, false));
+        return this._authBackend.authWithCustomToken(<string>credentials);
     }
   }
 
   public logout(): void {
-    if (this._authBackend.getAuth() !== null) {
-      this._authBackend.unauth();
-    }
+    this._authBackend.unauth();
   }
 
-  public getAuth(): FirebaseAuthData {
-    return this._authBackend.getAuth();
+  public getAuth(): FirebaseAuthState {
+    return this._authBackend.getAuth()
   }
 
-  public createUser(credentials: FirebaseCredentials): Promise<FirebaseAuthData> {
+  public createUser(credentials: EmailPasswordCredentials): firebase.Promise<FirebaseAuthState> {
     return this._authBackend.createUser(credentials);
   }
 
@@ -115,10 +145,10 @@ export class FirebaseAuth extends ReplaySubject<FirebaseAuthState> {
     return Object.assign({}, this._config, config);
   }
 
-  private _reject(msg: string): Promise<FirebaseAuthState> {
-    return new Promise((res, rej) => {
+  private _reject(msg: string): firebase.Promise<FirebaseAuthState> {
+    return (<Promise<FirebaseAuthState>>new Promise((res, rej) => {
       return rej(msg);
-    });
+    }));
   }
 
   private _scrubConfig(config: AuthConfiguration, scrubProvider = true): any {
@@ -131,11 +161,26 @@ export class FirebaseAuth extends ReplaySubject<FirebaseAuthState> {
   }
 
 
-  private _emitAuthData(authData: FirebaseAuthDataAllProviders): void {
+  private _emitAuthData(authData: FirebaseAuthState): void {
     if (authData == null) {
       this.next(null);
     } else {
-      this.next(authDataToAuthState(authData));
+      if (authData.auth && authData.auth.providerData && authData.auth.providerData[0]) {
+        let providerId = authData.auth.providerData[0].providerId;
+        let providerCredential = this._credentialCache[providerId];
+        if (providerCredential) {
+          authData = attachCredentialToAuthState(authData, providerCredential, providerId);
+        }
+      }
+
+      this.next(authData);
     }
   }
 }
+
+function attachCredentialToAuthState (authState: FirebaseAuthState, credential, providerId: string): FirebaseAuthState {
+  if (!authState) return authState;
+  // TODO make authState immutable
+  authState[stripProviderId(providerId)] = credential;
+  return authState;
+}

src/providers/auth.ts

@@ -0,0 +1,106 @@
+import {
+  expect,
+  ddescribe,
+  describe,
+  it,
+  iit,
+  beforeEach
+} from '@angular/core/testing';
+
+import {
+  authDataToAuthState,
+  AuthProviders,
+  FirebaseAuthState,
+  CommonOAuthCredential,
+  GoogleCredential,
+  TwitterCredential
+} from './auth_backend';
+
+const baseFBUser = {
+  uid: '12345',
+  providerId: '',
+  providerData: [{}]
+};
+
+const baseAuthState: FirebaseAuthState = {
+  uid: baseFBUser.uid,
+  provider: AuthProviders.Anonymous,
+  auth: <firebase.User>baseFBUser
+};
+
+const baseGithubCredential: CommonOAuthCredential = {
+  accessToken: 'GH_ACCESS_TOKEN',
+  provider: 'github.com'
+};
+
+const baseFacebookCredential: CommonOAuthCredential = {
+  accessToken: 'FB_ACCESS_TOKEN',
+  provider: 'facebook.com'
+};
+
+const baseGoogleCredential: GoogleCredential = {
+  idToken: 'GOOGLE_ID_TOKEN',
+  provider: 'google.com'
+};
+
+const baseTwitterCredential: TwitterCredential = {
+  accessToken: 'TWITTER_ACCESS_TOKEN',
+  provider: 'twitter.com',
+  secret: 'TWITTER_SECRET'
+};
+
+describe('auth_backend', () => {
+  describe('authDataToAuthState', () => {
+    it('Github: should return a FirebaseAuthState object with full provider data', () => {
+      let githubUser = Object.assign({}, baseFBUser, {
+        providerData: [{providerId: 'github.com'}]
+      });
+      let expectedAuthState = Object.assign({}, baseAuthState, {
+        github: baseGithubCredential,
+        auth: githubUser
+      });
+
+      let actualAuthState = authDataToAuthState(githubUser, baseGithubCredential);
+      expect(actualAuthState.github.accessToken).toEqual(baseGithubCredential.accessToken);
+    });
+  });
+
+  it('Google: should return a FirebaseAuthState object with full provider data', () => {
+    let googleUser = Object.assign({}, baseFBUser, {
+      providerData: [{providerId: 'google.com'}]
+    });
+    let expectedAuthState = Object.assign({}, baseAuthState, {
+      google: baseGoogleCredential,
+      auth: googleUser
+    });
+
+    let actualAuthState = authDataToAuthState(googleUser, baseGoogleCredential);
+    expect(actualAuthState.google.idToken).toEqual(baseGoogleCredential.idToken);
+  });
+
+  it('Twitter: should return a FirebaseAuthState object with full provider data', () => {
+    let twitterUser = Object.assign({}, baseFBUser, {
+      providerData: [{providerId: 'twitter.com'}]
+    });
+    let expectedAuthState = Object.assign({}, baseAuthState, {
+      twitter: baseTwitterCredential,
+      auth: twitterUser
+    });
+
+    let actualAuthState = authDataToAuthState(twitterUser, baseTwitterCredential);
+    expect(actualAuthState.twitter.secret).toEqual(baseTwitterCredential.secret);
+  });
+
+  it('Facebook: should return a FirebaseAuthState object with full provider data', () => {
+    let facebookUser = Object.assign({}, baseFBUser, {
+      providerData: [{providerId: 'facebook.com'}]
+    });
+    let expectedAuthState = Object.assign({}, baseAuthState, {
+      facebook: baseFacebookCredential,
+      auth: facebookUser
+    });
+
+    let actualAuthState = authDataToAuthState(facebookUser, baseFacebookCredential);
+    expect(actualAuthState.facebook.accessToken).toEqual(baseFacebookCredential.accessToken);
+  });
+});