@azure/msal-common 14.0.3 → 14.1.0-alpha.0

package/dist/authority/RegionDiscovery.mjs

@@ -1,115 +1,114 @@
-/*! @azure/msal-common v14.0.3 2023-09-05 */
+/*! @azure/msal-common v14.1.0-alpha.0 2023-09-20 */
 'use strict';
 import { Constants, ResponseCodes, RegionDiscoverySources } from '../utils/Constants.mjs';
 import { PerformanceEvents } from '../telemetry/performance/PerformanceEvent.mjs';
+import { invokeAsync } from '../utils/FunctionWrappers.mjs';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-class RegionDiscovery {
-    constructor(networkInterface, performanceClient, correlationId) {
-        this.networkInterface = networkInterface;
-        this.performanceClient = performanceClient;
-        this.correlationId = correlationId;
-    }
-    /**
-     * Detect the region from the application's environment.
-     *
-     * @returns Promise<string | null>
-     */
-    async detectRegion(environmentRegion, regionDiscoveryMetadata) {
-        this.performanceClient?.addQueueMeasurement(PerformanceEvents.RegionDiscoveryDetectRegion, this.correlationId);
-        // Initialize auto detected region with the region from the envrionment
-        let autodetectedRegionName = environmentRegion;
-        // Check if a region was detected from the environment, if not, attempt to get the region from IMDS
-        if (!autodetectedRegionName) {
-            const options = RegionDiscovery.IMDS_OPTIONS;
-            try {
-                this.performanceClient?.setPreQueueTime(PerformanceEvents.RegionDiscoveryGetRegionFromIMDS, this.correlationId);
-                const localIMDSVersionResponse = await this.getRegionFromIMDS(Constants.IMDS_VERSION, options);
-                if (localIMDSVersionResponse.status ===
-                    ResponseCodes.httpSuccess) {
-                    autodetectedRegionName = localIMDSVersionResponse.body;
-                    regionDiscoveryMetadata.region_source =
-                        RegionDiscoverySources.IMDS;
-                }
-                // If the response using the local IMDS version failed, try to fetch the current version of IMDS and retry.
-                if (localIMDSVersionResponse.status ===
-                    ResponseCodes.httpBadRequest) {
-                    this.performanceClient?.setPreQueueTime(PerformanceEvents.RegionDiscoveryGetCurrentVersion, this.correlationId);
-                    const currentIMDSVersion = await this.getCurrentVersion(options);
-                    if (!currentIMDSVersion) {
-                        regionDiscoveryMetadata.region_source =
-                            RegionDiscoverySources.FAILED_AUTO_DETECTION;
-                        return null;
-                    }
-                    this.performanceClient?.setPreQueueTime(PerformanceEvents.RegionDiscoveryGetRegionFromIMDS, this.correlationId);
-                    const currentIMDSVersionResponse = await this.getRegionFromIMDS(currentIMDSVersion, options);
-                    if (currentIMDSVersionResponse.status ===
-                        ResponseCodes.httpSuccess) {
-                        autodetectedRegionName =
-                            currentIMDSVersionResponse.body;
-                        regionDiscoveryMetadata.region_source =
-                            RegionDiscoverySources.IMDS;
-                    }
-                }
-            }
-            catch (e) {
-                regionDiscoveryMetadata.region_source =
-                    RegionDiscoverySources.FAILED_AUTO_DETECTION;
-                return null;
-            }
-        }
-        else {
-            regionDiscoveryMetadata.region_source =
-                RegionDiscoverySources.ENVIRONMENT_VARIABLE;
-        }
-        // If no region was auto detected from the environment or from the IMDS endpoint, mark the attempt as a FAILED_AUTO_DETECTION
-        if (!autodetectedRegionName) {
-            regionDiscoveryMetadata.region_source =
-                RegionDiscoverySources.FAILED_AUTO_DETECTION;
-        }
-        return autodetectedRegionName || null;
-    }
-    /**
-     * Make the call to the IMDS endpoint
-     *
-     * @param imdsEndpointUrl
-     * @returns Promise<NetworkResponse<string>>
-     */
-    async getRegionFromIMDS(version, options) {
-        this.performanceClient?.addQueueMeasurement(PerformanceEvents.RegionDiscoveryGetRegionFromIMDS, this.correlationId);
-        return this.networkInterface.sendGetRequestAsync(`${Constants.IMDS_ENDPOINT}?api-version=${version}&format=text`, options, Constants.IMDS_TIMEOUT);
-    }
-    /**
-     * Get the most recent version of the IMDS endpoint available
-     *
-     * @returns Promise<string | null>
-     */
-    async getCurrentVersion(options) {
-        this.performanceClient?.addQueueMeasurement(PerformanceEvents.RegionDiscoveryGetCurrentVersion, this.correlationId);
-        try {
-            const response = await this.networkInterface.sendGetRequestAsync(`${Constants.IMDS_ENDPOINT}?format=json`, options);
-            // When IMDS endpoint is called without the api version query param, bad request response comes back with latest version.
-            if (response.status === ResponseCodes.httpBadRequest &&
-                response.body &&
-                response.body["newest-versions"] &&
-                response.body["newest-versions"].length > 0) {
-                return response.body["newest-versions"][0];
-            }
-            return null;
-        }
-        catch (e) {
-            return null;
-        }
-    }
-}
-// Options for the IMDS endpoint request
-RegionDiscovery.IMDS_OPTIONS = {
-    headers: {
-        Metadata: "true",
-    },
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class RegionDiscovery {
+    constructor(networkInterface, logger, performanceClient, correlationId) {
+        this.networkInterface = networkInterface;
+        this.logger = logger;
+        this.performanceClient = performanceClient;
+        this.correlationId = correlationId;
+    }
+    /**
+     * Detect the region from the application's environment.
+     *
+     * @returns Promise<string | null>
+     */
+    async detectRegion(environmentRegion, regionDiscoveryMetadata) {
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.RegionDiscoveryDetectRegion, this.correlationId);
+        // Initialize auto detected region with the region from the envrionment
+        let autodetectedRegionName = environmentRegion;
+        // Check if a region was detected from the environment, if not, attempt to get the region from IMDS
+        if (!autodetectedRegionName) {
+            const options = RegionDiscovery.IMDS_OPTIONS;
+            try {
+                const localIMDSVersionResponse = await invokeAsync(this.getRegionFromIMDS.bind(this), PerformanceEvents.RegionDiscoveryGetRegionFromIMDS, this.logger, this.performanceClient, this.correlationId)(Constants.IMDS_VERSION, options);
+                if (localIMDSVersionResponse.status ===
+                    ResponseCodes.httpSuccess) {
+                    autodetectedRegionName = localIMDSVersionResponse.body;
+                    regionDiscoveryMetadata.region_source =
+                        RegionDiscoverySources.IMDS;
+                }
+                // If the response using the local IMDS version failed, try to fetch the current version of IMDS and retry.
+                if (localIMDSVersionResponse.status ===
+                    ResponseCodes.httpBadRequest) {
+                    const currentIMDSVersion = await invokeAsync(this.getCurrentVersion.bind(this), PerformanceEvents.RegionDiscoveryGetCurrentVersion, this.logger, this.performanceClient, this.correlationId)(options);
+                    if (!currentIMDSVersion) {
+                        regionDiscoveryMetadata.region_source =
+                            RegionDiscoverySources.FAILED_AUTO_DETECTION;
+                        return null;
+                    }
+                    const currentIMDSVersionResponse = await invokeAsync(this.getRegionFromIMDS.bind(this), PerformanceEvents.RegionDiscoveryGetRegionFromIMDS, this.logger, this.performanceClient, this.correlationId)(currentIMDSVersion, options);
+                    if (currentIMDSVersionResponse.status ===
+                        ResponseCodes.httpSuccess) {
+                        autodetectedRegionName =
+                            currentIMDSVersionResponse.body;
+                        regionDiscoveryMetadata.region_source =
+                            RegionDiscoverySources.IMDS;
+                    }
+                }
+            }
+            catch (e) {
+                regionDiscoveryMetadata.region_source =
+                    RegionDiscoverySources.FAILED_AUTO_DETECTION;
+                return null;
+            }
+        }
+        else {
+            regionDiscoveryMetadata.region_source =
+                RegionDiscoverySources.ENVIRONMENT_VARIABLE;
+        }
+        // If no region was auto detected from the environment or from the IMDS endpoint, mark the attempt as a FAILED_AUTO_DETECTION
+        if (!autodetectedRegionName) {
+            regionDiscoveryMetadata.region_source =
+                RegionDiscoverySources.FAILED_AUTO_DETECTION;
+        }
+        return autodetectedRegionName || null;
+    }
+    /**
+     * Make the call to the IMDS endpoint
+     *
+     * @param imdsEndpointUrl
+     * @returns Promise<NetworkResponse<string>>
+     */
+    async getRegionFromIMDS(version, options) {
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.RegionDiscoveryGetRegionFromIMDS, this.correlationId);
+        return this.networkInterface.sendGetRequestAsync(`${Constants.IMDS_ENDPOINT}?api-version=${version}&format=text`, options, Constants.IMDS_TIMEOUT);
+    }
+    /**
+     * Get the most recent version of the IMDS endpoint available
+     *
+     * @returns Promise<string | null>
+     */
+    async getCurrentVersion(options) {
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.RegionDiscoveryGetCurrentVersion, this.correlationId);
+        try {
+            const response = await this.networkInterface.sendGetRequestAsync(`${Constants.IMDS_ENDPOINT}?format=json`, options);
+            // When IMDS endpoint is called without the api version query param, bad request response comes back with latest version.
+            if (response.status === ResponseCodes.httpBadRequest &&
+                response.body &&
+                response.body["newest-versions"] &&
+                response.body["newest-versions"].length > 0) {
+                return response.body["newest-versions"][0];
+            }
+            return null;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+}
+// Options for the IMDS endpoint request
+RegionDiscovery.IMDS_OPTIONS = {
+    headers: {
+        Metadata: "true",
+    },
 };
 
 export { RegionDiscovery };

package/dist/authority/RegionDiscovery.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"RegionDiscovery.mjs","sources":["../../src/authority/RegionDiscovery.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAKA;AAQA;AACA;AACA;AAOI,MAAS,eAAkB,CAAA;AAE3B,IAAA,WAAuB,CAAA,gBAAQ,EAAA,iBAAa,EAAA,aAAA,EAAA;AAE5C,QAAA,IAAA,CAAS,gBAAoB,GAAA,gBAI3B,CAAA;8BAGkB,GAAA,iBAChB,CAAiB;AAQrB,QAAA,IAAA,CAAA,aAAA,GAAA,aAAA,CAAA;;;;AAIG;AACU;AA0Fb;;;;;AAKG;YACW,CAAiB,sBAAA,EAAA;AAe/B,YAAA,MAAA,OAAA,GAAA,eAAA,CAAA,YAAA,CAAA;;;;AAIG,gBAAA,IAAA,wBAAA,CAAA,MAAA;oBAC4B,aAAA,CAAA,WAAA,EAAA;AA6BlC,oBAAA,sBAAA,GAAA,wBAAA,CAAA,IAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"RegionDiscovery.mjs","sources":["../../src/authority/RegionDiscovery.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAKA;AAQA;AACA;AACA;AASW,qBAAgB,CAAA;AAEvB,IAAA,WAA2B,CAAA,gBAAA,EAAoB,MAAA,EAAA,gCAAa,EAAA;AAE5D,QAAA,IAAA,CAAS,gBAAgB,GAAM,gBAAa,CAAA;AAE5C,QAAA,IAAA,CAAS,MAAO,GAAa,MAAA,CAAA;AAOzB,QAAA,IAAA,CAAA,iBAAA,GAAkB,iBAClB,CAAA;AAUJ,QAAA,IAAA,CAAA,aAAA,GAAA,aAAA,CAAA;;;;AAIG;AACU;AAuFb;;;;;AAKG;YACW,CAAiB,sBAAA,EAAA;AAe/B,YAAA,MAAA,OAAA,GAAA,eAAA,CAAA,YAAA,CAAA;;;;AAIG,oBAAA,aAAA,CAAA,WAAA,EAAA;oBAC4B,sBAAA,GAAA,wBAAA,CAAA,IAAA,CAAA;AA6BlC,oBAAA,uBAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/authority/RegionDiscoveryMetadata.d.ts

@@ -1,7 +1,7 @@
-import { RegionDiscoveryOutcomes, RegionDiscoverySources } from "../utils/Constants";
-export type RegionDiscoveryMetadata = {
-    region_used?: string;
-    region_source?: RegionDiscoverySources;
-    region_outcome?: RegionDiscoveryOutcomes;
-};
+import { RegionDiscoveryOutcomes, RegionDiscoverySources } from "../utils/Constants";
+export type RegionDiscoveryMetadata = {
+    region_used?: string;
+    region_source?: RegionDiscoverySources;
+    region_outcome?: RegionDiscoveryOutcomes;
+};
 //# sourceMappingURL=RegionDiscoveryMetadata.d.ts.map

package/dist/broker/nativeBroker/INativeBrokerPlugin.d.ts

@@ -1,16 +1,16 @@
-/// <reference types="node" />
-import { AccountInfo } from "../../account/AccountInfo";
-import { LoggerOptions } from "../../config/ClientConfiguration";
-import { NativeRequest } from "../../request/NativeRequest";
-import { NativeSignOutRequest } from "../../request/NativeSignOutRequest";
-import { AuthenticationResult } from "../../response/AuthenticationResult";
-export interface INativeBrokerPlugin {
-    isBrokerAvailable: boolean;
-    setLogger(loggerOptions: LoggerOptions): void;
-    getAccountById(accountId: string, correlationId: string): Promise<AccountInfo>;
-    getAllAccounts(clientId: string, correlationId: string): Promise<AccountInfo[]>;
-    acquireTokenSilent(request: NativeRequest): Promise<AuthenticationResult>;
-    acquireTokenInteractive(request: NativeRequest, windowHandle?: Buffer): Promise<AuthenticationResult>;
-    signOut(request: NativeSignOutRequest): Promise<void>;
-}
+/// <reference types="node" />
+import { AccountInfo } from "../../account/AccountInfo";
+import { LoggerOptions } from "../../config/ClientConfiguration";
+import { NativeRequest } from "../../request/NativeRequest";
+import { NativeSignOutRequest } from "../../request/NativeSignOutRequest";
+import { AuthenticationResult } from "../../response/AuthenticationResult";
+export interface INativeBrokerPlugin {
+    isBrokerAvailable: boolean;
+    setLogger(loggerOptions: LoggerOptions): void;
+    getAccountById(accountId: string, correlationId: string): Promise<AccountInfo>;
+    getAllAccounts(clientId: string, correlationId: string): Promise<AccountInfo[]>;
+    acquireTokenSilent(request: NativeRequest): Promise<AuthenticationResult>;
+    acquireTokenInteractive(request: NativeRequest, windowHandle?: Buffer): Promise<AuthenticationResult>;
+    signOut(request: NativeSignOutRequest): Promise<void>;
+}
 //# sourceMappingURL=INativeBrokerPlugin.d.ts.map