@azure-rest/maps-route 1.0.0-beta.2 → 1.0.0-beta.4

package/README.md

@@ -15,7 +15,7 @@ Key links:
 
 ### Currently supported environments
 
-- [LTS versions of Node.js](https://nodejs.org/about/releases/)
+- [LTS versions of Node.js](https://github.com/nodejs/release#release-schedule)
 - Latest versions of Safari, Chrome, Edge and Firefox.
 
 ### Prerequisites
@@ -35,19 +35,19 @@ npm install @azure-rest/maps-route
 
 ### Create and authenticate a `MapsRouteClient`
 
-To create a client object to access the Azure Maps Route APIs, you will need a `credential` object. The Azure Maps Route client can use an Azure Active Directory credential or an Azure Key credential to authenticate.
+To create a client object to access the Azure Maps Route APIs, you will need a `credential` object. The Azure Maps Route client can use a Microsoft Entra ID credential or an Azure Key credential to authenticate.
 
-#### Using an Azure Active Directory Credential
+#### Using a Microsoft Entra ID Credential
 
-You can authenticate with Azure Active Directory using the [Azure Identity library][azure_identity]. To use the [DefaultAzureCredential][defaultazurecredential] provider shown below, or other credential providers provided with the Azure SDK, please install the `@azure/identity` package:
+You can authenticate with Microsoft Entra ID using the [Azure Identity library][azure_identity]. To use the [DefaultAzureCredential][defaultazurecredential] provider shown below, or other credential providers provided with the Azure SDK, please install the `@azure/identity` package:
 
 ```bash
 npm install @azure/identity
 ```
 
-You will also need to register a new AAD application and grant access to Azure Maps by assigning the suitable role to your service principal. Please refer to the [Manage authentication](https://docs.microsoft.com/azure/azure-maps/how-to-manage-authentication) page.
+You will also need to register a new Microsoft Entra ID application and grant access to Azure Maps by assigning the suitable role to your service principal. Please refer to the [Manage authentication](https://docs.microsoft.com/azure/azure-maps/how-to-manage-authentication) page.
 
-Set the values of the client ID, tenant ID, and client secret of the AAD application as environment variables: `AZURE_CLIENT_ID`, `AZURE_TENANT_ID`, `AZURE_CLIENT_SECRET`.
+Set the values of the client ID, tenant ID, and client secret of the Microsoft Entra ID application as environment variables: `AZURE_CLIENT_ID`, `AZURE_TENANT_ID`, `AZURE_CLIENT_SECRET`.
 
 You will also need to specify the Azure Maps resource you intend to use by specifying the `clientId` in the client options.
 The Azure Maps resource client id can be found in the Authentication sections in the Azure Maps resource. Please refer to the [documentation](https://docs.microsoft.com/azure/azure-maps/how-to-manage-authentication#view-authentication-details) on how to find it.
@@ -72,6 +72,52 @@ const credential = new AzureKeyCredential("<subscription-key>");
 const client = MapsRoute(credential);
 ```
 
+#### Using a Shared Access Signature (SAS) Token Credential
+
+Shared access signature (SAS) tokens are authentication tokens created using the JSON Web token (JWT) format and are cryptographically signed to prove authentication for an application to the Azure Maps REST API.
+
+You can get the SAS token using [`AzureMapsManagementClient.accounts.listSas`](https://learn.microsoft.com/javascript/api/%40azure/arm-maps/accounts?view=azure-node-latest#@azure-arm-maps-accounts-listsas) from ["@azure/arm-maps"](https://www.npmjs.com/package/@azure/arm-maps) package. Please follow the section [Create and authenticate a `AzureMapsManagementClient`](https://github.com/Azure/azure-sdk-for-js/tree/main/sdk/maps/arm-maps#create-and-authenticate-a-azuremapsmanagementclient) to setup first.
+
+Second, follow [Managed identities for Azure Maps](https://techcommunity.microsoft.com/t5/azure-maps-blog/managed-identities-for-azure-maps/ba-p/3666312) to create a managed identity for your Azure Maps account. Copy the principal ID (object ID) of the managed identity.
+
+Third, you will need to install["@azure/core-auth"](https://www.npmjs.com/package/@azure/core-auth)package to use `AzureSASCredential`:
+
+```bash
+npm install @azure/core-auth
+```
+
+Finally, you can use the SAS token to authenticate the client:
+
+```javascript
+const MapsRoute = require("@azure-rest/maps-route").default;
+const { AzureSASCredential } = require("@azure/core-auth");
+const { DefaultAzureCredential } = require("@azure/identity");
+const { AzureMapsManagementClient } = require("@azure/arm-maps");
+
+const subscriptionId = "<subscription ID of the map account>";
+const resourceGroupName = "<resource group name of the map account>";
+const accountName = "<name of the map account>";
+const mapsAccountSasParameters = {
+  start: "<start time in ISO format>", // e.g. "2023-11-24T03:51:53.161Z"
+  expiry: "<expiry time in ISO format>", // maximum value to start + 1 day
+  maxRatePerSecond: 500,
+  principalId: "<principle ID (object ID) of the managed identity>",
+  signingKey: "primaryKey",
+};
+const credential = new DefaultAzureCredential();
+const managementClient = new AzureMapsManagementClient(credential, subscriptionId);
+const { accountSasToken } = await managementClient.accounts.listSas(
+  resourceGroupName,
+  accountName,
+  mapsAccountSasParameters,
+);
+if (accountSasToken === undefined) {
+  throw new Error("No accountSasToken was found for the Maps Account.");
+}
+const sasCredential = new AzureSASCredential(accountSasToken);
+const client = MapsRoute(sasCredential);
+```
+
 ## Examples
 
 The following sections provide several code snippets covering some of the most common Azure Maps Route tasks, including:
@@ -89,15 +135,15 @@ To retrieve the route direction, you need to pass in the parameters the coordina
 By default, the Route service will return an array of coordinates. The response will contain the coordinates that make up the path in a list named points. Route response also includes the distance from the start of the route and the estimated elapsed time. These values can be used to calculate the average speed for the entire route.
 
 ```javascript
-const routeDirectionsResult = await client.path("/route/directions/{format}", "json").get({
+const { toColonDelimitedLatLonString, isUnexpected } = require("@azure-rest/maps-route");
+const routeDirectionsResult1 = await client.path("/route/directions/{format}", "json").get({
   queryParameters: {
     query: "51.368752,-0.118332:41.385426,-0.128929",
   },
 });
 
 // You can use the helper function `toColonDelimitedLatLonString` to compose the query string.
-const { toColonDelimitedLatLonString } = require("@azure-rest/maps-route");
-const routeDirectionsResult = await client.path("/route/directions/{format}", "json").get({
+const routeDirectionsResult2 = await client.path("/route/directions/{format}", "json").get({
   queryParameters: {
     query: toColonDelimitedLatLonString([
       // Origin:
@@ -113,19 +159,19 @@ const routeDirectionsResult = await client.path("/route/directions/{format}", "j
 });
 
 // Handle the error if the request failed
-if (isUnexpected(routeDirectionsResult)) {
-  throw routeDirectionsResult.body.error;
+if (isUnexpected(routeDirectionsResult2)) {
+  throw routeDirectionsResult2.body.error;
 }
 
-routeDirectionsResult.body.routes.forEach(({ summary, legs }) => {
+routeDirectionsResult2.body.routes.forEach(({ summary, legs }) => {
   console.log(
-    `The total distance is ${summary.lengthInMeters} meters, and it takes ${summary.travelTimeInSeconds} seconds.`
+    `The total distance is ${summary.lengthInMeters} meters, and it takes ${summary.travelTimeInSeconds} seconds.`,
   );
   legs.forEach(({ summary, points }, idx) => {
     console.log(
       `The ${idx + 1}th leg's length is ${summary.lengthInMeters} meters, and it takes ${
         summary.travelTimeInSeconds
-      } seconds. Followings are the first 10 points: `
+      } seconds. Followings are the first 10 points: `,
     );
     console.table(points.slice(0, 10));
   });
@@ -137,6 +183,7 @@ routeDirectionsResult.body.routes.forEach(({ summary, legs }) => {
 The service supports commercial vehicle routing, covering commercial trucks routing. The APIs consider specified limits. Such as, the height and weight of the vehicle, and if the vehicle is carrying hazardous cargo. For example, if a vehicle is carrying flammable, the routing engine avoid certain tunnels that are near residential areas.
 
 ```javascript
+const { toColonDelimitedLatLonString, isUnexpected } = require("@azure-rest/maps-route");
 const routeDirectionsResult = await client.path("/route/directions/{format}", "json").get({
   queryParameters: {
     query: toColonDelimitedLatLonString([
@@ -163,13 +210,13 @@ if (isUnexpected(routeDirectionsResult)) {
 
 routeDirectionsResult.body.routes.forEach(({ summary, legs }) => {
   console.log(
-    `The total distance is ${summary.lengthInMeters} meters, and it takes ${summary.travelTimeInSeconds} seconds.`
+    `The total distance is ${summary.lengthInMeters} meters, and it takes ${summary.travelTimeInSeconds} seconds.`,
   );
   legs.forEach(({ summary, points }, idx) => {
     console.log(
       `The ${idx + 1}th leg's length is ${summary.lengthInMeters} meters, and it takes ${
         summary.travelTimeInSeconds
-      } seconds. Followings are the first 10 points: `
+      } seconds. Followings are the first 10 points: `,
     );
     console.table(points.slice(0, 10));
   });
@@ -188,6 +235,7 @@ For multi-stop routing, up to 150 waypoints may be specified in a single route r
 If you want to optimize the best order to visit the given waypoints, then you need to specify `computeBestWaypointOrder=true`. This scenario is also known as the traveling salesman optimization problem.
 
 ```javascript
+const { toColonDelimitedLatLonString, isUnexpected } = require("@azure-rest/maps-route");
 const routeDirectionsResult = await client.path("/route/directions/{format}", "json").get({
   queryParameters: {
     query: toColonDelimitedLatLonString([
@@ -200,7 +248,7 @@ const routeDirectionsResult = await client.path("/route/directions/{format}", "j
       // Destination:
       [41.385426, -0.128929],
     ]),
-    computeBestWaypointOrder: true,
+    computeBestOrder: true,
     routeType: "shortest",
   },
 });
@@ -209,13 +257,13 @@ if (isUnexpected(routeDirectionsResult)) {
   throw routeDirectionsResult.body.error;
 }
 
-const { summary } = routeDirectionsResult.body.routes;
+const { summary } = routeDirectionsResult.body.routes[0];
 console.log(
-  `The optimized distance is ${summary.lengthInMeters} meters, and it takes ${summary.travelTimeInSeconds} seconds.`
+  `The optimized distance is ${summary.lengthInMeters} meters, and it takes ${summary.travelTimeInSeconds} seconds.`,
 );
 console.log("The route is optimized by: ");
 routeDirectionsResult.body.optimizedWaypoints.forEach(
-  ({ providedIndex, optimizedIndex }) => `Moving index ${providedIndex} to ${optimizedIndex}`
+  ({ providedIndex, optimizedIndex }) => `Moving index ${providedIndex} to ${optimizedIndex}`,
 );
 ```
 

package/dist/index.js

@@ -4,45 +4,67 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var coreAuth = require('@azure/core-auth');
 var mapsCommon = require('@azure/maps-common');
+var tslib = require('tslib');
 var coreClient = require('@azure-rest/core-client');
+var logger$1 = require('@azure/logger');
 var coreRestPipeline = require('@azure/core-rest-pipeline');
 var coreLro = require('@azure/core-lro');
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+const logger = logger$1.createClientLogger("maps-route");
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
 /**
- * Initialize a new instance of the class MapsRouteClient class.
- * @param credentials type: KeyCredential
+ * Initialize a new instance of `MapsRouteClient`
+ * @param credentials - uniquely identify client credential
+ * @param options - the parameter for all optional parameters
  */
-function createClient(credentials, options = {}) {
-    var _a, _b;
-    const baseUrl = (_a = options.baseUrl) !== null && _a !== void 0 ? _a : `https://atlas.microsoft.com`;
-    options.apiVersion = (_b = options.apiVersion) !== null && _b !== void 0 ? _b : "1.0";
-    options = Object.assign(Object.assign({}, options), { credentials: {
-            apiKeyHeaderName: "subscription-key"
-        } });
-    const userAgentInfo = `azsdk-js-maps-route-rest/1.0.0-beta.1`;
+function createClient(credentials, _a = {}) {
+    var _b, _c, _d, _e, _f, _g;
+    var { apiVersion = "1.0" } = _a, options = tslib.__rest(_a, ["apiVersion"]);
+    const endpointUrl = (_c = (_b = options.endpoint) !== null && _b !== void 0 ? _b : options.baseUrl) !== null && _c !== void 0 ? _c : `https://atlas.microsoft.com`;
+    const userAgentInfo = `azsdk-js-maps-route-rest/1.0.0-beta.4`;
     const userAgentPrefix = options.userAgentOptions && options.userAgentOptions.userAgentPrefix
         ? `${options.userAgentOptions.userAgentPrefix} ${userAgentInfo}`
         : `${userAgentInfo}`;
     options = Object.assign(Object.assign({}, options), { userAgentOptions: {
-            userAgentPrefix
+            userAgentPrefix,
+        }, loggingOptions: {
+            logger: (_e = (_d = options.loggingOptions) === null || _d === void 0 ? void 0 : _d.logger) !== null && _e !== void 0 ? _e : logger.info,
+        }, credentials: {
+            apiKeyHeaderName: (_g = (_f = options.credentials) === null || _f === void 0 ? void 0 : _f.apiKeyHeaderName) !== null && _g !== void 0 ? _g : "subscription-key",
         } });
-    const client = coreClient.getClient(baseUrl, credentials, options);
+    const client = coreClient.getClient(endpointUrl, credentials, options);
+    client.pipeline.removePolicy({ name: "ApiVersionPolicy" });
+    client.pipeline.addPolicy({
+        name: "ClientApiVersionPolicy",
+        sendRequest: (req, next) => {
+            // Use the apiVersion defined in request url directly
+            // Append one if there is no apiVersion and we have one at client options
+            const url = new URL(req.url);
+            if (!url.searchParams.get("api-version") && apiVersion) {
+                req.url = `${req.url}${Array.from(url.searchParams.keys()).length > 0 ? "&" : "?"}api-version=${apiVersion}`;
+            }
+            return next(req);
+        },
+    });
     return client;
 }
 
 // Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
+// Licensed under the MIT License.
 const responseMap = {
-    "POST /route/matrix/{format}": ["200", "202"],
     "GET /route/matrix/{format}": ["200", "202"],
+    "POST /route/matrix/{format}": ["200", "202"],
     "POST /route/matrix/sync/{format}": ["200"],
     "GET /route/directions/{format}": ["200"],
     "POST /route/directions/{format}": ["200"],
     "GET /route/range/{format}": ["200"],
-    "POST /route/directions/batch/{format}": ["200", "202"],
     "GET /route/directions/batch/{format}": ["200", "202"],
-    "POST /route/directions/batch/sync/{format}": ["200"]
+    "POST /route/directions/batch/{format}": ["200", "202"],
+    "POST /route/directions/batch/sync/{format}": ["200"],
 };
 function isUnexpected(response) {
     const lroOriginal = response.headers["x-ms-original-url"];
@@ -50,13 +72,17 @@ function isUnexpected(response) {
     const method = response.request.method;
     let pathDetails = responseMap[`${method} ${url.pathname}`];
     if (!pathDetails) {
-        pathDetails = geParametrizedPathSuccess(method, url.pathname);
+        pathDetails = getParametrizedPathSuccess(method, url.pathname);
     }
     return !pathDetails.includes(response.status);
 }
-function geParametrizedPathSuccess(method, path) {
-    var _a, _b;
+function getParametrizedPathSuccess(method, path) {
+    var _a, _b, _c, _d;
     const pathParts = path.split("/");
+    // Traverse list to match the longest candidate
+    // matchedLen: the length of candidate path
+    // matchedValue: the matched status code array
+    let matchedLen = -1, matchedValue = [];
     // Iterate the responseMap to find a match
     for (const [key, value] of Object.entries(responseMap)) {
         // Extracting the path from the map key which is in format
@@ -67,41 +93,39 @@ function geParametrizedPathSuccess(method, path) {
         const candidatePath = getPathFromMapKey(key);
         // Get each part of the url path
         const candidateParts = candidatePath.split("/");
-        // If the candidate and actual paths don't match in size
-        // we move on to the next candidate path
-        if (candidateParts.length === pathParts.length &&
-            hasParametrizedPath(key)) {
-            // track if we have found a match to return the values found.
-            let found = true;
-            for (let i = 0; i < candidateParts.length; i++) {
-                if (((_a = candidateParts[i]) === null || _a === void 0 ? void 0 : _a.startsWith("{")) &&
-                    ((_b = candidateParts[i]) === null || _b === void 0 ? void 0 : _b.endsWith("}"))) {
-                    // If the current part of the candidate is a "template" part
-                    // it is a match with the actual path part on hand
-                    // skip as the parameterized part can match anything
-                    continue;
-                }
-                // If the candidate part is not a template and
-                // the parts don't match mark the candidate as not found
-                // to move on with the next candidate path.
-                if (candidateParts[i] !== pathParts[i]) {
+        // track if we have found a match to return the values found.
+        let found = true;
+        for (let i = candidateParts.length - 1, j = pathParts.length - 1; i >= 1 && j >= 1; i--, j--) {
+            if (((_a = candidateParts[i]) === null || _a === void 0 ? void 0 : _a.startsWith("{")) &&
+                ((_b = candidateParts[i]) === null || _b === void 0 ? void 0 : _b.indexOf("}")) !== -1) {
+                const start = candidateParts[i].indexOf("}") + 1, end = (_c = candidateParts[i]) === null || _c === void 0 ? void 0 : _c.length;
+                // If the current part of the candidate is a "template" part
+                // Try to use the suffix of pattern to match the path
+                // {guid} ==> $
+                // {guid}:export ==> :export$
+                const isMatched = new RegExp(`${(_d = candidateParts[i]) === null || _d === void 0 ? void 0 : _d.slice(start, end)}`).test(pathParts[j] || "");
+                if (!isMatched) {
                     found = false;
                     break;
                 }
+                continue;
             }
-            // We finished evaluating the current candidate parts
-            // if all parts matched we return the success values form
-            // the path mapping.
-            if (found) {
-                return value;
+            // If the candidate part is not a template and
+            // the parts don't match mark the candidate as not found
+            // to move on with the next candidate path.
+            if (candidateParts[i] !== pathParts[j]) {
+                found = false;
+                break;
             }
         }
+        // We finished evaluating the current candidate parts
+        // Update the matched value if and only if we found the longer pattern
+        if (found && candidatePath.length > matchedLen) {
+            matchedLen = candidatePath.length;
+            matchedValue = value;
+        }
     }
-    // No match was found, return an empty array.
-    return [];
-}
-function hasParametrizedPath(path) {
-    return path.includes("/{");
+    return matchedValue;
 }
 function getPathFromMapKey(mapKey) {
     const pathStart = mapKey.indexOf("/");
@@ -109,6 +133,7 @@ function getPathFromMapKey(mapKey) {
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
 /**
  * Helper function that builds a Poller object to help polling a long running operation.
  * @param client - Client to use for sending the request to get additional pages.
@@ -116,36 +141,90 @@ function getPathFromMapKey(mapKey) {
  * @param options - Options to set a resume state or custom polling interval.
  * @returns - A poller object to poll for operation state updates and eventually get the final response.
  */
-function getLongRunningPoller(client, initialResponse, options = {}) {
+async function getLongRunningPoller(client, initialResponse, options = {}) {
+    var _a;
+    const abortController = new AbortController();
     const poller = {
-        requestMethod: initialResponse.request.method,
-        requestPath: initialResponse.request.url,
         sendInitialRequest: async () => {
             // In the case of Rest Clients we are building the LRO poller object from a response that's the reason
             // we are not triggering the initial request here, just extracting the information from the
             // response we were provided.
             return getLroResponse(initialResponse);
         },
-        sendPollRequest: async (path) => {
+        sendPollRequest: async (path, pollOptions) => {
             // This is the callback that is going to be called to poll the service
             // to get the latest status. We use the client provided and the polling path
             // which is an opaque URL provided by caller, the service sends this in one of the following headers: operation-location, azure-asyncoperation or location
             // depending on the lro pattern that the service implements. If non is provided we default to the initial path.
-            const response = await client
-                .pathUnchecked(path !== null && path !== void 0 ? path : initialResponse.request.url)
-                .get();
+            function abortListener() {
+                abortController.abort();
+            }
+            const inputAbortSignal = pollOptions === null || pollOptions === void 0 ? void 0 : pollOptions.abortSignal;
+            const abortSignal = abortController.signal;
+            if (inputAbortSignal === null || inputAbortSignal === void 0 ? void 0 : inputAbortSignal.aborted) {
+                abortController.abort();
+            }
+            else if (!abortSignal.aborted) {
+                inputAbortSignal === null || inputAbortSignal === void 0 ? void 0 : inputAbortSignal.addEventListener("abort", abortListener, {
+                    once: true,
+                });
+            }
+            let response;
+            try {
+                response = await client
+                    .pathUnchecked(path !== null && path !== void 0 ? path : initialResponse.request.url)
+                    .get({ abortSignal });
+            }
+            finally {
+                inputAbortSignal === null || inputAbortSignal === void 0 ? void 0 : inputAbortSignal.removeEventListener("abort", abortListener);
+            }
             const lroResponse = getLroResponse(response);
             lroResponse.rawResponse.headers["x-ms-original-url"] =
                 initialResponse.request.url;
             return lroResponse;
-        }
+        },
     };
-    return new coreLro.LroEngine(poller, options);
+    options.resolveOnUnsuccessful = (_a = options.resolveOnUnsuccessful) !== null && _a !== void 0 ? _a : true;
+    const httpPoller = coreLro.createHttpPoller(poller, options);
+    const simplePoller = {
+        isDone() {
+            return httpPoller.isDone;
+        },
+        isStopped() {
+            return abortController.signal.aborted;
+        },
+        getOperationState() {
+            if (!httpPoller.operationState) {
+                throw new Error("Operation state is not available. The poller may not have been started and you could await submitted() before calling getOperationState().");
+            }
+            return httpPoller.operationState;
+        },
+        getResult() {
+            return httpPoller.result;
+        },
+        toString() {
+            if (!httpPoller.operationState) {
+                throw new Error("Operation state is not available. The poller may not have been started and you could await submitted() before calling getOperationState().");
+            }
+            return JSON.stringify({
+                state: httpPoller.operationState,
+            });
+        },
+        stopPolling() {
+            abortController.abort();
+        },
+        onProgress: httpPoller.onProgress,
+        poll: httpPoller.poll,
+        pollUntilDone: httpPoller.pollUntilDone,
+        serialize: httpPoller.serialize,
+        submitted: httpPoller.submitted,
+    };
+    return simplePoller;
 }
 /**
- * Converts a Rest Client response to a response that the LRO engine knows about
+ * Converts a Rest Client response to a response that the LRO implementation understands
  * @param response - a rest client http response
- * @returns - An LRO response that the LRO engine can work with
+ * @returns - An LRO response that the LRO implementation understands
  */
 function getLroResponse(response) {
     if (Number.isNaN(response.status)) {
@@ -153,15 +232,29 @@ function getLroResponse(response) {
     }
     return {
         flatResponse: response,
-        rawResponse: Object.assign(Object.assign({}, response), { statusCode: Number.parseInt(response.status), body: response.body })
+        rawResponse: Object.assign(Object.assign({}, response), { statusCode: Number.parseInt(response.status), body: response.body }),
     };
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+function buildMultiCollection(items, parameterName) {
+    return items
+        .map((item, index) => {
+        if (index === 0) {
+            return item;
+        }
+        return `${parameterName}=${item}`;
+    })
+        .join("&");
+}
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
 function MapsRoute(credential, clientIdOrOptions = {}, maybeOptions = {}) {
     const options = typeof clientIdOrOptions === "string" ? maybeOptions : clientIdOrOptions;
     /**
-     * maps service requires a header "ms-x-client-id", which is different from the standard AAD.
+     * maps service requires a header "ms-x-client-id", which is different from the standard Microsoft Entra ID.
      * So we need to do our own implementation.
      * This customized authentication is following by this guide: https://github.com/Azure/azure-sdk-for-js/blob/main/documentation/RLC-customization.md#custom-authentication
      */
@@ -173,16 +266,27 @@ function MapsRoute(credential, clientIdOrOptions = {}, maybeOptions = {}) {
         const client = createClient(undefined, options);
         client.pipeline.addPolicy(coreRestPipeline.bearerTokenAuthenticationPolicy({
             credential,
-            scopes: `${options.baseUrl || "https://atlas.microsoft.com"}/.default`,
+            scopes: "https://atlas.microsoft.com/.default",
         }));
         client.pipeline.addPolicy(mapsCommon.createMapsClientIdPolicy(clientId));
         return client;
     }
+    if (coreAuth.isSASCredential(credential)) {
+        const client = createClient(undefined, options);
+        client.pipeline.addPolicy({
+            name: "mapsSASCredentialPolicy",
+            async sendRequest(request, next) {
+                request.headers.set("Authorization", `jwt-sas ${credential.signature}`);
+                return next(request);
+            },
+        });
+        return client;
+    }
     return createClient(credential, options);
 }
 
 // Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
+// Licensed under the MIT License.
 function toLatLonString(coordinates) {
     return `${coordinates[0]},${coordinates[1]}`;
 }
@@ -225,9 +329,11 @@ function createRouteDirectionsBatchRequest(queryParamProperties) {
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
 
+exports.buildMultiCollection = buildMultiCollection;
 exports.createRouteDirectionsBatchRequest = createRouteDirectionsBatchRequest;
-exports["default"] = MapsRoute;
+exports.default = MapsRoute;
 exports.getLongRunningPoller = getLongRunningPoller;
 exports.isUnexpected = isUnexpected;
 exports.toColonDelimitedLatLonString = toColonDelimitedLatLonString;