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

package/src/__tests__/versioning/resolve-version.test.ts

@@ -1,161 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { SemVer } from 'semver';
-
-// Mock the version first (hoisted)
-vi.mock('../../version', () => ({
-  version: '6.1.2-next.0+1493919587',
-}));
-
-import { resolveVersion } from '../../versioning/resolve-version';
-import { MsalModuleVersion } from '../../static';
-
-describe('resolveVersion', () => {
-  describe('successful version resolution', () => {
-    it('should resolve a valid version string', () => {
-      const result = resolveVersion('2.1.0');
-
-      expect(result).toMatchObject({
-        wantedVersion: expect.any(SemVer),
-        latestVersion: expect.any(SemVer),
-        isLatest: false,
-        satisfiesLatest: false, // 2.x is not compatible with 5.x
-        enumVersion: MsalModuleVersion.V2,
-      });
-
-      expect(result.wantedVersion.version).toBe('2.1.0');
-      expect(result.latestVersion.version).toBe('6.1.2');
-    });
-
-    it('should resolve with SemVer object', () => {
-      const semver = new SemVer('2.0.0');
-      const result = resolveVersion(semver);
-
-      expect(result.wantedVersion).toBe(semver);
-      expect(result.satisfiesLatest).toBe(false); // 2.x is not compatible with 5.x
-    });
-
-    it('should resolve latest version when no version provided', () => {
-      const result = resolveVersion();
-
-      expect(result.wantedVersion.version).toBe('6.1.2');
-      expect(result.latestVersion.version).toBe('6.1.2');
-      expect(result.isLatest).toBe(true);
-      expect(result.satisfiesLatest).toBe(true);
-    });
-
-    it('should resolve latest version when empty string provided', () => {
-      const result = resolveVersion('');
-
-      expect(result.wantedVersion.version).toBe('6.1.2');
-      expect(result.isLatest).toBe(true);
-    });
-
-    it('should find correct enum version for major version', () => {
-      const result = resolveVersion('2.5.0');
-
-      expect(result.enumVersion).toBe(MsalModuleVersion.V2);
-      expect(result.satisfiesLatest).toBe(false); // 2.x is not compatible with 5.x
-    });
-  });
-
-  describe('version comparison and warnings', () => {
-    it('should identify version states correctly', () => {
-      // Exact latest version
-      expect(resolveVersion('6.1.2-next.0+1493919587').isLatest).toBe(true);
-
-      // Patch difference (satisfies but not latest)
-      const patchResult = resolveVersion('6.1.1');
-      expect(patchResult.isLatest).toBe(false);
-      expect(patchResult.satisfiesLatest).toBe(true);
-      expect(patchResult.warnings).toBeUndefined();
-
-      // Minor difference (satisfies)
-      const minorResult = resolveVersion('6.0.0');
-      expect(minorResult.isLatest).toBe(false);
-      expect(minorResult.satisfiesLatest).toBe(true);
-
-      // Major difference (doesn't satisfy)
-      const majorResult = resolveVersion('7.0.0');
-      expect(majorResult.satisfiesLatest).toBe(false);
-    });
-
-    it('should handle versions without matching enum with warnings', () => {
-      // Lower major version - should map to V2
-      const lowerResult = resolveVersion('3.0.0');
-      expect(lowerResult.enumVersion).toBe(MsalModuleVersion.V2);
-      expect(lowerResult.warnings).toBeDefined();
-      expect(lowerResult.warnings?.[0]).toContain(
-        'Requested major version 3 is behind the latest major version 6',
-      );
-
-      // Zero version - should map to V2
-      const zeroResult = resolveVersion('0.0.0');
-      expect(zeroResult.enumVersion).toBe(MsalModuleVersion.V2);
-      expect(zeroResult.warnings).toBeDefined();
-      expect(zeroResult.warnings?.[0]).toContain(
-        'Requested major version 0 is behind the latest major version 6',
-      );
-    });
-  });
-
-  describe('error handling', () => {
-    it('should handle invalid version strings gracefully', () => {
-      const invalidVersions = ['invalid-version', 'not-a-version', 'invalid', 'bad.version'];
-
-      invalidVersions.forEach((invalidVersion) => {
-        const result = resolveVersion(invalidVersion);
-        expect(result.warnings).toBeDefined();
-        expect(result.warnings).toHaveLength(1);
-        expect(result.warnings?.[0]).toContain(
-          `Failed to parse requested version "${invalidVersion}"`,
-        );
-        // Should fall back to latest version (coerced)
-        expect(result.wantedVersion.version).toBe('6.1.2');
-      });
-    });
-
-    it('should handle malformed but coercible versions', () => {
-      // semver.coerce handles these gracefully
-      expect(() => resolveVersion('2.')).not.toThrow();
-      expect(() => resolveVersion('4')).not.toThrow();
-    });
-  });
-
-  describe('edge cases', () => {
-    it('should handle complex version strings with pre-release and build metadata', () => {
-      const testCases = [
-        { input: '6.1.2-next.0+1493919587-beta.1', expected: '6.1.2' },
-        { input: '6.1.2-next.0+1493919587+build.123', expected: '6.1.2' },
-        { input: '6.1.2-next.0+1493919587-beta.1.alpha.2+build.123.456', expected: '6.1.2' },
-      ];
-
-      testCases.forEach(({ input, expected }) => {
-        const result = resolveVersion(input);
-        expect(result.satisfiesLatest).toBe(true);
-        expect(result.wantedVersion.version).toBe(expected);
-      });
-    });
-
-    it('should return consistent structure across calls', () => {
-      const result1 = resolveVersion('2.0.0');
-      const result2 = resolveVersion('4.0.0');
-
-      // Latest version should be consistent
-      expect(result1.latestVersion.version).toBe(result2.latestVersion.version);
-      expect(result1.latestVersion.version).toBe('6.1.2');
-
-      // Structure should be consistent
-      expect(result1).toHaveProperty('wantedVersion');
-      expect(result1).toHaveProperty('latestVersion');
-      expect(result1).toHaveProperty('isLatest');
-      expect(result1).toHaveProperty('satisfiesLatest');
-      expect(result1).toHaveProperty('enumVersion');
-
-      expect(result1.wantedVersion).toBeInstanceOf(SemVer);
-      expect(result1.latestVersion).toBeInstanceOf(SemVer);
-      expect(typeof result1.isLatest).toBe('boolean');
-      expect(typeof result1.satisfiesLatest).toBe('boolean');
-      expect(typeof result1.enumVersion).toBe('string');
-    });
-  });
-});

package/src/create-client-log-callback.ts

@@ -1,102 +0,0 @@
-import { type ILoggerCallback, LogLevel } from '@azure/msal-browser';
-import {
-  type ITelemetryProvider,
-  TelemetryLevel,
-} from '@equinor/fusion-framework-module-telemetry';
-
-/**
- * Maps MSAL log levels to corresponding telemetry levels.
- *
- * This mapping ensures consistent log level translation between MSAL's logging
- * system and the framework's telemetry system.
- */
-const levelMap: Partial<Record<LogLevel, TelemetryLevel>> = {
-  [LogLevel.Verbose]: TelemetryLevel.Debug,
-  [LogLevel.Info]: TelemetryLevel.Information,
-  [LogLevel.Warning]: TelemetryLevel.Warning,
-  [LogLevel.Error]: TelemetryLevel.Error,
-};
-
-/**
- * Parses MSAL log message into structured components.
- *
- * MSAL log messages follow the format:
- * [timestamp] : [correlationId] : [package] : [level] - [component] - [message]
- *
- * @param message - Raw MSAL log message
- * @returns Parsed message components
- */
-const parseMsalMessage = (message: string) => {
-  // Match the structured format: [timestamp] : [correlationId] : [package] : [level] - [component] - [message]
-  const match = message.match(
-    /^\[([^\]]+)\]\s*:\s*\[([^\]]*)\]\s*:\s*([^:]+)\s*:\s*(\w+)\s*-\s*([^-]+)\s*-\s*(.*)$/,
-  );
-
-  // A structured match means we can extract package/component/message parts
-  if (match) {
-    const [, _timestamp, _correlationId, packageInfo, _logLevel, component, logMessage] = match;
-    return {
-      package: packageInfo.trim() ?? undefined,
-      component: component.trim() ?? undefined,
-      message: logMessage.trim() ?? undefined,
-    };
-  }
-
-  // Fallback for non-structured messages
-  return { message: message.trim() };
-};
-
-/**
- * Creates a telemetry callback function for MSAL logging integration.
- *
- * This function bridges MSAL's internal logging system with the framework's
- * telemetry infrastructure. It maps MSAL log levels to telemetry levels and
- * forwards log events to the provided telemetry provider with structured metadata.
- *
- * The callback function returned by this method will be called by MSAL whenever
- * a log event occurs, allowing for centralized logging and monitoring of
- * authentication-related events.
- *
- * @param provider - Telemetry provider instance to receive log events
- * @param metadata - Additional metadata to include with each telemetry event (e.g., module version, environment)
- * @param scope - Telemetry scope identifiers for categorization and filtering
- * @returns Logger callback function for MSAL that forwards events to telemetry provider
- *
- * @example
- * ```typescript
- * const callback = createClientLogCallback(
- *   telemetryProvider,
- *   { module: 'msal', version: '4.0.0' },
- *   ['framework', 'authentication']
- * );
- *
- * // Use with MSAL configuration
- * const config = {
- *   system: {
- *     loggerOptions: {
- *       loggerCallback: callback,
- *       piiLoggingEnabled: false
- *     }
- *   }
- * };
- * ```
- */
-export const createClientLogCallback = (
-  provider: ITelemetryProvider,
-  metadata: Record<string, unknown>,
-  scope: string[],
-): ILoggerCallback | undefined => {
-  return (level: LogLevel, message: string, _containsPii: boolean) => {
-    const parsedMessage = parseMsalMessage(message);
-
-    provider.trackEvent({
-      name: 'MsalClient',
-      level: levelMap[level] ?? TelemetryLevel.Information,
-      scope,
-      metadata,
-      properties: {
-        ...parsedMessage,
-      },
-    });
-  };
-};

package/src/create-proxy-provider.ts

@@ -1,97 +0,0 @@
-import type { IMsalProvider } from './MsalProvider.interface';
-import { MsalModuleVersion } from './static';
-import { resolveVersion } from './versioning/resolve-version';
-import { createProxyProvider as createProxyProvider_v2 } from './v2/create-proxy-provider';
-import { createProxyProvider as createProxyProvider_v4 } from './v4/create-proxy-provider';
-
-/**
- * Creates a proxy provider for version compatibility.
- *
- * This function handles the creation of proxy providers that maintain
- * backward compatibility with different MSAL versions while using the
- * latest MSAL v4 implementation under the hood.
- *
- * @param provider - The base MSAL provider instance
- * @param version - The target version string (e.g., '2.0.0', '4.0.0')
- * @returns A proxy provider compatible with the specified version
- *
- * @template T - The provider interface type expected by the target version.
- * @throws {Error} If the resolved version is not supported.
- *
- * @example
- * ```typescript
- * const baseProvider = new MsalProvider(config);
- * const v2Proxy = createProxyProvider(baseProvider, '2.0.0');
- * ```
- */
-export function createProxyProvider<T = IMsalProvider>(
-  provider: IMsalProvider,
-  version: string,
-): T {
-  // Resolve the requested version to determine which proxy to create
-  const { enumVersion } = resolveVersion(version);
-
-  // Build the version-appropriate proxy based on the resolved MSAL module version
-  switch (enumVersion) {
-    case MsalModuleVersion.V2:
-      // Create v2-compatible proxy with legacy API adapters
-      return createProxyProvider_v2(provider) as T;
-    case MsalModuleVersion.V4:
-      // Create v4-compatible proxy (passthrough with v4 version metadata)
-      return createProxyProvider_v4(provider) as T;
-    case MsalModuleVersion.V5:
-      // Create transparent proxy for v5 - passes through to original provider
-      return new Proxy(provider, {
-        get: (target: IMsalProvider, prop: keyof IMsalProvider) => {
-          // Delegate every known property/method to the underlying provider
-          switch (prop) {
-            case 'version': {
-              return target.version;
-            }
-            case 'msalVersion': {
-              return enumVersion;
-            }
-            case 'client': {
-              return target.client;
-            }
-            case 'account': {
-              return target.account;
-            }
-            case 'acquireAccessToken': {
-              return target.acquireAccessToken.bind(target);
-            }
-            case 'acquireToken': {
-              return target.acquireToken.bind(target);
-            }
-            case 'login': {
-              return target.login.bind(target);
-            }
-            case 'logout': {
-              return target.logout.bind(target);
-            }
-            case 'handleRedirect': {
-              return target.handleRedirect.bind(target);
-            }
-            case 'createProxyProvider': {
-              return target.createProxyProvider.bind(target);
-            }
-            case 'initialize': {
-              return () => {
-                // noop - initialize is handled by the provider, not the proxy
-              };
-            }
-            default: {
-              // backstop to prevent then from being called - this is not an async operation
-              if (prop === 'then') return undefined;
-
-              // Exhaustive check: TypeScript-only guard to ensure all IMsalProvider keys are handled
-              const exhausted: never = prop;
-              return (target as IMsalProvider)[exhausted];
-            }
-          }
-        },
-      }) as T;
-    default:
-      throw new Error(`Version ${version} is not supported`);
-  }
-}

package/src/index.ts

@@ -1,48 +0,0 @@
-/**
- * @packageDocumentation
- *
- * MSAL authentication module for Fusion Framework.
- *
- * Provides Microsoft Authentication Library (MSAL) integration with support for:
- * - Azure AD / Entra ID authentication (SSO, popup, redirect)
- * - Automatic token management with silent refresh
- * - Module hoisting for shared auth state across application scopes
- * - Backward-compatible v2 proxy layer alongside native MSAL v4/v5 API
- * - Backend-issued SPA authorization code exchange
- *
- * @example
- * ```typescript
- * import { enableMSAL } from '@equinor/fusion-framework-module-msal';
- *
- * enableMSAL(configurator, (builder) => {
- *   builder.setClientConfig({
- *     auth: { clientId: 'your-client-id', tenantId: 'your-tenant-id' },
- *   });
- *   builder.setRequiresAuth(true);
- * });
- * ```
- *
- * @module @equinor/fusion-framework-module-msal
- */
-
-export {
-  module,
-  configureMsal,
-  enableMSAL,
-  type MsalModule,
-  type AuthConfigFn,
-} from './module';
-
-export type { IMsalProvider } from './MsalProvider.interface';
-export type { IMsalClient } from './MsalClient.interface';
-export { MsalClient, type MsalClientConfig } from './MsalClient';
-
-/**
- * Required to implement {@link IMsalProvider}, whose `msalVersion` member is
- * typed as this enum.
- */
-export { MsalModuleVersion } from './static';
-
-export type { AccountInfo, AuthenticationResult } from './types';
-
-export { default } from './module';