Use storage for faster calls to isLoggedIn on mobile

packages/@magic-sdk/provider/src/core/sdk.ts

@@ -117,6 +117,7 @@ export interface MagicSDKAdditionalConfiguration<
   extensions?: TExt;
   testMode?: boolean;
   deferPreload?: boolean;
+  useStorageCache?: boolean;
 }
 
 export class SDKBase {
@@ -126,6 +127,7 @@ export class SDKBase {
   protected readonly parameters: string;
   protected readonly networkHash: string;
   public readonly testMode: boolean;
+  public readonly useStorageCache: boolean;
 
   /**
    * Contains methods for starting a Magic SDK authentication flow.
@@ -167,6 +169,7 @@ export class SDKBase {
 
     const { defaultEndpoint, version } = SDKEnvironment;
     this.testMode = !!options?.testMode;
+    this.useStorageCache = !!options?.useStorageCache;
     this.endpoint = createURL(options?.endpoint ?? defaultEndpoint).origin;
 
     // Prepare built-in modules

packages/@magic-sdk/provider/src/modules/user.ts

@@ -9,12 +9,13 @@ import {
   RecoverAccountConfiguration,
   ShowSettingsConfiguration,
 } from '@magic-sdk/types';
-import { getItem, removeItem } from '../util/storage';
+import { getItem, setItem, removeItem } from '../util/storage';
 import { BaseModule } from './base-module';
 import { createJsonRpcRequestPayload } from '../core/json-rpc';
 import { createDeprecationWarning } from '../core/sdk-exceptions';
 import { ProductConsolidationMethodRemovalVersions } from './auth';
 import { clearDeviceShares } from '../util/device-share-web-crypto';
+import { createPromiEvent } from '../util';
 
 export type UpdateEmailEvents = {
   'email-sent': () => void;
@@ -23,6 +24,9 @@ export type UpdateEmailEvents = {
   'new-email-confirmed': () => void;
   retry: () => void;
 };
+
+type UserLoggedOutCallback = (loggedOut: boolean) => void;
+
 export class UserModule extends BaseModule {
   public getIdToken(configuration?: GetIdTokenConfiguration) {
     const requestPayload = createJsonRpcRequestPayload(
@@ -47,19 +51,59 @@ export class UserModule extends BaseModule {
   }
 
   public isLoggedIn() {
-    const requestPayload = createJsonRpcRequestPayload(
-      this.sdk.testMode ? MagicPayloadMethod.IsLoggedInTestMode : MagicPayloadMethod.IsLoggedIn,
-    );
-    return this.request<boolean>(requestPayload);
+    return createPromiEvent<boolean, any>(async (resolve, reject) => {
+      try {
+        let cachedIsLoggedIn = false;
+        if (this.sdk.useStorageCache) {
+          cachedIsLoggedIn = (await getItem(this.localForageIsLoggedInKey)) === 'true';
+
+          // if isLoggedIn is true on storage, optimistically resolve with true
+          // if it is false, we use `usr.isLoggedIn` as the source of truth.
+          if (cachedIsLoggedIn) {
+            resolve(true);
+          }
+        }
+
+        const requestPayload = createJsonRpcRequestPayload(
+          this.sdk.testMode ? MagicPayloadMethod.IsLoggedInTestMode : MagicPayloadMethod.IsLoggedIn,
+        );
+        const isLoggedInResponse = await this.request<boolean>(requestPayload);
+        if (this.sdk.useStorageCache) {
+          if (isLoggedInResponse) {
+            setItem(this.localForageIsLoggedInKey, true);
+          } else {
+            removeItem(this.localForageIsLoggedInKey);
+          }
+          if (cachedIsLoggedIn && !isLoggedInResponse) {
+            this.emitUserLoggedOut(true);
+          }
+        }
+        resolve(isLoggedInResponse);
+      } catch (err) {
+        reject(err);
+      }
+    });
   }
 
   public logout() {
     removeItem(this.localForageKey);
+    removeItem(this.localForageIsLoggedInKey);
     clearDeviceShares();
-    const requestPayload = createJsonRpcRequestPayload(
-      this.sdk.testMode ? MagicPayloadMethod.LogoutTestMode : MagicPayloadMethod.Logout,
-    );
-    return this.request<boolean>(requestPayload);
+
+    return createPromiEvent<boolean, any>(async (resolve, reject) => {
+      try {
+        const requestPayload = createJsonRpcRequestPayload(
+          this.sdk.testMode ? MagicPayloadMethod.LogoutTestMode : MagicPayloadMethod.Logout,
+        );
+        const response = await this.request<boolean>(requestPayload);
+        if (this.sdk.useStorageCache) {
+          this.emitUserLoggedOut(response);
+        }
+        resolve(response);
+      } catch (err) {
+        reject(err);
+      }
+    });
   }
 
   /* Request email address from logged in user */
@@ -112,6 +156,18 @@ export class UserModule extends BaseModule {
     return this.request<string | null, UpdateEmailEvents>(requestPayload);
   }
 
+  public onUserLoggedOut(callback: UserLoggedOutCallback): void {
+    this.userLoggedOutCallbacks.push(callback);
+  }
+
   // Private members
+  private emitUserLoggedOut(loggedOut: boolean): void {
+    this.userLoggedOutCallbacks.forEach((callback) => {
+      callback(loggedOut);
+    });
+  }
+
   private localForageKey = 'mc_active_wallet';
+  private localForageIsLoggedInKey = 'magic_auth_is_logged_in';
+  private userLoggedOutCallbacks: UserLoggedOutCallback[] = [];
 }

packages/@magic-sdk/provider/test/spec/modules/auth/loginWithMagicLink.spec.ts

@@ -1,11 +1,13 @@
 /* eslint-disable global-require, @typescript-eslint/no-var-requires */
 
 import browserEnv from '@ikscodes/browser-env';
-import { MagicPayloadMethod } from '@magic-sdk/types';
+import { MagicPayloadMethod, SDKWarningCode } from '@magic-sdk/types';
 
 import { SDKEnvironment } from '../../../../src/core/sdk-environment';
 import { isPromiEvent } from '../../../../src/util';
 import { createMagicSDK, createMagicSDKTestMode } from '../../../factories';
+import * as SdkExceptions from '../../../../src/core/sdk-exceptions';
+import { ProductConsolidationMethodRemovalVersions } from '../../../../src/modules/auth';
 
 beforeEach(() => {
   browserEnv.restore();
@@ -97,3 +99,25 @@ test('Throws error when the SDK version is 19 or higher', async () => {
     );
   }
 });
+
+test('Creates deprecation warning if ran on a react native environment with version < 19', async () => {
+  const magic = createMagicSDK();
+  magic.auth.request = jest.fn();
+  const deprecationWarnStub = jest.spyOn(SdkExceptions, 'createDeprecationWarning').mockReturnValue({
+    log: jest.fn(),
+    message: 'test',
+    code: SDKWarningCode.DeprecationNotice,
+    rawMessage: 'test',
+  });
+
+  // Set SDKEnvironment version to 18
+  SDKEnvironment.version = '18';
+  SDKEnvironment.sdkName = '@magic-sdk/react-native';
+
+  await magic.auth.loginWithMagicLink({ email: 'test' });
+  expect(deprecationWarnStub).toHaveBeenCalledWith({
+    method: 'auth.loginWithMagicLink()',
+    removalVersions: ProductConsolidationMethodRemovalVersions,
+    useInstead: 'auth.loginWithEmailOTP()',
+  });
+});

packages/@magic-sdk/provider/test/spec/modules/user/emitUserLoggedOut.spec.ts

@@ -0,0 +1,14 @@
+import browserEnv from '@ikscodes/browser-env';
+import { createMagicSDK } from '../../../factories';
+
+beforeEach(() => {
+  browserEnv.restore();
+});
+
+test('emitUserLoggedOut emits event', () => {
+  const magic = createMagicSDK();
+  const callbackMock = jest.fn();
+  magic.user.onUserLoggedOut(callbackMock);
+  magic.user.emitUserLoggedOut(true);
+  expect(callbackMock).toHaveBeenCalledWith(true);
+});

packages/@magic-sdk/provider/test/spec/modules/user/isLoggedIn.spec.ts

@@ -1,17 +1,60 @@
 import browserEnv from '@ikscodes/browser-env';
 import { createMagicSDK, createMagicSDKTestMode } from '../../../factories';
 import { BaseModule } from '../../../../src/modules/base-module';
-import { isPromiEvent } from '../../../../src/util';
+import { isPromiEvent, storage } from '../../../../src/util';
+import { mockLocalForage } from '../../../mocks';
 
 beforeEach(() => {
   browserEnv.restore();
 });
 
+test('Resolves immediately when cached magic_auth_is_logged_in is true', async () => {
+  mockLocalForage({ magic_auth_is_logged_in: 'true' });
+  const magic = createMagicSDK();
+  magic.useStorageCache = true;
+
+  const isLoggedIn = await magic.user.isLoggedIn();
+
+  expect(isLoggedIn).toEqual(true);
+});
+
+test('Waits for request before resolving when cached magic_auth_is_logged_in is false', async () => {
+  mockLocalForage({ magic_auth_is_logged_in: 'true' });
+  const magic = createMagicSDK();
+  magic.user.request = jest.fn().mockResolvedValue(true);
+
+  const isLoggedIn = await magic.user.isLoggedIn();
+
+  expect(isLoggedIn).toEqual(true);
+});
+
+test('Stores magic_auth_is_logged_in=true in local storage when request resolves true', async () => {
+  mockLocalForage();
+  const magic = createMagicSDK();
+  magic.useStorageCache = true;
+  magic.user.request = jest.fn().mockResolvedValue(true);
+
+  await magic.user.isLoggedIn();
+
+  expect(storage.setItem).toHaveBeenCalledWith('magic_auth_is_logged_in', true);
+});
+
+test('Removes magic_auth_is_logged_in=true from local storage when request resolves false', async () => {
+  mockLocalForage();
+  const magic = createMagicSDK();
+  magic.useStorageCache = true;
+  magic.user.request = jest.fn().mockResolvedValue(false);
+
+  await magic.user.isLoggedIn();
+
+  expect(storage.removeItem).toHaveBeenCalledWith('magic_auth_is_logged_in');
+});
+
 test(' Generate JSON RPC request payload with method `magic_is_logged_in`', async () => {
   const magic = createMagicSDK();
   magic.user.request = jest.fn();
 
-  magic.user.isLoggedIn();
+  await magic.user.isLoggedIn();
 
   const requestPayload = magic.user.request.mock.calls[0][0];
   expect(requestPayload.method).toBe('magic_is_logged_in');
@@ -22,7 +65,7 @@ test('If `testMode` is enabled, testing-specific RPC method is used', async () =
   const magic = createMagicSDKTestMode();
   magic.user.request = jest.fn();
 
-  magic.user.isLoggedIn();
+  await magic.user.isLoggedIn();
 
   const requestPayload = magic.user.request.mock.calls[0][0];
   expect(requestPayload.method).toBe('magic_auth_is_logged_in_testing_mode');
@@ -33,3 +76,23 @@ test('method should return a PromiEvent', () => {
   const magic = createMagicSDK();
   expect(isPromiEvent(magic.user.isLoggedIn())).toBeTruthy();
 });
+
+test('Should reject with error if error occurs', async () => {
+  const magic = createMagicSDKTestMode();
+  magic.user.request = jest.fn().mockRejectedValue(new Error('something went wrong'));
+
+  await expect(magic.user.isLoggedIn()).rejects.toThrowError(new Error('something went wrong'));
+});
+
+test('Emits user logged out event when logout resolves', async () => {
+  mockLocalForage({ magic_auth_is_logged_in: 'true' });
+  const magic = createMagicSDK();
+  magic.useStorageCache = true;
+  magic.user.request = jest.fn().mockResolvedValue(true);
+
+  const spyEmitUserLoggedOut = jest.spyOn(magic.user, 'emitUserLoggedOut');
+
+  await magic.user.logout();
+
+  expect(spyEmitUserLoggedOut).toHaveBeenCalledWith(true);
+});

packages/@magic-sdk/provider/test/spec/modules/user/logout.spec.ts

@@ -1,6 +1,7 @@
 import browserEnv from '@ikscodes/browser-env';
-import { isPromiEvent } from '../../../../src/util';
+import { isPromiEvent, storage } from '../../../../src/util';
 import { createMagicSDK, createMagicSDKTestMode } from '../../../factories';
+import { mockLocalForage } from '../../../mocks';
 
 beforeEach(() => {
   browserEnv.restore();
@@ -32,3 +33,28 @@ test('If `testMode` is enabled, testing-specific RPC method is used', async () =
   expect(requestPayload.method).toBe('magic_auth_logout_testing_mode');
   expect(requestPayload.params).toEqual([]);
 });
+
+test('Removes magic_auth_is_logged_in from local storage', async () => {
+  const magic = createMagicSDKTestMode();
+  mockLocalForage({ magic_auth_is_logged_in: 'true' });
+
+  magic.user.logout();
+
+  expect(storage.removeItem).toHaveBeenCalledWith('magic_auth_is_logged_in');
+});
+
+test('Removes mc_active_wallet from local storage', async () => {
+  const magic = createMagicSDKTestMode();
+  mockLocalForage({ mc_active_wallet: 'test' });
+
+  magic.user.logout();
+
+  expect(storage.removeItem).toHaveBeenCalledWith('mc_active_wallet');
+});
+
+test('Should reject with error if error occurs', async () => {
+  const magic = createMagicSDKTestMode();
+  magic.user.request = jest.fn().mockRejectedValue(new Error('something went wrong'));
+
+  await expect(magic.user.logout()).rejects.toThrowError(new Error('something went wrong'));
+});

packages/@magic-sdk/provider/test/spec/modules/user/onUserLoggedOut.spec.ts

@@ -0,0 +1,15 @@
+import browserEnv from '@ikscodes/browser-env';
+import { createMagicSDK } from '../../../factories';
+
+beforeEach(() => {
+  browserEnv.restore();
+});
+
+test('onUserLoggedOut adds callback', () => {
+  const magic = createMagicSDK();
+  const callbackMock = jest.fn();
+  magic.user.onUserLoggedOut(callbackMock);
+  const callbacks = magic.user.userLoggedOutCallbacks;
+  expect(callbacks).toHaveLength(1);
+  expect(callbacks[0]).toBe(callbackMock);
+});