sync with java: 890fe52470095482f42298a59e0227d318fc69ce

ml054 · ml054 · commit c7e140c54d88 · 2020-12-14T00:40:22.000+01:00
diff --git a/src/Documents/DocumentStoreBase.ts b/src/Documents/DocumentStoreBase.ts
@@ -36,6 +36,7 @@ import { DatabaseSmuggler } from "./Smuggler/DatabaseSmuggler";
 import { IDisposable } from "../Types/Contracts";
 import { TimeSeriesOperations } from "./TimeSeries/TimeSeriesOperations";
 import { IAbstractIndexCreationTask } from "./Indexes/IAbstractIndexCreationTask";
+import { StringUtil } from "../Utility/StringUtil";
 
 export abstract class DocumentStoreBase
     extends EventEmitter
diff --git a/src/Documents/Identity/MultiDatabaseHiLoIdGenerator.ts b/src/Documents/Identity/MultiDatabaseHiLoIdGenerator.ts
@@ -1,6 +1,7 @@
 import { MultiTypeHiLoIdGenerator } from "./MultiTypeHiLoIdGenerator";
 import { DocumentStore } from "../DocumentStore";
 import { IRavenObject } from "../../Types/IRavenObject";
+import { DocumentStoreBase } from "../DocumentStoreBase";
 
 export class MultiDatabaseHiLoIdGenerator {
 
@@ -13,7 +14,7 @@ export class MultiDatabaseHiLoIdGenerator {
     }
 
     public generateDocumentId(database: string, entity: object): Promise<string> {
-        return this._getGeneratorForDatabase(database || this._store.database)
+        return this._getGeneratorForDatabase(DocumentStoreBase.getEffectiveDatabase(this._store, database))
             .generateDocumentId(entity);
     }
 
diff --git a/src/Documents/Indexes/AbstractIndexCreationTaskBase.ts b/src/Documents/Indexes/AbstractIndexCreationTaskBase.ts
@@ -9,8 +9,7 @@ import { DocumentStoreBase } from "../DocumentStoreBase";
 
 export abstract class AbstractIndexCreationTaskBase<TIndexDefinition extends IndexDefinition>
     extends AbstractCommonApiForIndexes implements IAbstractIndexCreationTask {
-
-
+    
     /**
      *  Creates the index definition.
      */
diff --git a/src/Documents/Queries/Facets/AggregationQueryBase.ts b/src/Documents/Queries/Facets/AggregationQueryBase.ts
@@ -43,7 +43,7 @@ export abstract class AggregationQueryBase {
         return (this._session as DocumentSession)
             .addLazyOperation(
                 new LazyAggregationQueryOperation(
-                    this._session.conventions,
+                    this._session,
                     this._query,
                     this,
                     (queryResult: QueryResult) =>
@@ -65,6 +65,8 @@ export abstract class AggregationQueryBase {
             results[facetResult.name] = facetResult;
         }
 
+        this._session.registerIncludes(queryResult.includes);
+
         QueryOperation.ensureIsAcceptable(
             queryResult, this._query.waitForNonStaleResults, this._duration, this._session);
 
diff --git a/src/Documents/Queries/Suggestions/SuggestionQueryBase.ts b/src/Documents/Queries/Suggestions/SuggestionQueryBase.ts
@@ -54,7 +54,7 @@ export abstract class SuggestionQueryBase {
 
         return (this._session as DocumentSession).addLazyOperation(
             new LazySuggestionQueryOperation(
-                this._session.conventions,
+                this._session,
                 this._query,
                 result => this._invokeAfterQueryExecuted(result),
                 (result) => this._processResults(result)
diff --git a/src/Documents/Session/AbstractDocumentQuery.ts b/src/Documents/Session/AbstractDocumentQuery.ts
@@ -428,7 +428,7 @@ export abstract class AbstractDocumentQuery<T extends object, TSelf extends Abst
 
         const clazz = this._conventions.getJsTypeByDocumentType(this._clazz);
         return  new LazyQueryOperation<T>(
-            this._theSession.conventions,
+            this._theSession,
             this._queryOperation,
             this,
             clazz);
@@ -2157,7 +2157,7 @@ export abstract class AbstractDocumentQuery<T extends object, TSelf extends Abst
         const clazz = this._conventions.getJsTypeByDocumentType(this._clazz);
         const lazyQueryOperation =
             new LazyQueryOperation<T>(
-                this._theSession.conventions,
+                this._theSession,
                 this._queryOperation,
                 this,
                 clazz);
diff --git a/src/Documents/Session/IDocumentQuery.ts b/src/Documents/Session/IDocumentQuery.ts
@@ -74,7 +74,7 @@ export interface IDocumentQuery<T extends object>
      * If the field is not stored in index, value will come from document directly.
      */
     selectFields<TProjection extends object>(
-        queryData: QueryData, projectionClass: DocumentType<TProjection>): IDocumentQuery<TProjection>; //TODO: update in 4.2 as well
+        queryData: QueryData, projectionClass: DocumentType<TProjection>): IDocumentQuery<TProjection>;
 
     /**
      * Selects a Time Series Aggregation based on
diff --git a/src/Documents/Session/Operations/Lazy/LazyAggregationQueryOperation.ts b/src/Documents/Session/Operations/Lazy/LazyAggregationQueryOperation.ts
@@ -7,21 +7,22 @@ import { GetRequest } from "../../../Commands/MultiGet/GetRequest";
 import { GetResponse } from "../../../Commands/MultiGet/GetResponse";
 import { FacetQueryCommand } from "../../../Commands/FacetQueryCommand";
 import { stringToReadable } from "../../../../Utility/StreamUtil";
+import { InMemoryDocumentSessionOperations } from "../../InMemoryDocumentSessionOperations";
 
 export class LazyAggregationQueryOperation implements ILazyOperation {
 
-    private readonly _conventions: DocumentConventions;
+    private readonly _session: InMemoryDocumentSessionOperations;
     private readonly _indexQuery: IndexQuery;
     private readonly _parent: AggregationQueryBase;
     private readonly _processResults:
         (queryResult: QueryResult) => FacetResultObject;
 
     public constructor(
-        conventions: DocumentConventions,
+        session: InMemoryDocumentSessionOperations,
         indexQuery: IndexQuery,
         parent: AggregationQueryBase,
         processResults: (queryResult: QueryResult) => FacetResultObject) {
-        this._conventions = conventions;
+        this._session = session;
         this._indexQuery = indexQuery;
         this._processResults = processResults;
         this._parent = parent;
@@ -32,7 +33,7 @@ export class LazyAggregationQueryOperation implements ILazyOperation {
         request.url = "/queries";
         request.method = "POST";
         request.query = "?queryHash=" + this._indexQuery.getQueryHash();
-        request.body = writeIndexQuery(this._conventions, this._indexQuery);
+        request.body = writeIndexQuery(this._session.conventions, this._indexQuery);
         return request;
     }
 
@@ -72,7 +73,7 @@ export class LazyAggregationQueryOperation implements ILazyOperation {
         }
 
         const result = await FacetQueryCommand.parseQueryResultResponseAsync(
-            stringToReadable(response.result), this._conventions, false);
+            stringToReadable(response.result), this._session.conventions, false);
         this._handleResponse(result);
     }
 
diff --git a/src/Documents/Session/Operations/Lazy/LazyQueryOperation.ts b/src/Documents/Session/Operations/Lazy/LazyQueryOperation.ts
@@ -9,21 +9,22 @@ import { GetResponse } from "../../../Commands/MultiGet/GetResponse";
 import { QueryCommand } from "../../../Commands/QueryCommand";
 import { stringToReadable } from "../../../../Utility/StreamUtil";
 import { QueryEventsEmitter } from "../../../Session/QueryEvents";
+import { InMemoryDocumentSessionOperations } from "../../InMemoryDocumentSessionOperations";
 
 export class LazyQueryOperation<T extends object> implements ILazyOperation {
     private readonly _clazz: ObjectTypeDescriptor<T>;
-    private readonly _conventions: DocumentConventions;
+    private readonly _session: InMemoryDocumentSessionOperations;
     private readonly _queryOperation: QueryOperation;
     private readonly _parent: QueryEventsEmitter;
 
     public constructor(
-        conventions: DocumentConventions,
+        session: InMemoryDocumentSessionOperations,
         queryOperation: QueryOperation,
         parent: QueryEventsEmitter,
         clazz: ObjectTypeDescriptor<T>) {
 
         this._clazz = clazz;
-        this._conventions = conventions;
+        this._session = session;
         this._queryOperation = queryOperation;
         this._parent = parent;
     }
@@ -33,7 +34,7 @@ export class LazyQueryOperation<T extends object> implements ILazyOperation {
         request.url = "/queries";
         request.method = "POST";
         request.query = "?queryHash=" + this._queryOperation.indexQuery.getQueryHash();
-        request.body = writeIndexQuery(this._conventions, this._queryOperation.indexQuery);
+        request.body = writeIndexQuery(this._session.conventions, this._queryOperation.indexQuery);
         return request;
     }
 
@@ -75,7 +76,7 @@ export class LazyQueryOperation<T extends object> implements ILazyOperation {
         let queryResult: QueryResult;
         if (response.result) {
             queryResult = await QueryCommand.parseQueryResultResponseAsync(
-                stringToReadable(response.result), this._conventions, false);
+                stringToReadable(response.result), this._session.conventions, false);
         }
         this._handleResponse(queryResult, response.elapsed);
     }
diff --git a/src/Documents/Session/Operations/Lazy/LazySuggestionQueryOperation.ts b/src/Documents/Session/Operations/Lazy/LazySuggestionQueryOperation.ts
@@ -7,24 +7,25 @@ import { stringToReadable } from "../../../../Utility/StreamUtil";
 import { DocumentConventions } from "../../../Conventions/DocumentConventions";
 import { IndexQuery, writeIndexQuery } from "../../../Queries/IndexQuery";
 import { SuggestionsResponseObject } from "../../../../Types";
+import { InMemoryDocumentSessionOperations } from "../../InMemoryDocumentSessionOperations";
 
 export class LazySuggestionQueryOperation implements ILazyOperation {
 
     private _result: Object;
     private _queryResult: QueryResult;
     private _requiresRetry: boolean;
 
-    private readonly _conventions: DocumentConventions;
+    private readonly _session: InMemoryDocumentSessionOperations;
     private readonly _indexQuery: IndexQuery;
     private readonly _invokeAfterQueryExecuted: (result: QueryResult) => void;
     private readonly _processResults:
         (result: QueryResult) => SuggestionsResponseObject;
 
-    public constructor(conventions: DocumentConventions, indexQuery: IndexQuery,
+    public constructor(session: InMemoryDocumentSessionOperations, indexQuery: IndexQuery,
                        invokeAfterQueryExecuted: (result: QueryResult) => void,
                        processResults: (result: QueryResult)
                            => SuggestionsResponseObject) {
-        this._conventions = conventions;
+        this._session = session;
         this._indexQuery = indexQuery;
         this._invokeAfterQueryExecuted = invokeAfterQueryExecuted;
         this._processResults = processResults;
@@ -35,7 +36,7 @@ export class LazySuggestionQueryOperation implements ILazyOperation {
         request.url = "/queries";
         request.method = "POST";
         request.query = "?queryHash=" + this._indexQuery.getQueryHash();
-        request.body = writeIndexQuery(this._conventions, this._indexQuery);
+        request.body = writeIndexQuery(this._session.conventions, this._indexQuery);
 
         return request;
     }
@@ -72,7 +73,7 @@ export class LazySuggestionQueryOperation implements ILazyOperation {
         }
 
         const result = await QueryCommand.parseQueryResultResponseAsync(
-            stringToReadable(response.result), this._conventions, false);
+            stringToReadable(response.result), this._session.conventions, false);
 
         this._handleResponse(result);
     }
diff --git a/src/Documents/TimeSeries/TimeSeriesOperations.ts b/src/Documents/TimeSeries/TimeSeriesOperations.ts
@@ -86,7 +86,7 @@ export class TimeSeriesOperations {
 
                 const mapping = TimeSeriesValuesHelper.getFieldsMapping(timeSeriesEntryClassOrName);
                 if (!mapping) {
-                    throwError("InvalidOperationException", TimeSeriesOperations.getTimeSeriesName(timeSeriesEntryClassOrName, this._store.conventions) + " must contain "); //TODO:
+                    throwError("InvalidOperationException", TimeSeriesOperations.getTimeSeriesName(timeSeriesEntryClassOrName, this._store.conventions) + " must contain valid mapping");
                 }
 
                 const collection = this._store.conventions.findCollectionName(collectionClass);
diff --git a/src/Mapping/Json/Streams/TransformJsonKeysProfiles.ts b/src/Mapping/Json/Streams/TransformJsonKeysProfiles.ts
@@ -1,6 +1,7 @@
 import { CasingConvention } from "../../../Utility/ObjectUtil";
 import { DocumentConventions } from "../../../Documents/Conventions/DocumentConventions";
 import { throwError } from "../../../Exceptions";
+import { CONSTANTS } from "../../../Constants";
 
 export type TransformJsonKeysProfile = 
     "CommandResponsePayload"
@@ -116,6 +117,15 @@ export function getTransformJsonKeysProfile(
 }
 
 function facetQueryGetTransform(key, stack) {
+    const len = stack.length;
+
+
+    if (stack[0] === "Includes") {
+        if (len >= 3 && stack[2] === "@metadata") {
+            return handleMetadataJsonKeys(key, stack, stack.length, 3);
+        }
+    }
+
     return "camel";
 }
 
diff --git a/test/Ported/Indexing/JavaScriptIndexTest.ts b/test/Ported/Indexing/JavaScriptIndexTest.ts
@@ -1036,4 +1036,4 @@ class Users_ByAddress extends AbstractJavaScriptIndexCreationTask<User, Pick<Use
 class ProductsWarrentyResult {
     public warranty: string;
     public duration: number;
-}
+}
diff --git a/test/Ported/Issues/RavenDB_14600.ts b/test/Ported/Issues/RavenDB_14600.ts
@@ -0,0 +1,66 @@
+import { disposeTestDocumentStore, testContext } from "../../Utils/TestUtil";
+import { AbstractJavaScriptIndexCreationTask, IDocumentStore } from "../../../src";
+import { Employee, Order } from "../../Assets/Orders";
+import { assertThat } from "../../Utils/AssertExtensions";
+
+describe("RavenDB_14600Test", function () {
+
+    let store: IDocumentStore;
+
+    beforeEach(async function () {
+        store = await testContext.getDocumentStore();
+    });
+
+    afterEach(async () =>
+        await disposeTestDocumentStore(store));
+
+    it("canIncludeFacetResult", async () => {
+        {
+            const session = store.openSession();
+            const employee = new Employee();
+            employee.firstName = "Test";
+            await session.store(employee, "employees/1");
+
+            const order = new Order();
+            order.employee = "employees/1";
+            order.company = "companies/1-A";
+
+            await session.store(order, "orders/1");
+            await session.saveChanges();
+        }
+
+        await store.executeIndex(new MyIndex());
+
+        await testContext.waitForIndexing(store);
+
+        {
+            const session = store.openSession();
+            const facets = await session.query(Order, MyIndex)
+                .include("employee")
+                .whereEquals("company", "companies/1-A")
+                .aggregateBy(x => x.byField("employee"))
+                .execute();
+
+            assertThat(facets["employee"].values)
+                .isNotNull();
+
+            for (const f of facets["employee"].values) {
+                await session.load(f.range);
+            }
+
+            assertThat(session.advanced.numberOfRequests)
+                .isEqualTo(1);
+        }
+    });
+});
+
+class MyIndex extends AbstractJavaScriptIndexCreationTask<Order, Pick<Order, "employee" | "company">> {
+    public constructor() {
+        super();
+
+        this.map(Order, o => ({
+            employee: o.employee,
+            company: o.company
+        }));
+    }
+}
diff --git a/test/Ported/Issues/RavenDB_15792.ts b/test/Ported/Issues/RavenDB_15792.ts
@@ -0,0 +1,54 @@
+import { IDocumentStore, TimeSeriesRawResult } from "../../../src";
+import { disposeTestDocumentStore, testContext } from "../../Utils/TestUtil";
+import moment = require("moment");
+import { User } from "../../Assets/Entities";
+import { assertThat } from "../../Utils/AssertExtensions";
+
+describe("RavenDB_15792Test", function () {
+
+    let store: IDocumentStore;
+
+    beforeEach(async function () {
+        store = await testContext.getDocumentStore();
+    });
+
+    afterEach(async () =>
+        await disposeTestDocumentStore(store));
+
+    it("canQueryTimeSeriesWithSpacesInName", async () => {
+        const documentId = "users/ayende";
+
+        const baseLine = moment().startOf("day");
+
+        {
+            const session = store.openSession();
+
+            await session.store(new User(), documentId);
+
+            const tsf = session.timeSeriesFor(documentId, "gas m3 usage");
+            tsf.append(baseLine.toDate(), 1);
+
+            await session.saveChanges();
+        }
+
+        {
+            const session = store.openSession();
+            const query = session.advanced.rawQuery(`declare timeseries out()
+{
+    from "gas m3 usage"
+}
+from Users as u
+select out()`, TimeSeriesRawResult);
+
+            const result = await query.first();
+
+            assertThat(result)
+                .isNotNull();
+
+            const results = result.results;
+            assertThat(results)
+                .hasSize(1);
+        }
+    });
+
+});
diff --git a/test/Ported/Server/Replication/PullReplicationTest.ts b/test/Ported/Server/Replication/PullReplicationTest.ts
@@ -244,6 +244,8 @@ import { delay } from "../../../../src/Utility/PromiseUtil";
 
                     await ReplicationTestContext.addWatcherToReplicationTopology(sink, pull, ...hub2.urls);
 
+                    await delay(500); // wait a bit to process updates
+
                     {
                         const main = hub.openSession();
                         await main.store(new User(), "hub1/2");
diff --git a/test/Ported/TimeSeries/TimeSeriesTypedSession.ts b/test/Ported/TimeSeries/TimeSeriesTypedSession.ts

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`import { MultiTypeHiLoIdGenerator } from "./MultiTypeHiLoIdGenerator";`
`2`	`2`	`import { DocumentStore } from "../DocumentStore";`
`3`	`3`	`import { IRavenObject } from "../../Types/IRavenObject";`
	`4`	`+import { DocumentStoreBase } from "../DocumentStoreBase";`
`4`	`5`
`5`	`6`	`export class MultiDatabaseHiLoIdGenerator {`
`6`	`7`
`@@ -13,7 +14,7 @@ export class MultiDatabaseHiLoIdGenerator {`
`13`	`14`	`}`
`14`	`15`
`15`	`16`	`public generateDocumentId(database: string, entity: object): Promise<string> {`
`16`		`- return this._getGeneratorForDatabase(database \|\| this._store.database)`
	`17`	`+ return this._getGeneratorForDatabase(DocumentStoreBase.getEffectiveDatabase(this._store, database))`
`17`	`18`	`.generateDocumentId(entity);`
`18`	`19`	`}`
`19`	`20`