Backtrack to previous state

Author: samtstern

packages/database/src/api/Database.ts

@@ -26,7 +26,7 @@ import { validateUrl } from '../core/util/validation';
 import { FirebaseApp } from '@firebase/app-types';
 import { FirebaseService } from '@firebase/app-types/private';
 import { RepoInfo } from '../core/RepoInfo';
-import { AuthTokenProvider } from '../core/AuthTokenProvider';
+import { FirebaseDatabase } from '@firebase/database-types';
 
 /**
  * Class representing a firebase database.
@@ -35,8 +35,11 @@ import { AuthTokenProvider } from '../core/AuthTokenProvider';
 export class Database implements FirebaseService {
   INTERNAL: DatabaseInternals;
 
-  private repoInternal_?: Repo;
-  private rootInternal_?: Reference;
+  /** Track if the instance has been used (root or repo accessed) */
+  private instanceUsed_: boolean = false;
+
+  /** Backing state for root_ */
+  private rootInternal_: Reference;
 
   static readonly ServerValue = {
     TIMESTAMP: {
@@ -53,53 +56,45 @@ export class Database implements FirebaseService {
 
   /**
    * The constructor should not be called by users of our public API.
+   * @param {!Repo} repoInternal_
    */
-  constructor(
-    private repoInfo_: RepoInfo,
-    readonly app: FirebaseApp,
-    private readonly authTokenProvider_: AuthTokenProvider
-  ) {
-    if (!(repoInfo_ instanceof RepoInfo)) {
+  constructor(private repoInternal_: Repo) {
+    if (!(repoInternal_ instanceof Repo)) {
       fatal(
-        "Don't call new Database() directly  please use firebase.database()."
+        "Don't call new Database() directly - please use firebase.database()."
       );
     }
-    
-    // We have to "reserve" the repo now so we can safely create it as-needed
-    // TOOD(samstern): Enabling this is a mess
-    // RepoManager.getInstance().reserveRepo(repoInfo_, app);
+
+    this.repo_ = repoInternal_;
     this.INTERNAL = new DatabaseInternals(this);
   }
 
-  private get repo_() {
-    if (!this.repoInternal_) {
-      this.repoInternal_ = RepoManager.getInstance().createRepo(
-        this.repoInfo_, 
-        this.app, 
-        this.authTokenProvider_, 
-        this
-      );
-    }
+  private get repo_(): Repo {
+    this.instanceUsed_ = true;
     return this.repoInternal_;
   }
-  
+
   private set repo_(repo: Repo) {
+    if (repo instanceof Repo) {
+      this.root_ = new Reference(repo, Path.Empty);
+    }
+
     this.repoInternal_ = repo;
-    this.rootInternal_ = null;
   }
 
-  private get root_() {
-    if (!this.rootInternal_) {
-      this.rootInternal_ = new Reference(this.repo_, Path.Empty);
-    }
-
+  get root_(): Reference {
+    this.instanceUsed_ = true;
     return this.rootInternal_;
   }
 
-  private set root_(root: Reference) {
+  set root_(root: Reference) {
     this.rootInternal_ = root;
   }
-  
+
+  get app(): FirebaseApp {
+    return this.repo_.app;
+  }
+
   /**
    * Modify this instance to communicate with the Realtime Database emulator.
    *
@@ -109,17 +104,19 @@ export class Database implements FirebaseService {
    * @param port the emulator port (ex: 8080)
    */
   useEmulator(host: string, port: number): void {
-    if (this.repoInternal_) {
+    if (this.instanceUsed_) {
       fatal(
         'Cannot call useEmulator() after instance has already been initialized.'
       );
       return;
     }
 
-    const url = `http://${host}:${port}?ns=${this.repoInfo_.namespace}`;
-    const { repoInfo } = parseRepoInfo(url, this.repoInfo_.nodeAdmin);
+    // Get a new Repo which has the emulator settings applied
+    const manager = RepoManager.getInstance();
+    const oldRepo = this.repo_;
 
-    this.repoInfo_ = repoInfo;
+    this.repo_ = manager.cloneRepoForEmulator(oldRepo, host, port);
+    manager.deleteRepo(oldRepo);
   }
 
   /**
@@ -180,7 +177,7 @@ export class Database implements FirebaseService {
    * @param {string} apiName
    */
   private checkDeleted_(apiName: string) {
-    if (this.INTERNAL === null) {
+    if (this.repo_ === null) {
       fatal('Cannot call ' + apiName + ' on a deleted database.');
     }
   }

packages/database/src/api/Reference.ts

@@ -37,6 +37,7 @@ import { validateArgCount, validateCallback, Deferred } from '@firebase/util';
 import { SyncPoint } from '../core/SyncPoint';
 import { Database } from './Database';
 import { DataSnapshot } from './DataSnapshot';
+import * as types from '@firebase/database-types';
 
 export interface ReferenceConstructor {
   new (repo: Repo, path: Path): Reference;

packages/database/src/core/Repo.ts

@@ -71,6 +71,7 @@ export class Repo {
   private interceptServerDataCallback_:
     | ((a: string, b: unknown) => void)
     | null = null;
+  private __database: Database;
 
   /** A list of data pieces and paths to be set when this client disconnects. */
   private onDisconnect_ = new SparseSnapshotTree();
@@ -82,8 +83,7 @@ export class Repo {
     public repoInfo_: RepoInfo,
     forceRestClient: boolean,
     public app: FirebaseApp,
-    public authTokenProvider: AuthTokenProvider,
-    public readonly database: Database,
+    public authTokenProvider: AuthTokenProvider
   ) {
     this.stats_ = StatsManager.getCollection(repoInfo_);
 
@@ -637,4 +637,8 @@ export class Repo {
       });
     }
   }
+
+  get database(): Database {
+    return this.__database || (this.__database = new Database(this));
+  }
 }

packages/database/src/core/RepoManager.ts

@@ -53,7 +53,7 @@ export class RepoManager {
    */
   private repos_: {
     [appName: string]: {
-      [dbUrl: string]: Repo | null;
+      [dbUrl: string]: Repo;
     };
   } = {};
 
@@ -74,25 +74,34 @@ export class RepoManager {
   interrupt() {
     for (const appName of Object.keys(this.repos_)) {
       for (const dbUrl of Object.keys(this.repos_[appName])) {
-        const repo = this.repos_[appName][dbUrl];
-        if (repo) {
-          repo.interrupt();
-        }
+        this.repos_[appName][dbUrl].interrupt();
       }
     }
   }
 
   resume() {
     for (const appName of Object.keys(this.repos_)) {
       for (const dbUrl of Object.keys(this.repos_[appName])) {
-        const repo = this.repos_[appName][dbUrl];
-        if (repo) {
-          repo.resume();
-        }
+        this.repos_[appName][dbUrl].resume();
       }
     }
   }
 
+  /**
+   * Create a new repo based on an old one but pointing to a particular host and port.
+   */
+  cloneRepoForEmulator(repo: Repo, host: string, port: number): Repo {
+    const nodeAdmin = repo.repoInfo_.nodeAdmin;
+    const url = `http://${host}:${port}?ns=${repo.repoInfo_.namespace}`;
+    const authTokenProvider = nodeAdmin
+      ? new EmulatorAdminTokenProvider()
+      : repo.authTokenProvider;
+
+    const parsedUrl = parseRepoInfo(url, nodeAdmin);
+
+    return this.createRepo(parsedUrl.repoInfo, repo.app, authTokenProvider);
+  }
+
   /**
    * This function should only ever be called to CREATE a new database instance.
    *
@@ -150,11 +159,9 @@ export class RepoManager {
       );
     }
 
-    return new Database(
-      repoInfo,
-      app,
-      authTokenProvider
-    );
+    const repo = this.createRepo(repoInfo, app, authTokenProvider);
+
+    return repo.database;
   }
 
   /**
@@ -185,64 +192,25 @@ export class RepoManager {
   createRepo(
     repoInfo: RepoInfo,
     app: FirebaseApp,
-    authTokenProvider: AuthTokenProvider,
-    database: Database,
+    authTokenProvider: AuthTokenProvider
   ): Repo {
     let appRepos = safeGet(this.repos_, app.name);
-    if (!appRepos) {
-      appRepos = {};
-      this.repos_[app.name] = appRepos;
-    }
-
-    this.assertUnique(repoInfo, app);
-    const repo = new Repo(repoInfo, this.useRestClient_, app, authTokenProvider, database);
-    appRepos[repoInfo.toURLString()] = repo;
-
-    return repo;
-  }
-
-  /**
-   * Reserve an info/app combination for future lazy repo creation.
-   * @param repoInfo The metadata about the Repo.
-   * @param app The FirebaseApp.
-   */
-  reserveRepo(
-    repoInfo: RepoInfo,
-    app: FirebaseApp,
-  ) {
-    this.assertUnique(repoInfo, app);
 
-    let appRepos = safeGet(this.repos_, app.name);
     if (!appRepos) {
       appRepos = {};
       this.repos_[app.name] = appRepos;
     }
 
-    // Reserve the spot by putting 'null' in the map.
-    // We know we're not overwriting anything because of assertUnique
-    appRepos[repoInfo.toURLString()] = null; 
-  }
-
-  /**
-   * Make sure no matching Repo already exists.
-   * @param repoInfo The metadata about the Repo.
-   * @param app The FirebaseApp.
-   */
-  assertUnique(
-    repoInfo: RepoInfo,
-    app: FirebaseApp,
-  ) {
-    const appRepos = safeGet(this.repos_, app.name);
-    if (!appRepos) {
-      return;
-    }
-
-    const repo = safeGet(appRepos, repoInfo.toURLString());
-    if (repo !== undefined) {
+    let repo = safeGet(appRepos, repoInfo.toURLString());
+    if (repo) {
       fatal(
         'Database initialized multiple times. Please make sure the format of the database URL matches with each database() call.'
       );
     }
+    repo = new Repo(repoInfo, this.useRestClient_, app, authTokenProvider);
+    appRepos[repoInfo.toURLString()] = repo;
+
+    return repo;
   }
 
   /**