Add a persistence manager class

packages-exp/auth-exp/src/core/persistence/browser.test.ts

@@ -15,12 +15,12 @@
  * limitations under the License.
  */
 
-import * as sinon from 'sinon';
-import { PersistenceType } from '.';
 import { expect } from 'chai';
-import { browserLocalPersistence, browserSessionPersistence } from './browser';
-import { User } from '../../model/user';
+import * as sinon from 'sinon';
+
 import { testUser } from '../../../test/mock_auth';
+import { PersistedBlob, PersistenceType } from './';
+import { browserLocalPersistence, browserSessionPersistence } from './browser';
 
 describe('core/persistence/browser', () => {
   beforeEach(() => {
@@ -44,16 +44,14 @@ describe('core/persistence/browser', () => {
       expect(await persistence.get(key)).to.be.null;
     });
 
-    it('should call instantiator function if provided', async () => {
+    it('should return persistedblob from user', async () => {
       const key = 'my-super-special-user';
       const value = testUser('some-uid');
 
       expect(await persistence.get(key)).to.be.null;
-      await persistence.set(key, value);
-      const out = await persistence.get<User>(key, blob =>
-        testUser(`test-${blob.uid}`)
-      );
-      expect(out?.uid).to.eql('test-some-uid');
+      await persistence.set(key, value.toPlainObject());
+      const out = await persistence.get<PersistedBlob>(key);
+      expect(out!['uid']).to.eql(value.uid);
       await persistence.remove(key);
       expect(await persistence.get(key)).to.be.null;
     });
@@ -89,16 +87,14 @@ describe('core/persistence/browser', () => {
       expect(await persistence.get(key)).to.be.null;
     });
 
-    it('should call instantiator function if provided', async () => {
+    it('should emit blobified persisted user', async () => {
       const key = 'my-super-special-user';
       const value = testUser('some-uid');
 
       expect(await persistence.get(key)).to.be.null;
-      await persistence.set(key, value);
-      const out = await persistence.get<User>(key, blob =>
-        testUser(`test-${blob.uid}`)
-      );
-      expect(out?.uid).to.eql('test-some-uid');
+      await persistence.set(key, value.toPlainObject());
+      const out = await persistence.get<PersistedBlob>(key);
+      expect(out!['uid']).to.eql(value.uid);
       await persistence.remove(key);
       expect(await persistence.get(key)).to.be.null;
     });

packages-exp/auth-exp/src/core/persistence/browser.ts

@@ -19,10 +19,8 @@ import {
   Persistence,
   PersistenceType,
   PersistenceValue,
-  Instantiator
-} from '.';
-
-const STORAGE_AVAILABLE_KEY_ = '__sak';
+  STORAGE_AVAILABLE_KEY
+} from './';
 
 class BrowserPersistence implements Persistence {
   type: PersistenceType = PersistenceType.LOCAL;
@@ -34,8 +32,8 @@ class BrowserPersistence implements Persistence {
       if (!this.storage) {
         return false;
       }
-      this.storage.setItem(STORAGE_AVAILABLE_KEY_, '1');
-      this.storage.removeItem(STORAGE_AVAILABLE_KEY_);
+      this.storage.setItem(STORAGE_AVAILABLE_KEY, '1');
+      this.storage.removeItem(STORAGE_AVAILABLE_KEY);
       return true;
     } catch {
       return false;
@@ -46,13 +44,9 @@ class BrowserPersistence implements Persistence {
     this.storage.setItem(key, JSON.stringify(value));
   }
 
-  async get<T extends PersistenceValue>(
-    key: string,
-    instantiator?: Instantiator<T>
-  ): Promise<T | null> {
+  async get<T extends PersistenceValue>(key: string): Promise<T | null> {
     const json = this.storage.getItem(key);
-    const obj = json ? JSON.parse(json) : null;
-    return instantiator && obj ? instantiator(obj) : obj;
+    return json ? JSON.parse(json) : null;
   }
 
   async remove(key: string): Promise<void> {

packages-exp/auth-exp/src/core/persistence/in_memory.test.ts

@@ -15,11 +15,11 @@
  * limitations under the License.
  */
 
-import { inMemoryPersistence as persistence } from './in_memory';
-import { PersistenceType } from '.';
 import { expect } from 'chai';
-import { User } from '../../model/user';
+
 import { testUser } from '../../../test/mock_auth';
+import { PersistenceType } from './';
+import { inMemoryPersistence as persistence } from './in_memory';
 
 describe('core/persistence/in_memory', () => {
   it('should work with persistence type', async () => {
@@ -38,8 +38,8 @@ describe('core/persistence/in_memory', () => {
     const value = testUser('uid');
 
     expect(await persistence.get(key)).to.be.null;
-    await persistence.set(key, value);
-    expect(await persistence.get<User>(key)).to.eql(value);
+    await persistence.set(key, value.toPlainObject());
+    expect(await persistence.get(key)).to.eql(value.toPlainObject());
     expect(await persistence.get('other-key')).to.be.null;
     await persistence.remove(key);
     expect(await persistence.get(key)).to.be.null;

packages-exp/auth-exp/src/core/persistence/index.ts

@@ -15,27 +15,28 @@
  * limitations under the License.
  */
 
-import { User } from '../../model/user';
-
 export enum PersistenceType {
   SESSION = 'SESSION',
   LOCAL = 'LOCAL',
   NONE = 'NONE'
 }
 
+export interface PersistedBlob {
+  [key: string]: unknown;
+}
+
 export interface Instantiator<T> {
-  (blob: { [key: string]: unknown }): T;
+  (blob: PersistedBlob): T;
 }
 
-export type PersistenceValue = PersistenceType | User;
+export type PersistenceValue = PersistedBlob | string;
+
+export const STORAGE_AVAILABLE_KEY = '__sak';
 
 export interface Persistence {
   type: PersistenceType;
   isAvailable(): Promise<boolean>;
   set(key: string, value: PersistenceValue): Promise<void>;
-  get<T extends PersistenceValue>(
-    key: string,
-    instantiator?: Instantiator<T>
-  ): Promise<T | null>;
+  get<T extends PersistenceValue>(key: string): Promise<T | null>;
   remove(key: string): Promise<void>;
 }

packages-exp/auth-exp/src/core/persistence/indexed_db.test.ts

@@ -15,12 +15,12 @@
  * limitations under the License.
  */
 
-import * as sinon from 'sinon';
-import { PersistenceType } from '.';
 import { expect } from 'chai';
-import { indexedDBLocalPersistence as persistence } from './indexed_db';
-import { User } from '../../model/user';
+import * as sinon from 'sinon';
+
 import { testUser } from '../../../test/mock_auth';
+import { PersistenceType } from './';
+import { indexedDBLocalPersistence as persistence } from './indexed_db';
 
 describe('core/persistence/indexed_db', () => {
   afterEach(sinon.restore);
@@ -36,16 +36,14 @@ describe('core/persistence/indexed_db', () => {
     expect(await persistence.get(key)).to.be.null;
   });
 
-  it('should call instantiator function if provided', async () => {
+  it('should return blobified user value', async () => {
     const key = 'my-super-special-user';
     const value = testUser('some-uid');
 
     expect(await persistence.get(key)).to.be.null;
-    await persistence.set(key, value);
-    const out = await persistence.get<User>(key, blob =>
-      testUser(`test-${blob.uid}`)
-    );
-    expect(out?.uid).to.eql('test-some-uid');
+    await persistence.set(key, value.toPlainObject());
+    const out = await persistence.get(key);
+    expect(out).to.eql(value.toPlainObject());
     await persistence.remove(key);
     expect(await persistence.get(key)).to.be.null;
   });

packages-exp/auth-exp/src/core/persistence/indexed_db.ts

@@ -16,24 +16,21 @@
  */
 
 import {
+  PersistedBlob,
   Persistence,
   PersistenceType,
   PersistenceValue,
-  Instantiator
-} from '.';
-
-const STORAGE_AVAILABLE_KEY_ = '__sak';
+  STORAGE_AVAILABLE_KEY
+} from './';
 
 export const DB_NAME = 'firebaseLocalStorageDb';
 const DB_VERSION = 1;
 const DB_OBJECTSTORE_NAME = 'firebaseLocalStorage';
 const DB_DATA_KEYPATH = 'fbase_key';
 
-type DBValue = { [key: string]: unknown } | string;
-
 interface DBObject {
   [DB_DATA_KEYPATH]: string;
-  value: DBValue;
+  value: PersistedBlob;
 }
 
 /**
@@ -110,7 +107,7 @@ async function putObject(
   const data = await new DBPromise<DBObject | null>(getRequest).toPromise();
   if (data) {
     // Force an index signature on the user object
-    data.value = value as DBValue;
+    data.value = value as PersistedBlob;
     const request = getObjectStore(db, true).put(data);
     return new DBPromise<void>(request).toPromise();
   } else {
@@ -125,7 +122,7 @@ async function putObject(
 async function getObject(
   db: IDBDatabase,
   key: string
-): Promise<DBValue | null> {
+): Promise<PersistedBlob | null> {
   const request = getObjectStore(db, false).get(key);
   const data = await new DBPromise<DBObject | undefined>(request).toPromise();
   return data === undefined ? null : data.value;
@@ -154,8 +151,8 @@ class IndexedDBLocalPersistence implements Persistence {
         return false;
       }
       const db = await openDatabase();
-      await putObject(db, STORAGE_AVAILABLE_KEY_, '1');
-      await deleteObject(db, STORAGE_AVAILABLE_KEY_);
+      await putObject(db, STORAGE_AVAILABLE_KEY, '1');
+      await deleteObject(db, STORAGE_AVAILABLE_KEY);
       return true;
     } catch {}
     return false;
@@ -166,15 +163,9 @@ class IndexedDBLocalPersistence implements Persistence {
     return putObject(db, key, value);
   }
 
-  async get<T extends PersistenceValue>(
-    key: string,
-    instantiator?: Instantiator<T>
-  ): Promise<T | null> {
+  async get<T extends PersistenceValue>(key: string): Promise<T | null> {
     const db = await this.initialize();
     const obj = await getObject(db, key);
-    if (instantiator && obj && typeof obj !== 'string') {
-      return instantiator(obj);
-    }
     return obj as T;
   }