Merge branch 'master' into ys/auth-exp-tab-sync

Author: yuchenshi

.changeset/cyan-wasps-worry.md

@@ -0,0 +1,5 @@
+---
+"@firebase/util": patch
+---
+
+Added a utility function and type for compat interop API

packages-exp/auth-compat-exp/index.node.ts

@@ -24,6 +24,7 @@
 export * from './index';
 import { FetchProvider } from '@firebase/auth-exp/internal';
 import * as fetchImpl from 'node-fetch';
+import './index';
 
 FetchProvider.initialize(
   (fetchImpl.default as unknown) as typeof fetch,

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

@@ -98,8 +98,8 @@ function registerAuthCompat(instance: _FirebaseNamespace): void {
       container => {
         // getImmediate for FirebaseApp will always succeed
         const app = container.getProvider('app-compat').getImmediate();
-        const auth = container.getProvider('auth-exp').getImmediate();
-        return new Auth(app, auth as impl.AuthImpl);
+        const authProvider = container.getProvider('auth-exp');
+        return new Auth(app, authProvider);
       },
       ComponentType.PUBLIC
     )
@@ -136,7 +136,7 @@ function registerAuthCompat(instance: _FirebaseNamespace): void {
       .setMultipleInstances(false)
   );
 
-  instance.registerVersion('auth', version);
+  instance.registerVersion('auth-compat', version);
 }
 
 registerAuthCompat(firebase as _FirebaseNamespace);

packages-exp/auth-compat-exp/package.json

@@ -25,7 +25,8 @@
     "test:browser:integration": "karma start --single-run --integration",
     "test:node": "ts-node -O '{\"module\": \"commonjs\", \"target\": \"es6\"}' scripts/run_node_tests.ts",
     "test:node:integration": "ts-node -O '{\"module\": \"commonjs\", \"target\": \"es6\"}' scripts/run_node_tests.ts --integration",
-    "test:integration": "run-s test:browser:integration test:node:integration"
+    "test:webdriver": "rollup -c test/integration/webdriver/static/rollup.config.js && ts-node -O '{\"module\": \"commonjs\", \"target\": \"es6\"}' scripts/run_node_tests.ts --webdriver",
+    "test:integration": "run-s test:browser:integration test:node:integration test:webdriver"
   },
   "peerDependencies": {
     "@firebase/app-compat": "0.x"
@@ -41,8 +42,8 @@
   "license": "Apache-2.0",
   "devDependencies": {
     "@firebase/app-compat": "0.x",
-    "rollup": "2.35.1",
     "@rollup/plugin-json": "4.1.0",
+    "rollup": "^2.35.1",
     "rollup-plugin-replace": "2.2.0",
     "rollup-plugin-typescript2": "0.29.0",
     "typescript": "4.2.2"

packages-exp/auth-compat-exp/rollup.config.shared.js

@@ -65,7 +65,7 @@ export function getEs5Builds(additionalTypescriptPlugins = {}) {
       plugins: es5BuildPlugins,
       external: id => deps.some(dep => id === dep || id.startsWith(`${dep}/`)),
       treeshake: {
-        moduleSideEffects: false
+        moduleSideEffects: true
       }
     },
     /**

packages-exp/auth-compat-exp/scripts/run_node_tests.ts

@@ -33,13 +33,14 @@ const nyc = resolve(__dirname, '../../../node_modules/.bin/nyc');
 const mocha = resolve(__dirname, '../../../node_modules/.bin/mocha');
 
 process.env.TS_NODE_COMPILER_OPTIONS = '{"module":"commonjs", "target": "es6"}';
+process.env.COMPAT_LAYER = 'true';
 
 let testConfig = ['src/**/*.test.ts'];
 
 if (argv.integration) {
   testConfig = ['test/integration/flows/**.test.ts'];
 } else if (argv.webdriver) {
-  testConfig = ['test/integration/webdriver/**.test.ts', '--delay'];
+  testConfig = ['../auth-exp/test/integration/webdriver/*.test.ts', '--delay'];
 }
 
 let args = [

packages-exp/auth-compat-exp/src/auth.test.ts

@@ -17,6 +17,7 @@
 
 import { FirebaseApp } from '@firebase/app-compat';
 import * as exp from '@firebase/auth-exp/internal';
+import { Provider } from '@firebase/component';
 import { expect, use } from 'chai';
 import * as sinon from 'sinon';
 import * as sinonChai from 'sinon-chai';
@@ -31,12 +32,16 @@ describe('auth compat', () => {
   context('redirect persistence key storage', () => {
     let underlyingAuth: exp.AuthImpl;
     let app: FirebaseApp;
+    let providerStub: sinon.SinonStubbedInstance<Provider<'auth-exp'>>;
+
     beforeEach(() => {
       app = { options: { apiKey: 'api-key' } } as FirebaseApp;
       underlyingAuth = new exp.AuthImpl(app, {
         apiKey: 'api-key'
       } as exp.Config);
       sinon.stub(underlyingAuth, '_initializeWithPersistence');
+
+      providerStub = sinon.createStubInstance(Provider);
     });
 
     afterEach(() => {
@@ -56,7 +61,12 @@ describe('auth compat', () => {
           ),
           '_openRedirect'
         );
-        const authCompat = new Auth(app, underlyingAuth);
+        providerStub.isInitialized.returns(true);
+        providerStub.getImmediate.returns(underlyingAuth);
+        const authCompat = new Auth(
+          app,
+          (providerStub as unknown) as Provider<'auth-exp'>
+        );
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         await authCompat.signInWithRedirect(new exp.GoogleAuthProvider());
         expect(
@@ -71,18 +81,20 @@ describe('auth compat', () => {
           'firebase:persistence:api-key:undefined',
           'none'
         );
-        new Auth(app, underlyingAuth);
+        providerStub.isInitialized.returns(false);
+        providerStub.initialize.returns(underlyingAuth);
+        new Auth(app, (providerStub as unknown) as Provider<'auth-exp'>);
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        expect(
-          underlyingAuth._initializeWithPersistence
-        ).to.have.been.calledWith(
-          [
-            exp._getInstance(exp.inMemoryPersistence),
-            exp._getInstance(exp.indexedDBLocalPersistence),
-            exp._getInstance(exp.browserLocalPersistence)
-          ],
-          CompatPopupRedirectResolver
-        );
+        expect(providerStub.initialize).to.have.been.calledWith({
+          options: {
+            popupRedirectResolver: CompatPopupRedirectResolver,
+            persistence: [
+              exp.inMemoryPersistence,
+              exp.indexedDBLocalPersistence,
+              exp.browserLocalPersistence
+            ]
+          }
+        });
       }
     });
   });

packages-exp/auth-compat-exp/src/auth.ts

@@ -18,6 +18,7 @@
 import { FirebaseApp, _FirebaseService } from '@firebase/app-compat';
 import * as exp from '@firebase/auth-exp/internal';
 import * as compat from '@firebase/auth-types';
+import { Provider } from '@firebase/component';
 import { ErrorFn, Observer, Unsubscribe } from '@firebase/util';
 
 import {
@@ -33,53 +34,63 @@ import {
   convertConfirmationResult,
   convertCredential
 } from './user_credential';
-import { unwrap, Wrapper } from './wrap';
+import { ReverseWrapper, unwrap, Wrapper } from './wrap';
 
 const _assert: typeof exp._assert = exp._assert;
 
 export class Auth
   implements compat.FirebaseAuth, Wrapper<exp.Auth>, _FirebaseService {
-  // private readonly auth: impl.AuthImpl;
+  private readonly auth: exp.AuthImpl;
 
-  constructor(readonly app: FirebaseApp, private readonly auth: exp.AuthImpl) {
-    const { apiKey } = app.options;
-    if (this.auth._deleted) {
+  constructor(readonly app: FirebaseApp, provider: Provider<'auth-exp'>) {
+    if (provider.isInitialized()) {
+      this.auth = provider.getImmediate() as exp.AuthImpl;
+      this.linkUnderlyingAuth();
       return;
     }
 
-    // Note this is slightly different behavior: in this case, the stored
-    // persistence is checked *first* rather than last. This is because we want
-    // to prefer stored persistence type in the hierarchy.
-    const persistences = _getPersistencesFromRedirect(this.auth);
+    const { apiKey } = app.options;
+    // TODO: platform needs to be determined using heuristics
+    _assert(apiKey, exp.AuthErrorCode.INVALID_API_KEY, {
+      appName: app.name
+    });
+
+    let persistences: exp.Persistence[] = [exp.inMemoryPersistence];
+
+    // Only deal with persistences in web environments
+    if (typeof window !== 'undefined') {
+      // Note this is slightly different behavior: in this case, the stored
+      // persistence is checked *first* rather than last. This is because we want
+      // to prefer stored persistence type in the hierarchy.
+      persistences = _getPersistencesFromRedirect(apiKey, app.name);
 
-    for (const persistence of [
-      exp.indexedDBLocalPersistence,
-      exp.browserLocalPersistence
-    ]) {
-      if (!persistences.includes(persistence)) {
-        persistences.push(persistence);
+      for (const persistence of [
+        exp.indexedDBLocalPersistence,
+        exp.browserLocalPersistence
+      ]) {
+        if (!persistences.includes(persistence)) {
+          persistences.push(persistence);
+        }
       }
     }
 
-    const hierarchy = persistences.map<exp.PersistenceInternal>(
-      exp._getInstance
-    );
-
     // TODO: platform needs to be determined using heuristics
     _assert(apiKey, exp.AuthErrorCode.INVALID_API_KEY, {
       appName: app.name
     });
 
-    this.auth._updateErrorMap(exp.debugErrorMap);
-
     // Only use a popup/redirect resolver in browser environments
     const resolver =
       typeof window !== 'undefined' ? CompatPopupRedirectResolver : undefined;
+    this.auth = provider.initialize({
+      options: {
+        persistence: persistences,
+        popupRedirectResolver: resolver
+      }
+    }) as exp.AuthImpl;
 
-    // This promise is intended to float; auth initialization happens in the
-    // background, meanwhile the auth object may be used by the app.
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    this.auth._initializeWithPersistence(hierarchy, resolver);
+    this.auth._updateErrorMap(exp.debugErrorMap);
+    this.linkUnderlyingAuth();
   }
 
   get emulatorConfig(): compat.EmulatorConfig | null {
@@ -208,7 +219,9 @@ export class Auth
         break;
       case Persistence.LOCAL:
         // Not using isIndexedDBAvailable() since it only checks if indexedDB is defined.
-        const isIndexedDBFullySupported = await (exp.indexedDBLocalPersistence as exp.PersistenceInternal)._isAvailable();
+        const isIndexedDBFullySupported = await exp
+          ._getInstance<exp.PersistenceInternal>(exp.indexedDBLocalPersistence)
+          ._isAvailable();
         converted = isIndexedDBFullySupported
           ? exp.indexedDBLocalPersistence
           : exp.browserLocalPersistence;
@@ -321,6 +334,9 @@ export class Auth
   _delete(): Promise<void> {
     return this.auth._delete();
   }
+  private linkUnderlyingAuth(): void {
+    ((this.auth as unknown) as ReverseWrapper<Auth>).wrapped = () => this;
+  }
 }
 
 function wrapObservers(

packages-exp/auth-compat-exp/src/persistence.ts

@@ -97,18 +97,15 @@ export async function _savePersistenceForRedirect(
 }
 
 export function _getPersistencesFromRedirect(
-  auth: exp.AuthInternal
+  apiKey: string,
+  appName: string
 ): exp.Persistence[] {
   const win = getSelfWindow();
   if (!win?.sessionStorage) {
     return [];
   }
 
-  const key = exp._persistenceKeyName(
-    PERSISTENCE_KEY,
-    auth.config.apiKey,
-    auth.name
-  );
+  const key = exp._persistenceKeyName(PERSISTENCE_KEY, apiKey, appName);
   const persistence = win.sessionStorage.getItem(key);
 
   switch (persistence) {

packages-exp/auth-compat-exp/src/popup_redirect.ts

@@ -39,23 +39,17 @@ export class CompatPopupRedirectResolver
   ) => Promise<exp.UserCredential | null> = exp._getRedirectResult;
 
   async _initialize(auth: exp.AuthImpl): Promise<exp.EventManager> {
-    if (this.underlyingResolver) {
-      return this.underlyingResolver._initialize(auth);
-    }
-
-    // We haven't yet determined whether or not we're in Cordova; go ahead
-    // and determine that state now.
-    const isCordova = await _isCordova();
-    this.underlyingResolver = isCordova ? CORDOVA_RESOLVER : BROWSER_RESOLVER;
+    await this.selectUnderlyingResolver();
     return this.assertedUnderlyingResolver._initialize(auth);
   }
 
-  _openPopup(
+  async _openPopup(
     auth: exp.AuthImpl,
     provider: exp.AuthProvider,
     authType: exp.AuthEventType,
     eventId?: string
   ): Promise<exp.AuthPopup> {
+    await this.selectUnderlyingResolver();
     return this.assertedUnderlyingResolver._openPopup(
       auth,
       provider,
@@ -64,12 +58,13 @@ export class CompatPopupRedirectResolver
     );
   }
 
-  _openRedirect(
+  async _openRedirect(
     auth: exp.AuthImpl,
     provider: exp.AuthProvider,
     authType: exp.AuthEventType,
     eventId?: string
   ): Promise<void> {
+    await this.selectUnderlyingResolver();
     return this.assertedUnderlyingResolver._openRedirect(
       auth,
       provider,
@@ -97,4 +92,15 @@ export class CompatPopupRedirectResolver
     _assert(this.underlyingResolver, exp.AuthErrorCode.INTERNAL_ERROR);
     return this.underlyingResolver;
   }
+
+  private async selectUnderlyingResolver(): Promise<void> {
+    if (this.underlyingResolver) {
+      return;
+    }
+
+    // We haven't yet determined whether or not we're in Cordova; go ahead
+    // and determine that state now.
+    const isCordova = await _isCordova();
+    this.underlyingResolver = isCordova ? CORDOVA_RESOLVER : BROWSER_RESOLVER;
+  }
 }