RDBC-622 removed transform json keys

Author: ml054

src/Documents/Commands/FacetQueryCommand.ts

@@ -48,19 +48,12 @@ export class FacetQueryCommand extends QueryCommand {
             defaultTransform: "camel"
         }) as any;
 
-        const mappedIncludes: Record<string, any> = {};
-        if (json.Includes) {
-            for (const [key, value] of Object.entries(json.Includes)) {
-                mappedIncludes[key] = ObjectUtil.transformDocumentKeys(value, conventions);
-            }
-        }
-
         return {
             ...restMapped,
             indexTimestamp: conventions.dateUtil.parse(IndexTimestamp),
             lastQueryTime: conventions.dateUtil.parse(LastQueryTime),
             results: Results.map(x => ObjectUtil.transformObjectKeys(x, { defaultTransform: "camel" })),
-            includes: mappedIncludes
+            includes: ObjectUtil.mapIncludesToLocalObject(json.Includes, conventions)
         };
     }
 }

src/Documents/Commands/GetDocumentsCommand.ts

@@ -346,16 +346,9 @@ export class GetDocumentsCommand extends RavenCommand<GetDocumentsResult> {
     }
 
     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,
+            includes: ObjectUtil.mapIncludesToLocalObject(json.Includes, conventions),
             compareExchangeValueIncludes: ObjectUtil.mapCompareExchangeToLocalObject(json.CompareExchangeValueIncludes),
             timeSeriesIncludes: ObjectUtil.mapTimeSeriesIncludesToLocalObject(json.TimeSeriesIncludes),
             counterIncludes: ObjectUtil.mapCounterIncludesToLocalObject(json.CounterIncludes),

src/Documents/Commands/QueryCommand.ts

@@ -154,16 +154,9 @@ export class QueryCommand extends RavenCommand<QueryResult> {
 
 
     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,
+            includes: ObjectUtil.mapIncludesToLocalObject(json.Includes, conventions),
             indexName: json.IndexName,
             indexTimestamp: conventions.dateUtil.parse(json.IndexTimestamp),
             includedPaths: json.IncludedPaths,

src/Documents/Subscriptions/SubscriptionConnectionServerMessage.ts

@@ -1,14 +1,14 @@
 
 export interface SubscriptionConnectionServerMessage {
     type: MessageType;
-    status: ConnectionStatus;
-    data: any;
-    includes: any;
-    counterIncludes: any;
-    includedCounterNames: Record<string, string[]>;
-    timeSeriesIncludes: any;
-    exception: string;
-    message: string;
+    status?: ConnectionStatus;
+    data?: any;
+    includes?: any;
+    counterIncludes?: any;
+    includedCounterNames?: Record<string, string[]>;
+    timeSeriesIncludes?: any;
+    exception?: string;
+    message?: string;
 }
 
 export interface SubscriptionRedirectData {

src/Documents/Subscriptions/SubscriptionWorker.ts

@@ -25,14 +25,15 @@ import { EmptyCallback } from "../../Types/Callbacks";
 import { delay } from "../../Utility/PromiseUtil";
 import * as Parser from "stream-json/Parser";
 import * as StreamValues from "stream-json/streamers/StreamValues";
-import { TransformKeysJsonStream } from "../../Mapping/Json/Streams/TransformKeysJsonStream";
-import { getTransformJsonKeysProfile } from "../../Mapping/Json/Streams/TransformJsonKeysProfiles";
 import { BatchFromServer, CounterIncludeItem } from "./BatchFromServer";
 import { ServerNode } from "../../Http/ServerNode";
 import { RequestExecutor } from "../../Http/RequestExecutor";
 import { GetTcpInfoCommand, TcpConnectionInfo } from "../../ServerWide/Commands/GetTcpInfoCommand";
 import { GetTcpInfoForRemoteTaskCommand } from "../Commands/GetTcpInfoForRemoteTaskCommand";
 import * as os from "os";
+import { DocumentConventions } from "../Conventions/DocumentConventions";
+import { ServerCasing, ServerResponse } from "../../Types";
+import { CONSTANTS } from "../../Constants";
 
 type EventTypes = "afterAcknowledgment" | "connectionRetry" | "batch" | "error" | "end" | "unexpectedSubscriptionError";
 
@@ -239,16 +240,29 @@ export class SubscriptionWorker<T extends object> implements IDisposable {
     }
 
     private _ensureParser(socket: Socket) {
-        const keysTransformProfile = getTransformJsonKeysProfile(
-            this._revisions
-                ? "SubscriptionRevisionsResponsePayload"
-                : "SubscriptionResponsePayload", this._store.conventions);
+        const conventions = this._store.conventions;
+        const revisions = this._revisions;
+
+        const keysTransform = new stream.Transform({
+            objectMode: true,
+            transform(chunk, encoding, callback) {
+                let value = chunk["value"];
+                if (!value) {
+                    return callback();
+                }
+
+                value = SubscriptionWorker._mapToLocalObject(value, revisions, conventions);
+
+                callback(null, {...chunk, value});
+            }
+        });
+
 
         this._parser = stream.pipeline([
             socket,
             new Parser({ jsonStreaming: true, streamValues: false }),
-            new TransformKeysJsonStream(keysTransformProfile),
-            new StreamValues()
+            new StreamValues(),
+            keysTransform
         ], err => {
             if (err && !socket.destroyed) {
                 this._emitter.emit("error", err);
@@ -804,4 +818,30 @@ export class SubscriptionWorker<T extends object> implements IDisposable {
         return this;
     }
 
+    private static _mapToLocalObject(json: ServerCasing<ServerResponse<SubscriptionConnectionServerMessage>>, revisions: boolean, conventions: DocumentConventions): SubscriptionConnectionServerMessage {
+        const { Data, Includes, CounterIncludes, ...rest } = json;
+
+        let data: any;
+        if (Data) {
+            if (revisions) {
+                data = {
+                    current: ObjectUtil.transformDocumentKeys(Data.Current, conventions),
+                    previous: ObjectUtil.transformDocumentKeys(Data.Previous, conventions),
+                    [CONSTANTS.Documents.Metadata.KEY]: ObjectUtil.transformMetadataKeys(Data[CONSTANTS.Documents.Metadata.KEY], conventions)
+                }
+            } else {
+                data = ObjectUtil.transformDocumentKeys(Data, conventions);
+            }
+        }
+
+        return {
+            ...ObjectUtil.transformObjectKeys(rest, {
+                defaultTransform: "camel"
+            }),
+            data,
+            includes: ObjectUtil.mapIncludesToLocalObject(Includes, conventions),
+            counterIncludes: ObjectUtil.mapCounterIncludesToLocalObject(CounterIncludes),
+        } as SubscriptionConnectionServerMessage;
+    }
+
 }

src/Http/RavenCommandResponsePipeline.ts

@@ -19,7 +19,6 @@ import {
 import { throwError, getError } from "../Exceptions";
 import { TypeUtil } from "../Utility/TypeUtil";
 import * as Asm from "stream-json/Assembler";
-import { DocumentConventions } from "../Documents/Conventions/DocumentConventions";
 import { ErrorFirstCallback } from "../Types/Callbacks";
 import { StringBuilder } from "../Utility/StringBuilder";
 import { parser as jsonlParser } from "stream-json/jsonl/Parser";

src/Mapping/Json/Streams/TransformJsonKeysProfiles.ts

@@ -155,6 +155,16 @@ export class ObjectUtil {
         };
     }
 
+    public static mapIncludesToLocalObject(json: any, conventions: DocumentConventions) {
+        const mappedIncludes: Record<string, any> = {};
+        if (json) {
+            for (const [key, value] of Object.entries(json)) {
+                mappedIncludes[key] = ObjectUtil.transformDocumentKeys(value, conventions);
+            }
+        }
+        return mappedIncludes;
+    }
+
     public static mapCompareExchangeToLocalObject(json: Record<string, any>) {
         if (!json) {
             return undefined;
@@ -345,16 +355,19 @@ function makeKeyPath(keyStack) {
 }
 
 function shouldTransformKey(currentKey, currentPath, opts) {
-    const currentPathPlusKey = currentPath ? currentPath + "." + currentKey : currentKey;
     for (const x of opts.ignoreKeys) {
         if ("test" in x ? x.test(currentKey) : x === currentKey) {
             return false;
         }
     }
 
-    for (const x of opts.ignorePaths) {
-        if ("test" in x ? x.test(currentPathPlusKey) : x === currentPathPlusKey) {
-            return false;
+    if (opts.ignorePaths) {
+        const currentPathPlusKey = currentPath ? currentPath + "." + currentKey : currentKey;
+
+        for (const x of opts.ignorePaths) {
+            if ("test" in x ? x.test(currentPathPlusKey) : x === currentPathPlusKey) {
+                return false;
+            }
         }
     }