Add the remaining oauth providers

packages-exp/auth-exp/demo/src/index.js

@@ -56,6 +56,9 @@ import {
   getMultiFactorResolver,
   OAuthProvider,
   GoogleAuthProvider,
+  FacebookAuthProvider,
+  TwitterAuthProvider,
+  GithubAuthProvider,
   signInWithPopup,
   linkWithPopup,
   reauthenticateWithPopup,
@@ -1217,18 +1220,18 @@ function onPopupRedirectProviderClick(_event) {
   const providerId = $(event.currentTarget).data('provider');
   let provider = null;
   switch (providerId) {
-    case 'google.com':
-      provider = new GoogleAuthProvider();
-      break;
-    // case 'facebook.com':
-    //   provider = new FacebookAuthProvider();
-    //   break;
-    // case 'github.com':
-    //   provider = new GithubAuthProvider();
-    //   break;
-    // case 'twitter.com':
-    //   provider = new TwitterAuthProvider();
-    //   break;
+      case 'google.com':
+        provider = new GoogleAuthProvider();
+        break;
+      case 'facebook.com':
+        provider = new FacebookAuthProvider();
+        break;
+      case 'github.com':
+        provider = new GithubAuthProvider();
+        break;
+      case 'twitter.com':
+        provider = new TwitterAuthProvider();
+        break;
     default:
       return;
   }

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

@@ -60,9 +60,12 @@ export { indexedDBLocalPersistence } from './src/core/persistence/indexed_db';
 
 // core/providers
 export { EmailAuthProvider } from './src/core/providers/email';
+export { FacebookAuthProvider } from './src/core/providers/facebook';
 export { GoogleAuthProvider } from './src/core/providers/google';
+export { GithubAuthProvider } from './src/core/providers/github';
 export { OAuthProvider } from './src/core/providers/oauth';
 export { PhoneAuthProvider } from './src/core/providers/phone';
+export { TwitterAuthProvider } from './src/core/providers/twitter';
 
 // core/strategies
 export { signInAnonymously } from './src/core/strategies/anonymous';

packages-exp/auth-exp/src/core/providers/facebook.test.ts

@@ -0,0 +1,71 @@
+/**
+ * @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 { expect } from 'chai';
+
+import {
+  OperationType,
+  ProviderId,
+  SignInMethod
+} from '@firebase/auth-types-exp';
+
+import { TEST_ID_TOKEN_RESPONSE } from '../../../test/helpers/id_token_response';
+import { testUser } from '../../../test/helpers/mock_auth';
+import { TaggedWithTokenResponse } from '../../model/id_token';
+import { AUTH_ERROR_FACTORY, AuthErrorCode } from '../errors';
+import { UserCredentialImpl } from '../user/user_credential_impl';
+import { FacebookAuthProvider } from './facebook';
+
+describe('src/core/providers/facebook', () => {
+  it('generates the correct type of oauth credential', () => {
+    const cred = FacebookAuthProvider.credential('access-token');
+    expect(cred.accessToken).to.eq('access-token');
+    expect(cred.providerId).to.eq(ProviderId.FACEBOOK);
+    expect(cred.signInMethod).to.eq(SignInMethod.FACEBOOK);
+  });
+
+  it('credentialFromResult creates the cred from a tagged result', () => {
+    const userCred = new UserCredentialImpl({
+      user: testUser({}, 'uid'),
+      providerId: ProviderId.FACEBOOK,
+      _tokenResponse: {
+        ...TEST_ID_TOKEN_RESPONSE,
+        oauthAccessToken: 'access-token'
+      },
+      operationType: OperationType.SIGN_IN
+    });
+    const cred = FacebookAuthProvider.credentialFromResult(userCred)!;
+    expect(cred.accessToken).to.eq('access-token');
+    expect(cred.providerId).to.eq(ProviderId.FACEBOOK);
+    expect(cred.signInMethod).to.eq(SignInMethod.FACEBOOK);
+  });
+
+  it('credentialFromError creates the cred from a tagged error', () => {
+    const error = AUTH_ERROR_FACTORY.create(AuthErrorCode.NEED_CONFIRMATION, {
+      appName: 'foo'
+    });
+    (error as TaggedWithTokenResponse)._tokenResponse = {
+      ...TEST_ID_TOKEN_RESPONSE,
+      oauthAccessToken: 'access-token'
+    };
+
+    const cred = FacebookAuthProvider.credentialFromError(error)!;
+    expect(cred.accessToken).to.eq('access-token');
+    expect(cred.providerId).to.eq(ProviderId.FACEBOOK);
+    expect(cred.signInMethod).to.eq(SignInMethod.FACEBOOK);
+  });
+});

packages-exp/auth-exp/src/core/providers/facebook.ts

@@ -0,0 +1,72 @@
+/**
+ * @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 externs from '@firebase/auth-types-exp';
+import { FirebaseError } from '@firebase/util';
+
+import { TaggedWithTokenResponse } from '../../model/id_token';
+import { UserCredential } from '../../model/user';
+import { OAuthCredential } from '../credentials/oauth';
+import { OAuthProvider } from './oauth';
+
+export class FacebookAuthProvider extends OAuthProvider {
+  static readonly FACEBOOK_SIGN_IN_METHOD = externs.SignInMethod.FACEBOOK;
+  static readonly PROVIDER_ID = externs.ProviderId.FACEBOOK;
+  readonly providerId = FacebookAuthProvider.PROVIDER_ID;
+
+  static credential(accessToken: string): externs.OAuthCredential {
+    return OAuthCredential._fromParams({
+      providerId: FacebookAuthProvider.PROVIDER_ID,
+      signInMethod: FacebookAuthProvider.FACEBOOK_SIGN_IN_METHOD,
+      accessToken
+    });
+  }
+
+  static credentialFromResult(
+    userCredential: externs.UserCredential
+  ): externs.OAuthCredential | null {
+    return FacebookAuthProvider.credentialFromTaggedObject(
+      userCredential as UserCredential
+    );
+  }
+
+  static credentialFromError(
+    error: FirebaseError
+  ): externs.OAuthCredential | null {
+    return FacebookAuthProvider.credentialFromTaggedObject(
+      error as TaggedWithTokenResponse
+    );
+  }
+
+  private static credentialFromTaggedObject({
+    _tokenResponse: tokenResponse
+  }: TaggedWithTokenResponse): externs.OAuthCredential | null {
+    if (!tokenResponse || !('oauthAccessToken' in tokenResponse)) {
+      return null;
+    }
+
+    if (!tokenResponse.oauthAccessToken) {
+      return null;
+    }
+
+    try {
+      return FacebookAuthProvider.credential(tokenResponse.oauthAccessToken);
+    } catch {
+      return null;
+    }
+  }
+}

packages-exp/auth-exp/src/core/providers/github.test.ts

@@ -0,0 +1,71 @@
+/**
+ * @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 { expect } from 'chai';
+
+import {
+  OperationType,
+  ProviderId,
+  SignInMethod
+} from '@firebase/auth-types-exp';
+
+import { TEST_ID_TOKEN_RESPONSE } from '../../../test/helpers/id_token_response';
+import { testUser } from '../../../test/helpers/mock_auth';
+import { TaggedWithTokenResponse } from '../../model/id_token';
+import { AUTH_ERROR_FACTORY, AuthErrorCode } from '../errors';
+import { UserCredentialImpl } from '../user/user_credential_impl';
+import { GithubAuthProvider } from './github';
+
+describe('src/core/providers/github', () => {
+  it('generates the correct type of oauth credential', () => {
+    const cred = GithubAuthProvider.credential('access-token');
+    expect(cred.accessToken).to.eq('access-token');
+    expect(cred.providerId).to.eq(ProviderId.GITHUB);
+    expect(cred.signInMethod).to.eq(SignInMethod.GITHUB);
+  });
+
+  it('credentialFromResult creates the cred from a tagged result', () => {
+    const userCred = new UserCredentialImpl({
+      user: testUser({}, 'uid'),
+      providerId: ProviderId.GITHUB,
+      _tokenResponse: {
+        ...TEST_ID_TOKEN_RESPONSE,
+        oauthAccessToken: 'access-token'
+      },
+      operationType: OperationType.SIGN_IN
+    });
+    const cred = GithubAuthProvider.credentialFromResult(userCred)!;
+    expect(cred.accessToken).to.eq('access-token');
+    expect(cred.providerId).to.eq(ProviderId.GITHUB);
+    expect(cred.signInMethod).to.eq(SignInMethod.GITHUB);
+  });
+
+  it('credentialFromError creates the cred from a tagged error', () => {
+    const error = AUTH_ERROR_FACTORY.create(AuthErrorCode.NEED_CONFIRMATION, {
+      appName: 'foo'
+    });
+    (error as TaggedWithTokenResponse)._tokenResponse = {
+      ...TEST_ID_TOKEN_RESPONSE,
+      oauthAccessToken: 'access-token'
+    };
+
+    const cred = GithubAuthProvider.credentialFromError(error)!;
+    expect(cred.accessToken).to.eq('access-token');
+    expect(cred.providerId).to.eq(ProviderId.GITHUB);
+    expect(cred.signInMethod).to.eq(SignInMethod.GITHUB);
+  });
+});

packages-exp/auth-exp/src/core/providers/github.ts

@@ -0,0 +1,72 @@
+/**
+ * @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 externs from '@firebase/auth-types-exp';
+import { FirebaseError } from '@firebase/util';
+
+import { TaggedWithTokenResponse } from '../../model/id_token';
+import { UserCredential } from '../../model/user';
+import { OAuthCredential } from '../credentials/oauth';
+import { OAuthProvider } from './oauth';
+
+export class GithubAuthProvider extends OAuthProvider {
+  static readonly GITHUB_SIGN_IN_METHOD = externs.SignInMethod.GITHUB;
+  static readonly PROVIDER_ID = externs.ProviderId.GITHUB;
+  readonly providerId = GithubAuthProvider.PROVIDER_ID;
+
+  static credential(accessToken: string): externs.OAuthCredential {
+    return OAuthCredential._fromParams({
+      providerId: GithubAuthProvider.PROVIDER_ID,
+      signInMethod: GithubAuthProvider.GITHUB_SIGN_IN_METHOD,
+      accessToken
+    });
+  }
+
+  static credentialFromResult(
+    userCredential: externs.UserCredential
+  ): externs.OAuthCredential | null {
+    return GithubAuthProvider.credentialFromTaggedObject(
+      userCredential as UserCredential
+    );
+  }
+
+  static credentialFromError(
+    error: FirebaseError
+  ): externs.OAuthCredential | null {
+    return GithubAuthProvider.credentialFromTaggedObject(
+      error as TaggedWithTokenResponse
+    );
+  }
+
+  private static credentialFromTaggedObject({
+    _tokenResponse: tokenResponse
+  }: TaggedWithTokenResponse): externs.OAuthCredential | null {
+    if (!tokenResponse || !('oauthAccessToken' in tokenResponse)) {
+      return null;
+    }
+
+    if (!tokenResponse.oauthAccessToken) {
+      return null;
+    }
+
+    try {
+      return GithubAuthProvider.credential(tokenResponse.oauthAccessToken);
+    } catch {
+      return null;
+    }
+  }
+}