@equinor/fusion-framework-module-msal 11.0.0 → 11.0.1

package/src/v2/MsalProvider.interface.ts

@@ -1,102 +0,0 @@
-import type { SemVer } from 'semver';
-import type { MsalModuleVersion } from '../static';
-import type { AccountInfo, AuthenticationResult } from './types';
-import type { IAuthClient } from './IAuthClient.interface';
-
-/**
- * Interface for MSAL v2 compatible authentication provider.
- *
- * This interface defines the contract for authentication providers that maintain
- * backward compatibility with MSAL v2 API while using MSAL v4 implementation
- * under the hood. Used by the v2 proxy layer during gradual migration scenarios.
- *
- * @example
- * ```typescript
- * // Obtain a v2 proxy from the current provider
- * const v2Provider: IMsalProvider = provider.createProxyProvider('2.0.0');
- *
- * // Use v2-style API
- * await v2Provider.login();
- * const token = await v2Provider.acquireAccessToken({ scopes: ['User.Read'] });
- * ```
- */
-export interface IMsalProvider {
-  /** Current version of the provider (MSAL module version) */
-  version: string | SemVer;
-
-  /** Current MSAL module version */
-  msalVersion: MsalModuleVersion;
-
-  /**
-   * The MSAL PublicClientApplication instance (v2 compatible)
-   */
-  readonly client: IAuthClient;
-
-  /**
-   * The current authenticated account (v2 compatibility)
-   * @deprecated Use activeAccount instead
-   */
-  readonly defaultAccount: AccountInfo | undefined;
-
-  /**
-   * The client configuration used to initialize this provider
-   * @deprecated Configuration should not be exposed
-   */
-  readonly defaultConfig: unknown | undefined;
-
-  /**
-   * The MSAL client instance (v2 compatibility)
-   * @deprecated Use client instead
-   */
-  readonly defaultClient: IAuthClient;
-
-  /**
-   * Create a new MSAL client instance
-   * @deprecated This method is deprecated in MSAL v4
-   */
-  createClient(): IAuthClient;
-
-  /**
-   * Acquire an access token for the specified scopes
-   * @param req - Auth request options (v2 compatible)
-   */
-  acquireAccessToken(req: { scopes: string[]; account?: AccountInfo }): Promise<string | undefined>;
-
-  /**
-   * Acquire full authentication result
-   * @param req - Auth request options (v2 compatible)
-   */
-  acquireToken(req: {
-    scopes: string[];
-    account?: AccountInfo;
-  }): Promise<AuthenticationResult | undefined>;
-
-  /**
-   * Login user interactively
-   * @param options - Login options (v2 compatible)
-   */
-  login(options?: { onlyIfRequired?: boolean }): Promise<void>;
-
-  /**
-   * Logout user
-   * @param options - Logout options (v2 compatible)
-   */
-  logout(options?: { redirectUri?: string }): Promise<void>;
-
-  /**
-   * Handle authentication redirect
-   */
-  handleRedirect(): Promise<undefined | null>;
-
-  /**
-   * Create a proxy provider for version compatibility
-   * @param version - Version string
-   * @returns Proxy provider
-   */
-  createProxyProvider<T = IMsalProvider>(version: string): T;
-
-  /**
-   * Dispose of the provider and clean up resources
-   */
-  dispose(): void;
-}

package/src/v2/create-proxy-client.ts

@@ -1,195 +0,0 @@
-import type { IMsalClient } from '../MsalClient.interface';
-import type { IAuthClient } from './IAuthClient.interface';
-import { mapAccountInfo } from './map-account-info';
-import { mapAuthenticationResult } from './map-authentication-result';
-import type { AccountInfo } from './types';
-
-/**
- * Creates a v2-compatible proxy wrapper around an MSAL v4 client.
- *
- * The proxy intercepts property access on the v4 `IMsalClient` and adapts method
- * signatures, return types, and account data to match the v2 `IAuthClient` interface.
- * This allows consumer code written against MSAL v2 to continue working unchanged
- * while the underlying implementation uses MSAL v4/v5.
- *
- * @param client - The MSAL v4 `IMsalClient` instance to wrap
- * @returns A proxy implementing the v2-compatible `IAuthClient` interface
- *
- * @example
- * ```typescript
- * const v4Client = new MsalClient(config);
- * const v2Client = createProxyClient(v4Client);
- *
- * // Use v2-compatible methods
- * const accounts = v2Client.getAllAccounts();
- * const result = await v2Client.acquireTokenSilent({ scopes: ['User.Read'], account });
- * ```
- */
-export function createProxyClient(client: IMsalClient): IAuthClient {
-  const proxy = new Proxy(client, {
-    get: (target: IMsalClient, prop: keyof IAuthClient) => {
-      // Adapt each v4 client member to the v2-compatible shape expected by callers
-      switch (prop) {
-        case 'getAllAccounts': {
-          return () => {
-            // Map each v4 account shape to its v2-compatible equivalent
-            return target.getAllAccounts().map(mapAccountInfo);
-          };
-        }
-
-        case 'acquireTokenSilent': {
-          return async (request: { scopes: string[]; account: AccountInfo }) => {
-            const result = await target.acquireTokenSilent({
-              scopes: request.scopes,
-              account: request.account, // AccountInfo is compatible between v2/v4
-            });
-
-            return mapAuthenticationResult(result);
-          };
-        }
-
-        case 'loginPopup': {
-          return async (request?: { scopes?: string[] }) => {
-            const result = await target.loginPopup({
-              scopes: request?.scopes || [],
-            });
-
-            return mapAuthenticationResult(result);
-          };
-        }
-
-        case 'logoutRedirect': {
-          return async (request?: { postLogoutRedirectUri?: string; account?: AccountInfo }) => {
-            await target.logoutRedirect({
-              postLogoutRedirectUri: request?.postLogoutRedirectUri,
-              account: request?.account,
-            });
-          };
-        }
-
-        case 'handleRedirectPromise': {
-          return async () => {
-            const result = await target.handleRedirectPromise();
-
-            // No redirect result means there's nothing pending to map
-            if (!result) {
-              return null;
-            }
-
-            return mapAuthenticationResult(result);
-          };
-        }
-
-        case 'getActiveAccount': {
-          return () => {
-            const account = target.getActiveAccount();
-            // No active account means there's nothing to map
-            if (!account) {
-              return null;
-            }
-
-            return mapAccountInfo(account);
-          };
-        }
-
-        case 'tenantId': {
-          return target.tenantId;
-        }
-
-        case 'account': {
-          const account = target.getActiveAccount();
-          return account ? mapAccountInfo(account) : undefined;
-        }
-
-        case 'hasValidClaims': {
-          return target.hasValidClaims;
-        }
-
-        case 'clientId': {
-          return target.getConfiguration().auth.clientId;
-        }
-
-        case 'requestOrigin': {
-          return target.getConfiguration().auth.redirectUri;
-        }
-
-        case 'login': {
-          return async (
-            options?: { scopes?: string[]; loginHint?: string },
-            behavior?: 'popup' | 'redirect',
-            silent?: boolean,
-          ) => {
-            return await target.login({
-              request: {
-                scopes: options?.scopes || [],
-                loginHint: options?.loginHint,
-              },
-              behavior: behavior,
-              silent: silent,
-            });
-          };
-        }
-
-        case 'acquireToken': {
-          return async (
-            options?: { scopes?: string[]; loginHint?: string },
-            behavior?: 'popup' | 'redirect',
-            silent?: boolean,
-          ) => {
-            return await target.acquireToken({
-              request: {
-                scopes: options?.scopes || [],
-                account: target.getActiveAccount() ?? undefined,
-                loginHint: options?.loginHint,
-              },
-              behavior: behavior,
-              silent: silent,
-            });
-          };
-        }
-
-        case 'initialize':
-        case 'acquireTokenPopup':
-        case 'acquireTokenRedirect':
-        case 'acquireTokenByCode':
-        case 'addEventCallback':
-        case 'removeEventCallback':
-        case 'addPerformanceCallback':
-        case 'removePerformanceCallback':
-        case 'enableAccountStorageEvents':
-        case 'disableAccountStorageEvents':
-        case 'getConfiguration':
-        case 'setActiveAccount':
-        case 'getAccountByHomeId':
-        case 'getAccountByLocalId':
-        case 'getAccountByUsername':
-        case 'loginRedirect':
-        case 'logout':
-        case 'logoutPopup':
-        case 'ssoSilent':
-        case 'getTokenCache':
-        case 'setLogger':
-        case 'getLogger':
-        case 'initializeWrapperLibrary':
-        case 'setNavigationClient':
-        case 'hydrateCache':
-        case 'clearCache': {
-          // Cast through unknown to access properties that may exist on MSAL v4 but aren't in the type definition
-          // or to handle v2-specific methods like clearCache that exist at runtime
-          return (target as unknown as Record<string, unknown>)[prop];
-        }
-
-        default: {
-          // TypeScript-only guard to catch missing properties at compile time
-          const _exhaustiveCheck: never = prop;
-          // For any other properties, return the original value
-          return (target as unknown as IAuthClient)[_exhaustiveCheck];
-        }
-      }
-    },
-  });
-
-  // The Proxy handler above implements every member of `IAuthClient` at runtime via its `get`
-  // trap, but TypeScript can't verify a `Proxy<T>` satisfies `T` structurally.
-  return proxy as unknown as IAuthClient;
-}

package/src/v2/create-proxy-provider.ts

@@ -1,177 +0,0 @@
-import type { IMsalProvider } from '../MsalProvider.interface';
-import type { IMsalProvider as IMsalProvider_v2 } from './MsalProvider.interface';
-import type { AccountInfo as AccountInfo_v2 } from './types';
-import type { AcquireTokenOptions } from '../MsalClient.interface';
-import { createProxyClient } from './create-proxy-client';
-import { mapAccountInfo } from './map-account-info';
-import { MsalModuleVersion } from '../static';
-
-/**
- * Checks if a request is in MSAL v4 format.
- *
- * @param req - The request object to check
- * @returns True if the request is in v4 format (has a `request` property with `scopes` and `account`)
- */
-function isRequestV4(req: unknown): req is AcquireTokenOptions {
-  // Non-object/null values can never match the v4 request shape
-  if (typeof req !== 'object' || req === null) {
-    return false;
-  }
-  const requestV4 = req as AcquireTokenOptions;
-  return 'request' in requestV4;
-}
-
-/**
- * Creates a proxy provider for MSAL v2 compatibility.
- *
- * This function creates a Proxy that wraps the MSAL v4 provider and provides
- * v2-compatible method signatures and return types while using the latest
- * MSAL v4 implementation under the hood. The proxy handles type conversions
- * and method adaptations to maintain backward compatibility.
- *
- * @param provider - The base MSAL v4 provider instance to wrap
- * @returns A proxy provider implementing the v2-compatible interface
- *
- * @example
- * ```typescript
- * const baseProvider = new MsalProvider(config);
- * const v2Proxy = createProxyProvider(baseProvider);
- *
- * // Use v2-compatible API
- * await v2Proxy.login();
- * const token = await v2Proxy.acquireAccessToken({ scopes: ['User.Read'] });
- * ```
- */
-export function createProxyProvider(provider: IMsalProvider): IMsalProvider_v2 {
-  // Create a v2-compatible client wrapper using the new client proxy
-  const v2Client = createProxyClient(provider.client);
-
-  // Use Proxy to intercept property access and provide v2-compatible implementations
-  const proxy = new Proxy(provider, {
-    get: (target: IMsalProvider, prop: keyof IMsalProvider_v2) => {
-      // Adapt each v4 provider member to the v2-compatible shape expected by callers
-      switch (prop) {
-        case 'version': {
-          return provider.version;
-        }
-        case 'msalVersion': {
-          return MsalModuleVersion.V2;
-        }
-        case 'client': {
-          // Return the v2-compatible client wrapper
-          return v2Client as unknown as IMsalProvider_v2['client'];
-        }
-        case 'defaultClient': {
-          // Deprecated property - redirect to client with warning
-          console.warn('defaultClient is deprecated, use client instead');
-          // Same v2-compatible client wrapper as the `client` case above.
-          return v2Client as unknown as IMsalProvider_v2['defaultClient'];
-        }
-        case 'defaultAccount': {
-          // Map v4 account to v2 format for backward compatibility
-          const account = target.account;
-          const defaultAccount: IMsalProvider_v2['defaultAccount'] = account
-            ? mapAccountInfo(account)
-            : undefined;
-          return defaultAccount;
-        }
-        case 'defaultConfig': {
-          // Deprecated property - not available in v4
-          console.warn('defaultConfig is deprecated and not available in v4');
-          return undefined;
-        }
-        case 'createClient': {
-          // Deprecated method - return function that returns v2 client
-          console.warn('createClient is deprecated in MSAL v4');
-          const createClient: IMsalProvider_v2['createClient'] = () => v2Client;
-          return createClient;
-        }
-        case 'acquireToken': {
-          // Adapt v4 acquireToken to v2 signature with proper type mapping
-          const acquireToken: IMsalProvider_v2['acquireToken'] = async (req: {
-            scopes: string[];
-            account?: AccountInfo_v2;
-          }) => {
-            const args = isRequestV4(req)
-              ? req
-              : { request: { scopes: req.scopes, account: req.account } };
-            const result = await target.acquireToken(args);
-
-            // Convert null to undefined for v2 compatibility
-            return result || undefined;
-          };
-          return acquireToken;
-        }
-        case 'acquireAccessToken': {
-          // Adapt v4 acquireAccessToken to v2 signature
-          const acquireAccessToken: IMsalProvider_v2['acquireAccessToken'] = async (req: {
-            scopes: string[];
-            account?: AccountInfo_v2;
-          }) => {
-            const args = isRequestV4(req)
-              ? req
-              : { request: { scopes: req.scopes, account: req.account } };
-            return await target.acquireAccessToken(args);
-          };
-          return acquireAccessToken;
-        }
-        case 'login': {
-          // Adapt v4 login to v2 signature with optional parameters
-          const login: IMsalProvider_v2['login'] = async (options?: {
-            onlyIfRequired?: boolean;
-          }) => {
-            // Skip login if already authenticated and onlyIfRequired is true
-            if (options?.onlyIfRequired && target.account) {
-              return;
-            }
-            // Call v4 login with empty scopes (v2 behavior)
-            await target.login({ request: { scopes: [] } });
-          };
-          return login;
-        }
-        case 'logout': {
-          // Adapt v4 logout to v2 signature
-          const logout: IMsalProvider_v2['logout'] = async (options?: { redirectUri?: string }) => {
-            await target.logout({ redirectUri: options?.redirectUri });
-          };
-          return logout;
-        }
-        case 'handleRedirect': {
-          // Adapt v4 handleRedirect to v2 signature
-          const handleRedirect: IMsalProvider_v2['handleRedirect'] = async () => {
-            await target.handleRedirect();
-            // v2 expects null after redirect handling
-            return null;
-          };
-          return handleRedirect;
-        }
-        case 'createProxyProvider': {
-          // Generic method to create proxy providers for different versions
-          const createProxyProvider: IMsalProvider_v2['createProxyProvider'] = <T = IMsalProvider>(
-            version: string,
-          ) => target.createProxyProvider(version as MsalModuleVersion) as T;
-          return createProxyProvider;
-        }
-        case 'dispose': {
-          // No-op dispose method for v2 compatibility
-          return () => {
-            /** noop */
-          };
-        }
-        default: {
-          // The proxy is awaited in some contexts, so `then` must resolve to undefined
-          if (prop === 'then') {
-            return undefined;
-          }
-          // Exhaustive check to ensure all v2 properties are handled
-          const exhaustiveCheck: never = prop;
-          // Fallback: return original property from target for any unhandled cases
-          return (target as IMsalProvider)[exhaustiveCheck];
-        }
-      }
-    },
-  });
-
-  // Return the proxy cast to v2 interface for type safety
-  return proxy as unknown as IMsalProvider_v2;
-}

package/src/v2/map-account-info.ts

@@ -1,23 +0,0 @@
-import type { AccountInfo } from '@azure/msal-browser';
-import type { AccountInfo as AccountInfo_v2 } from './types';
-
-/**
- * Maps a current (v4/v5) `AccountInfo` object to the v2-compatible `AccountInfo` format.
- *
- * Strips properties that don't exist in v2, ensuring backward-compatible serialization
- * and type safety when passing account data through the v2 proxy layer.
- *
- * @param account - The current MSAL v4/v5 `AccountInfo` to convert
- * @returns A v2-compatible `AccountInfo` containing only fields recognised by MSAL v2 consumers
- */
-export function mapAccountInfo(account: AccountInfo): AccountInfo_v2 {
-  return {
-    homeAccountId: account.homeAccountId,
-    environment: account.environment,
-    tenantId: account.tenantId,
-    username: account.username,
-    localAccountId: account.localAccountId,
-    name: account.name,
-    idTokenClaims: account.idTokenClaims,
-  };
-}

package/src/v2/map-authentication-result.ts

@@ -1,28 +0,0 @@
-import type { AuthenticationResult } from '@azure/msal-browser';
-import type { AuthenticationResult as AuthenticationResult_v2 } from './types';
-import { mapAccountInfo } from './map-account-info';
-
-/**
- * Maps a current (v4/v5) `AuthenticationResult` to the v2-compatible format.
- *
- * Converts the full authentication result — including the nested account object —
- * to the subset of fields that MSAL v2 consumers expect. This enables the v2 proxy
- * layer to return type-safe results without exposing v4/v5-only properties.
- *
- * @param result - The current MSAL v4/v5 `AuthenticationResult` to convert
- * @returns A v2-compatible `AuthenticationResult` with mapped account and token fields
- */
-export function mapAuthenticationResult(result: AuthenticationResult): AuthenticationResult_v2 {
-  return {
-    authority: result.authority,
-    uniqueId: result.uniqueId,
-    tenantId: result.tenantId,
-    scopes: result.scopes,
-    account: result.account ? mapAccountInfo(result.account) : null,
-    idToken: result.idToken,
-    idTokenClaims: result.idTokenClaims,
-    accessToken: result.accessToken,
-    expiresOn: result.expiresOn,
-    tokenType: result.tokenType,
-  } as AuthenticationResult_v2;
-}