Merge pull request #188 from Web3Auth/feat/disableSessionManager

Feat/disable session manager

Author: himanshuchawla009

src/interfaces.ts

@@ -336,6 +336,13 @@ export interface Web3AuthOptions {
    */
   storage: IAsyncStorage | IStorage;
 
+  /**
+   * @defaultValue false
+   * disable session manager creation
+   * signatures from web3auth newtorks will still expired after sessionTime if session manager is disabled
+   */
+  disableSessionManager?: boolean;
+
   /**
    * @defaultValue 86400
    */

src/mpcCoreKit.ts

@@ -80,7 +80,7 @@ export class Web3AuthMPCCoreKit implements ICoreKit {
 
   private tkey: TKeyTSS | null = null;
 
-  private sessionManager!: SessionManager<SessionData>;
+  private sessionManager?: SessionManager<SessionData>;
 
   private currentStorage: AsyncStorage;
 
@@ -108,27 +108,33 @@ export class Web3AuthMPCCoreKit implements ICoreKit {
 
     const isNodejsOrRN = this.isNodejsOrRN(options.uxMode);
 
-    // if (await storageAvailable(options.storage)) {
-    //   throw CoreKitError.storageTypeUnsupported(`Unsupported storage type ${options.storageKey} for ${options.uxMode} mode.`);
-    // }
-
     if (options.enableLogging) {
       log.enableAll();
       this.enableLogging = true;
     } else log.setLevel("error");
     if (typeof options.manualSync !== "boolean") options.manualSync = false;
     if (!options.web3AuthNetwork) options.web3AuthNetwork = WEB3AUTH_NETWORK.MAINNET;
+    // if sessionTime is not provided, it is defaulted to 86400
     if (!options.sessionTime) options.sessionTime = 86400;
     if (!options.serverTimeOffset) options.serverTimeOffset = 0;
     if (!options.uxMode) options.uxMode = UX_MODE.REDIRECT;
     if (!options.redirectPathName) options.redirectPathName = "redirect";
     if (!options.baseUrl) options.baseUrl = isNodejsOrRN ? "https://localhost" : `${window?.location.origin}/serviceworker`;
     if (!options.disableHashedFactorKey) options.disableHashedFactorKey = false;
     if (!options.hashedFactorNonce) options.hashedFactorNonce = options.web3AuthClientId;
+    if (options.disableSessionManager === undefined) options.disableSessionManager = false;
 
     this.options = options as Web3AuthOptionsWithDefaults;
 
     this.currentStorage = new AsyncStorage(this._storageBaseKey, options.storage);
+
+    if (!options.disableSessionManager) {
+      this.sessionManager = new SessionManager<SessionData>({
+        sessionTime: options.sessionTime,
+      });
+    }
+
+    TorusUtils.setSessionTime(this.options.sessionTime);
   }
 
   get tKey(): TKeyTSS {
@@ -270,13 +276,6 @@ export class Web3AuthMPCCoreKit implements ICoreKit {
 
     this.ready = true;
 
-    // setup session Manager during init instead of async constructor
-    const sessionId = await this.currentStorage.get<string>("sessionId");
-    this.sessionManager = new SessionManager({
-      sessionTime: this.options.sessionTime,
-      sessionId,
-    });
-
     // try handle redirect flow if enabled and return(redirect) from oauth login
     if (
       params.handleRedirectResult &&
@@ -286,26 +285,31 @@ export class Web3AuthMPCCoreKit implements ICoreKit {
       // on failed redirect, instance is reseted.
       // skip check feature gating on redirection as it was check before login
       await this.handleRedirectResult();
+
+      // return early on successful redirect, the rest of the code will not be executed
+      return;
+    } else if (params.rehydrate && this.sessionManager) {
       // if not redirect flow try to rehydrate session if available
-    } else if (params.rehydrate && this.sessionManager.sessionId) {
-      // swallowed, should not throw on rehydrate timed out session
-      const sessionResult = await this.sessionManager.authorizeSession().catch(async (err) => {
-        log.error("rehydrate session error", err);
-      });
+      const sessionId = await this.currentStorage.get<string>("sessionId");
+      if (sessionId) {
+        this.sessionManager.sessionId = sessionId;
 
-      // try rehydrate session
-      if (sessionResult) {
-        await this.rehydrateSession(sessionResult);
-      } else {
-        // feature gating on no session rehydration
-        await this.featureRequest();
-        TorusUtils.setSessionTime(this.options.sessionTime);
+        // swallowed, should not throw on rehydrate timed out session
+        const sessionResult = await this.sessionManager.authorizeSession().catch(async (err) => {
+          log.error("rehydrate session error", err);
+        });
+
+        // try rehydrate session
+        if (sessionResult) {
+          await this.rehydrateSession(sessionResult);
+
+          // return early on success rehydration
+          return;
+        }
       }
-    } else {
-      // feature gating if not redirect flow or session rehydration
-      await this.featureRequest();
-      TorusUtils.setSessionTime(this.options.sessionTime);
     }
+    // feature gating if not redirect flow or session rehydration
+    await this.featureRequest();
   }
 
   public async loginWithOAuth(params: OAuthLoginParams): Promise<void> {
@@ -697,7 +701,7 @@ export class Web3AuthMPCCoreKit implements ICoreKit {
   }
 
   public async logout(): Promise<void> {
-    if (this.sessionManager.sessionId) {
+    if (this.sessionManager?.sessionId) {
       await this.sessionManager.invalidateSession();
     }
     // to accommodate async storage
@@ -1034,11 +1038,15 @@ export class Web3AuthMPCCoreKit implements ICoreKit {
         userInfo: result.userInfo,
       });
     } catch (err) {
-      log.error("error trying to authorize session", err);
+      log.warn("failed to authorize session", err);
     }
   }
 
   private async createSession() {
+    if (!this.sessionManager) {
+      throw new Error("sessionManager is not available");
+    }
+
     try {
       const sessionId = SessionManager.generateRandomSessionKey();
       this.sessionManager.sessionId = sessionId;

tests/sessionTime.spec.ts

@@ -15,9 +15,13 @@ type TestVariable = {
   email: string;
   gated?: boolean;
   sessionTime?: number;
+  disableSessionManager?: boolean;
 };
 
 const defaultTestEmail = "testEmail1";
+
+const isBasePlan = (id: string) => id === "BCriFlI9ihm81N-bc7x6N-xbqwBLuxfRDMmSH87spKH27QTNOPj1W9s2K3-mp9NzXuaRiqxvAGHyuGlXG5wLD1g";
+// BasePlan up to 1 day only
 const variable: TestVariable[] = [
   { web3AuthNetwork: WEB3AUTH_NETWORK.DEVNET, uxMode: "nodejs", email: defaultTestEmail, web3ClientID: "torus-key-test", sessionTime: 3600 },
   {
@@ -34,46 +38,78 @@ const variable: TestVariable[] = [
     web3ClientID: "BCriFlI9ihm81N-bc7x6N-xbqwBLuxfRDMmSH87spKH27QTNOPj1W9s2K3-mp9NzXuaRiqxvAGHyuGlXG5wLD1g",
     sessionTime: 172800,
   },
+  {
+    web3AuthNetwork: WEB3AUTH_NETWORK.MAINNET,
+    uxMode: "nodejs",
+    email: defaultTestEmail,
+    web3ClientID: "BJ57yveG_XBLqZUpjtJCnJMrord0AaXpd_9OSy4HzkxpnpPn6Co73h-vR6GEI1VogtW4yMHq13GNPKmVpliFXY0",
+    sessionTime: 7200,
+    disableSessionManager : false
+  },
+
+  {
+    web3AuthNetwork: WEB3AUTH_NETWORK.MAINNET,
+    uxMode: "nodejs",
+    email: defaultTestEmail,
+    web3ClientID: "BJ57yveG_XBLqZUpjtJCnJMrord0AaXpd_9OSy4HzkxpnpPn6Co73h-vR6GEI1VogtW4yMHq13GNPKmVpliFXY0",
+    sessionTime: 7200,
+    disableSessionManager : true
+  },
 ];
 
 const storageInstance = new MemoryStorage();
-variable.forEach((testVariable) => {
-  const { web3AuthNetwork, uxMode, manualSync, email, web3ClientID: web3AuthClientId, sessionTime } = variable[0];
-  const coreKitInstance = new Web3AuthMPCCoreKit({
-    web3AuthClientId,
-    web3AuthNetwork,
-    baseUrl: "http://localhost:3000",
-    uxMode,
-    tssLib,
-    storage: storageInstance,
-    manualSync,
-    sessionTime,
-  });
+variable.forEach(async (testVariable) => {
+  const { web3AuthNetwork, uxMode, manualSync, email, web3ClientID: web3AuthClientId, sessionTime, disableSessionManager } = testVariable;
+  
+
+  await test(`#Variable SessionTime test :  ${JSON.stringify({ sessionTime: testVariable.sessionTime })} - disableSessionManager: ${disableSessionManager} client_id: ${web3AuthClientId}`, async (t) => {
+    const coreKitInstance = new Web3AuthMPCCoreKit({
+      web3AuthClientId,
+      web3AuthNetwork,
+      baseUrl: "http://localhost:3000",
+      uxMode,
+      tssLib,
+      storage: storageInstance,
+      manualSync,
+      sessionTime,
+      disableSessionManager,
+    });
 
-  test(`#Variable SessionTime test :  ${JSON.stringify({ sessionTime: testVariable.sessionTime })}`, async (t) => {
     async function beforeTest() {
       if (coreKitInstance.status === COREKIT_STATUS.INITIALIZED) await criticalResetAccount(coreKitInstance);
     }
 
     t.after(async function () {
       // after all test tear down
-      await coreKitInstance.logout();
+      if (!isBasePlan(web3AuthClientId)) await coreKitInstance.logout();
     });
 
     await beforeTest();
 
-    await t.test("`sessionTime` should be equal to `sessionTokenDuration` from #Login", async function () {
+    await t.test("`sessionTime` should be equal to `sessionTokenDuration` from #Login", async function (t) {
       // mocklogin
       const { idToken, parsedToken } = await mockLogin(email);
 
-      await coreKitInstance.init({ handleRedirectResult: false });
+      await coreKitInstance.init({ handleRedirectResult: false }).catch((err) => {
+        if ( !isBasePlan(testVariable.web3ClientID) ) {
+          throw err;
+        }
+      });
 
       await coreKitInstance.loginWithJWT({
         verifier: "torus-test-health",
         verifierId: parsedToken.email,
         idToken,
+      }).catch((err) => {
+        if ( !isBasePlan(testVariable.web3ClientID) ) {
+          throw err;
+        }
       });
-
+      if ( !isBasePlan(testVariable.web3ClientID) ) {
+        // skip remaining test if is BasePlan
+        return;
+      }
+      
       coreKitInstance.signatures.forEach((sig) => {
         const parsedSig = JSON.parse(sig);
         const parsedSigData = JSON.parse(atob(parsedSig.data));
@@ -84,6 +120,14 @@ variable.forEach((testVariable) => {
         const sessionTimeDiff = Math.abs(sessionTokenDuration - sessionTime);
         assert.strictEqual(sessionTimeDiff <= 3, true);
       });
+
+      if (disableSessionManager) {
+        assert.equal(coreKitInstance.sessionId , undefined); 
+      } else {
+        assert.notEqual(coreKitInstance.sessionId , undefined);
+      }
     });
+
+
   });
 });