Added React Native persistence class

Author: scottcrossen

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

@@ -23,5 +23,9 @@
  */
 
 import { testFxn } from './src';
+import { AsyncStorage } from 'react-native';
+import { ReactNativePersistence } from '@firebase/auth-exp/src/core/persistence/react';
+
+const reactNativeLocalPersistence = new ReactNativePersistence(AsyncStorage);
 
 testFxn();

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

@@ -26,13 +26,16 @@
   },
   "peerDependencies": {
     "@firebase/app-exp": "0.x",
-    "@firebase/app-types-exp": "0.x"
+    "@firebase/app-types-exp": "0.x",
+    "@firebase/auth-exp": "0.x",
+    "@firebase/auth-types-exp": "0.x"
   },
   "dependencies": {
     "tslib": "1.11.1"
   },
   "license": "Apache-2.0",
   "devDependencies": {
+    "react-native": "0.62.2",
     "rollup": "1.32.1",
     "rollup-plugin-json": "4.0.0",
     "rollup-plugin-replace": "2.2.0",

packages-exp/auth-compat-exp/react-native.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2019 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.
+ */
+
+/**
+ * Basic stub for what is expected from the package 'react-native'.
+ *
+ * This should be a subset `@types/react-native` which cannot be installed
+ * because it has conflicting definitions with typescript/dom. If included in
+ * deps, yarn will attempt to install this in the root directory of the
+ * monolithic repository which will then be included in the base `tsconfig.json`
+ * via `typeroots` and then break every other package in this repo.
+ */
+
+declare module 'react-native' {
+  interface ReactNativeAsyncStorage {
+    setItem: (key: string, value: string) => Promise<void>
+    getItem: (key: string) => Promise<string|null>
+    removeItem: (key: string) => Promise<void>
+  }
+  export const AsyncStorage: ReactNativeAsyncStorage;
+}

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

@@ -55,7 +55,7 @@ const es5Builds = [
     external: id => deps.some(dep => id === dep || id.startsWith(`${dep}/`))
   },
   /**
-   * App React Native Builds
+   * React Native Builds
    */
   {
     input: 'index.rn.ts',

packages-exp/auth-exp/package.json

@@ -26,7 +26,8 @@
   },
   "peerDependencies": {
     "@firebase/app-exp": "0.x",
-    "@firebase/app-types-exp": "0.x"
+    "@firebase/app-types-exp": "0.x",
+    "@firebase/auth-types-exp": "0.x"
   },
   "dependencies": {
     "@firebase/util": "^0.2.44",

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

@@ -0,0 +1,95 @@
+/**
+ * @license
+ * Copyright 2019 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 { expect } from 'chai';
+import * as sinon from 'sinon';
+
+import { testUser } from '../../../test/mock_auth';
+import {PersistedBlob, PersistenceType} from './';
+import {ReactNativePersistence} from './react';
+import {inMemoryPersistence} from './in_memory';
+import {ReactNativeAsyncStorage} from '@firebase/auth-types-exp';
+
+/**
+ * Wraps in-memory storage with the react native AsyncStorage API.
+ */
+class FakeAsyncStorage implements ReactNativeAsyncStorage {
+  private readonly delegate = inMemoryPersistence;
+
+  getItem(key: string): Promise<string | null> {
+    return this.delegate.get(key);
+  }
+  removeItem(key: string): Promise<void> {
+    return this.delegate.remove(key);
+  }
+  setItem(key: string, value: string): Promise<void> {
+    return this.delegate.set(key, value);
+  }
+}
+
+describe('core/persistence/react', () => {
+  const persistence = new ReactNativePersistence(new FakeAsyncStorage());
+
+  beforeEach(() => {
+    localStorage.clear();
+    sessionStorage.clear();
+  });
+
+  afterEach(() => sinon.restore());
+
+  describe('ReactNativePersistence', () => {
+
+    it('should work with persistence type', async () => {
+      const key = 'my-super-special-persistence-type';
+      const value = PersistenceType.LOCAL;
+      expect(await persistence.get(key)).to.be.null;
+      await persistence.set(key, value);
+      expect(await persistence.get(key)).to.be.eq(value);
+      expect(await persistence.get('other-key')).to.be.null;
+      await persistence.remove(key);
+      expect(await persistence.get(key)).to.be.null;
+    });
+
+    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.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;
+    });
+
+    describe('#isAvailable', () => {
+      it('should emit false if localStorage setItem throws', async () => {
+        sinon.stub(localStorage, 'setItem').throws(new Error('nope'));
+        expect(await persistence.isAvailable()).to.be.false;
+      });
+
+      it('should emit false if localStorage removeItem throws', async () => {
+        sinon.stub(localStorage, 'removeItem').throws(new Error('nope'));
+        expect(await persistence.isAvailable()).to.be.false;
+      });
+
+      it('should emit true if everything works properly', async () => {
+        expect(await persistence.isAvailable()).to.be.true;
+      });
+    });
+  });
+});

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

@@ -0,0 +1,64 @@
+/**
+ * @license
+ * Copyright 2019 Google Inc.
+ *
+ * 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 {
+  Persistence,
+  PersistenceType,
+  PersistenceValue,
+  STORAGE_AVAILABLE_KEY
+} from './';
+import {ReactNativeAsyncStorage} from '@firebase/auth-types-exp';
+
+/**
+ * Persistence class that wraps AsyncStorage imported from `react-native` or `@react-native-community/async-storage`.
+ */
+export class ReactNativePersistence implements Persistence {
+  readonly type: PersistenceType = PersistenceType.LOCAL;
+  private readonly storage: ReactNativeAsyncStorage;
+
+  constructor(storage: ReactNativeAsyncStorage) {
+    this.storage = storage;
+  }
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      if (!this.storage) {
+        return false;
+      }
+      await this.storage.setItem(STORAGE_AVAILABLE_KEY, '1');
+      await this.storage.removeItem(STORAGE_AVAILABLE_KEY);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async set(key: string, value: PersistenceValue): Promise<void> {
+    await this.storage.setItem(key, JSON.stringify(value));
+  }
+
+  async get<T extends PersistenceValue>(
+    key: string
+  ): Promise<T | null> {
+    const json = await this.storage.getItem(key);
+    return json ? JSON.parse(json) : null;
+  }
+
+  async remove(key: string): Promise<void> {
+    await this.storage.removeItem(key);
+  }
+}

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

@@ -15,6 +15,8 @@
  * limitations under the License.
  */
 
-export interface TestType {
-  prop?: string;
+export interface ReactNativeAsyncStorage {
+  setItem: (key: string, value: string) => Promise<void>
+  getItem: (key: string) => Promise<string|null>
+  removeItem: (key: string) => Promise<void>
 }