Supporting isDeeplyNestedAuthSupported flag for Legacy Teams Mobile Scenario (#2803)

* deeplyNesteAuth config for mobile legacy

Author: prpatwa

change/@microsoft-teams-js-ade231c1-27a2-4670-b268-bdfc0daa5b0a.json

@@ -0,0 +1,7 @@
+{
+  "type": "minor",
+  "comment": "Added a new client version `2.1.2` to support isDeeplyNestedAuthSupported for Teams Mobile legacy code",
+  "packageName": "@microsoft/teams-js",
+  "email": "[email protected]",
+  "dependentChangeType": "patch"
+}

packages/teams-js/src/public/nestedAppAuth.ts

@@ -5,11 +5,11 @@
  */
 import { callFunctionInHostAndHandleResponse, Communication } from '../internal/communication';
 import { GlobalVars } from '../internal/globalVars';
-import { ensureInitialized } from '../internal/internalAPIs';
+import { ensureInitialized, isCurrentSDKVersionAtLeast } from '../internal/internalAPIs';
 import { ResponseHandler, SimpleType } from '../internal/responseHandler';
 import { ApiName, ApiVersionNumber, getApiVersionTag } from '../internal/telemetry';
 import { errorNotSupportedOnPlatform, HostClientType } from './constants';
-import { runtime } from './runtime';
+import { runtime, legacyTeamsMobileVersionForDeeplyNestedAuth } from './runtime';
 import { ISerializable } from './serializable.interface';
 
 /**
@@ -84,9 +84,21 @@ export function canParentManageNAATrustedOrigins(): boolean {
  * @beta
  */
 export function isDeeplyNestedAuthSupported(): boolean {
-  return (ensureInitialized(runtime) && runtime.isDeeplyNestedAuthSupported) ?? false;
+  return (
+    (ensureInitialized(runtime) &&
+      (runtime.isDeeplyNestedAuthSupported || isDeeplyNestedAuthSupportedForLegacyTeamsMobile())) ??
+    false
+  );
 }
 
+function isDeeplyNestedAuthSupportedForLegacyTeamsMobile(): boolean {
+  return ensureInitialized(runtime) &&
+    isHostAndroidOrIOSOrIPadOSOrVisionOS() &&
+    runtime.isLegacyTeams &&
+    isCurrentSDKVersionAtLeast(legacyTeamsMobileVersionForDeeplyNestedAuth)
+    ? true
+    : false;
+}
 function isNAAChannelRecommendedForLegacyTeamsMobile(): boolean {
   return ensureInitialized(runtime) &&
     isHostAndroidOrIOSOrIPadOSOrVisionOS() &&

packages/teams-js/src/public/runtime.ts

@@ -544,6 +544,12 @@ export const upgradeChain: IRuntimeUpgrade[] = [
   },
 ];
 
+/**
+ * This version is for legacy Teams mobile clients that don’t pass a runtime object during initialization.
+ * It’s the minimum version required to support deeply nested app auth.
+ */
+export const legacyTeamsMobileVersionForDeeplyNestedAuth = '2.1.2';
+
 /**
  * This structure is used for versions of Teams that don't pass a runtime object during initialization.
  * Please see the extensive comments in versionAndPlatformAgnosticTeamsRuntimeConfig for more information
@@ -611,6 +617,10 @@ export const mapTeamsVersionToSupportedCapabilities: Record<string, Array<ICapab
       hostClientTypes: [HostClientType.android, HostClientType.ios, HostClientType.ipados, HostClientType.visionOS],
     },
   ],
+  '2.1.2': [
+    // isDeeplyNestedAuthSupported: true (based on const legacyTeamsMobileVersionForDeeplyNestedAuth)
+    // for hostClientTypes: [HostClientType.android, HostClientType.ios, HostClientType.ipados, HostClientType.visionOS]
+  ],
 };
 
 const generateBackCompatRuntimeConfigLogger = runtimeLogger.extend('generateBackCompatRuntimeConfig');

packages/teams-js/test/public/nestedAppAuth.spec.ts

@@ -2,7 +2,11 @@ import * as communication from '../../src/internal/communication';
 import { errorLibraryNotInitialized } from '../../src/internal/constants';
 import { app, FrameContexts, HostClientType, nestedAppAuth } from '../../src/public';
 import { errorNotSupportedOnPlatform } from '../../src/public/constants';
-import { _minRuntimeConfigToUninitialize, Runtime } from '../../src/public/runtime';
+import {
+  _minRuntimeConfigToUninitialize,
+  Runtime,
+  legacyTeamsMobileVersionForDeeplyNestedAuth,
+} from '../../src/public/runtime';
 import { Utils } from '../utils';
 
 /* eslint-disable */
@@ -125,84 +129,143 @@ describe('nestedAppAuth', () => {
       });
     });
   });
-  describe('canParentManageNAATrustedOrigins', () => {
+
+  describe('isDeeplyNestedAuthSupported', () => {
     it('should throw if called before initialization', () => {
       utils.uninitializeRuntimeConfig();
-      expect(() => nestedAppAuth.canParentManageNAATrustedOrigins()).toThrowError(
-        new Error(errorLibraryNotInitialized),
-      );
+      expect(() => nestedAppAuth.isDeeplyNestedAuthSupported()).toThrowError(new Error(errorLibraryNotInitialized));
     });
 
-    it('should return true if canParentManageNAATrustedOrigins set to true in runtime object', async () => {
+    it('should return true if isDeeplyNestedAuthSupported set to true in runtime object', async () => {
       await utils.initializeWithContext(FrameContexts.content);
       const runtimeConfig: Runtime = {
         apiVersion: 4,
         supports: {},
-        canParentManageNAATrustedOrigins: true,
+        isDeeplyNestedAuthSupported: true,
       };
       utils.setRuntimeConfig(runtimeConfig);
-      expect(nestedAppAuth.canParentManageNAATrustedOrigins()).toBeTruthy();
+      expect(nestedAppAuth.isDeeplyNestedAuthSupported()).toBeTruthy();
     });
 
-    it('should return false if canParentManageNAATrustedOrigins set to false in runtime object ', async () => {
+    it('should return false if isDeeplyNestedAuthSupported set to false in runtime object ', async () => {
       await utils.initializeWithContext(FrameContexts.content);
       const runtimeConfig: Runtime = {
         apiVersion: 4,
         supports: {},
-        canParentManageNAATrustedOrigins: false,
+        isDeeplyNestedAuthSupported: false,
       };
       utils.setRuntimeConfig(runtimeConfig);
-      expect(nestedAppAuth.canParentManageNAATrustedOrigins()).toBeFalsy();
+      expect(nestedAppAuth.isDeeplyNestedAuthSupported()).toBeFalsy();
     });
 
-    it('should return false if canParentManageNAATrustedOrigins not present in runtime object ', async () => {
+    it('should return false if isDeeplyNestedAuthSupported not present in runtime object ', async () => {
       await utils.initializeWithContext(FrameContexts.content);
       const runtimeConfig: Runtime = {
         apiVersion: 4,
         supports: {},
       };
       utils.setRuntimeConfig(runtimeConfig);
-      expect(nestedAppAuth.canParentManageNAATrustedOrigins()).toBeFalsy();
+      expect(nestedAppAuth.isDeeplyNestedAuthSupported()).toBeFalsy();
+    });
+
+    describe('should return false when isDeeplyNestedAuthSupported is false across different host clients', () => {
+      const hostClients = [HostClientType.macos, HostClientType.desktop, HostClientType.web];
+
+      hostClients.forEach((hostClient) => {
+        it(`${hostClient} client`, async () => {
+          await utils.initializeWithContext(FrameContexts.content, hostClient);
+          const runtimeConfig: Runtime = {
+            apiVersion: 4,
+            supports: {},
+            isDeeplyNestedAuthSupported: false,
+          };
+          utils.setRuntimeConfig(runtimeConfig);
+          expect(nestedAppAuth.isDeeplyNestedAuthSupported()).toBeFalsy();
+        });
+      });
+    });
+
+    it('should return false if isDeeplyNestedAuthSupported is false and isLegacyTeams is false in runtimeConfig', async () => {
+      await utils.initializeWithContext(FrameContexts.content, HostClientType.android);
+      const runtimeConfig: Runtime = {
+        apiVersion: 4,
+        supports: {},
+        isDeeplyNestedAuthSupported: false,
+        isLegacyTeams: false,
+      };
+      utils.setRuntimeConfig(runtimeConfig);
+      expect(nestedAppAuth.isDeeplyNestedAuthSupported()).toBeFalsy();
+    });
+
+    it('should return false if isDeeplyNestedAuthSupported is false and isLegacyTeams is true in runtimeConfig for android client for version < legacyTeamsMobileVersionForDeeplyNestedAuth', async () => {
+      await utils.initializeWithContext(FrameContexts.content, HostClientType.android);
+      const runtimeConfig: Runtime = {
+        apiVersion: 4,
+        supports: {},
+        isDeeplyNestedAuthSupported: false,
+        isLegacyTeams: true,
+      };
+      utils.setClientSupportedSDKVersion('2.1.1');
+      utils.setRuntimeConfig(runtimeConfig);
+      expect(nestedAppAuth.isDeeplyNestedAuthSupported()).toBeFalsy();
+    });
+
+    describe('should return true if isDeeplyNestedAuthSupported is false and isLegacyTeams is true in runtimeConfig for android clients with version legacyTeamsMobileVersionForDeeplyNestedAuth', () => {
+      const hostClients = [HostClientType.ipados, HostClientType.ios, HostClientType.android];
+      hostClients.forEach((hostClient) => {
+        it(`for ${hostClient} client`, async () => {
+          await utils.initializeWithContext(FrameContexts.content, hostClient);
+          utils.setClientSupportedSDKVersion(legacyTeamsMobileVersionForDeeplyNestedAuth);
+          const runtimeConfig: Runtime = {
+            apiVersion: 4,
+            supports: {},
+            isDeeplyNestedAuthSupported: false,
+            isLegacyTeams: true,
+          };
+          utils.setRuntimeConfig(runtimeConfig);
+          expect(nestedAppAuth.isDeeplyNestedAuthSupported()).toBeTruthy();
+        });
+      });
     });
   });
-  describe('nestedAppAuth.isDeeplyNestedAuthSupported', () => {
+  describe('canParentManageNAATrustedOrigins', () => {
     it('should throw if called before initialization', () => {
       utils.uninitializeRuntimeConfig();
-      expect(() => nestedAppAuth.isDeeplyNestedAuthSupported()).toThrowError(new Error(errorLibraryNotInitialized));
+      expect(() => nestedAppAuth.canParentManageNAATrustedOrigins()).toThrowError(
+        new Error(errorLibraryNotInitialized),
+      );
     });
 
-    it('should return true if isDeeplyNestedAuthSupported set to true in runtime object', async () => {
+    it('should return true if canParentManageNAATrustedOrigins set to true in runtime object', async () => {
       await utils.initializeWithContext(FrameContexts.content);
       const runtimeConfig: Runtime = {
         apiVersion: 4,
         supports: {},
-        isNAAChannelRecommended: true,
-        isDeeplyNestedAuthSupported: true,
+        canParentManageNAATrustedOrigins: true,
       };
       utils.setRuntimeConfig(runtimeConfig);
-      expect(nestedAppAuth.isDeeplyNestedAuthSupported()).toBeTruthy();
+      expect(nestedAppAuth.canParentManageNAATrustedOrigins()).toBeTruthy();
     });
 
-    it('should return false if isDeeplyNestedAuthSupported set to false in runtime object ', async () => {
+    it('should return false if canParentManageNAATrustedOrigins set to false in runtime object ', async () => {
       await utils.initializeWithContext(FrameContexts.content);
       const runtimeConfig: Runtime = {
         apiVersion: 4,
         supports: {},
-        isNAAChannelRecommended: false,
+        canParentManageNAATrustedOrigins: false,
       };
       utils.setRuntimeConfig(runtimeConfig);
-      expect(nestedAppAuth.isDeeplyNestedAuthSupported()).toBeFalsy();
+      expect(nestedAppAuth.canParentManageNAATrustedOrigins()).toBeFalsy();
     });
 
-    it('should return false if isDeeplyNestedAuthSupported not present in runtime object ', async () => {
+    it('should return false if canParentManageNAATrustedOrigins not present in runtime object ', async () => {
       await utils.initializeWithContext(FrameContexts.content);
       const runtimeConfig: Runtime = {
         apiVersion: 4,
         supports: {},
-        isNAAChannelRecommended: true,
       };
       utils.setRuntimeConfig(runtimeConfig);
-      expect(nestedAppAuth.isDeeplyNestedAuthSupported()).toBeFalsy();
+      expect(nestedAppAuth.canParentManageNAATrustedOrigins()).toBeFalsy();
     });
   });
   describe('getParentOrigin', () => {