conventions: add method aliases to align to naming convention

gregolsky · gregolsky · commit 5cda28bcd389 · 2018-12-10T10:24:06.000+01:00
diff --git a/src/Documents/BulkInsertOperation.ts b/src/Documents/BulkInsertOperation.ts
@@ -171,7 +171,7 @@ export class BulkInsertOperation {
         }
 
         if (!("Raven-Node-Type" as keyof MetadataObject in metadata)) {
-            const descriptor = this._conventions.getEntityTypeDescriptor(entity);
+            const descriptor = this._conventions.getTypeDescriptorByEntity(entity);
             const jsType = this._requestExecutor.conventions.getJsTypeName(descriptor);
             if (jsType) {
                 metadata["Raven-Node-Type"] = jsType;
diff --git a/src/Documents/Conventions/DocumentConventions.ts b/src/Documents/Conventions/DocumentConventions.ts
@@ -79,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;
@@ -94,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 =
@@ -420,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;
@@ -492,7 +498,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;
     }
@@ -594,10 +600,6 @@ export class DocumentConventions {
         }
     }
 
-    // TODO:
-    // public get registeredTypeDescriptors() {
-    //     return this._registeredTypeDescriptors;
-    // }
     public get knownEntityTypesByName() {
         return this._knownEntityTypes;
     }
@@ -606,6 +608,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 {
@@ -622,26 +630,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
@@ -95,8 +95,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
@@ -2002,7 +2002,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,
@@ -2018,7 +2018,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
@@ -102,7 +102,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)) {
@@ -466,7 +466,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
@@ -163,7 +163,7 @@ export class DocumentSession extends InMemoryDocumentSessionOperations
 
     private _prepareLoadInternalOpts<TEntity extends object>(options: LoadOptions<TEntity>) {
         const internalOpts: SessionLoadInternalParameters<TEntity> = { documentType: options.documentType };
-        this.conventions.tryRegisterEntityType(internalOpts.documentType);
+        this.conventions.tryRegisterJsType(internalOpts.documentType);
         if ("includes" in options) {
             if (TypeUtil.isFunction(options.includes)) {
                 const builder = new IncludeBuilder(this.conventions);
@@ -420,7 +420,7 @@ export class DocumentSession extends InMemoryDocumentSessionOperations
             loadOperation.setResult(command.result);
         }
 
-        const clazz = this.conventions.findEntityType(opts.documentType);
+        const clazz = this.conventions.getJsTypeByDocumentType(opts.documentType);
         return loadOperation.getDocuments(clazz);
     }
 
@@ -539,7 +539,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);
@@ -570,7 +570,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);
@@ -590,7 +590,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;
         }
@@ -808,7 +808,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
@@ -130,7 +130,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
@@ -885,9 +885,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;
@@ -968,8 +968,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;
@@ -1419,7 +1419,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[], {
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
@@ -83,7 +83,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);
 
         if (this._session.noTracking) {
             if (!this._currentLoadResults) {
diff --git a/src/Documents/Session/Operations/QueryOperation.ts b/src/Documents/Session/Operations/QueryOperation.ts
@@ -162,7 +162,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);
         }
 
@@ -206,7 +206,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
`@@ -171,7 +171,7 @@ export class BulkInsertOperation {`
`171`	`171`	`}`
`172`	`172`
`173`	`173`	`if (!("Raven-Node-Type" as keyof MetadataObject in metadata)) {`
`174`		`- const descriptor = this._conventions.getEntityTypeDescriptor(entity);`
	`174`	`+ const descriptor = this._conventions.getTypeDescriptorByEntity(entity);`
`175`	`175`	`const jsType = this._requestExecutor.conventions.getJsTypeName(descriptor);`
`176`	`176`	`if (jsType) {`
`177`	`177`	`metadata["Raven-Node-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
`@@ -102,7 +102,7 @@ export class DocumentQuery<T extends object>`
`102`	`102`	`propertiesOrQueryData: string \| string[] \| QueryData,`
`103`	`103`	`projectionType?: DocumentType<TProjection>): IDocumentQuery<TProjection> {`
`104`	`104`	`if (projectionType) {`
`105`		`- this._theSession.conventions.tryRegisterEntityType(projectionType);`
	`105`	`+ this._theSession.conventions.tryRegisterJsType(projectionType);`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`if (TypeUtil.isString(propertiesOrQueryData)) {`
`@@ -466,7 +466,7 @@ export class DocumentQuery<T extends object>`
`466`	`466`
`467`	`467`	`public ofType<TResult extends object>(tResultClass: DocumentType<TResult>): IDocumentQuery<TResult> {`
`468`	`468`	`if (tResultClass) {`
`469`		`- this._theSession.conventions.tryRegisterEntityType(tResultClass);`
	`469`	`+ this._theSession.conventions.tryRegisterJsType(tResultClass);`
`470`	`470`	`}`
`471`	`471`
`472`	`472`	`return this._createDocumentQueryInternal(tResultClass);`
Original file line number	Diff line number	Diff line change
`@@ -163,7 +163,7 @@ export class DocumentSession extends InMemoryDocumentSessionOperations`
`163`	`163`
`164`	`164`	`private _prepareLoadInternalOpts<TEntity extends object>(options: LoadOptions<TEntity>) {`
`165`	`165`	`const internalOpts: SessionLoadInternalParameters<TEntity> = { documentType: options.documentType };`
`166`		`- this.conventions.tryRegisterEntityType(internalOpts.documentType);`
	`166`	`+ this.conventions.tryRegisterJsType(internalOpts.documentType);`
`167`	`167`	`if ("includes" in options) {`
`168`	`168`	`if (TypeUtil.isFunction(options.includes)) {`
`169`	`169`	`const builder = new IncludeBuilder(this.conventions);`
`@@ -420,7 +420,7 @@ export class DocumentSession extends InMemoryDocumentSessionOperations`
`420`	`420`	`loadOperation.setResult(command.result);`
`421`	`421`	`}`
`422`	`422`
`423`		`- const clazz = this.conventions.findEntityType(opts.documentType);`
	`423`	`+ const clazz = this.conventions.getJsTypeByDocumentType(opts.documentType);`
`424`	`424`	`return loadOperation.getDocuments(clazz);`
`425`	`425`	`}`
`426`	`426`
`@@ -539,7 +539,7 @@ export class DocumentSession extends InMemoryDocumentSessionOperations`
`539`	`539`	`public rawQuery<TEntity extends object>(`
`540`	`540`	`query: string, documentType?: DocumentType<TEntity>): IRawDocumentQuery<TEntity> {`
`541`	`541`	`if (documentType) {`
`542`		`- this.conventions.tryRegisterEntityType(documentType);`
	`542`	`+ this.conventions.tryRegisterJsType(documentType);`
`543`	`543`	`}`
`544`	`544`
`545`	`545`	`return new RawDocumentQuery(this, query, documentType);`
`@@ -570,7 +570,7 @@ export class DocumentSession extends InMemoryDocumentSessionOperations`
`570`	`570`	`}`
`571`	`571`
`572`	`572`	`if (opts.documentType) {`
`573`		`- this.conventions.tryRegisterEntityType(opts.documentType);`
	`573`	`+ this.conventions.tryRegisterJsType(opts.documentType);`
`574`	`574`	`}`
`575`	`575`
`576`	`576`	`const { indexName, collection } = this._processQueryParameters(opts, this.conventions);`
`@@ -590,7 +590,7 @@ export class DocumentSession extends InMemoryDocumentSessionOperations`
`590`	`590`	`}`
`591`	`591`
`592`	`592`	`if (!isIndex && !isCollection) {`
`593`		`- const entityType = this.conventions.findEntityType(opts.documentType);`
	`593`	`+ const entityType = this.conventions.getJsTypeByDocumentType(opts.documentType);`
`594`	`594`	`collection = this.conventions.getCollectionNameForType(entityType)`
`595`	`595`	`\|\| CONSTANTS.Documents.Metadata.ALL_DOCUMENTS_COLLECTION;`
`596`	`596`	`}`
`@@ -808,7 +808,7 @@ export class DocumentSession extends InMemoryDocumentSessionOperations`
`808`	`808`	`const docsReadable = streamOperation.setResult(command.result);`
`809`	`809`	`let clazz = null;`
`810`	`810`	`if (opts && "documentType" in opts) {`
`811`		`- clazz = this.conventions.findEntityType(opts.documentType);`
	`811`	`+ clazz = this.conventions.getJsTypeByDocumentType(opts.documentType);`
`812`	`812`	`}`
`813`	`813`
`814`	`814`	`const result = this._getStreamResultTransform(this, clazz, null);`