@azure/cosmos 4.5.0 → 4.6.0

package/dist/browser/ClientContext.js

@@ -19,6 +19,7 @@ import { CosmosDbDiagnosticLevel } from "./diagnostics/CosmosDbDiagnosticLevel.j
 import { randomUUID } from "@azure/core-util";
 import { getUserAgent } from "./common/platform.js";
 import { PartitionKeyRangeCache } from "./routing/partitionKeyRangeCache.js";
+import { AAD_DEFAULT_SCOPE, AAD_AUTH_PREFIX, AAD_RESOURCE_NOT_FOUND_ERROR, } from "./common/constants.js";
 const logger = createClientLogger("ClientContext");
 const QueryJsonContentType = "application/query+json";
 const HttpHeaders = Constants.HttpHeaders;
@@ -26,14 +27,27 @@ const HttpHeaders = Constants.HttpHeaders;
  * @hidden
  */
 export class ClientContext {
+    cosmosClientOptions;
+    globalEndpointManager;
+    clientConfig;
+    diagnosticLevel;
+    globalPartitionEndpointManager;
+    sessionContainer;
+    connectionPolicy;
+    pipeline;
+    diagnosticWriter;
+    diagnosticFormatter;
+    partitionKeyDefinitionCache; // TODO: PartitionKeyDefinitionCache
+    /** @internal */
+    partitionKeyRangeCache;
+    /** boolean flag to support operations with client-side encryption */
+    enableEncryption = false;
     constructor(cosmosClientOptions, globalEndpointManager, clientConfig, diagnosticLevel, globalPartitionEndpointManager) {
         this.cosmosClientOptions = cosmosClientOptions;
         this.globalEndpointManager = globalEndpointManager;
         this.clientConfig = clientConfig;
         this.diagnosticLevel = diagnosticLevel;
         this.globalPartitionEndpointManager = globalPartitionEndpointManager;
-        /** boolean flag to support operations with client-side encryption */
-        this.enableEncryption = false;
         if (cosmosClientOptions.clientEncryptionOptions) {
             this.enableEncryption = true;
         }
@@ -44,16 +58,40 @@ export class ClientContext {
         if (cosmosClientOptions.aadCredentials) {
             this.pipeline = createEmptyPipeline();
             const hrefEndpoint = sanitizeEndpoint(cosmosClientOptions.endpoint);
-            const scope = `${hrefEndpoint}/.default`;
+            // Use custom AAD scope if provided, otherwise use account-based scope
+            const accountScope = `${hrefEndpoint}/.default`;
+            const primaryScope = cosmosClientOptions.aadScope || accountScope;
+            const fallbackScope = AAD_DEFAULT_SCOPE;
             this.pipeline.addPolicy(bearerTokenAuthenticationPolicy({
                 credential: cosmosClientOptions.aadCredentials,
-                scopes: scope,
+                scopes: primaryScope,
                 challengeCallbacks: {
                     async authorizeRequest({ request, getAccessToken }) {
-                        const tokenResponse = await getAccessToken([scope], {});
-                        const AUTH_PREFIX = `type=aad&ver=1.0&sig=`;
-                        const authorizationToken = `${AUTH_PREFIX}${tokenResponse.token}`;
-                        request.headers.set("Authorization", authorizationToken);
+                        try {
+                            const tokenResponse = await getAccessToken([primaryScope], {});
+                            const authorizationToken = `${AAD_AUTH_PREFIX}${tokenResponse.token}`;
+                            request.headers.set(Constants.HttpHeaders.Authorization, authorizationToken);
+                        }
+                        catch (error) {
+                            // If no custom scope is provided and we get AADSTS500011 error,
+                            // fallback to the default Cosmos scope
+                            if (!cosmosClientOptions.aadScope &&
+                                error?.message?.includes(AAD_RESOURCE_NOT_FOUND_ERROR)) {
+                                try {
+                                    const fallbackTokenResponse = await getAccessToken([fallbackScope], {});
+                                    const authorizationToken = `${AAD_AUTH_PREFIX}${fallbackTokenResponse.token}`;
+                                    request.headers.set(Constants.HttpHeaders.Authorization, authorizationToken);
+                                }
+                                catch (fallbackError) {
+                                    // If fallback also fails, throw the original error
+                                    throw error;
+                                }
+                            }
+                            else {
+                                // If custom scope is provided or error is not AADSTS500011, throw the original error
+                                throw error;
+                            }
+                        }
                     },
                 },
             }));
@@ -64,10 +102,16 @@ export class ClientContext {
     /** @hidden */
     async read({ path, resourceType, resourceId, options = {}, partitionKey, diagnosticNode, partitionKeyRangeId, }) {
         try {
-            const request = Object.assign(Object.assign({}, this.getContextDerivedPropsForRequestCreation()), { method: HTTPMethod.get, path, operationType: OperationType.Read, resourceId,
+            const request = {
+                ...this.getContextDerivedPropsForRequestCreation(),
+                method: HTTPMethod.get,
+                path,
+                operationType: OperationType.Read,
+                resourceId,
                 options,
                 resourceType,
-                partitionKey });
+                partitionKey,
+            };
             diagnosticNode.addData({
                 operationType: OperationType.Read,
                 resourceType,
@@ -82,7 +126,13 @@ export class ClientContext {
             }
             this.applySessionToken(request);
             // read will use ReadEndpoint since it uses GET operation
-            request.endpoint = await this.globalEndpointManager.resolveServiceEndpoint(diagnosticNode, request.resourceType, request.operationType);
+            request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
+                diagnosticNode: diagnosticNode,
+                resourceType: request.resourceType,
+                operationType: request.operationType,
+                startServiceEndpointIndex: 0,
+                excludedLocations: options?.excludedLocations,
+            });
             const response = await executePlugins(diagnosticNode, request, RequestHandler.request, PluginOn.operation);
             this.captureSessionToken(undefined, path, OperationType.Read, response.headers);
             return response;
@@ -95,10 +145,18 @@ export class ClientContext {
     async queryFeed({ path, resourceType, resourceId, resultFn, query, options, diagnosticNode, partitionKeyRangeId, partitionKey, startEpk, endEpk, correlatedActivityId, }) {
         // Query operations will use ReadEndpoint even though it uses
         // GET(for queryFeed) and POST(for regular query operations)
-        const request = Object.assign(Object.assign({}, this.getContextDerivedPropsForRequestCreation()), { method: HTTPMethod.get, path, operationType: OperationType.Query, partitionKeyRangeId,
+        const request = {
+            ...this.getContextDerivedPropsForRequestCreation(),
+            method: HTTPMethod.get,
+            path,
+            operationType: OperationType.Query,
+            partitionKeyRangeId,
             resourceId,
             resourceType,
-            options, body: query, partitionKey });
+            options,
+            body: query,
+            partitionKey,
+        };
         diagnosticNode.addData({
             operationType: OperationType.Query,
             resourceType,
@@ -107,7 +165,13 @@ export class ClientContext {
         if (query !== undefined) {
             request.method = HTTPMethod.post;
         }
-        request.endpoint = await this.globalEndpointManager.resolveServiceEndpoint(diagnosticNode, request.resourceType, request.operationType);
+        request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
+            diagnosticNode: diagnosticNode,
+            resourceType: request.resourceType,
+            operationType: request.operationType,
+            startServiceEndpointIndex: 0,
+            excludedLocations: options?.excludedLocations,
+        });
         request.headers = await this.buildHeaders(request);
         if (startEpk !== undefined && endEpk !== undefined) {
             request.headers[HttpHeaders.StartEpk] = startEpk;
@@ -137,14 +201,27 @@ export class ClientContext {
         return this.processQueryFeedResponse(response, !!query, resultFn);
     }
     async getQueryPlan(path, resourceType, resourceId, query, options = {}, diagnosticNode, correlatedActivityId) {
-        const request = Object.assign(Object.assign({}, this.getContextDerivedPropsForRequestCreation()), { method: HTTPMethod.post, path, operationType: OperationType.Read, resourceId,
+        const request = {
+            ...this.getContextDerivedPropsForRequestCreation(),
+            method: HTTPMethod.post,
+            path,
+            operationType: OperationType.Read,
+            resourceId,
             resourceType,
-            options, body: query });
+            options,
+            body: query,
+        };
         diagnosticNode.addData({
             operationType: OperationType.Read,
             resourceType,
         });
-        request.endpoint = await this.globalEndpointManager.resolveServiceEndpoint(diagnosticNode, request.resourceType, request.operationType);
+        request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
+            diagnosticNode: diagnosticNode,
+            resourceType: request.resourceType,
+            operationType: request.operationType,
+            startServiceEndpointIndex: 0,
+            excludedLocations: options?.excludedLocations,
+        });
         request.headers = await this.buildHeaders(request);
         if (correlatedActivityId !== undefined) {
             request.headers[HttpHeaders.CorrelatedActivityId] = correlatedActivityId;
@@ -180,11 +257,16 @@ export class ClientContext {
     }
     async delete({ path, resourceType, resourceId, options = {}, partitionKey, method = HTTPMethod.delete, diagnosticNode, partitionKeyRangeId, }) {
         try {
-            const request = Object.assign(Object.assign({}, this.getContextDerivedPropsForRequestCreation()), { method: method, operationType: OperationType.Delete, path,
+            const request = {
+                ...this.getContextDerivedPropsForRequestCreation(),
+                method: method,
+                operationType: OperationType.Delete,
+                path,
                 resourceType,
                 options,
                 resourceId,
-                partitionKey });
+                partitionKey,
+            };
             diagnosticNode.addData({
                 operationType: OperationType.Delete,
                 resourceType,
@@ -193,7 +275,13 @@ export class ClientContext {
             request.partitionKeyRangeId = partitionKeyRangeId;
             this.applySessionToken(request);
             // deleteResource will use WriteEndpoint since it uses DELETE operation
-            request.endpoint = await this.globalEndpointManager.resolveServiceEndpoint(diagnosticNode, request.resourceType, request.operationType);
+            request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
+                diagnosticNode: diagnosticNode,
+                resourceType: request.resourceType,
+                operationType: request.operationType,
+                startServiceEndpointIndex: 0,
+                excludedLocations: options?.excludedLocations,
+            });
             const response = await executePlugins(diagnosticNode, request, RequestHandler.request, PluginOn.operation);
             if (parseLink(path).type !== "colls") {
                 this.captureSessionToken(undefined, path, OperationType.Delete, response.headers);
@@ -210,12 +298,17 @@ export class ClientContext {
     }
     async patch({ body, path, resourceType, resourceId, options = {}, partitionKey, diagnosticNode, partitionKeyRangeId, }) {
         try {
-            const request = Object.assign(Object.assign({}, this.getContextDerivedPropsForRequestCreation()), { method: HTTPMethod.patch, operationType: OperationType.Patch, path,
+            const request = {
+                ...this.getContextDerivedPropsForRequestCreation(),
+                method: HTTPMethod.patch,
+                operationType: OperationType.Patch,
+                path,
                 resourceType,
                 body,
                 resourceId,
                 options,
-                partitionKey });
+                partitionKey,
+            };
             diagnosticNode.addData({
                 operationType: OperationType.Patch,
                 resourceType,
@@ -224,7 +317,13 @@ export class ClientContext {
             request.partitionKeyRangeId = partitionKeyRangeId;
             this.applySessionToken(request);
             // patch will use WriteEndpoint
-            request.endpoint = await this.globalEndpointManager.resolveServiceEndpoint(diagnosticNode, request.resourceType, request.operationType);
+            request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
+                diagnosticNode: diagnosticNode,
+                resourceType: request.resourceType,
+                operationType: request.operationType,
+                startServiceEndpointIndex: 0,
+                excludedLocations: options?.excludedLocations,
+            });
             const response = await executePlugins(diagnosticNode, request, RequestHandler.request, PluginOn.operation);
             this.captureSessionToken(undefined, path, OperationType.Patch, response.headers);
             return response;
@@ -236,12 +335,17 @@ export class ClientContext {
     }
     async create({ body, path, resourceType, resourceId, diagnosticNode, options = {}, partitionKey, partitionKeyRangeId, }) {
         try {
-            const request = Object.assign(Object.assign({}, this.getContextDerivedPropsForRequestCreation()), { method: HTTPMethod.post, operationType: OperationType.Create, path,
+            const request = {
+                ...this.getContextDerivedPropsForRequestCreation(),
+                method: HTTPMethod.post,
+                operationType: OperationType.Create,
+                path,
                 resourceType,
                 resourceId,
                 body,
                 options,
-                partitionKey });
+                partitionKey,
+            };
             diagnosticNode.addData({
                 operationType: OperationType.Create,
                 resourceType,
@@ -250,7 +354,13 @@ export class ClientContext {
             request.partitionKeyRangeId = partitionKeyRangeId;
             // create will use WriteEndpoint since it uses POST operation
             this.applySessionToken(request);
-            request.endpoint = await this.globalEndpointManager.resolveServiceEndpoint(diagnosticNode, request.resourceType, request.operationType);
+            request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
+                diagnosticNode: diagnosticNode,
+                resourceType: request.resourceType,
+                operationType: request.operationType,
+                startServiceEndpointIndex: 0,
+                excludedLocations: options?.excludedLocations,
+            });
             const response = await executePlugins(diagnosticNode, request, RequestHandler.request, PluginOn.operation);
             this.captureSessionToken(undefined, path, OperationType.Create, response.headers);
             return response;
@@ -298,12 +408,17 @@ export class ClientContext {
     }
     async replace({ body, path, resourceType, resourceId, options = {}, partitionKey, diagnosticNode, partitionKeyRangeId, }) {
         try {
-            const request = Object.assign(Object.assign({}, this.getContextDerivedPropsForRequestCreation()), { method: HTTPMethod.put, operationType: OperationType.Replace, path,
+            const request = {
+                ...this.getContextDerivedPropsForRequestCreation(),
+                method: HTTPMethod.put,
+                operationType: OperationType.Replace,
+                path,
                 resourceType,
                 body,
                 resourceId,
                 options,
-                partitionKey });
+                partitionKey,
+            };
             diagnosticNode.addData({
                 operationType: OperationType.Replace,
                 resourceType,
@@ -312,7 +427,13 @@ export class ClientContext {
             request.partitionKeyRangeId = partitionKeyRangeId;
             this.applySessionToken(request);
             // replace will use WriteEndpoint since it uses PUT operation
-            request.endpoint = await this.globalEndpointManager.resolveServiceEndpoint(diagnosticNode, request.resourceType, request.operationType);
+            request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
+                diagnosticNode: diagnosticNode,
+                resourceType: request.resourceType,
+                operationType: request.operationType,
+                startServiceEndpointIndex: 0,
+                excludedLocations: options?.excludedLocations,
+            });
             const response = await executePlugins(diagnosticNode, request, RequestHandler.request, PluginOn.operation);
             this.captureSessionToken(undefined, path, OperationType.Replace, response.headers);
             return response;
@@ -324,12 +445,17 @@ export class ClientContext {
     }
     async upsert({ body, path, resourceType, resourceId, options = {}, partitionKey, diagnosticNode, partitionKeyRangeId, }) {
         try {
-            const request = Object.assign(Object.assign({}, this.getContextDerivedPropsForRequestCreation()), { method: HTTPMethod.post, operationType: OperationType.Upsert, path,
+            const request = {
+                ...this.getContextDerivedPropsForRequestCreation(),
+                method: HTTPMethod.post,
+                operationType: OperationType.Upsert,
+                path,
                 resourceType,
                 body,
                 resourceId,
                 options,
-                partitionKey });
+                partitionKey,
+            };
             diagnosticNode.addData({
                 operationType: OperationType.Upsert,
                 resourceType,
@@ -339,7 +465,13 @@ export class ClientContext {
             request.headers[HttpHeaders.IsUpsert] = true;
             this.applySessionToken(request);
             // upsert will use WriteEndpoint since it uses POST operation
-            request.endpoint = await this.globalEndpointManager.resolveServiceEndpoint(diagnosticNode, request.resourceType, request.operationType);
+            request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
+                diagnosticNode: diagnosticNode,
+                resourceType: request.resourceType,
+                operationType: request.operationType,
+                startServiceEndpointIndex: 0,
+                excludedLocations: options?.excludedLocations,
+            });
             const response = await executePlugins(diagnosticNode, request, RequestHandler.request, PluginOn.operation);
             this.captureSessionToken(undefined, path, OperationType.Upsert, response.headers);
             return response;
@@ -357,7 +489,17 @@ export class ClientContext {
         }
         const path = getPathFromLink(sprocLink);
         const id = getIdFromLink(sprocLink);
-        const request = Object.assign(Object.assign({}, this.getContextDerivedPropsForRequestCreation()), { method: HTTPMethod.post, operationType: OperationType.Execute, path, resourceType: ResourceType.sproc, options, resourceId: id, body: params, partitionKey });
+        const request = {
+            ...this.getContextDerivedPropsForRequestCreation(),
+            method: HTTPMethod.post,
+            operationType: OperationType.Execute,
+            path,
+            resourceType: ResourceType.sproc,
+            options,
+            resourceId: id,
+            body: params,
+            partitionKey,
+        };
         diagnosticNode.addData({
             operationType: OperationType.Execute,
             resourceType: ResourceType.sproc,
@@ -365,7 +507,13 @@ export class ClientContext {
         request.headers = await this.buildHeaders(request);
         request.partitionKeyRangeId = partitionKeyRangeId;
         // executeStoredProcedure will use WriteEndpoint since it uses POST operation
-        request.endpoint = await this.globalEndpointManager.resolveServiceEndpoint(diagnosticNode, request.resourceType, request.operationType);
+        request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
+            diagnosticNode: diagnosticNode,
+            resourceType: request.resourceType,
+            operationType: request.operationType,
+            startServiceEndpointIndex: 0,
+            excludedLocations: options?.excludedLocations,
+        });
         const response = await executePlugins(diagnosticNode, request, RequestHandler.request, PluginOn.operation);
         return response;
     }
@@ -376,7 +524,15 @@ export class ClientContext {
      */
     async getDatabaseAccount(diagnosticNode, options = {}) {
         const endpoint = options.urlConnection || this.cosmosClientOptions.endpoint;
-        const request = Object.assign(Object.assign({}, this.getContextDerivedPropsForRequestCreation()), { endpoint, method: HTTPMethod.get, operationType: OperationType.Read, path: "", resourceType: ResourceType.none, options });
+        const request = {
+            ...this.getContextDerivedPropsForRequestCreation(),
+            endpoint,
+            method: HTTPMethod.get,
+            operationType: OperationType.Read,
+            path: "",
+            resourceType: ResourceType.none,
+            options,
+        };
         diagnosticNode.addData({
             operationType: OperationType.Read,
             resourceType: ResourceType.none,
@@ -407,10 +563,17 @@ export class ClientContext {
     }
     async batch({ body, path, partitionKey, resourceId, options = {}, diagnosticNode, partitionKeyRangeId, }) {
         try {
-            const request = Object.assign(Object.assign({}, this.getContextDerivedPropsForRequestCreation()), { method: HTTPMethod.post, operationType: OperationType.Batch, path,
-                body, resourceType: ResourceType.item, resourceId,
+            const request = {
+                ...this.getContextDerivedPropsForRequestCreation(),
+                method: HTTPMethod.post,
+                operationType: OperationType.Batch,
+                path,
+                body,
+                resourceType: ResourceType.item,
+                resourceId,
                 options,
-                partitionKey });
+                partitionKey,
+            };
             diagnosticNode.addData({
                 operationType: OperationType.Batch,
                 resourceType: ResourceType.item,
@@ -420,7 +583,13 @@ export class ClientContext {
             request.headers[HttpHeaders.IsBatchRequest] = true;
             request.headers[HttpHeaders.IsBatchAtomic] = true;
             this.applySessionToken(request);
-            request.endpoint = await this.globalEndpointManager.resolveServiceEndpoint(diagnosticNode, request.resourceType, request.operationType);
+            request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
+                diagnosticNode: diagnosticNode,
+                resourceType: request.resourceType,
+                operationType: request.operationType,
+                startServiceEndpointIndex: 0,
+                excludedLocations: options?.excludedLocations,
+            });
             const response = await executePlugins(diagnosticNode, request, RequestHandler.request, PluginOn.operation);
             this.captureSessionToken(undefined, path, OperationType.Batch, response.headers);
             response.diagnostics = diagnosticNode.toDiagnostic(this.getClientConfig());
@@ -432,11 +601,17 @@ export class ClientContext {
         }
     }
     async bulk({ body, path, partitionKeyRangeId, resourceId, bulkOptions = {}, options = {}, diagnosticNode, }) {
-        var _a;
         try {
-            const request = Object.assign(Object.assign({}, this.getContextDerivedPropsForRequestCreation()), { method: HTTPMethod.post, operationType: OperationType.Batch, path,
-                body, resourceType: ResourceType.item, resourceId,
-                options });
+            const request = {
+                ...this.getContextDerivedPropsForRequestCreation(),
+                method: HTTPMethod.post,
+                operationType: OperationType.Batch,
+                path,
+                body,
+                resourceType: ResourceType.item,
+                resourceId,
+                options,
+            };
             diagnosticNode.addData({
                 operationType: OperationType.Batch,
                 resourceType: ResourceType.item,
@@ -446,9 +621,15 @@ export class ClientContext {
             request.headers[HttpHeaders.IsBatchRequest] = true;
             request.headers[HttpHeaders.PartitionKeyRangeID] = partitionKeyRangeId;
             request.headers[HttpHeaders.IsBatchAtomic] = false;
-            request.headers[HttpHeaders.BatchContinueOnError] = (_a = bulkOptions.continueOnError) !== null && _a !== void 0 ? _a : true;
+            request.headers[HttpHeaders.BatchContinueOnError] = bulkOptions.continueOnError ?? true;
             this.applySessionToken(request);
-            request.endpoint = await this.globalEndpointManager.resolveServiceEndpoint(diagnosticNode, request.resourceType, request.operationType);
+            request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
+                diagnosticNode: diagnosticNode,
+                resourceType: request.resourceType,
+                operationType: request.operationType,
+                startServiceEndpointIndex: 0,
+                excludedLocations: options?.excludedLocations,
+            });
             const response = await executePlugins(diagnosticNode, request, RequestHandler.request, PluginOn.operation);
             this.captureSessionToken(undefined, path, OperationType.Batch, response.headers);
             return response;
@@ -518,7 +699,10 @@ export class ClientContext {
     buildHeaders(requestContext) {
         return getHeaders({
             clientOptions: this.cosmosClientOptions,
-            defaultHeaders: Object.assign(Object.assign({}, this.cosmosClientOptions.defaultHeaders), requestContext.options.initialHeaders),
+            defaultHeaders: {
+                ...this.cosmosClientOptions.defaultHeaders,
+                ...requestContext.options.initialHeaders,
+            },
             verb: requestContext.method,
             path: requestContext.path,
             resourceId: requestContext.resourceId,
@@ -571,8 +755,8 @@ export class ClientContext {
      * @internal
      */
     isPartitionLevelFailOverEnabled() {
-        return (this.connectionPolicy.enablePartitionLevelFailover ||
-            this.connectionPolicy.enablePartitionLevelCircuitBreaker);
+        return (this.globalEndpointManager.enablePartitionLevelFailover ||
+            this.globalEndpointManager.enablePartitionLevelCircuitBreaker);
     }
 }
 //# sourceMappingURL=ClientContext.js.map