@azure/cosmos
Version:
Microsoft Azure Cosmos DB Service Node.js SDK for NOSQL API
873 lines (872 loc) • 32.4 kB
JavaScript
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var ClientContext_exports = {};
__export(ClientContext_exports, {
ClientContext: () => ClientContext
});
module.exports = __toCommonJS(ClientContext_exports);
var import_core_rest_pipeline = require("@azure/core-rest-pipeline");
var import_constants = require("./common/constants.js");
var import_helper = require("./common/helper.js");
var import_statusCodes = require("./common/statusCodes.js");
var import_documents = require("./documents/index.js");
var import_Plugin = require("./plugins/Plugin.js");
var import_queryIterator = require("./queryIterator.js");
var import_request = require("./request/request.js");
var import_RequestHandler = require("./request/RequestHandler.js");
var import_sessionContainer = require("./session/sessionContainer.js");
var import_checkURL = require("./utils/checkURL.js");
var import_supportedQueryFeaturesBuilder = require("./utils/supportedQueryFeaturesBuilder.js");
var import_logger = require("@azure/logger");
var import_DiagnosticWriter = require("./diagnostics/DiagnosticWriter.js");
var import_DiagnosticFormatter = require("./diagnostics/DiagnosticFormatter.js");
var import_CosmosDbDiagnosticLevel = require("./diagnostics/CosmosDbDiagnosticLevel.js");
var import_core_util = require("@azure/core-util");
var import_platform = require("./common/platform.js");
var import_partitionKeyRangeCache = require("./routing/partitionKeyRangeCache.js");
var import_constants2 = require("./common/constants.js");
const logger = (0, import_logger.createClientLogger)("ClientContext");
const QueryJsonContentType = "application/query+json";
const HttpHeaders = import_constants.Constants.HttpHeaders;
class ClientContext {
constructor(cosmosClientOptions, globalEndpointManager, clientConfig, diagnosticLevel, globalPartitionEndpointManager) {
this.cosmosClientOptions = cosmosClientOptions;
this.globalEndpointManager = globalEndpointManager;
this.clientConfig = clientConfig;
this.diagnosticLevel = diagnosticLevel;
this.globalPartitionEndpointManager = globalPartitionEndpointManager;
if (cosmosClientOptions.clientEncryptionOptions) {
this.enableEncryption = true;
}
this.connectionPolicy = cosmosClientOptions.connectionPolicy;
this.sessionContainer = new import_sessionContainer.SessionContainer();
this.partitionKeyDefinitionCache = {};
this.pipeline = null;
if (cosmosClientOptions.aadCredentials) {
this.pipeline = (0, import_core_rest_pipeline.createEmptyPipeline)();
const hrefEndpoint = (0, import_checkURL.sanitizeEndpoint)(cosmosClientOptions.endpoint);
const accountScope = `${hrefEndpoint}/.default`;
const primaryScope = cosmosClientOptions.aadScope || accountScope;
const fallbackScope = import_constants2.AAD_DEFAULT_SCOPE;
this.pipeline.addPolicy(
(0, import_core_rest_pipeline.bearerTokenAuthenticationPolicy)({
credential: cosmosClientOptions.aadCredentials,
scopes: primaryScope,
challengeCallbacks: {
async authorizeRequest({ request, getAccessToken }) {
try {
const tokenResponse = await getAccessToken([primaryScope], {});
const authorizationToken = `${import_constants2.AAD_AUTH_PREFIX}${tokenResponse.token}`;
request.headers.set(import_constants.Constants.HttpHeaders.Authorization, authorizationToken);
} catch (error) {
if (!cosmosClientOptions.aadScope && error?.message?.includes(import_constants2.AAD_RESOURCE_NOT_FOUND_ERROR)) {
try {
const fallbackTokenResponse = await getAccessToken([fallbackScope], {});
const authorizationToken = `${import_constants2.AAD_AUTH_PREFIX}${fallbackTokenResponse.token}`;
request.headers.set(import_constants.Constants.HttpHeaders.Authorization, authorizationToken);
} catch (fallbackError) {
throw error;
}
} else {
throw error;
}
}
}
}
})
);
}
this.initializeDiagnosticSettings(diagnosticLevel);
this.partitionKeyRangeCache = new import_partitionKeyRangeCache.PartitionKeyRangeCache(this);
}
sessionContainer;
connectionPolicy;
pipeline;
diagnosticWriter;
diagnosticFormatter;
partitionKeyDefinitionCache;
// TODO: PartitionKeyDefinitionCache
/** @internal */
partitionKeyRangeCache;
/** boolean flag to support operations with client-side encryption */
enableEncryption = false;
/** @hidden */
async read({
path,
resourceType,
resourceId,
options = {},
partitionKey,
diagnosticNode,
partitionKeyRangeId
}) {
try {
const request = {
...this.getContextDerivedPropsForRequestCreation(),
method: import_constants.HTTPMethod.get,
path,
operationType: import_constants.OperationType.Read,
resourceId,
options,
resourceType,
partitionKey
};
diagnosticNode.addData({
operationType: import_constants.OperationType.Read,
resourceType
});
request.headers = await this.buildHeaders(request);
request.partitionKeyRangeId = partitionKeyRangeId;
if (resourceType === import_constants.ResourceType.clientencryptionkey) {
request.headers[HttpHeaders.AllowCachedReadsHeader] = true;
if (options.databaseRid) {
request.headers[HttpHeaders.DatabaseRidHeader] = options.databaseRid;
}
}
this.applySessionToken(request);
request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
diagnosticNode,
resourceType: request.resourceType,
operationType: request.operationType,
startServiceEndpointIndex: 0,
excludedLocations: options?.excludedLocations
});
const response = await (0, import_Plugin.executePlugins)(
diagnosticNode,
request,
import_RequestHandler.RequestHandler.request,
import_Plugin.PluginOn.operation
);
this.captureSessionToken(void 0, path, import_constants.OperationType.Read, response.headers);
return response;
} catch (err) {
this.captureSessionToken(err, path, import_constants.OperationType.Upsert, err.headers);
throw err;
}
}
async queryFeed({
path,
resourceType,
resourceId,
resultFn,
query,
options,
diagnosticNode,
partitionKeyRangeId,
partitionKey,
startEpk,
endEpk,
correlatedActivityId
}) {
const request = {
...this.getContextDerivedPropsForRequestCreation(),
method: import_constants.HTTPMethod.get,
path,
operationType: import_constants.OperationType.Query,
partitionKeyRangeId,
resourceId,
resourceType,
options,
body: query,
partitionKey
};
diagnosticNode.addData({
operationType: import_constants.OperationType.Query,
resourceType
});
const requestId = (0, import_core_util.randomUUID)();
if (query !== void 0) {
request.method = import_constants.HTTPMethod.post;
}
request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
diagnosticNode,
resourceType: request.resourceType,
operationType: request.operationType,
startServiceEndpointIndex: 0,
excludedLocations: options?.excludedLocations
});
request.headers = await this.buildHeaders(request);
if (startEpk !== void 0 && endEpk !== void 0) {
request.headers[HttpHeaders.StartEpk] = startEpk;
request.headers[HttpHeaders.EndEpk] = endEpk;
request.headers[HttpHeaders.ReadFeedKeyType] = "EffectivePartitionKeyRange";
}
if (query !== void 0) {
if (correlatedActivityId !== void 0) {
request.headers[HttpHeaders.CorrelatedActivityId] = correlatedActivityId;
}
request.headers[HttpHeaders.IsQuery] = "true";
request.headers[HttpHeaders.ContentType] = QueryJsonContentType;
if (typeof query === "string") {
request.body = { query };
}
}
this.applySessionToken(request);
logger.info(
"query " + requestId + " started" + (request.partitionKeyRangeId ? " pkrid: " + request.partitionKeyRangeId : "")
);
logger.verbose(request);
const start = Date.now();
const response = await import_RequestHandler.RequestHandler.request(request, diagnosticNode);
logger.info("query " + requestId + " finished - " + (Date.now() - start) + "ms");
this.captureSessionToken(void 0, path, import_constants.OperationType.Query, response.headers);
return this.processQueryFeedResponse(response, !!query, resultFn);
}
async getQueryPlan(path, resourceType, resourceId, query, options = {}, diagnosticNode, correlatedActivityId) {
const request = {
...this.getContextDerivedPropsForRequestCreation(),
method: import_constants.HTTPMethod.post,
path,
operationType: import_constants.OperationType.Read,
resourceId,
resourceType,
options,
body: query
};
diagnosticNode.addData({
operationType: import_constants.OperationType.Read,
resourceType
});
request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
diagnosticNode,
resourceType: request.resourceType,
operationType: request.operationType,
startServiceEndpointIndex: 0,
excludedLocations: options?.excludedLocations
});
request.headers = await this.buildHeaders(request);
if (correlatedActivityId !== void 0) {
request.headers[HttpHeaders.CorrelatedActivityId] = correlatedActivityId;
}
request.headers[HttpHeaders.IsQueryPlan] = "True";
request.headers[HttpHeaders.QueryVersion] = "1.4";
request.headers[HttpHeaders.ContentType] = QueryJsonContentType;
request.headers[HttpHeaders.SupportedQueryFeatures] = (0, import_supportedQueryFeaturesBuilder.supportedQueryFeaturesBuilder)(options);
if (typeof query === "string") {
request.body = { query };
}
this.applySessionToken(request);
const response = await import_RequestHandler.RequestHandler.request(request, diagnosticNode);
this.captureSessionToken(void 0, path, import_constants.OperationType.Query, response.headers);
return response;
}
queryPartitionKeyRanges(collectionLink, query, options) {
const path = (0, import_helper.getPathFromLink)(collectionLink, import_constants.ResourceType.pkranges);
const id = (0, import_helper.getIdFromLink)(collectionLink);
const cb = async (diagNode, innerOptions) => {
const response = await this.queryFeed({
path,
resourceType: import_constants.ResourceType.pkranges,
resourceId: id,
resultFn: (result) => result.PartitionKeyRanges,
query,
options: innerOptions,
diagnosticNode: diagNode
});
return response;
};
return new import_queryIterator.QueryIterator(this, query, options, cb);
}
async delete({
path,
resourceType,
resourceId,
options = {},
partitionKey,
method = import_constants.HTTPMethod.delete,
diagnosticNode,
partitionKeyRangeId
}) {
try {
const request = {
...this.getContextDerivedPropsForRequestCreation(),
method,
operationType: import_constants.OperationType.Delete,
path,
resourceType,
options,
resourceId,
partitionKey
};
diagnosticNode.addData({
operationType: import_constants.OperationType.Delete,
resourceType
});
request.headers = await this.buildHeaders(request);
request.partitionKeyRangeId = partitionKeyRangeId;
this.applySessionToken(request);
request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
diagnosticNode,
resourceType: request.resourceType,
operationType: request.operationType,
startServiceEndpointIndex: 0,
excludedLocations: options?.excludedLocations
});
const response = await (0, import_Plugin.executePlugins)(
diagnosticNode,
request,
import_RequestHandler.RequestHandler.request,
import_Plugin.PluginOn.operation
);
if ((0, import_helper.parseLink)(path).type !== "colls") {
this.captureSessionToken(void 0, path, import_constants.OperationType.Delete, response.headers);
} else {
this.clearSessionToken(path);
}
return response;
} catch (err) {
this.captureSessionToken(err, path, import_constants.OperationType.Upsert, err.headers);
throw err;
}
}
async patch({
body,
path,
resourceType,
resourceId,
options = {},
partitionKey,
diagnosticNode,
partitionKeyRangeId
}) {
try {
const request = {
...this.getContextDerivedPropsForRequestCreation(),
method: import_constants.HTTPMethod.patch,
operationType: import_constants.OperationType.Patch,
path,
resourceType,
body,
resourceId,
options,
partitionKey
};
diagnosticNode.addData({
operationType: import_constants.OperationType.Patch,
resourceType
});
request.headers = await this.buildHeaders(request);
request.partitionKeyRangeId = partitionKeyRangeId;
this.applySessionToken(request);
request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
diagnosticNode,
resourceType: request.resourceType,
operationType: request.operationType,
startServiceEndpointIndex: 0,
excludedLocations: options?.excludedLocations
});
const response = await (0, import_Plugin.executePlugins)(
diagnosticNode,
request,
import_RequestHandler.RequestHandler.request,
import_Plugin.PluginOn.operation
);
this.captureSessionToken(void 0, path, import_constants.OperationType.Patch, response.headers);
return response;
} catch (err) {
this.captureSessionToken(err, path, import_constants.OperationType.Upsert, err.headers);
throw err;
}
}
async create({
body,
path,
resourceType,
resourceId,
diagnosticNode,
options = {},
partitionKey,
partitionKeyRangeId
}) {
try {
const request = {
...this.getContextDerivedPropsForRequestCreation(),
method: import_constants.HTTPMethod.post,
operationType: import_constants.OperationType.Create,
path,
resourceType,
resourceId,
body,
options,
partitionKey
};
diagnosticNode.addData({
operationType: import_constants.OperationType.Create,
resourceType
});
request.headers = await this.buildHeaders(request);
request.partitionKeyRangeId = partitionKeyRangeId;
this.applySessionToken(request);
request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
diagnosticNode,
resourceType: request.resourceType,
operationType: request.operationType,
startServiceEndpointIndex: 0,
excludedLocations: options?.excludedLocations
});
const response = await (0, import_Plugin.executePlugins)(
diagnosticNode,
request,
import_RequestHandler.RequestHandler.request,
import_Plugin.PluginOn.operation
);
this.captureSessionToken(void 0, path, import_constants.OperationType.Create, response.headers);
return response;
} catch (err) {
this.captureSessionToken(err, path, import_constants.OperationType.Upsert, err.headers);
throw err;
}
}
processQueryFeedResponse(res, isQuery, resultFn) {
if (isQuery) {
return {
result: resultFn(res.result),
headers: res.headers,
code: res.code
};
} else {
const newResult = resultFn(res.result).map((body) => body);
return {
result: newResult,
headers: res.headers,
code: res.code
};
}
}
applySessionToken(requestContext) {
const request = this.getSessionParams(requestContext.path);
if (requestContext.headers && requestContext.headers[HttpHeaders.SessionToken]) {
return;
}
const sessionConsistency = requestContext.headers[HttpHeaders.ConsistencyLevel];
if (!sessionConsistency) {
return;
}
if (sessionConsistency !== import_documents.ConsistencyLevel.Session) {
return;
}
if (request.resourceAddress) {
const sessionToken = this.sessionContainer.get(request);
if (sessionToken) {
requestContext.headers[HttpHeaders.SessionToken] = sessionToken;
}
}
}
async replace({
body,
path,
resourceType,
resourceId,
options = {},
partitionKey,
diagnosticNode,
partitionKeyRangeId
}) {
try {
const request = {
...this.getContextDerivedPropsForRequestCreation(),
method: import_constants.HTTPMethod.put,
operationType: import_constants.OperationType.Replace,
path,
resourceType,
body,
resourceId,
options,
partitionKey
};
diagnosticNode.addData({
operationType: import_constants.OperationType.Replace,
resourceType
});
request.headers = await this.buildHeaders(request);
request.partitionKeyRangeId = partitionKeyRangeId;
this.applySessionToken(request);
request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
diagnosticNode,
resourceType: request.resourceType,
operationType: request.operationType,
startServiceEndpointIndex: 0,
excludedLocations: options?.excludedLocations
});
const response = await (0, import_Plugin.executePlugins)(
diagnosticNode,
request,
import_RequestHandler.RequestHandler.request,
import_Plugin.PluginOn.operation
);
this.captureSessionToken(void 0, path, import_constants.OperationType.Replace, response.headers);
return response;
} catch (err) {
this.captureSessionToken(err, path, import_constants.OperationType.Upsert, err.headers);
throw err;
}
}
async upsert({
body,
path,
resourceType,
resourceId,
options = {},
partitionKey,
diagnosticNode,
partitionKeyRangeId
}) {
try {
const request = {
...this.getContextDerivedPropsForRequestCreation(),
method: import_constants.HTTPMethod.post,
operationType: import_constants.OperationType.Upsert,
path,
resourceType,
body,
resourceId,
options,
partitionKey
};
diagnosticNode.addData({
operationType: import_constants.OperationType.Upsert,
resourceType
});
request.headers = await this.buildHeaders(request);
request.partitionKeyRangeId = partitionKeyRangeId;
request.headers[HttpHeaders.IsUpsert] = true;
this.applySessionToken(request);
request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
diagnosticNode,
resourceType: request.resourceType,
operationType: request.operationType,
startServiceEndpointIndex: 0,
excludedLocations: options?.excludedLocations
});
const response = await (0, import_Plugin.executePlugins)(
diagnosticNode,
request,
import_RequestHandler.RequestHandler.request,
import_Plugin.PluginOn.operation
);
this.captureSessionToken(void 0, path, import_constants.OperationType.Upsert, response.headers);
return response;
} catch (err) {
this.captureSessionToken(err, path, import_constants.OperationType.Upsert, err.headers);
throw err;
}
}
async execute({
sprocLink,
params,
options = {},
partitionKey,
diagnosticNode,
partitionKeyRangeId
}) {
if (params !== null && params !== void 0 && !Array.isArray(params)) {
params = [params];
}
const path = (0, import_helper.getPathFromLink)(sprocLink);
const id = (0, import_helper.getIdFromLink)(sprocLink);
const request = {
...this.getContextDerivedPropsForRequestCreation(),
method: import_constants.HTTPMethod.post,
operationType: import_constants.OperationType.Execute,
path,
resourceType: import_constants.ResourceType.sproc,
options,
resourceId: id,
body: params,
partitionKey
};
diagnosticNode.addData({
operationType: import_constants.OperationType.Execute,
resourceType: import_constants.ResourceType.sproc
});
request.headers = await this.buildHeaders(request);
request.partitionKeyRangeId = partitionKeyRangeId;
request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
diagnosticNode,
resourceType: request.resourceType,
operationType: request.operationType,
startServiceEndpointIndex: 0,
excludedLocations: options?.excludedLocations
});
const response = await (0, import_Plugin.executePlugins)(
diagnosticNode,
request,
import_RequestHandler.RequestHandler.request,
import_Plugin.PluginOn.operation
);
return response;
}
/**
* Gets the Database account information.
* @param options - `urlConnection` in the options is the endpoint url whose database account needs to be retrieved.
* If not present, current client's url will be used.
*/
async getDatabaseAccount(diagnosticNode, options = {}) {
const endpoint = options.urlConnection || this.cosmosClientOptions.endpoint;
const request = {
...this.getContextDerivedPropsForRequestCreation(),
endpoint,
method: import_constants.HTTPMethod.get,
operationType: import_constants.OperationType.Read,
path: "",
resourceType: import_constants.ResourceType.none,
options
};
diagnosticNode.addData({
operationType: import_constants.OperationType.Read,
resourceType: import_constants.ResourceType.none
});
request.headers = await this.buildHeaders(request);
const { result, headers, code, substatus, diagnostics } = await (0, import_Plugin.executePlugins)(
diagnosticNode,
request,
import_RequestHandler.RequestHandler.request,
import_Plugin.PluginOn.operation
);
const databaseAccount = new import_documents.DatabaseAccount(result, headers);
return {
result: databaseAccount,
headers,
diagnostics,
code,
substatus
};
}
getWriteEndpoint(diagnosticNode) {
return this.globalEndpointManager.getWriteEndpoint(diagnosticNode);
}
getReadEndpoint(diagnosticNode) {
return this.globalEndpointManager.getReadEndpoint(diagnosticNode);
}
getWriteEndpoints() {
return this.globalEndpointManager.getWriteEndpoints();
}
getReadEndpoints() {
return this.globalEndpointManager.getReadEndpoints();
}
async batch({
body,
path,
partitionKey,
resourceId,
options = {},
diagnosticNode,
partitionKeyRangeId
}) {
try {
const request = {
...this.getContextDerivedPropsForRequestCreation(),
method: import_constants.HTTPMethod.post,
operationType: import_constants.OperationType.Batch,
path,
body,
resourceType: import_constants.ResourceType.item,
resourceId,
options,
partitionKey
};
diagnosticNode.addData({
operationType: import_constants.OperationType.Batch,
resourceType: import_constants.ResourceType.item
});
request.headers = await this.buildHeaders(request);
request.partitionKeyRangeId = partitionKeyRangeId;
request.headers[HttpHeaders.IsBatchRequest] = true;
request.headers[HttpHeaders.IsBatchAtomic] = true;
this.applySessionToken(request);
request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
diagnosticNode,
resourceType: request.resourceType,
operationType: request.operationType,
startServiceEndpointIndex: 0,
excludedLocations: options?.excludedLocations
});
const response = await (0, import_Plugin.executePlugins)(
diagnosticNode,
request,
import_RequestHandler.RequestHandler.request,
import_Plugin.PluginOn.operation
);
this.captureSessionToken(void 0, path, import_constants.OperationType.Batch, response.headers);
response.diagnostics = diagnosticNode.toDiagnostic(this.getClientConfig());
return response;
} catch (err) {
this.captureSessionToken(err, path, import_constants.OperationType.Upsert, err.headers);
throw err;
}
}
async bulk({
body,
path,
partitionKeyRangeId,
resourceId,
bulkOptions = {},
options = {},
diagnosticNode
}) {
try {
const request = {
...this.getContextDerivedPropsForRequestCreation(),
method: import_constants.HTTPMethod.post,
operationType: import_constants.OperationType.Batch,
path,
body,
resourceType: import_constants.ResourceType.item,
resourceId,
options
};
diagnosticNode.addData({
operationType: import_constants.OperationType.Batch,
resourceType: import_constants.ResourceType.item
});
request.headers = await this.buildHeaders(request);
request.partitionKeyRangeId = partitionKeyRangeId;
request.headers[HttpHeaders.IsBatchRequest] = true;
request.headers[HttpHeaders.PartitionKeyRangeID] = partitionKeyRangeId;
request.headers[HttpHeaders.IsBatchAtomic] = false;
request.headers[HttpHeaders.BatchContinueOnError] = bulkOptions.continueOnError ?? true;
this.applySessionToken(request);
request.endpoint = await this.globalEndpointManager.resolveServiceEndpointInternal({
diagnosticNode,
resourceType: request.resourceType,
operationType: request.operationType,
startServiceEndpointIndex: 0,
excludedLocations: options?.excludedLocations
});
const response = await (0, import_Plugin.executePlugins)(
diagnosticNode,
request,
import_RequestHandler.RequestHandler.request,
import_Plugin.PluginOn.operation
);
this.captureSessionToken(void 0, path, import_constants.OperationType.Batch, response.headers);
return response;
} catch (err) {
this.captureSessionToken(err, path, import_constants.OperationType.Upsert, err.headers);
throw err;
}
}
captureSessionToken(err, path, operationType, resHeaders) {
const request = this.getSessionParams(path);
request.operationType = operationType;
if (!err || !this.isMasterResource(request.resourceType) && (err.code === import_statusCodes.StatusCodes.PreconditionFailed || err.code === import_statusCodes.StatusCodes.Conflict || err.code === import_statusCodes.StatusCodes.NotFound && err.substatus !== import_statusCodes.SubStatusCodes.ReadSessionNotAvailable)) {
this.sessionContainer.set(request, resHeaders);
}
}
clearSessionToken(path) {
const request = this.getSessionParams(path);
this.sessionContainer.remove(request);
}
recordDiagnostics(diagnostic) {
const formatted = this.diagnosticFormatter.format(diagnostic);
this.diagnosticWriter.write(formatted);
}
initializeDiagnosticSettings(diagnosticLevel) {
this.diagnosticFormatter = new import_DiagnosticFormatter.DefaultDiagnosticFormatter();
switch (diagnosticLevel) {
case import_CosmosDbDiagnosticLevel.CosmosDbDiagnosticLevel.info:
this.diagnosticWriter = new import_DiagnosticWriter.NoOpDiagnosticWriter();
break;
default:
this.diagnosticWriter = new import_DiagnosticWriter.LogDiagnosticWriter();
}
}
// TODO: move
getSessionParams(resourceLink) {
const resourceId = null;
let resourceAddress = null;
const parserOutput = (0, import_helper.parseLink)(resourceLink);
resourceAddress = parserOutput.objectBody.self;
const resourceType = parserOutput.type;
return {
resourceId,
resourceAddress,
resourceType,
isNameBased: true
};
}
isMasterResource(resourceType) {
if (resourceType === import_constants.Constants.Path.OffersPathSegment || resourceType === import_constants.Constants.Path.DatabasesPathSegment || resourceType === import_constants.Constants.Path.UsersPathSegment || resourceType === import_constants.Constants.Path.PermissionsPathSegment || resourceType === import_constants.Constants.Path.TopologyPathSegment || resourceType === import_constants.Constants.Path.DatabaseAccountPathSegment || resourceType === import_constants.Constants.Path.PartitionKeyRangesPathSegment || resourceType === import_constants.Constants.Path.CollectionsPathSegment) {
return true;
}
return false;
}
buildHeaders(requestContext) {
return (0, import_request.getHeaders)({
clientOptions: this.cosmosClientOptions,
defaultHeaders: {
...this.cosmosClientOptions.defaultHeaders,
...requestContext.options.initialHeaders
},
verb: requestContext.method,
path: requestContext.path,
resourceId: requestContext.resourceId,
resourceType: requestContext.resourceType,
options: requestContext.options,
partitionKeyRangeId: requestContext.partitionKeyRangeId,
useMultipleWriteLocations: this.connectionPolicy.useMultipleWriteLocations,
partitionKey: requestContext.partitionKey !== void 0 ? (0, import_documents.convertToInternalPartitionKey)(requestContext.partitionKey) : void 0,
// TODO: Move this check from here to PartitionKey
operationType: requestContext.operationType
});
}
/**
* Returns collection of properties which are derived from the context for Request Creation.
* These properties have client wide scope, as opposed to request specific scope.
* @returns
*/
getContextDerivedPropsForRequestCreation() {
return {
globalEndpointManager: this.globalEndpointManager,
requestAgent: this.cosmosClientOptions.agent,
connectionPolicy: this.connectionPolicy,
client: this,
plugins: this.cosmosClientOptions.plugins,
pipeline: this.pipeline,
httpClient: this.cosmosClientOptions.httpClient,
globalPartitionEndpointManager: this.globalPartitionEndpointManager
};
}
getClientConfig() {
return this.clientConfig;
}
/**
* @internal
*/
refreshUserAgent(hostFramework) {
const updatedUserAgent = (0, import_platform.getUserAgent)(this.cosmosClientOptions, hostFramework);
this.cosmosClientOptions.defaultHeaders[import_constants.Constants.HttpHeaders.UserAgent] = updatedUserAgent;
this.cosmosClientOptions.defaultHeaders[import_constants.Constants.HttpHeaders.CustomUserAgent] = updatedUserAgent;
}
/**
* @internal
*/
getRetryOptions() {
return this.connectionPolicy.retryOptions;
}
/**
* @internal
*/
isPartitionLevelFailOverEnabled() {
return this.globalEndpointManager.lastKnownPPAFEnabled || this.globalEndpointManager.lastKnownPPCBEnabled;
}
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
ClientContext
});