Merge pull request #274 from ml054/RDB-424

RDBC-424

Author: gregolsky

src/Documents/Commands/GetDocumentsCommand.ts

@@ -14,6 +14,11 @@ import { HashCalculator } from "../Queries/HashCalculator";
 import { IRavenObject } from "../../Types/IRavenObject";
 import { TimeSeriesRange } from "../Operations/TimeSeries/TimeSeriesRange";
 import { DateUtil } from "../../Utility/DateUtil";
+import { readToEnd, stringToReadable } from "../../Utility/StreamUtil";
+import { ServerResponse } from "../../Types";
+import { QueryResult } from "../Queries/QueryResult";
+import { QueryCommand } from "./QueryCommand";
+import { ObjectUtil } from "../../Utility/ObjectUtil";
 
 export interface GetDocumentsCommandCounterOptions {
     counterIncludes?: string[];
@@ -274,11 +279,39 @@ export class GetDocumentsCommand extends RavenCommand<GetDocumentsResult> {
         conventions: DocumentConventions,
         bodyCallback?: (body: string) => void): Promise<GetDocumentsResult> {
 
-        return RavenCommandResponsePipeline.create<GetDocumentsResult>()
-            .collectBody(bodyCallback)
-            .parseJsonAsync()
-            .jsonKeysTransform("DocumentLoad", conventions)
-            .process(bodyStream);
+        const body = await readToEnd(bodyStream);
+        bodyCallback?.(body);
+
+        let parsedJson: any;
+        if (body.length > conventions.syncJsonParseLimit) {
+            const bodyStreamCopy = stringToReadable(body);
+            // response is quite big - fallback to async (slower) parsing to avoid blocking event loop
+            parsedJson = await RavenCommandResponsePipeline.create<ServerResponse<GetDocumentsResult>>()
+                .parseJsonAsync()
+                .process(bodyStreamCopy);
+        } else {
+            parsedJson = JSON.parse(body);
+        }
+
+        return GetDocumentsCommand._mapToLocalObject(parsedJson, conventions);
+    }
+
+    private static _mapToLocalObject(json: any, conventions: DocumentConventions): GetDocumentsResult {
+        const mappedIncludes: Record<string, any> = {};
+        if (json.Includes) {
+            for (const [key, value] of Object.entries(json.Includes)) {
+                mappedIncludes[key] = ObjectUtil.transformDocumentKeys(value, conventions);
+            }
+        }
+
+        return {
+            results: json.Results.map(x => ObjectUtil.transformDocumentKeys(x, conventions)),
+            includes: mappedIncludes,
+            compareExchangeValueIncludes: ObjectUtil.mapCompareExchangeToLocalObject(json.CompareExchangeValueIncludes),
+            timeSeriesIncludes: ObjectUtil.mapTimeSeriesIncludesToLocalObject(json.TimeSeriesIncludes),
+            counterIncludes: ObjectUtil.mapCounterIncludesToLocalObject(json.CounterIncludes),
+            nextPageStart: json.NextPageStart
+        };
     }
 
     public get isReadRequest(): boolean {

src/Documents/Commands/QueryCommand.ts

@@ -12,6 +12,12 @@ import { StringBuilder } from "../../Utility/StringBuilder";
 import { ServerResponse } from "../../Types";
 import { QueryTimings } from "../Queries/Timings/QueryTimings";
 import { StringUtil } from "../../Utility/StringUtil";
+import { CounterDetail } from "../Operations/Counters/CounterDetail";
+import { CompareExchangeResultItem } from "../Operations/CompareExchange/CompareExchangeValueResultParser";
+import { TimeSeriesRangeResult } from "../Operations/TimeSeries/TimeSeriesRangeResult";
+import { TimeSeriesEntry } from "../Session/TimeSeries/TimeSeriesEntry";
+import { readToEnd, stringToReadable } from "../../Utility/StreamUtil";
+import { ObjectUtil } from "../../Utility/ObjectUtil";
 
 export interface QueryCommandOptions {
     metadataOnly?: boolean;
@@ -105,13 +111,21 @@ export class QueryCommand extends RavenCommand<QueryResult> {
         fromCache: boolean,
         bodyCallback?: (body: string) => void): Promise<QueryResult> {
 
-        const rawResult = await RavenCommandResponsePipeline.create<ServerResponse<QueryResult>>()
-            .collectBody(bodyCallback)
-            .parseJsonAsync()
-            .jsonKeysTransform("DocumentQuery", conventions)
-            .process(bodyStream);
+        const body = await readToEnd(bodyStream);
+        bodyCallback?.(body);
+
+        let parsedJson: any;
+        if (body.length > conventions.syncJsonParseLimit) {
+            const bodyStreamCopy = stringToReadable(body);
+            // response is quite big - fallback to async (slower) parsing to avoid blocking event loop
+            parsedJson = await RavenCommandResponsePipeline.create<ServerResponse<QueryResult>>()
+                .parseJsonAsync()
+                .process(bodyStreamCopy);
+        } else {
+            parsedJson = JSON.parse(body);
+        }
 
-        const queryResult = QueryCommand._mapToLocalObject(rawResult, conventions);
+        const queryResult = QueryCommand._mapToLocalObject(parsedJson, conventions);
 
         if (fromCache) {
             queryResult.durationInMs = -1;
@@ -125,31 +139,57 @@ export class QueryCommand extends RavenCommand<QueryResult> {
         return queryResult;
     }
 
-    private static _mapToLocalObject(json: ServerResponse<QueryResult>, conventions: DocumentConventions): QueryResult {
-        const { indexTimestamp, lastQueryTime, timings, ...otherProps } = json;
-
-        const overrides: Partial<QueryResult> = {
-            indexTimestamp: conventions.dateUtil.parse(indexTimestamp),
-            lastQueryTime: conventions.dateUtil.parse(lastQueryTime),
-            timings: QueryCommand._mapTimingsToLocalObject(timings)
-        };
-
-        return Object.assign(new QueryResult(), otherProps, overrides);
-    }
-
-    private static _mapTimingsToLocalObject(timings: ServerResponse<QueryTimings>) {
+    //TODO: use ServerCasing<QueryTimings> instead of any, after upgrading to TS 4.2
+    private static _mapTimingsToLocalObject(timings: any) {
         if (!timings) {
             return undefined;
         }
 
         const mapped = new QueryTimings();
-        mapped.durationInMs = timings.durationInMs;
-        mapped.timings = timings.timings ? {} : undefined;
-        if (timings.timings) {
-            Object.keys(timings.timings).forEach(time => {
-                mapped.timings[StringUtil.uncapitalize(time)] = QueryCommand._mapTimingsToLocalObject(timings.timings[time]);
+        mapped.durationInMs = timings.DurationInMs;
+        mapped.timings = timings.Timings ? {} : undefined;
+        if (timings.Timings) {
+            Object.keys(timings.Timings).forEach(time => {
+                mapped.timings[StringUtil.uncapitalize(time)] = QueryCommand._mapTimingsToLocalObject(timings.Timings[time]);
             });
         }
         return mapped;
     }
+
+
+    //TODO: use ServerCasing<ServerResponse<QueryResult>> instead of any, after upgrading to TS 4.2
+    private static _mapToLocalObject(json: any, conventions: DocumentConventions): QueryResult {
+        const mappedIncludes: Record<string, any> = {};
+        if (json.Includes) {
+            for (const [key, value] of Object.entries(json.Includes)) {
+                mappedIncludes[key] = ObjectUtil.transformDocumentKeys(value, conventions);
+            }
+        }
+
+        const props: Omit<QueryResult, "scoreExplanations" | "cappedMaxResults" | "createSnapshot" | "resultSize"> = {
+            results: json.Results.map(x => ObjectUtil.transformDocumentKeys(x, conventions)),
+            includes: mappedIncludes,
+            indexName: json.IndexName,
+            indexTimestamp: conventions.dateUtil.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: conventions.dateUtil.parse(json.LastQueryTime),
+            durationInMs: json.DurationInMs,
+            resultEtag: json.ResultEtag,
+            nodeTag: json.NodeTag,
+            counterIncludes: ObjectUtil.mapCounterIncludesToLocalObject(json.CounterIncludes),
+            includedCounterNames: json.IncludedCounterNames,
+            timeSeriesIncludes: ObjectUtil.mapTimeSeriesIncludesToLocalObject(json.TimeSeriesIncludes),
+            compareExchangeValueIncludes: ObjectUtil.mapCompareExchangeToLocalObject(json.CompareExchangeValueIncludes),
+            timeSeriesFields: json.TimeSeriesFields,
+            timings: QueryCommand._mapTimingsToLocalObject(json.Timings)
+        }
+
+        return Object.assign(new QueryResult(), props);
+    }
 }

src/Documents/Conventions/DocumentConventions.ts

@@ -90,6 +90,7 @@ export class DocumentConventions {
 
     private _objectMapper: TypesAwareObjectMapper;
     private _dateUtil: DateUtil;
+    private _syncJsonParseLimit: number;
 
     private _useCompression: boolean;
     private _sendApplicationIdentifier: boolean;
@@ -147,6 +148,7 @@ export class DocumentConventions {
 
         this._dateUtilOpts = {};
         this._dateUtil = new DateUtil(this._dateUtilOpts);
+        this._syncJsonParseLimit = 2 * 1_024 * 1_024;
 
         this._firstBroadcastAttemptTimeout = 5_000;
         this._secondBroadcastAttemptTimeout = 30_000;
@@ -239,6 +241,23 @@ export class DocumentConventions {
         this._objectMapper = value;
     }
 
+    /**
+     * Sets json length limit for sync parsing. Beyond that size
+     * we fallback to async parsing
+     */
+    public get syncJsonParseLimit(): number {
+        return this._syncJsonParseLimit;
+    }
+
+    /**
+     * Gets json length limit for sync parsing. Beyond that size
+     * we fallback to async parsing
+     */
+    public set syncJsonParseLimit(value: number) {
+        this._assertNotFrozen();
+        this._syncJsonParseLimit = value;
+    }
+
     public get dateUtil(): DateUtil {
         return this._dateUtil;
     }

src/Documents/Identity/GenerateEntityIdOnTheClient.ts

@@ -76,10 +76,6 @@ export class GenerateEntityIdOnTheClient {
      * Tries to set the identity property
      */
     public trySetIdentity(entity: object, id: string, isProjection: boolean = false): void {
-        this._trySetIdentityInternal(entity, id, isProjection);
-    }
-
-    private _trySetIdentityInternal(entity: object, id: string, isProjection): void {
         const docType: DocumentType = TypeUtil.findType(entity, this._conventions.knownEntityTypes);
         const identityProperty = this._conventions.getIdentityProperty(docType);
 

src/Mapping/Json/Docs/index.ts

@@ -6,7 +6,6 @@ export type TransformJsonKeysProfile =
     "CommandResponsePayload"
     | "NoChange" 
     | "DocumentLoad"
-    | "DocumentQuery"
     | "FacetQuery"
     | "Patch"
     | "CompareExchangeValue"
@@ -41,15 +40,6 @@ export function getTransformJsonKeysProfile(
             return { getCurrentTransform };
         }
 
-        if (profile === "DocumentQuery") {
-            if (!conventions) {
-                throwError("InvalidArgumentException", "Document conventions are required for this profile.");
-            }
-
-            const getCurrentTransform = buildEntityKeysTransformForDocumentQuery(conventions.entityFieldNameConvention);
-            return { getCurrentTransform };
-        }
-
         if (profile === "FacetQuery") {
             return {
                 getCurrentTransform: facetQueryGetTransform
@@ -381,97 +371,6 @@ function buildEntityKeysTransformForDocumentLoad(entityCasingConvention) {
     };
 }
 
-function buildEntityKeysTransformForDocumentQuery(entityCasingConvention: CasingConvention) {
-    return function entityKeysTransform(key, stack) {
-        const len = stack.length;
-
-        if (len === 1) {
-            // Results, Includes, Timings...
-            return "camel";
-        }
-
-        // len === 2 is array index
-        if (stack[0] === "Results" || stack[0] === "Includes") {
-            if (len === 3) {
-                // top document level
-                return key === "@metadata" ? null : entityCasingConvention;
-            }
-
-            if (len === 4) {
-                if (stack[2] === "@metadata") {
-                    // handle @metadata object keys
-                    if (key[0] === "@" || key === "Raven-Node-Type") {
-                        return null;
-                    }
-                }
-            }
-
-            if (len === 5) {
-                // do not touch @nested-object-types keys
-                if (stack[len - 2] === "@nested-object-types") {
-                    return null;
-                }
-            }
-
-            if (len === 6) {
-                // @metadata.@attachments.[].name
-                if (stack[2] === "@metadata") {
-                    if (stack[3] === "@attachments") {
-                        return "camel";
-                    }
-
-                    return null;
-                }
-            }
-        }
-
-        if (stack[0] === "CounterIncludes") {
-            if (len === 2 || len === 3) {
-                return null;
-            }
-            if (len === 4) {
-                return "camel";
-            }
-        }
-
-        if (stack[0] === "IncludedCounterNames") {
-            if (len === 2) {
-                return null;
-            }
-        }
-
-        if (len === 3) {
-            if (stack[0] === "CompareExchangeValueIncludes") {
-                return "camel";
-            }
-        }
-
-        if (len === 4) {
-            if (stack[0] === "CompareExchangeValueIncludes" && stack[2] === "Value" && stack[3] === "Object") {
-                return "camel";
-            }
-        }
-
-        if (len === 5) {
-            if (stack[0] === "TimeSeriesIncludes") {
-                return "camel";
-            }
-        }
-
-        if (len === 7) {
-            if (stack[0] === "TimeSeriesIncludes") {
-                return "camel";
-            }
-        }
-
-        if (stack[0] === "Timings") {
-            return "camel";
-        }
-
-        return entityCasingConvention; 
-    };
-}
-
 function handleMetadataJsonKeys(key: string, stack: string[], stackLength: number, metadataKeyLevel: number): CasingConvention {
     if (stackLength === metadataKeyLevel) {
         return null; // don't touch @metadata key

src/Mapping/Json/Streams/TransformJsonKeysProfiles.ts

@@ -371,8 +371,7 @@ export class TypesAwareObjectMapper implements ITypesAwareObjectMapper {
             throwError("InvalidArgumentException", "ctor argument must not be null or undefined.");
         }
 
-        // tslint:disable-next-line:new-parens
-        return new (Function.prototype.bind.apply(ctor)) as TResult;
+        return new ctor() as TResult;
     }
 
     private _makeObjectLiteral(