Use typescript asserts keyword for typesafe assertions

Author: avolkovi

packages-exp/auth-exp/package.json

@@ -29,6 +29,7 @@
     "@firebase/app-types-exp": "0.x"
   },
   "dependencies": {
+    "@firebase/logger": "^0.2.2",
     "@firebase/util": "^0.2.44",
     "tslib": "1.11.1"
   },

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

@@ -17,7 +17,7 @@
 
 import { IdTokenResponse } from '../../model/id_token';
 import { PersistedBlob } from '../persistence';
-import { assertType } from '../util/assert';
+import { assert } from '../util/assert';
 
 /**
  * The number of milliseconds before the official expiration time of a token
@@ -79,13 +79,16 @@ export class StsTokenManager {
 
     const manager = new StsTokenManager();
     if (refreshToken) {
-      manager.refreshToken = assertType(refreshToken, 'string', appName);
+      assert(typeof refreshToken === 'string', appName);
+      manager.refreshToken = refreshToken;
     }
     if (accessToken) {
-      manager.accessToken = assertType(accessToken, 'string', appName);
+      assert(typeof accessToken === 'string', appName);
+      manager.accessToken = accessToken;
     }
     if (expirationTime) {
-      manager.expirationTime = assertType(expirationTime, 'number', appName);
+      assert(typeof expirationTime === 'number', appName);
+      manager.expirationTime = expirationTime;
     }
     return manager;
   }

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

@@ -20,7 +20,7 @@ import { IdTokenResult } from '../../model/id_token';
 import { User } from '../../model/user';
 import { PersistedBlob } from '../persistence';
 import { ProviderId } from '../providers';
-import { assert, assertType } from '../util/assert';
+import { assert, assertStringOrUndefined} from '../util/assert';
 import { StsTokenManager } from './token_manager';
 
 export interface UserParameters {
@@ -104,23 +104,26 @@ export class UserImpl implements User {
       photoURL
     } = object;
 
-    assert(uid && plainObjectTokenManager, auth.name);
+    assert(uid && !!plainObjectTokenManager, auth.name);
 
     const stsTokenManager = StsTokenManager.fromPlainObject(
       auth.name,
       plainObjectTokenManager as PersistedBlob
     );
 
-    const stringOrUndef = ['string', 'undefined'];
-
+    assert(typeof uid === 'string', auth.name);
+    assertStringOrUndefined(displayName, auth.name);
+    assertStringOrUndefined(email, auth.name);
+    assertStringOrUndefined(phoneNumber, auth.name);
+    assertStringOrUndefined(photoURL, auth.name);
     return new UserImpl({
-      uid: assertType(uid, 'string', auth.name),
+      uid,
       auth,
       stsTokenManager,
-      displayName: assertType(displayName, stringOrUndef, auth.name),
-      email: assertType(email, stringOrUndef, auth.name),
-      phoneNumber: assertType(phoneNumber, stringOrUndef, auth.name),
-      photoURL: assertType(photoURL, stringOrUndef, auth.name)
+      displayName,
+      email,
+      phoneNumber,
+      photoURL
     });
   }
 }

packages-exp/auth-exp/src/core/util/assert.ts

@@ -15,29 +15,66 @@
  * limitations under the License.
  */
 
+import { SDK_VERSION } from '@firebase/app-exp';
 import { AUTH_ERROR_FACTORY, AuthErrorCode } from '../errors';
+import { logError } from './log';
 
-export function assert<T>(
-  expression: T | null | undefined,
-  appName: string,
-  code = AuthErrorCode.INTERNAL_ERROR
-): T {
-  if (!expression) {
-    throw AUTH_ERROR_FACTORY.create(code, { appName });
+/**
+ * Unconditionally fails, throwing a developer facing INTERNAL_ERROR
+ * 
+ * @param appName App name for tagging the error
+ * @throws FirebaseError
+ */
+export function fail(
+  appName: string
+): never {
+  throw AUTH_ERROR_FACTORY.create(AuthErrorCode.INTERNAL_ERROR, { appName });
+}
+
+/**
+ * Verifies the given condition and fails if false, throwing a developer facing error
+ * 
+ * @param assertion
+ * @param appName 
+ */
+export function assert(assertion: boolean, appName: string): asserts assertion {
+  if (!assertion) {
+    fail(appName);
   }
+}
 
-  return expression;
+export function assertStringOrUndefined(assertion: unknown, appName: string): asserts assertion is string | undefined {
+  assert(typeof assertion === 'string' || typeof assertion === 'undefined', appName);
 }
 
-export function assertType<T>(
-  expression: unknown,
-  expected: string | string[],
-  appName: string
-): T {
-  if (typeof expected === 'string') {
-    expected = [expected];
-  }
+/**
+ * Unconditionally fails, throwing an internal error with the given message.
+ *
+ * @param failure type of failure encountered
+ * @throws Error
+ */
+export function debugFail(failure: string): never {
+  // Log the failure in addition to throw an exception, just in case the
+  // exception is swallowed.
+  const message =
+    `AUTH (${SDK_VERSION}) INTERNAL ASSERTION FAILED: ` + failure;
+  logError(message);
 
-  assert(expected.includes(typeof expression), appName);
-  return expression as T;
+  // NOTE: We don't use FirestoreError here because these are internal failures
+  // that cannot be handled by the user. (Also it would create a circular
+  // dependency between the error and assert modules which doesn't work.)
+  throw new Error(message);
 }
+
+/**
+ * Fails if the given assertion condition is false, throwing an Error with the
+ * given message if it did.
+ * 
+ * @param assertion
+ * @param message
+ */
+export function debugAssert(assertion: boolean, message: string): asserts assertion {
+  if (!assertion) {
+    debugFail(message);
+  }
+}

packages-exp/auth-exp/src/core/util/log.ts

@@ -0,0 +1,44 @@
+/**
+ * @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 { Logger, LogLevel } from '@firebase/logger';
+import { SDK_VERSION } from '@firebase/app-exp';
+
+export { LogLevel };
+
+const logClient = new Logger('@firebase/auth-exp');
+
+// Helper methods are needed because variables can't be exported as read/write
+export function getLogLevel(): LogLevel {
+  return logClient.logLevel;
+}
+
+export function setLogLevel(newLevel: LogLevel): void {
+  logClient.logLevel = newLevel;
+}
+
+export function logDebug(msg: string, ...args: string[]): void {
+  if (logClient.logLevel <= LogLevel.DEBUG) {
+    logClient.debug(`Auth (${SDK_VERSION}): ${msg}`, ...args);
+  }
+}
+
+export function logError(msg: string, ...args: string[]): void {
+  if (logClient.logLevel <= LogLevel.ERROR) {
+    logClient.error(`Auth (${SDK_VERSION}): ${msg}`, ...args);
+  }
+}