ravendb
Version:
RavenDB client for Node.js
127 lines • 5.03 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.GetCounterValuesCommand = exports.GetCountersOperation = void 0;
const RavenCommand_js_1 = require("../../../Http/RavenCommand.js");
const index_js_1 = require("../../../Exceptions/index.js");
const DocumentCountersOperation_js_1 = require("./DocumentCountersOperation.js");
const CounterOperation_js_1 = require("./CounterOperation.js");
const CounterBatch_js_1 = require("./CounterBatch.js");
const StringBuilder_js_1 = require("../../../Utility/StringBuilder.js");
class GetCountersOperation {
_docId;
_counters;
_returnFullResults;
constructor(docId, counters, returnFullResults = false) {
this._docId = docId;
if (counters) {
this._counters = Array.isArray(counters) ? counters : [counters];
}
else {
this._counters = [];
}
this._returnFullResults = returnFullResults;
}
getCommand(store, conventions, cache) {
return new GetCounterValuesCommand(this._docId, this._counters, this._returnFullResults, conventions);
}
get resultType() {
return "CommandResult";
}
}
exports.GetCountersOperation = GetCountersOperation;
class GetCounterValuesCommand extends RavenCommand_js_1.RavenCommand {
_docId;
_counters;
_returnFullResults;
_conventions;
constructor(docId, counters, returnFullResults, conventions) {
super();
if (!docId) {
(0, index_js_1.throwError)("InvalidArgumentException", "DocId cannot be null");
}
this._docId = docId;
this._counters = counters;
this._returnFullResults = returnFullResults;
this._conventions = conventions;
}
createRequest(node) {
const pathBuilder = new StringBuilder_js_1.StringBuilder(node.url);
pathBuilder.append("/databases/")
.append(node.database)
.append("/counters?docId=")
.append(encodeURIComponent(this._docId));
let req = { uri: null, method: "GET" };
if (this._counters.length > 0) {
if (this._counters && this._counters.length > 1) {
req = this._prepareRequestWithMultipleCounters(pathBuilder, req);
}
else {
pathBuilder.append("&counter=")
.append(encodeURIComponent(this._counters[0]));
}
}
if (this._returnFullResults && req.method === "GET") {
// if we dropped to Post, _returnFullResults is part of the request content
pathBuilder.append("&full=true");
}
req.uri = pathBuilder.toString();
return req;
}
_prepareRequestWithMultipleCounters(pathBuilder, request) {
const [uniqueNames, sumLength] = this._getOrderedUniqueNames();
// if it is too big, we drop to POST (note that means that we can't use the HTTP cache any longer)
// we are fine with that, such requests are going to be rare
if (sumLength < 1024) {
for (const uniqueName of uniqueNames) {
pathBuilder
.append("&counter=")
.append(encodeURIComponent(uniqueName || ""));
}
}
else {
request = { method: "POST" };
const docOps = new DocumentCountersOperation_js_1.DocumentCountersOperation();
docOps.documentId = this._docId;
docOps.operations = [];
for (const counter of uniqueNames) {
const counterOperation = new CounterOperation_js_1.CounterOperation();
counterOperation.type = "Get";
counterOperation.counterName = counter;
docOps.operations.push(counterOperation);
}
const batch = new CounterBatch_js_1.CounterBatch();
batch.documents = [docOps];
batch.replyWithAllNodesValues = this._returnFullResults;
request.body = JSON.stringify(batch.serialize());
request.headers = this._headers().typeAppJson().build();
}
return request;
}
_getOrderedUniqueNames() {
const uniqueNames = new Set();
const orderedUniqueNames = [];
let sum = 0;
for (const counter of this._counters) {
const containsCounter = uniqueNames.has(counter);
if (!containsCounter) {
uniqueNames.add(counter);
orderedUniqueNames.push(counter);
sum += counter?.length || 0;
}
}
return [orderedUniqueNames, sum];
}
get isReadRequest() {
return true;
}
async setResponseAsync(bodyStream, fromCache) {
if (!bodyStream) {
return;
}
let body = "";
this.result = await this._defaultPipeline(_ => body += _).process(bodyStream);
return body;
}
}
exports.GetCounterValuesCommand = GetCounterValuesCommand;
//# sourceMappingURL=GetCountersOperation.js.map