conventions: add method aliases to align to naming convention

gregolsky · gregolsky · commit fb69e374301b · 2018-12-10T10:22:57.000+01:00
diff --git a/src/Documents/BulkInsertOperation.ts b/src/Documents/BulkInsertOperation.ts
@@ -170,7 +170,7 @@ export class BulkInsertOperation {
         }
 
         if (!(CONSTANTS.Documents.Metadata.RAVEN_JS_TYPE in metadata)) {
-            const descriptor = this._conventions.getEntityTypeDescriptor(entity);
+            const descriptor = this._conventions.getTypeDescriptorByEntity(entity);
             const jsType = this._requestExecutor.conventions.getJsTypeName(descriptor);
             if (jsType) {
                 metadata[CONSTANTS.Documents.Metadata.RAVEN_JS_TYPE] = jsType;
diff --git a/src/Documents/Conventions/DocumentConventions.ts b/src/Documents/Conventions/DocumentConventions.ts
@@ -45,7 +45,6 @@ export class DocumentConventions {
     private _frozen: boolean;
     private _originalConfiguration: ClientConfiguration;
     private _idPropertyCache: Map<ObjectTypeDescriptor, string> = new Map(); //TODO: is it used?
-    // TODO: private _saveEnumsAsIntegers: number;
     private _identityPartsSeparator: string;
     private _disableTopologyUpdates: boolean;
 
@@ -80,11 +79,12 @@ export class DocumentConventions {
         this._identityPartsSeparator = "/";
 
         this._findIdentityPropertyNameFromCollectionName = () => "id";
+        
         this._findJsType = (id: string, doc: object) => {
             const metadata = doc[CONSTANTS.Documents.Metadata.KEY];
             if (metadata) {
                 const jsType = metadata[CONSTANTS.Documents.Metadata.RAVEN_JS_TYPE] as string;
-                return this._knownEntityTypes.get(jsType) || null;
+                return this.getJsTypeByDocumentType(jsType);
             }
 
             return null;
@@ -95,11 +95,12 @@ export class DocumentConventions {
                 return null;
             }
 
-            if (TypeUtil.isFunction(ctorOrTypeChecker["isType"])) {
-                return (ctorOrTypeChecker as ObjectLiteralDescriptor).name;
+            const name = (ctorOrTypeChecker as ClassConstructor).name;
+            if (name === "Object") {
+                return null;
             }
 
-            return (ctorOrTypeChecker as ClassConstructor).name;
+            return name;
         };
 
         this._transformClassCollectionNameToDocumentIdPrefix =
@@ -421,6 +422,10 @@ export class DocumentConventions {
         this._findCollectionNameForObjectLiteral = value;
     }
 
+    public getTypeDescriptorByEntity<T extends object>(entity: T): ObjectTypeDescriptor<T> {
+        return this.getEntityTypeDescriptor(entity);
+    }
+
     public getEntityTypeDescriptor<T extends object>(entity: T): ObjectTypeDescriptor<T> {
         if (TypeUtil.isClass(entity.constructor)) {
             return entity.constructor as ClassConstructor;
@@ -497,7 +502,7 @@ export class DocumentConventions {
      *  Gets the identity property.
      */
     public getIdentityProperty(documentType: DocumentType): string {
-        const typeDescriptor = this.findEntityType(documentType);
+        const typeDescriptor = this.getJsTypeByDocumentType(documentType);
         return this._registeredIdPropertyNames.get(typeDescriptor)
             || CONSTANTS.Documents.Metadata.ID_PROPERTY;
     }
@@ -599,10 +604,6 @@ export class DocumentConventions {
         }
     }
 
-    // TODO:
-    // public get registeredTypeDescriptors() {
-    //     return this._registeredTypeDescriptors;
-    // }
     public get knownEntityTypesByName() {
         return this._knownEntityTypes;
     }
@@ -611,6 +612,12 @@ export class DocumentConventions {
         return Array.from(this._knownEntityTypes.values());
     }
 
+    public registerJsType(entityType: ObjectTypeDescriptor): this;
+    public registerJsType(entityType: ObjectTypeDescriptor, name: string): this;
+    public registerJsType(entityType: ObjectTypeDescriptor, name?: string): this {
+        return this.registerEntityType(entityType, name);
+    }
+
     public registerEntityType(entityType: ObjectTypeDescriptor): this;
     public registerEntityType(entityType: ObjectTypeDescriptor, name: string): this;
     public registerEntityType(entityType: ObjectTypeDescriptor, name?: string): this {
@@ -627,26 +634,36 @@ export class DocumentConventions {
         return this;
     }
 
+    public tryRegisterJsType(docType: DocumentType): this {
+        return this.tryRegisterEntityType(docType);
+    }
+
     public tryRegisterEntityType(docType: DocumentType): this {
         if (TypeUtil.isObjectTypeDescriptor(docType)) {
-            this.registerEntityType(docType as ObjectTypeDescriptor);
+            this.registerJsType(docType as ObjectTypeDescriptor);
         }
 
         return this;
     }
 
-    public findEntityType<T extends object>(documentType: DocumentType<T>): ObjectTypeDescriptor<T>;
-    public findEntityType<T extends object>(typeName: string): ObjectTypeDescriptor<T>;
-    public findEntityType<T extends object>(docTypeOrTypeName: string | DocumentType<T>): ObjectTypeDescriptor<T> {
+    public getJsTypeByDocumentType<T extends object>(documentType: DocumentType<T>): ObjectTypeDescriptor<T>;
+    public getJsTypeByDocumentType<T extends object>(typeName: string): ObjectTypeDescriptor<T>;
+    public getJsTypeByDocumentType<T extends object>(
+        docTypeOrTypeName: string | DocumentType<T>): ObjectTypeDescriptor<T> {
         if (!docTypeOrTypeName) {
             return null;
         }
 
-        if (typeof(docTypeOrTypeName) !== "string") {
-            return docTypeOrTypeName as ObjectTypeDescriptor<T>;
+        if (typeof(docTypeOrTypeName) === "string") {
+            return this._knownEntityTypes.get(
+                docTypeOrTypeName) as ObjectLiteralDescriptor<T> || null;
+        }
+
+        if (docTypeOrTypeName.name === "Object") {
+            return null;
         }
 
-        return this._knownEntityTypes.get(docTypeOrTypeName) as ObjectLiteralDescriptor<T>;
+        return docTypeOrTypeName as ObjectTypeDescriptor<T>;
     }
 
     public transformObjectKeysToRemoteFieldNameConvention(obj: object, opts?: ObjectChangeCaseOptions) {
diff --git a/src/Documents/Identity/HiloMultiTypeIdGenerator.ts b/src/Documents/Identity/HiloMultiTypeIdGenerator.ts
@@ -15,7 +15,7 @@ export class HiloMultiTypeIdGenerator extends AbstractHiloIdGenerator implements
     }
 
     public generateDocumentId(entity: object, documentType?: string): Promise<string> {
-        const entityType = this._conventions.findEntityType(documentType);
+        const entityType = this._conventions.getJsTypeByDocumentType(documentType);
         const typeTagName: string = entityType
             ? this._conventions.getCollectionNameForType(entityType)
             : this._conventions.getCollectionNameForEntity(entity);
diff --git a/src/Documents/Operations/CompareExchange/CompareExchangeResult.ts b/src/Documents/Operations/CompareExchange/CompareExchangeResult.ts
@@ -60,7 +60,7 @@ export class CompareExchangeResult<T> {
         conventions: DocumentConventions,
         clazz?: ClassConstructor<T>): CompareExchangeResult<T> {
 
-        conventions.tryRegisterEntityType(clazz);
+        conventions.tryRegisterJsType(clazz);
 
         if (!val) {
             const emptyExchangeResult = new CompareExchangeResult<T>();
@@ -75,7 +75,7 @@ export class CompareExchangeResult<T> {
             result = val as any as T;
         } else {
             // val comes here with proper key case already
-            const entityType = conventions.findEntityType(clazz);
+            const entityType = conventions.getJsTypeByDocumentType(clazz);
             result = conventions.deserializeEntityFromJson(entityType, val) as any as T;
         }
 
diff --git a/src/Documents/Operations/CompareExchange/CompareExchangeValueResultParser.ts b/src/Documents/Operations/CompareExchange/CompareExchangeValueResultParser.ts
@@ -53,7 +53,7 @@ export class CompareExchangeValueResultParser {
                 if (!rawValue) {
                     results[key] = new CompareExchangeValue(key, index, null);
                 } else {
-                    const entityType = conventions.findEntityType(clazz);
+                    const entityType = conventions.getJsTypeByDocumentType(clazz);
                     if (conventions.entityFieldNameConvention) {
                         rawValue = ObjectUtil.transformObjectKeys(
                             rawValue, {
diff --git a/src/Documents/Operations/CompareExchange/PutCompareExchangeValueOperation.ts b/src/Documents/Operations/CompareExchange/PutCompareExchangeValueOperation.ts
@@ -97,7 +97,7 @@ export class PutCompareExchangeValueCommand<T> extends RavenCommand<CompareExcha
             .process(bodyStream);
 
         const type = !TypeUtil.isPrimitive(this._value)
-            ? this._conventions.getEntityTypeDescriptor(this._value as any) as ObjectTypeDescriptor
+            ? this._conventions.getTypeDescriptorByEntity(this._value as any) as ObjectTypeDescriptor
             : null;
         const clazz: ClassConstructor<T> = TypeUtil.isClass(type) ? type as any : null;
         this.result = CompareExchangeResult.parseFromObject(resObj, this._conventions, clazz);
diff --git a/src/Documents/Operations/OperationExecutor.ts b/src/Documents/Operations/OperationExecutor.ts
@@ -90,8 +90,8 @@ export class OperationExecutor {
                     const patchResult = command.result as any as PatchResult;
                     patchOperationResult.status = patchResult.status;
                     const { conventions } = this._requestExecutor;
-                    conventions.tryRegisterEntityType(documentType);
-                    const entityType = conventions.findEntityType(documentType);
+                    conventions.tryRegisterJsType(documentType);
+                    const entityType = conventions.getJsTypeByDocumentType(documentType);
                     patchOperationResult.document = conventions.deserializeEntityFromJson(
                         entityType, patchResult.modifiedDocument) as TResult;
                     return patchOperationResult;
diff --git a/src/Documents/Session/AbstractDocumentQuery.ts b/src/Documents/Session/AbstractDocumentQuery.ts
@@ -1907,7 +1907,7 @@ export abstract class AbstractDocumentQuery<T extends object, TSelf extends Abst
             this._queryOperation = this._initializeQueryOperation();
         }
 
-        const clazz = this._conventions.findEntityType(this._clazz);
+        const clazz = this._conventions.getJsTypeByDocumentType(this._clazz);
         const lazyQueryOperation = new LazyQueryOperation<T>(
             this._theSession.conventions,
             this._queryOperation,
@@ -1923,7 +1923,7 @@ export abstract class AbstractDocumentQuery<T extends object, TSelf extends Abst
             this._queryOperation = this._initializeQueryOperation();
         }
 
-        const clazz = this._conventions.findEntityType(this._clazz);
+        const clazz = this._conventions.getJsTypeByDocumentType(this._clazz);
         const lazyQueryOperation =
             new LazyQueryOperation<T>(
                 this._theSession.conventions,
diff --git a/src/Documents/Session/DocumentQuery.ts b/src/Documents/Session/DocumentQuery.ts
@@ -94,7 +94,7 @@ export class DocumentQuery<T extends object>
         propertiesOrQueryData: string | string[] | QueryData,
         projectionType?: DocumentType<TProjection>): IDocumentQuery<TProjection> {
         if (projectionType) {
-            this._theSession.conventions.tryRegisterEntityType(projectionType);
+            this._theSession.conventions.tryRegisterJsType(projectionType);
         }
 
         if (TypeUtil.isString(propertiesOrQueryData)) {
@@ -428,7 +428,7 @@ export class DocumentQuery<T extends object>
 
     public ofType<TResult extends object>(tResultClass: DocumentType<TResult>): IDocumentQuery<TResult> {
         if (tResultClass) {
-            this._theSession.conventions.tryRegisterEntityType(tResultClass);
+            this._theSession.conventions.tryRegisterJsType(tResultClass);
         }
 
         return this._createDocumentQueryInternal(tResultClass);
diff --git a/src/Documents/Session/DocumentSession.ts b/src/Documents/Session/DocumentSession.ts
@@ -138,7 +138,7 @@ export class DocumentSession extends InMemoryDocumentSessionOperations
         callback = callback || TypeUtil.NOOP;
         options = options || {};
 
-        this.conventions.tryRegisterEntityType(options.documentType);
+        this.conventions.tryRegisterJsType(options.documentType);
         const loadInternalPromise = this.loadInternal(ids, options.includes, options.documentType)
             .then((docs: EntitiesCollectionObject<TEntity> | TEntity) => {
                 if (isLoadingSingle) {
@@ -373,7 +373,7 @@ export class DocumentSession extends InMemoryDocumentSessionOperations
             loadOperation.setResult(command.result);
         }
 
-        const clazz = this.conventions.findEntityType(documentType);
+        const clazz = this.conventions.getJsTypeByDocumentType(documentType);
         return loadOperation.getDocuments(clazz);
     }
 
@@ -492,7 +492,7 @@ export class DocumentSession extends InMemoryDocumentSessionOperations
     public rawQuery<TEntity extends object>(
         query: string, documentType?: DocumentType<TEntity>): IRawDocumentQuery<TEntity> {
         if (documentType) {
-            this.conventions.tryRegisterEntityType(documentType);
+            this.conventions.tryRegisterJsType(documentType);
         }
 
         return new RawDocumentQuery(this, query, documentType);
@@ -523,7 +523,7 @@ export class DocumentSession extends InMemoryDocumentSessionOperations
         }
 
         if (opts.documentType) {
-            this.conventions.tryRegisterEntityType(opts.documentType);
+            this.conventions.tryRegisterJsType(opts.documentType);
         }
 
         const { indexName, collection } = this._processQueryParameters(opts, this.conventions);
@@ -543,7 +543,7 @@ export class DocumentSession extends InMemoryDocumentSessionOperations
         }
 
         if (!isIndex && !isCollection) {
-            const entityType = this.conventions.findEntityType(opts.documentType);
+            const entityType = this.conventions.getJsTypeByDocumentType(opts.documentType);
             collection = this.conventions.getCollectionNameForType(entityType) 
                 || CONSTANTS.Documents.Metadata.ALL_DOCUMENTS_COLLECTION;
         }
@@ -740,7 +740,7 @@ export class DocumentSession extends InMemoryDocumentSessionOperations
         const docsReadable = streamOperation.setResult(command.result);
         let clazz = null;
         if (opts && "documentType" in opts) {
-            clazz = this.conventions.findEntityType(opts.documentType);
+            clazz = this.conventions.getJsTypeByDocumentType(opts.documentType);
         }
 
         const result = this._getStreamResultTransform(this, clazz, null);
diff --git a/src/Documents/Session/EntityToJson.ts b/src/Documents/Session/EntityToJson.ts
@@ -121,7 +121,7 @@ export class EntityToJson {
     public convertToEntity(targetEntityType: DocumentType, id: string, document: object): object {
         const conventions = this._session.conventions;
 
-        const entityType: ObjectTypeDescriptor = conventions.findEntityType(targetEntityType);
+        const entityType: ObjectTypeDescriptor = conventions.getJsTypeByDocumentType(targetEntityType);
         try {
             if (TypeUtil.isType(document, targetEntityType)) {
                 return document;
diff --git a/src/Documents/Session/InMemoryDocumentSessionOperations.ts b/src/Documents/Session/InMemoryDocumentSessionOperations.ts
@@ -605,9 +605,9 @@ export abstract class InMemoryDocumentSessionOperations
 
         const changeVector = options.changeVector;
         documentType = documentType || options.documentType;
-        this.conventions.tryRegisterEntityType(documentType);
+        this.conventions.tryRegisterJsType(documentType);
         if (entity.constructor !== Object) {
-            this.conventions.tryRegisterEntityType(entity.constructor as ClassConstructor);
+            this.conventions.tryRegisterJsType(entity.constructor as ClassConstructor);
         }
 
         let forceConcurrencyCheck: ConcurrencyCheckMode;
@@ -689,8 +689,8 @@ export abstract class InMemoryDocumentSessionOperations
                 }
 
                 const entityType = documentType
-                    ? conventions.findEntityType(documentType)
-                    : conventions.getEntityTypeDescriptor(entity);
+                    ? conventions.getJsTypeByDocumentType(documentType)
+                    : conventions.getTypeDescriptorByEntity(entity);
                 const jsType = conventions.getJsTypeName(entityType);
                 if (jsType) {
                     metadata[CONSTANTS.Documents.Metadata.RAVEN_JS_TYPE] = jsType;
@@ -1029,7 +1029,7 @@ export abstract class InMemoryDocumentSessionOperations
         }
 
         documentInfo.document = document;
-        const entityType = this.conventions.getEntityTypeDescriptor(entity);
+        const entityType = this.conventions.getTypeDescriptorByEntity(entity);
         documentInfo.entity = this.entityToJson.convertToEntity(entityType, documentInfo.id, document);
 
         Object.assign(entity, documentInfo.entity);
diff --git a/src/Documents/Session/Loaders/MultiLoaderWithInclude.ts b/src/Documents/Session/Loaders/MultiLoaderWithInclude.ts
@@ -57,7 +57,7 @@ export class MultiLoaderWithInclude implements ILoaderWithInclude {
             singleResult = true;
         }
 
-        const entityType = this._session.conventions.findEntityType(documentType);
+        const entityType = this._session.conventions.getJsTypeByDocumentType(documentType);
 
         const result = BluebirdPromise.resolve()
             .then(() => this._session.loadInternal(ids as string[], this._includes, entityType))
diff --git a/src/Documents/Session/Operations/Lazy/LazyStartsWithOperation.ts b/src/Documents/Session/Operations/Lazy/LazyStartsWithOperation.ts
@@ -34,7 +34,7 @@ export class LazyStartsWithOperation<T extends object> implements ILazyOperation
         this._pageSize = opts.pageSize;
         this._sessionOperations = sessionOperations;
         this._startAfter = opts.startAfter;
-        this._clazz = sessionOperations.conventions.findEntityType(opts.documentType);
+        this._clazz = sessionOperations.conventions.getJsTypeByDocumentType(opts.documentType);
     }
 
     public createRequest(): GetRequest {
diff --git a/src/Documents/Session/Operations/LoadStartingWithOperation.ts b/src/Documents/Session/Operations/LoadStartingWithOperation.ts
@@ -72,7 +72,7 @@ export class LoadStartingWithOperation {
     }
 
     public getDocuments<T extends object>(docType: DocumentType<T>): T[] {
-        const entityType = this._session.conventions.findEntityType<T>(docType);
+        const entityType = this._session.conventions.getJsTypeByDocumentType<T>(docType);
         return this._returnedIds.reduce((result, id) => {
             const doc = this._getDocument(entityType, id);
             return [...result, doc];
diff --git a/src/Documents/Session/Operations/QueryOperation.ts b/src/Documents/Session/Operations/QueryOperation.ts
@@ -158,7 +158,7 @@ export class QueryOperation {
         const { entityFieldNameConvention } = conventions;
         const projection = metadata["@projection"];
         if (TypeUtil.isNullOrUndefined(projection) || projection === false) {
-            const entityType = conventions.findEntityType(clazz);
+            const entityType = conventions.getJsTypeByDocumentType(clazz);
             return session.trackEntity(entityType, id, document, metadata, disableEntitiesTracking);
         }
 
@@ -196,7 +196,7 @@ export class QueryOperation {
         }
 
         const raw: T = conventions.objectMapper.fromObjectLiteral(document);
-        const projType = conventions.findEntityType(clazz);
+        const projType = conventions.getJsTypeByDocumentType(clazz);
         // tslint:disable-next-line:new-parens
         const result = projType ? new (Function.prototype.bind.apply(projType)) : {};
 
diff --git a/src/Documents/Subscriptions/DocumentSubscriptions.ts b/src/Documents/Subscriptions/DocumentSubscriptions.ts
@@ -102,7 +102,7 @@ export class DocumentSubscriptions implements IDisposable {
             criteria = {} as SubscriptionCreationOptions;
         }
 
-        const objectDescriptor = this._store.conventions.findEntityType(criteria.documentType);
+        const objectDescriptor = this._store.conventions.getJsTypeByDocumentType(criteria.documentType);
         const collectionName = this._store.conventions.getCollectionNameForType(objectDescriptor);
 
         if (!criteria.query) {

Original file line number	Diff line number	Diff line change
`@@ -170,7 +170,7 @@ export class BulkInsertOperation {`
`170`	`170`	`}`
`171`	`171`
`172`	`172`	`if (!(CONSTANTS.Documents.Metadata.RAVEN_JS_TYPE in metadata)) {`
`173`		`- const descriptor = this._conventions.getEntityTypeDescriptor(entity);`
	`173`	`+ const descriptor = this._conventions.getTypeDescriptorByEntity(entity);`
`174`	`174`	`const jsType = this._requestExecutor.conventions.getJsTypeName(descriptor);`
`175`	`175`	`if (jsType) {`
`176`	`176`	`metadata[CONSTANTS.Documents.Metadata.RAVEN_JS_TYPE] = jsType;`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ export class HiloMultiTypeIdGenerator extends AbstractHiloIdGenerator implements`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`public generateDocumentId(entity: object, documentType?: string): Promise<string> {`
`18`		`- const entityType = this._conventions.findEntityType(documentType);`
	`18`	`+ const entityType = this._conventions.getJsTypeByDocumentType(documentType);`
`19`	`19`	`const typeTagName: string = entityType`
`20`	`20`	`? this._conventions.getCollectionNameForType(entityType)`
`21`	`21`	`: this._conventions.getCollectionNameForEntity(entity);`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ export class DocumentQuery<T extends object>`
`94`	`94`	`propertiesOrQueryData: string \| string[] \| QueryData,`
`95`	`95`	`projectionType?: DocumentType<TProjection>): IDocumentQuery<TProjection> {`
`96`	`96`	`if (projectionType) {`
`97`		`- this._theSession.conventions.tryRegisterEntityType(projectionType);`
	`97`	`+ this._theSession.conventions.tryRegisterJsType(projectionType);`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`if (TypeUtil.isString(propertiesOrQueryData)) {`
`@@ -428,7 +428,7 @@ export class DocumentQuery<T extends object>`
`428`	`428`
`429`	`429`	`public ofType<TResult extends object>(tResultClass: DocumentType<TResult>): IDocumentQuery<TResult> {`
`430`	`430`	`if (tResultClass) {`
`431`		`- this._theSession.conventions.tryRegisterEntityType(tResultClass);`
	`431`	`+ this._theSession.conventions.tryRegisterJsType(tResultClass);`
`432`	`432`	`}`
`433`	`433`
`434`	`434`	`return this._createDocumentQueryInternal(tResultClass);`
Original file line number	Diff line number	Diff line change
`@@ -138,7 +138,7 @@ export class DocumentSession extends InMemoryDocumentSessionOperations`
`138`	`138`	`callback = callback \|\| TypeUtil.NOOP;`
`139`	`139`	`options = options \|\| {};`
`140`	`140`
`141`		`- this.conventions.tryRegisterEntityType(options.documentType);`
	`141`	`+ this.conventions.tryRegisterJsType(options.documentType);`
`142`	`142`	`const loadInternalPromise = this.loadInternal(ids, options.includes, options.documentType)`
`143`	`143`	`.then((docs: EntitiesCollectionObject<TEntity> \| TEntity) => {`
`144`	`144`	`if (isLoadingSingle) {`
`@@ -373,7 +373,7 @@ export class DocumentSession extends InMemoryDocumentSessionOperations`
`373`	`373`	`loadOperation.setResult(command.result);`
`374`	`374`	`}`
`375`	`375`
`376`		`- const clazz = this.conventions.findEntityType(documentType);`
	`376`	`+ const clazz = this.conventions.getJsTypeByDocumentType(documentType);`
`377`	`377`	`return loadOperation.getDocuments(clazz);`
`378`	`378`	`}`
`379`	`379`
`@@ -492,7 +492,7 @@ export class DocumentSession extends InMemoryDocumentSessionOperations`
`492`	`492`	`public rawQuery<TEntity extends object>(`
`493`	`493`	`query: string, documentType?: DocumentType<TEntity>): IRawDocumentQuery<TEntity> {`
`494`	`494`	`if (documentType) {`
`495`		`- this.conventions.tryRegisterEntityType(documentType);`
	`495`	`+ this.conventions.tryRegisterJsType(documentType);`
`496`	`496`	`}`
`497`	`497`
`498`	`498`	`return new RawDocumentQuery(this, query, documentType);`
`@@ -523,7 +523,7 @@ export class DocumentSession extends InMemoryDocumentSessionOperations`
`523`	`523`	`}`
`524`	`524`
`525`	`525`	`if (opts.documentType) {`
`526`		`- this.conventions.tryRegisterEntityType(opts.documentType);`
	`526`	`+ this.conventions.tryRegisterJsType(opts.documentType);`
`527`	`527`	`}`
`528`	`528`
`529`	`529`	`const { indexName, collection } = this._processQueryParameters(opts, this.conventions);`
`@@ -543,7 +543,7 @@ export class DocumentSession extends InMemoryDocumentSessionOperations`
`543`	`543`	`}`
`544`	`544`
`545`	`545`	`if (!isIndex && !isCollection) {`
`546`		`- const entityType = this.conventions.findEntityType(opts.documentType);`
	`546`	`+ const entityType = this.conventions.getJsTypeByDocumentType(opts.documentType);`
`547`	`547`	`collection = this.conventions.getCollectionNameForType(entityType)`
`548`	`548`	`\|\| CONSTANTS.Documents.Metadata.ALL_DOCUMENTS_COLLECTION;`
`549`	`549`	`}`
`@@ -740,7 +740,7 @@ export class DocumentSession extends InMemoryDocumentSessionOperations`
`740`	`740`	`const docsReadable = streamOperation.setResult(command.result);`
`741`	`741`	`let clazz = null;`
`742`	`742`	`if (opts && "documentType" in opts) {`
`743`		`- clazz = this.conventions.findEntityType(opts.documentType);`
	`743`	`+ clazz = this.conventions.getJsTypeByDocumentType(opts.documentType);`
`744`	`744`	`}`
`745`	`745`
`746`	`746`	`const result = this._getStreamResultTransform(this, clazz, null);`