@azure/cosmos
Version:
Microsoft Azure Cosmos DB Service Node.js SDK for NOSQL API
190 lines (189 loc) • 8.03 kB
JavaScript
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var RequestHandler_exports = {};
__export(RequestHandler_exports, {
RequestHandler: () => RequestHandler
});
module.exports = __toCommonJS(RequestHandler_exports);
var import_core_rest_pipeline = require("@azure/core-rest-pipeline");
var import_common = require("../common/index.js");
var import_constants = require("../common/constants.js");
var import_Plugin = require("../plugins/Plugin.js");
var RetryUtility = __toESM(require("../retry/retryUtility.js"));
var import_defaultAgent = require("./defaultAgent.js");
var import_ErrorResponse = require("./ErrorResponse.js");
var import_request = require("./request.js");
var import_TimeoutError = require("./TimeoutError.js");
var import_cachedClient = require("../utils/cachedClient.js");
var import_logger = require("@azure/logger");
var import_DiagnosticNodeInternal = require("../diagnostics/DiagnosticNodeInternal.js");
var import_diagnostics = require("../utils/diagnostics.js");
var import_time = require("../utils/time.js");
const logger = (0, import_logger.createClientLogger)("RequestHandler");
async function executeRequest(diagnosticNode, requestContext) {
return (0, import_Plugin.executePlugins)(diagnosticNode, requestContext, httpRequest, import_Plugin.PluginOn.request);
}
async function httpRequest(requestContext, diagnosticNode) {
const controller = new AbortController();
const signal = controller.signal;
const userSignal = requestContext.options && requestContext.options.abortSignal;
let userSignalListener = void 0;
if (userSignal) {
if (userSignal.aborted) {
controller.abort();
} else {
userSignalListener = () => {
controller.abort();
};
userSignal.addEventListener("abort", userSignalListener);
}
}
let requestTimeout = requestContext.connectionPolicy.requestTimeout;
if ((requestContext.globalPartitionEndpointManager?.isPartitionLevelAutomaticFailoverEnabled() || requestContext.globalPartitionEndpointManager?.isPartitionLevelCircuitBreakerEnabled()) && requestContext.partitionKeyRangeId && requestContext.resourceType === import_constants.ResourceType.item && (0, import_common.isReadRequest)(requestContext.operationType)) {
requestTimeout = Math.min(
requestContext.connectionPolicy.requestTimeout,
import_constants.Constants.RequestTimeoutForReadsInMs
);
}
const timeout = setTimeout(() => {
controller.abort();
}, requestTimeout);
let response;
if (requestContext.body) {
requestContext.body = (0, import_request.bodyFromData)(requestContext.body);
}
const httpsClient = requestContext.httpClient ?? (0, import_cachedClient.getCachedDefaultHttpClient)();
const url = (0, import_common.prepareURL)(requestContext.endpoint, requestContext.path);
const reqHeaders = (0, import_core_rest_pipeline.createHttpHeaders)(requestContext.headers);
const pipelineRequest = (0, import_core_rest_pipeline.createPipelineRequest)({
url,
headers: reqHeaders,
method: requestContext.method,
abortSignal: signal,
body: requestContext.body
});
if (requestContext.requestAgent) {
pipelineRequest.agent = requestContext.requestAgent;
} else {
const parsedUrl = new URL(url);
pipelineRequest.agent = parsedUrl.protocol === "http:" ? import_defaultAgent.defaultHttpAgent : import_defaultAgent.defaultHttpsAgent;
pipelineRequest.allowInsecureConnection = parsedUrl.protocol === "http:";
}
const startTimeUTCInMs = (0, import_time.getCurrentTimestampInMs)();
try {
if (requestContext.pipeline) {
response = await requestContext.pipeline.sendRequest(httpsClient, pipelineRequest);
} else {
response = await httpsClient.sendRequest(pipelineRequest);
}
} catch (error) {
if (error.name === "AbortError") {
if (userSignal && userSignal.aborted === true) {
throw error;
}
throw new import_TimeoutError.TimeoutError(
`Timeout Error! Request took more than ${requestContext.connectionPolicy.requestTimeout} ms`
);
}
throw error;
} finally {
clearTimeout(timeout);
if (userSignal && userSignalListener) {
userSignal.removeEventListener("abort", userSignalListener);
}
}
const result = response.status === 204 || response.status === 304 || response.bodyAsText === "" ? null : JSON.parse(response.bodyAsText);
const responseHeaders = response.headers.toJSON();
const substatus = responseHeaders[import_constants.Constants.HttpHeaders.SubStatus] ? parseInt(responseHeaders[import_constants.Constants.HttpHeaders.SubStatus], 10) : void 0;
diagnosticNode.recordSuccessfulNetworkCall(
startTimeUTCInMs,
requestContext,
response,
substatus,
url
);
if (response.status >= 400) {
const errorResponse = new import_ErrorResponse.ErrorResponse(result.message);
logger.warning(
response.status + " " + requestContext.endpoint + " " + requestContext.path + " " + result.message
);
errorResponse.code = response.status;
errorResponse.body = result;
errorResponse.headers = responseHeaders;
if (import_constants.Constants.HttpHeaders.ActivityId in responseHeaders) {
errorResponse.activityId = responseHeaders[import_constants.Constants.HttpHeaders.ActivityId];
}
if (import_constants.Constants.HttpHeaders.SubStatus in responseHeaders) {
errorResponse.substatus = substatus;
}
if (import_constants.Constants.HttpHeaders.RetryAfterInMs in responseHeaders) {
errorResponse.retryAfterInMs = parseInt(
responseHeaders[import_constants.Constants.HttpHeaders.RetryAfterInMs],
10
);
Object.defineProperty(errorResponse, "retryAfterInMilliseconds", {
get: () => {
return errorResponse.retryAfterInMs;
}
});
}
throw errorResponse;
}
return {
headers: responseHeaders,
result,
code: response.status,
substatus
};
}
async function request(requestContext, diagnosticNode) {
if (requestContext.body) {
requestContext.body = (0, import_request.bodyFromData)(requestContext.body);
if (!requestContext.body) {
throw new Error("parameter data must be a javascript object, string, or Buffer");
}
}
return (0, import_diagnostics.addDiagnosticChild)(
async (childNode) => {
return RetryUtility.execute({
diagnosticNode: childNode,
requestContext,
executeRequest
});
},
diagnosticNode,
import_DiagnosticNodeInternal.DiagnosticNodeType.REQUEST_ATTEMPTS
);
}
const RequestHandler = {
request
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
RequestHandler
});