@configurator/ravendb/dist/Documents/Commands/QueryCommand.js

RavenDB client for Node.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.QueryCommand = void 0;
const RavenCommand_1 = require("../../Http/RavenCommand");
const QueryResult_1 = require("../Queries/QueryResult");
const IndexQuery_1 = require("../Queries/IndexQuery");
const Exceptions_1 = require("../../Exceptions");
const RavenCommandResponsePipeline_1 = require("../../Http/RavenCommandResponsePipeline");
const StringBuilder_1 = require("../../Utility/StringBuilder");
const QueryTimings_1 = require("../Queries/Timings/QueryTimings");
const StringUtil_1 = require("../../Utility/StringUtil");
const StreamUtil_1 = require("../../Utility/StreamUtil");
const ObjectUtil_1 = require("../../Utility/ObjectUtil");
class QueryCommand extends RavenCommand_1.RavenCommand {
    constructor(session, indexQuery, opts) {
        super();
        this._session = session;
        if (!indexQuery) {
            (0, Exceptions_1.throwError)("InvalidArgumentException", "indexQuery cannot be null.");
        }
        this._indexQuery = indexQuery;
        opts = opts || {};
        this._metadataOnly = opts.metadataOnly;
        this._indexEntriesOnly = opts.indexEntriesOnly;
    }
    createRequest(node) {
        this._canCache = !this._indexQuery.disableCaching;
        this._canCacheAggressively = this._canCache && !this._indexQuery.waitForNonStaleResults;
        const path = new StringBuilder_1.StringBuilder(node.url)
            .append("/databases/")
            .append(node.database)
            .append("/queries?queryHash=")
            .append(this._indexQuery.getQueryHash(this._session.conventions.objectMapper));
        if (this._metadataOnly) {
            path.append("&metadataOnly=true");
        }
        if (this._indexEntriesOnly) {
            path.append("&debug=entries");
        }
        path.append("&addTimeSeriesNames=true");
        const uri = path.toString();
        const body = (0, IndexQuery_1.writeIndexQuery)(this._session.conventions, this._indexQuery);
        const headers = this._headers().typeAppJson().build();
        return {
            method: "POST",
            uri,
            headers,
            body
        };
    }
    get _serializer() {
        return super._serializer;
    }
    async setResponseAsync(bodyStream, fromCache) {
        if (!bodyStream) {
            this.result = null;
            return;
        }
        let body = null;
        this.result = await QueryCommand.parseQueryResultResponseAsync(bodyStream, this._session.conventions, fromCache, b => body = b);
        return body;
    }
    get isReadRequest() {
        return true;
    }
    static async parseQueryResultResponseAsync(bodyStream, conventions, fromCache, bodyCallback) {
        const body = await (0, StreamUtil_1.readToEnd)(bodyStream);
        bodyCallback?.(body);
        let parsedJson;
        if (body.length > conventions.syncJsonParseLimit) {
            const bodyStreamCopy = (0, StreamUtil_1.stringToReadable)(body);
            parsedJson = await RavenCommandResponsePipeline_1.RavenCommandResponsePipeline.create()
                .parseJsonAsync()
                .process(bodyStreamCopy);
        }
        else {
            parsedJson = JSON.parse(body);
        }
        const queryResult = QueryCommand._mapToLocalObject(parsedJson, conventions);
        if (fromCache) {
            queryResult.durationInMs = -1;
            if (queryResult.timingsInMs) {
                queryResult.timingsInMs.durationInMs = -1;
                queryResult.timingsInMs = null;
            }
        }
        return queryResult;
    }
    static _mapTimingsToLocalObject(timings) {
        if (!timings) {
            return undefined;
        }
        const mapped = new QueryTimings_1.QueryTimings();
        mapped.durationInMs = timings.DurationInMs;
        mapped.timings = timings.Timings ? {} : undefined;
        if (timings.Timings) {
            Object.keys(timings.Timings).forEach(time => {
                mapped.timings[StringUtil_1.StringUtil.uncapitalize(time)] = QueryCommand._mapTimingsToLocalObject(timings.Timings[time]);
            });
        }
        return mapped;
    }
    static _mapToLocalObject(json, conventions) {
        const props = {
            results: json.Results.map(x => ObjectUtil_1.ObjectUtil.transformDocumentKeys(x, conventions)),
            includes: ObjectUtil_1.ObjectUtil.mapIncludesToLocalObject(json.Includes, conventions),
            indexName: json.IndexName,
            indexTimestamp: conventions.dateUtil.parse(json.IndexTimestamp),
            includedPaths: json.IncludedPaths,
            isStale: json.IsStale,
            skippedResults: json.SkippedResults,
            totalResults: json.TotalResults,
            longTotalResults: json.LongTotalResults,
            highlightings: json.Highlightings,
            explanations: json.Explanations,
            timingsInMs: json.TimingsInMs,
            lastQueryTime: conventions.dateUtil.parse(json.LastQueryTime),
            durationInMs: json.DurationInMs,
            resultEtag: json.ResultEtag,
            nodeTag: json.NodeTag,
            scannedResults: json.ScannedResults,
            counterIncludes: ObjectUtil_1.ObjectUtil.mapCounterIncludesToLocalObject(json.CounterIncludes),
            includedCounterNames: json.IncludedCounterNames,
            timeSeriesIncludes: ObjectUtil_1.ObjectUtil.mapTimeSeriesIncludesToLocalObject(json.TimeSeriesIncludes),
            compareExchangeValueIncludes: ObjectUtil_1.ObjectUtil.mapCompareExchangeToLocalObject(json.CompareExchangeValueIncludes),
            revisionIncludes: json.RevisionIncludes,
            timeSeriesFields: json.TimeSeriesFields,
            timings: QueryCommand._mapTimingsToLocalObject(json.Timings)
        };
        return Object.assign(new QueryResult_1.QueryResult(), props);
    }
}
exports.QueryCommand = QueryCommand;
//# sourceMappingURL=QueryCommand.js.map