@equinor/fusion-framework-module-msal 4.0.0 → 4.0.2

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

@@ -1,9 +1,9 @@
-import { Configuration, IPublicClientApplication } from '@azure/msal-browser';
+import type { Configuration, IPublicClientApplication } from '@azure/msal-browser';
 import { AuthClient } from './client';
 import { normalizeUri } from './util/url';
 
 export type AuthClientConfig = Configuration & {
-    auth: Partial<Configuration['auth']>;
+  auth: Partial<Configuration['auth']>;
 };
 
 /**
@@ -27,22 +27,22 @@ export type AuthClientConfig = Configuration & {
  * @param ctor - optional client class
  */
 export const createAuthClient = <T extends IPublicClientApplication = AuthClient>(
-    tenantId: string,
-    clientId: string,
-    redirectUri?: string,
-    config?: AuthClientConfig,
-    ctor?: new (tenantId: string, config: Configuration) => T,
+  tenantId: string,
+  clientId: string,
+  redirectUri?: string,
+  config?: AuthClientConfig,
+  ctor?: new (tenantId: string, config: Configuration) => T,
 ): T => {
-    const auth: Configuration['auth'] = {
-        clientId,
-        redirectUri: normalizeUri(redirectUri || ''),
-        navigateToLoginRequestUrl: false,
-        authority: `https://login.microsoftonline.com/${tenantId}`,
-        ...config?.auth,
-    };
-    const cache = { cacheLocation: 'localStorage', ...config?.cache };
-    const system = config?.system;
-    return new (ctor || AuthClient)(tenantId, { auth, cache, system }) as T;
+  const auth: Configuration['auth'] = {
+    clientId,
+    redirectUri: normalizeUri(redirectUri || ''),
+    navigateToLoginRequestUrl: false,
+    authority: `https://login.microsoftonline.com/${tenantId}`,
+    ...config?.auth,
+  };
+  const cache = { cacheLocation: 'localStorage', ...config?.cache };
+  const system = config?.system;
+  return new (ctor || AuthClient)(tenantId, { auth, cache, system }) as T;
 };
 
 export default createAuthClient;

package/src/v2/client/log/console.ts

@@ -14,42 +14,45 @@ type ConsoleLevel = 'error' | 'warn' | 'info' | 'debug';
  * ```
  */
 export class ConsoleLogger extends Logger {
-    /**
-     * @param logLevel - 0-1-2-3 (error-warning-info-debug) if not provided all records logged
-     */
-    constructor(logLevel?: LogLevel) {
-        super({
-            logLevel,
-            loggerCallback: (...args: [LogLevel, string, boolean]) => this.loggerCallback(...args),
-        });
-    }
+  /**
+   * @param logLevel - 0-1-2-3 (error-warning-info-debug) if not provided all records logged
+   */
+  constructor(logLevel?: LogLevel) {
+    super({
+      logLevel,
+      loggerCallback: (...args: [LogLevel, string, boolean]) => this.loggerCallback(...args),
+    });
+  }
 
-    /** @inheritdoc */
-    protected loggerCallback(lvl: LogLevel, msg: string, _containsPii?: boolean): void {
-        console[this.getLogType(lvl)](
-            `%c FUSION::MSAL %c %s`,
-            'border: 1px solid;',
-            'border: none;',
-            msg,
-        );
-    }
+  /** @inheritdoc */
+  protected loggerCallback(lvl: LogLevel, msg: string, _containsPii?: boolean): void {
+    console[this.getLogType(lvl)](
+      `%c FUSION::MSAL %c %s`,
+      'border: 1px solid;',
+      'border: none;',
+      msg,
+    );
+  }
 
-    /**
-     * Map log level to console log function type
-     */
-    protected getLogType = (lvl: LogLevel): ConsoleLevel => {
-        switch (lvl) {
-            case LogLevel.Error:
-                return 'error';
-            case LogLevel.Warning:
-                return 'warn';
-            case LogLevel.Info:
-                return 'info';
-            case LogLevel.Verbose:
-            default:
-                return 'debug';
-        }
-    };
+  /**
+   * Map log level to console log function type
+   *
+   * @default LogLevel.Verbose
+   */
+  protected getLogType = (lvl: LogLevel): ConsoleLevel => {
+    switch (lvl) {
+      case LogLevel.Error:
+        return 'error';
+      case LogLevel.Warning:
+        return 'warn';
+      case LogLevel.Info:
+        return 'info';
+      case LogLevel.Verbose:
+        return 'debug';
+      default:
+        return this.getLogType(LogLevel.Verbose);
+    }
+  };
 }
 
 export default ConsoleLogger;

package/src/v2/client/request.ts

@@ -1,4 +1,4 @@
-import { PopupRequest, RedirectRequest } from '@azure/msal-browser';
+import type { PopupRequest, RedirectRequest } from '@azure/msal-browser';
 
 /**
  * Request object passed by user to retrieve a Code from the

package/src/v2/client/util/browser.ts

@@ -9,6 +9,6 @@
  * @param history - append navigation to history
  */
 export const redirect = (url: string, timeout = 3000, history?: boolean): Promise<void> => {
-    history ? window.location.assign(url) : window.location.replace(url);
-    return new Promise((_, reject) => setTimeout(reject, timeout));
+  history ? window.location.assign(url) : window.location.replace(url);
+  return new Promise((_, reject) => setTimeout(reject, timeout));
 };

package/src/v2/client/util/url.ts

@@ -8,9 +8,9 @@
  * @param home - base url for relative urls
  */
 export const normalizeUri = (uri: string, home: string = window.location.origin): string => {
-    uri = uri.match(/^http[s]?/) ? uri : home + uri;
-    const { origin, pathname } = new URL(uri);
-    return origin + pathname.replace(/([^:]\/)\/+/g, '$1');
+  uri = uri.match(/^http[s]?/) ? uri : home + uri;
+  const { origin, pathname } = new URL(uri);
+  return origin + pathname.replace(/([^:]\/)\/+/g, '$1');
 };
 
 /**
@@ -19,6 +19,6 @@ export const normalizeUri = (uri: string, home: string = window.location.origin)
  * @internal
  */
 export const compareOrigin = (a: string, b: string): boolean => {
-    const url = { a: normalizeUri(a), b: normalizeUri(b) };
-    return url.a === url.b;
+  const url = { a: normalizeUri(a), b: normalizeUri(b) };
+  return url.a === url.b;
 };

package/src/v2/configurator.ts

@@ -4,55 +4,55 @@ import { BaseConfigBuilder } from '@equinor/fusion-framework-module';
 
 import { MsalModuleVersion } from '../static';
 import semver from 'semver';
-import { IAuthProvider } from './provider';
+import type { IAuthProvider } from './provider';
 
 const VersionSchema = z.string().transform((x: string) => String(semver.coerce(x)));
 
 const AuthClientConfigSchema = z.object({
-    clientId: z.string(),
-    tenantId: z.string(),
-    redirectUri: z.string().optional(),
+  clientId: z.string(),
+  tenantId: z.string(),
+  redirectUri: z.string().optional(),
 });
 
 // NOTE: this might need refinement to validate the provider
 const AuthClientSchema = z.custom<IAuthProvider>();
 
 const AuthConfigSchema = z.object({
-    client: AuthClientConfigSchema.optional(),
-    provider: AuthClientSchema.optional(),
-    requiresAuth: z.boolean().optional(),
-    version: VersionSchema,
+  client: AuthClientConfigSchema.optional(),
+  provider: AuthClientSchema.optional(),
+  requiresAuth: z.boolean().optional(),
+  version: VersionSchema,
 });
 
 export type AuthClientConfig = z.infer<typeof AuthClientConfigSchema>;
 export type AuthConfig = z.infer<typeof AuthConfigSchema>;
 
 export class AuthConfigurator extends BaseConfigBuilder<AuthConfig> {
-    public version = MsalModuleVersion.Latest as const;
+  public version = MsalModuleVersion.Latest as const;
 
-    constructor() {
-        super();
-        this._set('version', async () => this.version);
-    }
+  constructor() {
+    super();
+    this._set('version', async () => this.version);
+  }
 
-    setClientConfig(config?: z.infer<typeof AuthClientConfigSchema>): void {
-        this._set('client', async () => config);
-    }
+  setClientConfig(config?: z.infer<typeof AuthClientConfigSchema>): void {
+    this._set('client', async () => config);
+  }
 
-    setRequiresAuth(requiresAuth: boolean): void {
-        this._set('requiresAuth', async () => requiresAuth);
-    }
+  setRequiresAuth(requiresAuth: boolean): void {
+    this._set('requiresAuth', async () => requiresAuth);
+  }
 
-    setProvider(provider?: z.infer<typeof AuthClientSchema>): void {
-        this._set('provider', async () => provider);
-    }
+  setProvider(provider?: z.infer<typeof AuthClientSchema>): void {
+    this._set('provider', async () => provider);
+  }
 
-    setVersion(version: string): void {
-        this._set('version', async () => version);
-    }
+  setVersion(version: string): void {
+    this._set('version', async () => version);
+  }
 
-    async _processConfig(config: AuthConfig): Promise<AuthConfig> {
-        // TODO: handle parsing of clientConfig
-        return AuthConfigSchema.parseAsync(config);
-    }
+  async _processConfig(config: AuthConfig): Promise<AuthConfig> {
+    // TODO: handle parsing of clientConfig
+    return AuthConfigSchema.parseAsync(config);
+  }
 }

package/src/v2/provider.ts

@@ -1,166 +1,170 @@
-import { AuthClient, createAuthClient, AuthRequest, ConsoleLogger } from './client';
+import { type AuthClient, createAuthClient, type AuthRequest, ConsoleLogger } from './client';
 
 import { MsalModuleVersion } from '../static';
 
-import { AuthClientConfig } from './configurator';
-import { AccountInfo, AuthenticationResult } from './types';
-import { IProxyProvider } from '../types';
+import type { AuthClientConfig } from './configurator';
+import type { AccountInfo, AuthenticationResult } from './types';
+import type { IProxyProvider } from '../types';
 import resolveVersion from '../resolve-version';
 import { SemanticVersion } from '@equinor/fusion-framework-module';
 
 export interface IAuthProvider {
-    // readonly defaultClient: AuthClient;
-    // readonly defaultConfig: AuthClientOptions | undefined;
-    readonly defaultAccount: AccountInfo | undefined;
-
-    /**
-     * Acquire token from default auth client
-     * @param req Auth request options
-     */
-    acquireToken(req: AuthRequest): Promise<AuthenticationResult | void>;
-
-    /**
-     * Acquire access token from default auth client
-     * @param req Auth request options
-     */
-    acquireAccessToken(req: AuthRequest): Promise<string | undefined>;
-
-    /**
-     * Login to default auth client
-     */
-    login(): Promise<void>;
-
-    /**
-     * Logout
-     */
-    logout(options?: { redirectUri?: string }): Promise<void>;
-
-    /**
-     * Handle default client redirect callback
-     */
-    handleRedirect(): Promise<void | null>;
+  // readonly defaultClient: AuthClient;
+  /**
+   * @deprecated
+   */
+  // biome-ignore lint/suspicious/noExplicitAny: this is deprecated
+  readonly defaultConfig: any | undefined;
+  readonly defaultAccount: AccountInfo | undefined;
+
+  /**
+   * Acquire token from default auth client
+   * @param req Auth request options
+   */
+  acquireToken(req: AuthRequest): Promise<AuthenticationResult | void>;
+
+  /**
+   * Acquire access token from default auth client
+   * @param req Auth request options
+   */
+  acquireAccessToken(req: AuthRequest): Promise<string | undefined>;
+
+  /**
+   * Login to default auth client
+   */
+  login(): Promise<void>;
+
+  /**
+   * Logout
+   */
+  logout(options?: { redirectUri?: string }): Promise<void>;
+
+  /**
+   * Handle default client redirect callback
+   */
+  handleRedirect(): Promise<void | null>;
 }
 
 export class AuthProvider implements IAuthProvider, IProxyProvider {
-    #client: AuthClient;
-
-    get version(): SemanticVersion {
-        return new SemanticVersion(MsalModuleVersion.Latest);
-    }
-
-    /** @deprecated */
-    get defaultClient(): AuthClient {
-        return this.getClient();
-    }
-
-    get defaultAccount(): AccountInfo | undefined {
-        return this.defaultClient.account;
-    }
-
-    /** @deprecated */
-    get defaultConfig(): AuthClientConfig | undefined {
-        return this._config;
+  #client: AuthClient;
+
+  get version(): SemanticVersion {
+    return new SemanticVersion(MsalModuleVersion.Latest);
+  }
+
+  /** @deprecated */
+  get defaultClient(): AuthClient {
+    return this.getClient();
+  }
+
+  get defaultAccount(): AccountInfo | undefined {
+    return this.defaultClient.account;
+  }
+
+  /** @deprecated */
+  get defaultConfig(): AuthClientConfig | undefined {
+    return this._config;
+  }
+
+  constructor(protected _config: AuthClientConfig) {
+    this.#client = this.createClient();
+  }
+
+  /** @deprecated */
+  getClient(): AuthClient {
+    return this.#client;
+  }
+
+  /** @deprecated */
+  createClient(): AuthClient {
+    const client = createAuthClient(
+      this._config.tenantId,
+      this._config.clientId,
+      this._config.redirectUri,
+    );
+    // TODO - fix with log streamer
+    client.setLogger(new ConsoleLogger(0));
+
+    return client;
+  }
+
+  async handleRedirect() {
+    const { redirectUri } = this.defaultConfig || {};
+    if (window.location.pathname === redirectUri) {
+      const client = this.defaultClient;
+      const logger = client.getLogger();
+      const { requestOrigin } = client;
+
+      await client.handleRedirectPromise();
+      if (requestOrigin === redirectUri) {
+        logger.warning(`detected callback loop from url ${redirectUri}, redirecting to root`);
+        window.location.replace('/');
+      } else {
+        window.location.replace(requestOrigin || '/');
+      }
     }
-
-    constructor(protected _config: AuthClientConfig) {
-        this.#client = this.createClient();
-    }
-
-    /** @deprecated */
-    getClient(): AuthClient {
-        return this.#client;
+    return null;
+  }
+
+  acquireToken(req: AuthRequest): ReturnType<IAuthProvider['acquireToken']> {
+    return this.defaultClient.acquireToken(req);
+  }
+
+  async acquireAccessToken(req: AuthRequest) {
+    const token = await this.acquireToken(req);
+    return token ? token.accessToken : undefined;
+  }
+
+  async login(options?: { onlyIfRequired?: boolean }) {
+    // skip login if already logged in and has valid claims
+    if (options?.onlyIfRequired && this.defaultClient.hasValidClaims) {
+      return;
     }
-
-    /** @deprecated */
-    createClient(): AuthClient {
-        const client = createAuthClient(
-            this._config.tenantId,
-            this._config.clientId,
-            this._config.redirectUri,
-        );
-        // TODO - fix with log streamer
-        client.setLogger(new ConsoleLogger(0));
-
-        return client;
+    await this.defaultClient.login();
+  }
+
+  async logout(options?: { redirectUri?: string }): Promise<void> {
+    // TODO - might have an option for popup or redirect
+    await this.defaultClient.logoutRedirect({
+      postLogoutRedirectUri: options?.redirectUri,
+      account: this.defaultAccount,
+    });
+  }
+
+  createProxyProvider<T = IAuthProvider>(version: string): T {
+    // TODO - check if version is supported and telemetry
+    const { enumVersion } = resolveVersion(version);
+    switch (enumVersion) {
+      case MsalModuleVersion.V2:
+      case MsalModuleVersion.Latest:
+        return this._createProxyProvider_v2() as T;
+      default:
+        throw new Error(`Version ${version} is not supported`);
     }
-
-    async handleRedirect() {
-        const { redirectUri } = this.defaultConfig || {};
-        if (window.location.pathname === redirectUri) {
-            const client = this.defaultClient;
-            const logger = client.getLogger();
-            const { requestOrigin } = client;
-
-            await client.handleRedirectPromise();
-            if (requestOrigin === redirectUri) {
-                logger.warning(
-                    `detected callback loop from url ${redirectUri}, redirecting to root`,
-                );
-                window.location.replace('/');
-            } else {
-                window.location.replace(requestOrigin || '/');
-            }
+  }
+
+  _createProxyProvider_v2(): IAuthProvider {
+    return new Proxy(this, {
+      get: (target: AuthProvider, prop) => {
+        switch (prop) {
+          case 'version':
+            return target.version;
+          case 'defaultAccount':
+            return target.defaultAccount;
+          case 'defaultConfig':
+            return target.defaultConfig;
+          case 'acquireToken':
+            return target.acquireToken.bind(target);
+          case 'acquireAccessToken':
+            return target.acquireAccessToken.bind(target);
+          case 'login':
+            return target.login.bind(target);
+          case 'handleRedirect':
+            return target.handleRedirect.bind(target);
+          case 'createProxyProvider':
+            return target.createProxyProvider.bind(target);
         }
-        return null;
-    }
-
-    acquireToken(req: AuthRequest): ReturnType<IAuthProvider['acquireToken']> {
-        return this.defaultClient.acquireToken(req);
-    }
-
-    async acquireAccessToken(req: AuthRequest) {
-        const token = await this.acquireToken(req);
-        return token ? token.accessToken : undefined;
-    }
-
-    async login(options?: { onlyIfRequired?: boolean }) {
-        // skip login if already logged in and has valid claims
-        if (options?.onlyIfRequired && this.defaultClient.hasValidClaims) {
-            return;
-        }
-        await this.defaultClient.login();
-    }
-
-    async logout(options?: { redirectUri?: string }): Promise<void> {
-        // TODO - might have an option for popup or redirect
-        await this.defaultClient.logoutRedirect({
-            postLogoutRedirectUri: options?.redirectUri,
-            account: this.defaultAccount,
-        });
-    }
-
-    createProxyProvider<T = IAuthProvider>(version: string): T {
-        // TODO - check if version is supported and telemetry
-        const { enumVersion } = resolveVersion(version);
-        switch (enumVersion) {
-            case MsalModuleVersion.V2:
-            case MsalModuleVersion.Latest:
-                return this._createProxyProvider_v2() as T;
-            default:
-                throw new Error(`Version ${version} is not supported`);
-        }
-    }
-
-    _createProxyProvider_v2(): IAuthProvider {
-        return new Proxy(this, {
-            get: (target: AuthProvider, prop) => {
-                switch (prop) {
-                    case 'version':
-                        return target.version;
-                    case 'defaultAccount':
-                        return target.defaultAccount;
-                    case 'acquireToken':
-                        return target.acquireToken.bind(target);
-                    case 'acquireAccessToken':
-                        return target.acquireAccessToken.bind(target);
-                    case 'login':
-                        return target.login.bind(target);
-                    case 'handleRedirect':
-                        return target.handleRedirect.bind(target);
-                    case 'createProxyProvider':
-                        return target.createProxyProvider.bind(target);
-                }
-            },
-        });
-    }
+      },
+    });
+  }
 }

package/src/v2/types.ts

@@ -1,24 +1,24 @@
 export type AccountInfo = {
-    homeAccountId: string;
-    environment: string;
-    tenantId: string;
-    username: string;
-    localAccountId: string;
-    name?: string;
-    idTokenClaims?: {
-        [key: string]: string | number | string[] | object | undefined | unknown;
-    };
+  homeAccountId: string;
+  environment: string;
+  tenantId: string;
+  username: string;
+  localAccountId: string;
+  name?: string;
+  idTokenClaims?: {
+    [key: string]: string | number | string[] | object | undefined | unknown;
+  };
 };
 
 export type AuthenticationResult = {
-    authority: string;
-    uniqueId: string;
-    tenantId: string;
-    scopes: Array<string>;
-    account: AccountInfo | null;
-    idToken: string;
-    idTokenClaims: object;
-    accessToken: string;
-    expiresOn: Date | null;
-    tokenType: string;
+  authority: string;
+  uniqueId: string;
+  tenantId: string;
+  scopes: Array<string>;
+  account: AccountInfo | null;
+  idToken: string;
+  idTokenClaims: object;
+  accessToken: string;
+  expiresOn: Date | null;
+  tokenType: string;
 };

package/src/version.ts

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