@equinor/fusion-framework-module-msal 5.0.0 → 5.1.0

package/dist/types/static.d.ts

@@ -1,5 +1,5 @@
 export declare const ModuleName: "msal";
 export declare enum MsalModuleVersion {
     V2 = "v2",
-    Latest = "5.0.0"
+    Latest = "5.1.0"
 }

package/dist/types/v2/provider.d.ts

@@ -9,6 +9,7 @@ export interface IAuthProvider {
      */
     readonly defaultConfig: any | undefined;
     readonly defaultAccount: AccountInfo | undefined;
+    readonly client: AuthClient;
     /**
      * Acquire token from default auth client
      * @param req Auth request options
@@ -38,14 +39,11 @@ export declare class AuthProvider implements IAuthProvider, IProxyProvider {
     #private;
     protected _config: AuthClientConfig;
     get version(): SemanticVersion;
-    /** @deprecated */
-    get defaultClient(): AuthClient;
     get defaultAccount(): AccountInfo | undefined;
     /** @deprecated */
     get defaultConfig(): AuthClientConfig | undefined;
     constructor(_config: AuthClientConfig);
-    /** @deprecated */
-    getClient(): AuthClient;
+    get client(): AuthClient;
     /** @deprecated */
     createClient(): AuthClient;
     handleRedirect(): Promise<null>;

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.0.0";
+export declare const version = "5.1.0";

package/dist/types/versioning/VersionError.d.ts

@@ -1,20 +1,4 @@
-import { VersionMessageType } from './static';
 import type { SemVer } from 'semver';
-/**
- * Creates a VersionError instance with a formatted message.
- *
- * This is a helper function that creates a VersionError with a human-readable
- * message based on the error type and version information.
- *
- * @param type - The type of version error
- * @param requestedVersion - The version that was requested
- * @param latestVersion - The latest available version
- * @param options - Additional error options including the error type
- * @returns A new VersionError instance with formatted message
- */
-declare const createVersionError: (type: VersionMessageType, requestedVersion: string | SemVer, latestVersion: string | SemVer, options?: ErrorOptions & {
-    type?: VersionMessageType;
-}) => VersionError;
 /**
  * Error class for version-related issues in the MSAL module.
  *
@@ -50,14 +34,8 @@ export declare class VersionError extends Error {
     readonly requestedVersion: string;
     /** The latest available version in the system */
     readonly latestVersion: string;
-    /** The specific type of version error that occurred */
-    readonly type?: VersionMessageType;
     /** The error name for instanceof checks */
     static Name: string;
-    /** Reference to the VersionMessageType enum for convenience */
-    static Type: typeof VersionMessageType;
-    /** Factory method for creating VersionError instances with formatted messages */
-    static create: typeof createVersionError;
     /**
      * Creates a new VersionError instance.
      *
@@ -66,8 +44,5 @@ export declare class VersionError extends Error {
      * @param latestVersion - The latest available version (will be stored as string)
      * @param options - Additional error options including the error type
      */
-    constructor(message: string, requestedVersion: string | SemVer, latestVersion: string | SemVer, options?: ErrorOptions & {
-        type?: VersionMessageType;
-    });
+    constructor(message: string, requestedVersion: string | SemVer, latestVersion: string | SemVer, options?: ErrorOptions);
 }
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/fusion-framework-module-msal",
-  "version": "5.0.0",
+  "version": "5.1.0",
   "description": "Microsoft Authentication Library (MSAL) integration module for Fusion Framework",
   "main": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",
@@ -40,7 +40,7 @@
     "@types/semver": "^7.5.0",
     "semver": "^7.5.4",
     "zod": "^4.1.8",
-    "@equinor/fusion-framework-module": "^5.0.1"
+    "@equinor/fusion-framework-module": "^5.0.3"
   },
   "devDependencies": {
     "typescript": "^5.8.2"

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

@@ -1,7 +1,6 @@
 import { describe, it, expect, vi } from 'vitest';
 import { SemVer } from 'semver';
 import { resolveVersion } from '../../versioning/resolve-version';
-import { VersionError } from '../../versioning/VersionError';
 
 // Mock the static module to avoid test failures when package version changes
 // This ensures tests remain stable regardless of package.json version bumps
@@ -16,14 +15,6 @@ vi.mock('../../static', () => ({
 import { MsalModuleVersion } from '../../static';
 
 describe('resolveVersion', () => {
-  describe('mock verification', () => {
-    it('should use mocked version for consistent testing', () => {
-      // Verify that our mock is working and we're using the fixed version
-      expect(MsalModuleVersion.Latest).toBe('4.0.9');
-      expect(MsalModuleVersion.V2).toBe('v2');
-    });
-  });
-
   describe('successful version resolution', () => {
     it('should resolve a valid version string', () => {
       const result = resolveVersion('2.1.0');
@@ -64,192 +55,120 @@ describe('resolveVersion', () => {
       expect(result.isLatest).toBe(true);
     });
 
-    it('should handle patch version differences without warnings', () => {
-      const result = resolveVersion('4.0.8');
-
-      expect(result.satisfiesLatest).toBe(true);
-      expect(result.isLatest).toBe(false);
-      expect(result.warnings).toBeUndefined();
-    });
-
-    it('should handle minor version differences with warnings', () => {
-      const result = resolveVersion('4.1.0');
-
-      expect(result.satisfiesLatest).toBe(true);
-      expect(result.isLatest).toBe(false);
-      expect(result.warnings).toBeDefined();
-      expect(result.warnings).toHaveLength(1);
-      expect(result.warnings?.[0]).toContain('Minor version mismatch');
-    });
-
     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 4.x
     });
+  });
 
-    it('should throw error when no matching major version exists in enum', () => {
-      // Version 3.0.0 should throw because there's no enum for major version 3
-      expect(() => resolveVersion('3.0.0')).toThrow(VersionError);
+  describe('version comparison and warnings', () => {
+    it('should identify version states correctly', () => {
+      // Exact latest version
+      expect(resolveVersion('4.0.9').isLatest).toBe(true);
+
+      // Patch difference (satisfies but not latest)
+      const patchResult = resolveVersion('4.0.8');
+      expect(patchResult.isLatest).toBe(false);
+      expect(patchResult.satisfiesLatest).toBe(true);
+      expect(patchResult.warnings).toBeUndefined();
+
+      // Minor difference (satisfies with warning)
+      const minorResult = resolveVersion('4.1.0');
+      expect(minorResult.isLatest).toBe(false);
+      expect(minorResult.satisfiesLatest).toBe(true);
+      expect(minorResult.warnings).toBeDefined();
+      expect(minorResult.warnings?.[0]).toContain(
+        'Requested minor version 1 is different from the latest minor version 0',
+      );
+
+      // Major difference (doesn't satisfy with warning)
+      const majorResult = resolveVersion('5.0.0');
+      expect(majorResult.satisfiesLatest).toBe(false);
+      expect(majorResult.warnings).toBeDefined();
+      expect(majorResult.warnings?.[0]).toContain(
+        'Requested major version 5 is greater than the latest major version 4',
+      );
+    });
+
+    it('should handle versions without matching enum with warnings', () => {
+      // Lower major version
+      const lowerResult = resolveVersion('3.0.0');
+      expect(lowerResult.enumVersion).toBe('4.0.9'); // Falls back to latest
+      expect(lowerResult.warnings).toBeDefined();
+      expect(lowerResult.warnings?.[0]).toContain(
+        'Requested major version 3 is behind the latest major version 4',
+      );
+
+      // Zero version
+      const zeroResult = resolveVersion('0.0.0');
+      expect(zeroResult.enumVersion).toBe('4.0.9'); // Falls back to latest
+      expect(zeroResult.warnings).toBeDefined();
+      expect(zeroResult.warnings?.[0]).toContain(
+        'Requested major version 0 is behind the latest major version 4',
+      );
     });
   });
 
   describe('error handling', () => {
-    it('should throw VersionError for invalid version string', () => {
-      expect(() => resolveVersion('invalid-version')).toThrow(VersionError);
+    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
+        expect(result.wantedVersion.version).toBe('4.0.9');
+      });
     });
 
-    it('should not throw for malformed version (coerce handles it)', () => {
-      // semver.coerce('2.') returns '2.0.0', so it doesn't throw
+    it('should handle malformed but coercible versions', () => {
+      // semver.coerce handles these gracefully
       expect(() => resolveVersion('2.')).not.toThrow();
-    });
-
-    it('should throw VersionError for non-semver string', () => {
-      expect(() => resolveVersion('not-a-version')).toThrow(VersionError);
-    });
-
-    it('should throw VersionError for major version incompatibility', () => {
-      expect(() => resolveVersion('5.0.0')).toThrow(VersionError);
-    });
-
-    it('should throw VersionError for very high major version', () => {
-      expect(() => resolveVersion('999.0.0')).toThrow(VersionError);
-    });
-
-    it('should include correct error type for major incompatibility', () => {
-      try {
-        resolveVersion('5.0.0');
-        expect.fail('Should have thrown VersionError');
-      } catch (error) {
-        expect(error).toBeInstanceOf(VersionError);
-        const versionError = error as VersionError;
-        expect(versionError.type).toBe('major-incompatibility');
-        expect(versionError.requestedVersion).toBe('5.0.0');
-        expect(versionError.latestVersion).toBe('4.0.9');
-      }
-    });
-
-    it('should include correct error type for invalid version', () => {
-      try {
-        resolveVersion('invalid');
-        expect.fail('Should have thrown VersionError');
-      } catch (error) {
-        expect(error).toBeInstanceOf(VersionError);
-        expect((error as VersionError).type).toBe('invalid-version');
-      }
-    });
-  });
-
-  describe('version comparison logic', () => {
-    it('should correctly identify latest version', () => {
-      const result = resolveVersion('4.0.9');
-      expect(result.isLatest).toBe(true);
-    });
-
-    it('should correctly identify non-latest version', () => {
-      const result = resolveVersion('4.0.8');
-      expect(result.isLatest).toBe(false);
-    });
-
-    it('should correctly identify satisfying version', () => {
-      const result = resolveVersion('4.1.0');
-      expect(result.satisfiesLatest).toBe(true);
-    });
-
-    it('should correctly identify non-satisfying version', () => {
-      expect(() => resolveVersion('5.0.0')).toThrow();
-    });
-
-    it('should throw error for major versions without enum values', () => {
-      // Version 3.0.0 should throw because there's no enum for major version 3
-      expect(() => resolveVersion('3.0.0')).toThrow(VersionError);
-    });
-  });
-
-  describe('warning behavior', () => {
-    it('should warn on minor version mismatch', () => {
-      const result = resolveVersion('4.1.0');
-
-      expect(result.warnings).toBeDefined();
-      expect(result.warnings).toHaveLength(1);
-      expect(result.warnings?.[0]).toContain('Minor version mismatch');
-    });
-
-    it('should not warn on patch version differences', () => {
-      const result = resolveVersion('4.0.8');
-
-      expect(result.warnings).toBeUndefined();
-    });
-
-    it('should not warn on exact version match', () => {
-      const result = resolveVersion('4.0.9');
-
-      expect(result.warnings).toBeUndefined();
-    });
-
-    it('should warn with correct version information', () => {
-      const result = resolveVersion('4.2.0');
-
-      expect(result.warnings).toBeDefined();
-      expect(result.warnings).toHaveLength(1);
-      expect(result.warnings?.[0]).toContain('4.2.0');
-      expect(result.warnings?.[0]).toContain('4.0.9');
+      expect(() => resolveVersion('4')).not.toThrow();
     });
   });
 
   describe('edge cases', () => {
-    it('should handle version with pre-release identifiers (coerce strips them)', () => {
-      const result = resolveVersion('4.0.9-beta.1');
-
-      expect(result.satisfiesLatest).toBe(true);
-      expect(result.wantedVersion.version).toBe('4.0.9'); // coerce strips pre-release
-    });
-
-    it('should handle version with build metadata (coerce strips them)', () => {
-      const result = resolveVersion('4.0.9+build.123');
-
-      expect(result.satisfiesLatest).toBe(true);
-      expect(result.wantedVersion.version).toBe('4.0.9'); // coerce strips build metadata
-    });
-
-    it('should handle very long version strings (coerce strips them)', () => {
-      const longVersion = '4.0.9-beta.1.alpha.2+build.123.456';
-      const result = resolveVersion(longVersion);
-
-      expect(result.satisfiesLatest).toBe(true);
-      expect(result.wantedVersion.version).toBe('4.0.9'); // coerce strips pre-release and build
-    });
-
-    it('should throw error for zero versions without enum values', () => {
-      // Version 0.0.0 should throw because there's no enum for major version 0
-      expect(() => resolveVersion('0.0.0')).toThrow(VersionError);
-    });
-  });
-
-  describe('return value structure', () => {
-    it('should return object with all required properties', () => {
-      const result = resolveVersion('2.1.0');
-
-      expect(result).toHaveProperty('wantedVersion');
-      expect(result).toHaveProperty('latestVersion');
-      expect(result).toHaveProperty('isLatest');
-      expect(result).toHaveProperty('satisfiesLatest');
-      expect(result).toHaveProperty('enumVersion');
-
-      expect(typeof result.isLatest).toBe('boolean');
-      expect(typeof result.satisfiesLatest).toBe('boolean');
-      expect(result.wantedVersion).toBeInstanceOf(SemVer);
-      expect(result.latestVersion).toBeInstanceOf(SemVer);
-      expect(typeof result.enumVersion).toBe('string');
+    it('should handle complex version strings with pre-release and build metadata', () => {
+      const testCases = [
+        { input: '4.0.9-beta.1', expected: '4.0.9' },
+        { input: '4.0.9+build.123', expected: '4.0.9' },
+        { input: '4.0.9-beta.1.alpha.2+build.123.456', expected: '4.0.9' },
+      ];
+
+      testCases.forEach(({ input, expected }) => {
+        const result = resolveVersion(input);
+        expect(result.satisfiesLatest).toBe(true);
+        expect(result.wantedVersion.version).toBe(expected);
+      });
     });
 
-    it('should have consistent latest version across calls', () => {
+    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('4.0.9');
+
+      // 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/v2/client/log/console.ts

@@ -27,7 +27,7 @@ export class ConsoleLogger extends Logger {
   /** @inheritdoc */
   protected loggerCallback(lvl: LogLevel, msg: string, _containsPii?: boolean): void {
     console[this.getLogType(lvl)](
-      `%c FUSION::MSAL %c %s`,
+      '%c FUSION::MSAL %c %s',
       'border: 1px solid;',
       'border: none;',
       msg,

package/src/v2/provider.ts

@@ -17,6 +17,8 @@ export interface IAuthProvider {
   readonly defaultConfig: any | undefined;
   readonly defaultAccount: AccountInfo | undefined;
 
+  readonly client: AuthClient;
+
   /**
    * Acquire token from default auth client
    * @param req Auth request options
@@ -52,13 +54,8 @@ export class AuthProvider implements IAuthProvider, IProxyProvider {
     return new SemanticVersion(MsalModuleVersion.Latest);
   }
 
-  /** @deprecated */
-  get defaultClient(): AuthClient {
-    return this.getClient();
-  }
-
   get defaultAccount(): AccountInfo | undefined {
-    return this.defaultClient.account;
+    return this.client.account;
   }
 
   /** @deprecated */
@@ -70,8 +67,7 @@ export class AuthProvider implements IAuthProvider, IProxyProvider {
     this.#client = this.createClient();
   }
 
-  /** @deprecated */
-  getClient(): AuthClient {
+  get client(): AuthClient {
     return this.#client;
   }
 
@@ -91,11 +87,10 @@ export class AuthProvider implements IAuthProvider, IProxyProvider {
   async handleRedirect() {
     const { redirectUri } = this.defaultConfig || {};
     if (window.location.pathname === redirectUri) {
-      const client = this.defaultClient;
-      const logger = client.getLogger();
-      const { requestOrigin } = client;
+      const logger = this.client.getLogger();
+      const { requestOrigin } = this.client;
 
-      await client.handleRedirectPromise();
+      await this.client.handleRedirectPromise();
       if (requestOrigin === redirectUri) {
         logger.warning(`detected callback loop from url ${redirectUri}, redirecting to root`);
         window.location.replace('/');
@@ -107,7 +102,7 @@ export class AuthProvider implements IAuthProvider, IProxyProvider {
   }
 
   acquireToken(req: AuthRequest): ReturnType<IAuthProvider['acquireToken']> {
-    return this.defaultClient.acquireToken(req);
+    return this.client.acquireToken(req);
   }
 
   async acquireAccessToken(req: AuthRequest) {
@@ -117,15 +112,15 @@ export class AuthProvider implements IAuthProvider, IProxyProvider {
 
   async login(options?: { onlyIfRequired?: boolean }) {
     // skip login if already logged in and has valid claims
-    if (options?.onlyIfRequired && this.defaultClient.hasValidClaims) {
+    if (options?.onlyIfRequired && this.client.hasValidClaims) {
       return;
     }
-    await this.defaultClient.login();
+    await this.client.login();
   }
 
   async logout(options?: { redirectUri?: string }): Promise<void> {
     // TODO - might have an option for popup or redirect
-    await this.defaultClient.logoutRedirect({
+    await this.client.logoutRedirect({
       postLogoutRedirectUri: options?.redirectUri,
       account: this.defaultAccount,
     });
@@ -145,10 +140,16 @@ export class AuthProvider implements IAuthProvider, IProxyProvider {
 
   _createProxyProvider_v2(): IAuthProvider {
     return new Proxy(this, {
-      get: (target: AuthProvider, prop) => {
+      get: (target: AuthProvider, prop: keyof AuthProvider) => {
         switch (prop) {
           case 'version':
             return target.version;
+          case 'client':
+            return target.client;
+          // @ts-expect-error - this is deprecated since version 5.0.1
+          case 'defaultClient':
+            console.warn('defaultClient is deprecated, use client instead');
+            return target.client;
           case 'defaultAccount':
             return target.defaultAccount;
           case 'defaultConfig':

package/src/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '5.0.0';
+export const version = '5.1.0';

package/src/versioning/VersionError.ts

@@ -1,33 +1,5 @@
-import { VersionMessageType } from './static';
-import { createVersionMessage } from './create-version-message';
 import type { SemVer } from 'semver';
 
-/**
- * Creates a VersionError instance with a formatted message.
- *
- * This is a helper function that creates a VersionError with a human-readable
- * message based on the error type and version information.
- *
- * @param type - The type of version error
- * @param requestedVersion - The version that was requested
- * @param latestVersion - The latest available version
- * @param options - Additional error options including the error type
- * @returns A new VersionError instance with formatted message
- */
-const createVersionError = (
-  type: VersionMessageType,
-  requestedVersion: string | SemVer,
-  latestVersion: string | SemVer,
-  options?: ErrorOptions & { type?: VersionMessageType },
-): VersionError => {
-  return new VersionError(
-    createVersionMessage(type, requestedVersion, latestVersion),
-    requestedVersion,
-    latestVersion,
-    { ...options, type },
-  );
-};
-
 /**
  * Error class for version-related issues in the MSAL module.
  *
@@ -65,18 +37,9 @@ export class VersionError extends Error {
   /** The latest available version in the system */
   public readonly latestVersion: string;
 
-  /** The specific type of version error that occurred */
-  public readonly type?: VersionMessageType;
-
   /** The error name for instanceof checks */
   static Name = 'VersionError';
 
-  /** Reference to the VersionMessageType enum for convenience */
-  static Type = VersionMessageType;
-
-  /** Factory method for creating VersionError instances with formatted messages */
-  static create: typeof createVersionError = createVersionError;
-
   /**
    * Creates a new VersionError instance.
    *
@@ -89,7 +52,7 @@ export class VersionError extends Error {
     message: string,
     requestedVersion: string | SemVer,
     latestVersion: string | SemVer,
-    options?: ErrorOptions & { type?: VersionMessageType },
+    options?: ErrorOptions,
   ) {
     super(message, options);
     this.name = VersionError.Name;
@@ -97,7 +60,5 @@ export class VersionError extends Error {
     // Store versions as strings
     this.requestedVersion = String(requestedVersion);
     this.latestVersion = String(latestVersion);
-
-    this.type = options?.type;
   }
 }