Add signInWithEmailAndPassword and signInWithEmailLink to auth-next

Author: avolkovi

packages-exp/auth-exp/src/core/credentials/email.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 * as externs from '@firebase/auth-types-exp';
+import { signInWithPassword } from '../../api/authentication/email_and_password';
+import { signInWithEmailLink } from '../../api/authentication/email_link';
+import { Auth } from '../../model/auth';
+import { IdTokenResponse } from '../../model/id_token';
+import { AuthErrorCode, AUTH_ERROR_FACTORY } from '../errors';
+import { EmailAuthProvider } from '../providers/email';
+import { debugFail } from '../util/assert';
+import { AuthCredential } from '.';
+
+export class EmailAuthCredential implements AuthCredential {
+  constructor(
+    readonly email: string,
+    readonly password: string,
+    readonly providerId: typeof EmailAuthProvider.PROVIDER_ID,
+    readonly signInMethod: externs.SignInMethod
+  ) {}
+
+  toJSON(): never {
+    debugFail('Method not implemented.');
+  }
+
+  static fromJSON(_json: object | string): EmailAuthCredential | null {
+    debugFail('Method not implemented');
+  }
+
+  async _getIdTokenResponse(auth: Auth): Promise<IdTokenResponse> {
+     switch (this.signInMethod) {
+      case EmailAuthProvider.EMAIL_PASSWORD_SIGN_IN_METHOD:
+        return signInWithPassword(auth, {
+          returnSecureToken: true,
+          email: this.email,
+          password: this.password
+        });
+      case EmailAuthProvider.EMAIL_LINK_SIGN_IN_METHOD:
+        return signInWithEmailLink(auth, {
+          email: this.email,
+          oobCode: this.password
+        });
+      default:
+        throw AUTH_ERROR_FACTORY.create(AuthErrorCode.INTERNAL_ERROR, {
+          appName: auth.name
+        });
+    }
+  }
+
+  async _linkToIdToken(_auth: Auth, _idToken: string): Promise<never> {
+    debugFail('Method not implemented.');
+  }
+
+  _matchIdTokenWithUid(_auth: Auth, _uid: string): Promise<never> {
+    debugFail('Method not implemented.');
+  }
+}

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

@@ -0,0 +1,73 @@
+/**
+ * @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 { Auth } from '../../model/auth';
+import { ActionCodeURL } from '../action_code_url';
+import { EmailAuthCredential } from '../credentials/email';
+import { AuthErrorCode, AUTH_ERROR_FACTORY } from '../errors';
+
+export class EmailAuthProvider implements externs.EmailAuthProvider {
+   static readonly PROVIDER_ID = externs.ProviderId.PASSWORD;
+   static readonly EMAIL_PASSWORD_SIGN_IN_METHOD =
+     externs.SignInMethod.EMAIL_PASSWORD;
+   static readonly EMAIL_LINK_SIGN_IN_METHOD = externs.SignInMethod.EMAIL_LINK;
+   readonly providerId: externs.ProviderId = EmailAuthProvider.PROVIDER_ID;
+
+   static credential(
+     email: string,
+     password: string,
+     signInMethod?: externs.SignInMethod
+   ): EmailAuthCredential {
+     return new EmailAuthCredential(
+       email,
+       password,
+       EmailAuthProvider.PROVIDER_ID,
+       signInMethod || this.EMAIL_PASSWORD_SIGN_IN_METHOD
+     );
+   }
+
+  static credentialWithLink(
+    auth: Auth,
+    email: string,
+    emailLink: string
+  ): EmailAuthCredential {
+    const actionCodeUrl = ActionCodeURL._fromLink(auth, emailLink);
+    if (!actionCodeUrl) {
+      throw AUTH_ERROR_FACTORY.create(AuthErrorCode.ARGUMENT_ERROR, {
+        appName: auth.name
+      });
+    }
+
+    const credential: EmailAuthCredential = this.credential(
+      email,
+      actionCodeUrl.code,
+      EmailAuthProvider.EMAIL_LINK_SIGN_IN_METHOD
+    );
+
+    // Check if the tenant ID in the email link matches the tenant ID on Auth
+    // instance.
+    if (actionCodeUrl.tenantId !== auth.tenantId) {
+      throw AUTH_ERROR_FACTORY.create(AuthErrorCode.TENANT_ID_MISMATCH, {
+        appName: auth.name
+      });
+    }
+
+    return credential;
+  }
+ }

packages-exp/auth-exp/src/core/strategies/email_and_password.ts

@@ -21,8 +21,10 @@ import { resetPassword } from '../../api/account_management/email_and_password';
 import * as api from '../../api/authentication/email_and_password';
 import { Operation } from '../../model/action_code_info';
 import { Auth } from '../../model/auth';
-import { AUTH_ERROR_FACTORY, AuthErrorCode } from '../errors';
+import { AuthErrorCode, AUTH_ERROR_FACTORY } from '../errors';
+import { EmailAuthProvider } from '../providers/email';
 import { setActionCodeSettingsOnRequest } from './action_code_settings';
+import { signInWithCredential } from './credential';
 
 export async function sendPasswordResetEmail(
   auth: externs.Auth,
@@ -82,3 +84,14 @@ export async function verifyPasswordResetCode(
   // Email should always be present since a code was sent to it
   return data.email!;
 }
+
+export async function signInWithEmailAndPassword(
+  auth: externs.Auth,
+  email: string,
+  password: string
+): Promise<externs.UserCredential> {
+  return signInWithCredential(
+    auth,
+    EmailAuthProvider.credential(email, password)
+  );
+}

packages-exp/auth-exp/src/core/strategies/email_link.ts

@@ -21,7 +21,11 @@ import * as api from '../../api/authentication/email_and_password';
 import { Operation } from '../../model/action_code_info';
 import { Auth } from '../../model/auth';
 import { ActionCodeURL } from '../action_code_url';
+import { EmailAuthProvider } from '../providers/email';
+import { _getCurrentUrl } from '../util/location';
 import { setActionCodeSettingsOnRequest } from './action_code_settings';
+import { signInWithCredential } from './credential';
+
 
 export async function sendSignInLinkToEmail(
   auth: externs.Auth,
@@ -46,3 +50,14 @@ export function isSignInWithEmailLink(
   const actionCodeUrl = ActionCodeURL._fromLink(auth as Auth, emailLink);
   return actionCodeUrl?.operation === Operation.EMAIL_SIGNIN;
 }
+
+export async function signInWithEmailLink(
+  auth: externs.Auth,
+  email: string,
+  emailLink?: string
+): Promise<externs.UserCredential> { 
+  return signInWithCredential(
+    auth,
+    EmailAuthProvider.credentialWithLink(auth as Auth, email, emailLink || _getCurrentUrl())
+  );
+}

packages-exp/auth-types-exp/index.d.ts

@@ -234,3 +234,16 @@ export interface PhoneInfoOptions {
 export interface AuthProvider {
   readonly providerId: ProviderId;
 }
+
+/**
+ * A provider for generating email & password and email link credentials
+ */
+export abstract class EmailAuthProvider implements AuthProvider {
+  private constructor();
+  static readonly PROVIDER_ID: string;
+  static readonly EMAIL_PASSWORD_SIGN_IN_METHOD: string;
+  static readonly EMAIL_LINK_SIGN_IN_METHOD: string;
+  static credential(email: string, password: string): AuthCredential;
+  static credentialWithLink(auth: Auth, email: string, emailLink: string): AuthCredential;
+  readonly providerId: ProviderId;
+}