RDBC-424 Investigate performance of RavenDb node js client

src/Documents/Changes/DatabaseChanges.ts

@@ -20,11 +20,10 @@ import CurrentIndexAndNode from "../../Http/CurrentIndexAndNode";
 import { RequestExecutor } from "../../Http/RequestExecutor";
 import { DocumentConventions } from "../Conventions/DocumentConventions";
 import { ServerNode } from "../../Http/ServerNode";
-import { ObjectTypeDescriptor } from "../../Types";
+import { ObjectTypeDescriptor, ServerResponse } from "../../Types";
 import { UpdateTopologyParameters } from "../../Http/UpdateTopologyParameters";
 import { TypeUtil } from "../../Utility/TypeUtil";
 import { TimeSeriesChange } from "./TimeSeriesChange";
-import { QueryResult } from "../Queries/QueryResult";
 
 export class DatabaseChanges implements IDatabaseChanges {
 
@@ -436,13 +435,16 @@ export class DatabaseChanges implements IDatabaseChanges {
                         const value = message.Value;
                         let transformedValue = ObjectUtil.transformObjectKeys(value, { defaultTransform: "camel" });
                         if (type === "TimeSeriesChange") {
-                            transformedValue = this._conventions.objectMapper
-                                .fromObjectLiteral<QueryResult>(transformedValue, {
-                                    nestedTypes: {
-                                        from: "date",
-                                        to: "date"
-                                    }
-                                });
+                            const dateUtil = this._conventions.dateUtil;
+
+                            const timeSeriesValue = transformedValue as ServerResponse<TimeSeriesChange>;
+
+                            const overrides: Partial<TimeSeriesChange> = {
+                                from: dateUtil.parse(timeSeriesValue.from),
+                                to: dateUtil.parse(timeSeriesValue.to)
+                            };
+
+                            transformedValue = Object.assign(transformedValue, overrides);
                         }
                         this._notifySubscribers(type, transformedValue, Array.from(this._counters.values()));
                         break;

src/Documents/Commands/FacetQueryCommand.ts

@@ -3,6 +3,7 @@ import { DocumentConventions } from "../Conventions/DocumentConventions";
 import * as stream from "readable-stream";
 import { QueryCommand } from "./QueryCommand";
 import { RavenCommandResponsePipeline } from "../../Http/RavenCommandResponsePipeline";
+import { ServerResponse } from "../../Types";
 
 export class FacetQueryCommand extends QueryCommand {
 
@@ -25,18 +26,18 @@ export class FacetQueryCommand extends QueryCommand {
         fromCache: boolean,
         bodyCallback?: (body: string) => void): Promise<QueryResult> {
 
-        const rawResult = await RavenCommandResponsePipeline.create<QueryResult>()
+        const rawResult = await RavenCommandResponsePipeline.create<ServerResponse<QueryResult>>()
             .collectBody(bodyCallback)
             .parseJsonAsync()
             .jsonKeysTransform("FacetQuery")
             .process(bodyStream);
-        const queryResult = conventions.objectMapper.fromObjectLiteral<QueryResult>(rawResult, {
-            typeName: QueryResult.name,
-            nestedTypes: {
-                indexTimestamp: "date",
-                lastQueryTime: "date"
-            }
-        }, new Map([[QueryResult.name, QueryResult]]));
+
+        const overrides: Partial<QueryResult> = {
+            indexTimestamp: conventions.dateUtil.parse(rawResult.indexTimestamp),
+            lastQueryTime: conventions.dateUtil.parse(rawResult.lastQueryTime)
+        };
+
+        const queryResult = Object.assign(new QueryResult(), rawResult, overrides) as QueryResult;
 
         if (fromCache) {
             queryResult.durationInMs = -1;

src/Documents/Commands/GetConflictsCommand.ts

@@ -4,6 +4,7 @@ import { GetConflictsResult } from "./GetConflictsResult";
 import { ServerNode } from "../../Http/ServerNode";
 import * as stream from "readable-stream";
 import { DocumentConventions } from "../Conventions/DocumentConventions";
+import { ServerResponse } from "../../Types";
 
 export class GetConflictsCommand extends RavenCommand<GetConflictsResult> {
 
@@ -35,12 +36,18 @@ export class GetConflictsCommand extends RavenCommand<GetConflictsResult> {
         }
 
         let body: string = null;
-        const results = await this._defaultPipeline(_ => body = _).process(bodyStream);
-        this.result = this._conventions.objectMapper.fromObjectLiteral(results, {
-            nestedTypes: {
-                "results[].lastModified": "date"
-            }
-        });
+        const payload = await this._defaultPipeline<ServerResponse<GetConflictsResult>>(_ => body = _).process(bodyStream);
+        const dateUtil = this._conventions.dateUtil;
+
+        const { results, ...otherProps } = payload;
+
+        this.result = {
+            ...otherProps,
+            results: results.map(r => ({
+                ...r,
+                lastModified: dateUtil.parse(r.lastModified)
+            }))
+        };
 
         return body;
     }

src/Documents/Commands/QueryCommand.ts

@@ -9,6 +9,9 @@ import { JsonSerializer } from "../../Mapping/Json/Serializer";
 import * as stream from "readable-stream";
 import { RavenCommandResponsePipeline } from "../../Http/RavenCommandResponsePipeline";
 import { StringBuilder } from "../../Utility/StringBuilder";
+import { ServerResponse } from "../../Types";
+import { QueryTimings } from "../Queries/Timings/QueryTimings";
+import { StringUtil } from "../../Utility/StringUtil";
 
 export interface QueryCommandOptions {
     metadataOnly?: boolean;
@@ -102,19 +105,13 @@ export class QueryCommand extends RavenCommand<QueryResult> {
         fromCache: boolean,
         bodyCallback?: (body: string) => void): Promise<QueryResult> {
 
-        const rawResult = await RavenCommandResponsePipeline.create<QueryResult>()
+        const rawResult = await RavenCommandResponsePipeline.create<ServerResponse<QueryResult>>()
             .collectBody(bodyCallback)
             .parseJsonAsync()
             .jsonKeysTransform("DocumentQuery", conventions)
             .process(bodyStream);
-        const queryResult = conventions.objectMapper
-            .fromObjectLiteral<QueryResult>(rawResult, {
-                typeName: QueryResult.name,
-                nestedTypes: {
-                    indexTimestamp: "date",
-                    lastQueryTime: "date"
-                }
-            }, new Map([[QueryResult.name, QueryResult]]));
+
+        const queryResult = QueryCommand._mapToLocalObject(rawResult, conventions);
 
         if (fromCache) {
             queryResult.durationInMs = -1;
@@ -127,4 +124,32 @@ 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>) {
+        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]);
+            });
+        }
+        return mapped;
+    }
 }

src/Documents/Operations/Counters/CounterDetail.ts

@@ -1,8 +1,8 @@
-export class CounterDetail {
-    public documentId: string;
-    public counterName: string;
-    public totalValue: number;
-    public etag: number;
-    public counterValues: { [key: string]: number };
-    public changeVector: string;
+export interface CounterDetail {
+    documentId: string;
+    counterName: string;
+    totalValue: number;
+    etag?: number;
+    counterValues?: { [key: string]: number };
+    changeVector?: string;
 } 

src/Documents/Operations/TimeSeries/GetTimeSeriesOperation.ts

@@ -13,6 +13,7 @@ import { DocumentConventions } from "../../Conventions/DocumentConventions";
 import { RavenCommand } from "../../../Http/RavenCommand";
 import { ServerNode } from "../../../Http/ServerNode";
 import { StringBuilder } from "../../../Utility/StringBuilder";
+import { ServerResponse } from "../../../Types";
 
 export class GetTimeSeriesOperation implements IOperation<TimeSeriesRangeResult> {
     private readonly _docId: string;
@@ -125,7 +126,7 @@ class GetTimeSeriesCommand extends RavenCommand<TimeSeriesRangeResult> {
         }
 
         let body: string = null;
-        const results = await this._defaultPipeline(_ => body = _)
+        const results = await this._defaultPipeline<ServerResponse<TimeSeriesRangeResult>>(_ => body = _)
             .process(bodyStream);
 
         this.result = reviveTimeSeriesRangeResult(results, this._conventions);
@@ -138,13 +139,25 @@ class GetTimeSeriesCommand extends RavenCommand<TimeSeriesRangeResult> {
     }
 }
 
-export function reviveTimeSeriesRangeResult(result: TimeSeriesRangeResult, conventions: DocumentConventions) {
-    return Object.assign(new TimeSeriesRangeResult(), conventions.objectMapper.fromObjectLiteral<TimeSeriesRangeResult>(result, {
-        nestedTypes: {
-            "from": "date",
-            "to": "date",
-            "entries": "TimeSeriesEntry",
-            "entries[].timestamp": "date"
+export function reviveTimeSeriesRangeResult(result: ServerResponse<TimeSeriesRangeResult>, conventions: DocumentConventions): TimeSeriesRangeResult {
+    const { entries, from, to, ...restProps } = result;
+
+    const entryMapper = (rawEntry: ServerResponse<TimeSeriesEntry>) => {
+        const result = new TimeSeriesEntry();
+
+        const entryOverrides: Partial<TimeSeriesEntry> = {
+            timestamp: conventions.dateUtil.parse(rawEntry.timestamp)
         }
-    }, new Map([[TimeSeriesEntry.name, TimeSeriesEntry]])));
+
+        return Object.assign(result, rawEntry, entryOverrides) as TimeSeriesEntry;
+    }
+
+    const overrides: Partial<TimeSeriesRangeResult> = {
+        ...restProps,
+        to: conventions.dateUtil.parse(result.to),
+        from: conventions.dateUtil.parse(result.from),
+        entries: entries.map(entryMapper),
+    }
+
+    return Object.assign(new TimeSeriesRangeResult(), overrides);
 }

src/Documents/Operations/TimeSeries/GetTimeSeriesStatisticsOperation.ts

@@ -7,6 +7,7 @@ import * as stream from "readable-stream";
 import { RavenCommand } from "../../../Http/RavenCommand";
 import { ServerNode } from "../../../Http/ServerNode";
 import { DocumentConventions } from "../../Conventions/DocumentConventions";
+import { ServerResponse } from "../../../Types";
 
 export class GetTimeSeriesStatisticsOperation implements IOperation<TimeSeriesStatistics> {
     private readonly _documentId: string;
@@ -54,13 +55,23 @@ class GetTimeSeriesStatisticsCommand extends RavenCommand<TimeSeriesStatistics>
 
     async setResponseAsync(bodyStream: stream.Stream, fromCache: boolean): Promise<string> {
         let body: string = null;
-        const results = await this._defaultPipeline(_ => body = _).process(bodyStream);
-        this.result = this._conventions.objectMapper.fromObjectLiteral(results, {
-            nestedTypes: {
-                "timeSeries[].startDate": "date",
-                "timeSeries[].endDate": "date"
-            }
-        });
+        const results = await this._defaultPipeline<ServerResponse<TimeSeriesStatistics>>(_ => body = _).process(bodyStream);
+
+        const { timeSeries, ...restProps } = results;
+
+        const dateUtil = this._conventions.dateUtil;
+
+        this.result = {
+            ...restProps,
+            timeSeries: timeSeries.map(t => {
+                const { startDate, endDate } = t;
+                return {
+                    ...t,
+                    startDate: dateUtil.parse(startDate),
+                    endDate: dateUtil.parse(endDate)
+                }
+            })
+        }
 
         return body;
     }

src/Documents/Queries/Facets/AggregationQueryBase.ts

@@ -15,9 +15,6 @@ export interface FacetResultObject {
     [key: string]: FacetResult;
 }
 
-const FACET_RESULT_TYPE_INFO = { typeName: FacetResult.name };
-const FACET_RESULT_TYPES_MAP = new Map([[FacetResult.name, FacetResult]]);
-
 export abstract class AggregationQueryBase {
 
     private readonly _session: InMemoryDocumentSessionOperations;
@@ -60,8 +57,7 @@ export abstract class AggregationQueryBase {
         const results: FacetResultObject = {};
         const mapper = new TypesAwareObjectMapper();
         for (const result of queryResult.results) {
-            const facetResult = mapper.fromObjectLiteral<FacetResult>(
-                result, FACET_RESULT_TYPE_INFO, FACET_RESULT_TYPES_MAP);
+            const facetResult = Object.assign(new FacetResult(), result);
             results[facetResult.name] = facetResult;
         }
 

src/Documents/Session/InMemoryDocumentSessionOperations.ts

@@ -2,7 +2,7 @@ import { EntityToJson } from "./EntityToJson";
 import { IDisposable } from "../../Types/Contracts";
 import { SessionInfo, ConcurrencyCheckMode, StoreOptions } from "./IDocumentSession";
 import { IMetadataDictionary } from "./IMetadataDictionary";
-import { ObjectTypeDescriptor, ClassConstructor } from "../../Types";
+import { ObjectTypeDescriptor, ClassConstructor, ServerResponse } from "../../Types";
 import {
     SessionEventsEmitter,
     SessionBeforeStoreEventArgs,
@@ -835,7 +835,7 @@ export abstract class InMemoryDocumentSessionOperations
         }
     }
 
-    public registerTimeSeries(resultTimeSeries: Record<string, Record<string, TimeSeriesRangeResult[]>>) {
+    public registerTimeSeries(resultTimeSeries: Record<string, Record<string, ServerResponse<TimeSeriesRangeResult>[]>>) {
         if (this.noTracking || !resultTimeSeries) {
             return;
         }
@@ -1110,7 +1110,7 @@ export abstract class InMemoryDocumentSessionOperations
         ranges.splice(fromRangeIndex + 1, toRangeIndex - fromRangeIndex);
     }
 
-    private static _parseTimeSeriesRangeResult(json: TimeSeriesRangeResult,
+    private static _parseTimeSeriesRangeResult(json: ServerResponse<TimeSeriesRangeResult>,
                                                id: string,
                                                databaseName: string,
                                                conventions: DocumentConventions): TimeSeriesRangeResult {
@@ -1706,7 +1706,7 @@ export abstract class InMemoryDocumentSessionOperations
                     dirty = true;
                 }
 
-                documentInfo.metadata[prop] = ObjectUtil.clone(documentInfo.metadataInstance[prop]);
+                documentInfo.metadata[prop] = ObjectUtil.deepJsonClone(documentInfo.metadataInstance[prop]);
             }
         }
 

src/Documents/Session/Operations/BatchOperation.ts

@@ -169,11 +169,11 @@ export class BatchOperation {
 
     private _applyMetadataModifications(id: string, documentInfo: DocumentInfo): void {
         documentInfo.metadataInstance = null;
-        documentInfo.metadata = ObjectUtil.clone(documentInfo.metadata);
+        documentInfo.metadata = ObjectUtil.deepLiteralClone(documentInfo.metadata);
 
         documentInfo.metadata["@change-vector"] = documentInfo.changeVector;
 
-        const documentCopy = ObjectUtil.clone(documentInfo.document);
+        const documentCopy = ObjectUtil.deepLiteralClone(documentInfo.document);
         documentCopy[CONSTANTS.Documents.Metadata.KEY] = documentInfo.metadata;
 
         documentInfo.document = documentCopy;