ravendb/dist/esm/Documents/Commands/QueryCommand.js

RavenDB client for Node.js

import { QueryResult } from "../Queries/QueryResult.js";
import { writeIndexQuery } from "../Queries/IndexQuery.js";
import { throwError } from "../../Exceptions/index.js";
import { QueryTimings } from "../Queries/Timings/QueryTimings.js";
import { StringUtil } from "../../Utility/StringUtil.js";
import { readToEnd } from "../../Utility/StreamUtil.js";
import { ObjectUtil } from "../../Utility/ObjectUtil.js";
import { AbstractQueryCommand } from "./AbstractQueryCommand.js";
import { DateUtil } from "../../Utility/DateUtil.js";
export class QueryCommand extends AbstractQueryCommand {
    _conventions;
    _indexQuery;
    _session;
    constructor(session, indexQuery, opts) {
        super(indexQuery, !indexQuery.disableCaching, opts?.metadataOnly, opts?.indexEntriesOnly, false);
        this._session = session;
        if (!indexQuery) {
            throwError("InvalidArgumentException", "indexQuery cannot be null.");
        }
        this._indexQuery = indexQuery;
        this._conventions = session.conventions;
    }
    getQueryHash() {
        return this._indexQuery.getQueryHash(this._session.conventions.objectMapper);
    }
    _getContent() {
        return writeIndexQuery(this._session.conventions, this._indexQuery);
    }
    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;
    }
    static async parseQueryResultResponseAsync(bodyStream, conventions, fromCache, bodyCallback) {
        const body = await readToEnd(bodyStream);
        bodyCallback?.(body);
        const 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();
        mapped.durationInMs = timings.DurationInMs;
        mapped.timings = timings.Timings ? {} : undefined;
        if (timings.Timings) {
            for (const time of Object.keys(timings.Timings)) {
                mapped.timings[StringUtil.uncapitalize(time)] = QueryCommand._mapTimingsToLocalObject(timings.Timings[time]);
            }
        }
        return mapped;
    }
    static _mapToLocalObject(json, conventions) {
        const props = {
            results: json.Results.map(x => ObjectUtil.transformDocumentKeys(x, conventions)),
            includes: ObjectUtil.mapIncludesToLocalObject(json.Includes, conventions),
            indexName: json.IndexName,
            indexTimestamp: DateUtil.utc.parse(json.IndexTimestamp),
            includedPaths: json.IncludedPaths,
            isStale: json.IsStale,
            skippedResults: json.SkippedResults,
            totalResults: json.TotalResults,
            highlightings: json.Highlightings,
            explanations: json.Explanations,
            timingsInMs: json.TimingsInMs,
            lastQueryTime: DateUtil.utc.parse(json.LastQueryTime),
            durationInMs: json.DurationInMs,
            resultEtag: json.ResultEtag,
            nodeTag: json.NodeTag,
            scannedResults: json.ScannedResults,
            counterIncludes: ObjectUtil.mapCounterIncludesToLocalObject(json.CounterIncludes),
            includedCounterNames: json.IncludedCounterNames,
            timeSeriesIncludes: ObjectUtil.mapTimeSeriesIncludesToLocalObject(json.TimeSeriesIncludes),
            compareExchangeValueIncludes: ObjectUtil.mapCompareExchangeToLocalObject(json.CompareExchangeValueIncludes),
            revisionIncludes: json.RevisionIncludes,
            timeSeriesFields: json.TimeSeriesFields,
            timings: QueryCommand._mapTimingsToLocalObject(json.Timings)
        };
        return Object.assign(new QueryResult(), props);
    }
}
//# sourceMappingURL=QueryCommand.js.map