@travetto/model-query 8.0.0-alpha.23 → 8.0.0-alpha.25

package/src/verifier.ts

@@ -1,10 +1,10 @@
 /* eslint @typescript-eslint/no-unused-vars: ["error", { "args": "none"} ] */
-import { DataUtil, ValidationResultError, type ValidationError, SchemaRegistryIndex } from '@travetto/schema';
-import { JSONUtil, type Class } from '@travetto/runtime';
 
-import type { ModelQuery, Query, PageableModelQuery } from './model/query.ts';
+import { type Class, JSONUtil } from '@travetto/runtime';
+import { DataUtil, SchemaRegistryIndex, type ValidationError, ValidationResultError } from '@travetto/schema';
 
 import { TypeUtil } from './internal/types.ts';
+import type { ModelQuery, PageableModelQuery, Query } from './model/query.ts';
 
 type SimpleType = keyof typeof TypeUtil.OPERATORS;
 
@@ -28,24 +28,19 @@ const WHERE = 'where';
 const SORT = 'sort';
 // const GROUP_BY = 'groupBy';
 
-const MULTIPLE_KEYS_ALLOWED = new Set([
-  '$maxDistance', '$gt', '$gte',
-  '$minDistance', '$lt', '$lte',
-  '$near'
-]);
+const MULTIPLE_KEYS_ALLOWED = new Set(['$maxDistance', '$gt', '$gte', '$minDistance', '$lt', '$lte', '$near']);
 
 /**
  * Query verification service.  Used to verify the query is valid before running.
  */
 export class QueryVerifier {
-
   /**
    * Internal mapping for various clauses
    */
   static #mapping = [
     [SELECT, 'processSelectClause'] as const,
     [WHERE, 'processWhereClause'] as const,
-    [SORT, 'processSortClause'] as const,
+    [SORT, 'processSortClause'] as const
   ];
 
   /**
@@ -59,19 +54,18 @@ export class QueryVerifier {
       return;
     }
 
-    if (handler.preMember && handler.preMember(state, clause)) {
+    if (handler.preMember?.(state, clause)) {
       return;
     }
 
     for (const [key, value] of Object.entries(clause)) {
-
       // Validate value is correct, and key is valid
       if (value === undefined || value === null) {
         // state.log(`${key} cannot be undefined or null`);
         continue;
       }
 
-      if (handler.preMember && handler.preMember(state, value)) {
+      if (handler.preMember?.(state, value)) {
         continue;
       }
 
@@ -91,7 +85,7 @@ export class QueryVerifier {
         // Otherwise recurse
         const subCls = field.type;
         const subValue = value;
-        if (handler.onComplexType && handler.onComplexType(state, subCls, subValue, field.array ?? false)) {
+        if (handler.onComplexType?.(state, subCls, subValue, field.array ?? false)) {
           continue;
         }
         this.processGenericClause(state.extend(key), subCls, subValue, handler);
@@ -109,7 +103,13 @@ export class QueryVerifier {
   /**
    * Check operator clause
    */
-  static checkOperatorClause(state: State, declaredType: SimpleType, value: unknown, allowed: Record<string, Set<string>>, isArray: boolean): void {
+  static checkOperatorClause(
+    state: State,
+    declaredType: SimpleType,
+    value: unknown,
+    allowed: Record<string, Set<string>>,
+    isArray: boolean
+  ): void {
     if (isArray && Array.isArray(value)) {
       // Handle array literal
       for (const item of value) {
@@ -128,11 +128,7 @@ export class QueryVerifier {
     } else {
       const keys = Object.keys(value).toSorted();
 
-      if (keys.length !== 1 && !(
-        keys.length >= 2 &&
-        MULTIPLE_KEYS_ALLOWED.has(keys[0]) ||
-        MULTIPLE_KEYS_ALLOWED.has(keys[1])
-      )) {
+      if (keys.length !== 1 && !((keys.length >= 2 && MULTIPLE_KEYS_ALLOWED.has(keys[0])) || MULTIPLE_KEYS_ALLOWED.has(keys[1]))) {
         state.log('One and only one operation may be specified in an operator clause');
         return;
       }
@@ -172,7 +168,7 @@ export class QueryVerifier {
    * Process where clause
    */
   static processWhereClause<T>(st: State, cls: Class<T>, passed: object): void {
-    return this.processGenericClause(st, cls, passed, {
+    this.processGenericClause(st, cls, passed, {
       preMember: (state: State, value: Record<string, unknown>) => {
         const keys = Object.keys(value);
         const firstKey = keys[0];
@@ -221,7 +217,7 @@ export class QueryVerifier {
    * Handle sort clause
    */
   static processSortClause<T>(st: State, cls: Class<T>, passed: object): void {
-    return this.processGenericClause(st, cls, passed, {
+    this.processGenericClause(st, cls, passed, {
       onSimpleType: (state, type, value) => {
         if (value === 1 || value === -1 || typeof value === 'boolean') {
           return;
@@ -235,7 +231,7 @@ export class QueryVerifier {
    * Handle select clause
    */
   static processSelectClause<T>(st: State, cls: Class<T>, passed: object): void {
-    return this.processGenericClause(st, cls, passed, {
+    this.processGenericClause(st, cls, passed, {
       onSimpleType: (state, type, value) => {
         const actual = TypeUtil.getActualType(value);
         if (actual === 'number' || actual === 'boolean') {
@@ -244,7 +240,7 @@ export class QueryVerifier {
           }
           state.log('Only true, false 0, and 1 are allowed for including/excluding fields');
         } else {
-        /* if (actual === 'string') {
+          /* if (actual === 'string') {
           if (!/[A-Za-z_$0-9]/.test(value)) {
             state.log(`Only A-Z, a-z, 0-9, '$' and '_' are allowed in aliases for selecting fields`);
             return;
@@ -258,7 +254,8 @@ export class QueryVerifier {
             // or { alias: string, calc?: string }
             // console.log('Yay');
           }
-        */}
+        */
+        }
         state.log('Only true, false, 0, and 1 are allowed for selecting fields');
       }
     });
@@ -293,10 +290,7 @@ export class QueryVerifier {
         continue;
       }
 
-      if (!(key in query)
-        || query[key] === undefined
-        || query[key] === null
-      ) {
+      if (!(key in query) || query[key] === undefined || query[key] === null) {
         continue;
       }
 
@@ -316,4 +310,4 @@ export class QueryVerifier {
       throw new ValidationResultError(errors);
     }
   }
-}
+}

package/support/doc.support.tsx

@@ -1,10 +1,10 @@
 /** @jsxImportSource @travetto/doc/support */
-import { d, type DocJSXElementByFn, type DocJSXElement, DocFileUtil } from '@travetto/doc';
-import { Runtime, toConcrete } from '@travetto/runtime';
+import { DocFileUtil, type DocJSXElement, type DocJSXElementByFn, d } from '@travetto/doc';
+import { castKey, Runtime, toConcrete } from '@travetto/runtime';
 
 import type { ModelQueryCrudSupport } from '../src/types/crud.ts';
+import type { ModelQueryFacetSupport } from '../src/types/facet.ts';
 import type { ModelQuerySupport } from '../src/types/query.ts';
-import type { ModelQueryFacetSupport, } from '../src/types/facet.ts';
 import type { ModelQuerySuggestSupport } from '../src/types/suggest.ts';
 
 const toLink = (title: string, target: Function): DocJSXElementByFn<'CodeLink'> =>
@@ -14,7 +14,7 @@ export const Links = {
   QueryCrud: toLink('Query Crud', toConcrete<ModelQueryCrudSupport>()),
   QueryFacet: toLink('Facet', toConcrete<ModelQueryFacetSupport>()),
   QuerySuggest: toLink('Suggest', toConcrete<ModelQuerySuggestSupport>()),
-  Query: toLink('Query', toConcrete<ModelQuerySupport>()),
+  Query: toLink('Query', toConcrete<ModelQuerySupport>())
 };
 
 export const ModelQueryTypes = (fn: Function): DocJSXElement[] => {
@@ -24,10 +24,9 @@ export const ModelQueryTypes = (fn: Function): DocJSXElement[] => {
   for (const [, key] of content.matchAll(/Model(Query(Suggest|Facet|Crud)?)Support/g)) {
     if (!seen.has(key) && key in Links) {
       seen.add(key);
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const link = Links[key as keyof typeof Links];
+      const link = Links[castKey(key)];
       found.push(link);
     }
   }
   return found.map(type => <li>{type}</li>);
-};
+};

package/support/test/crud.ts

@@ -1,15 +1,14 @@
 import assert from 'node:assert';
 
-import { Suite, Test } from '@travetto/test';
-import { ExistsError, Model, type ModelCrudSupport, NotFoundError } from '@travetto/model';
+import { Model, type ModelCrudSupport, NotFoundError, UniqueError } from '@travetto/model';
 import { castTo } from '@travetto/runtime';
+import { Suite, Test } from '@travetto/test';
 
 import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
 
-import { Address, Person, Todo, BigIntModel } from './model.ts';
-import type { ModelQueryCrudSupport } from '../../src/types/crud.ts';
 import { QueryIndex } from '../../__index__.ts';
-
+import type { ModelQueryCrudSupport } from '../../src/types/crud.ts';
+import { Address, BigIntModel, Person, Todo } from './model.ts';
 
 @Model()
 @QueryIndex({
@@ -24,14 +23,13 @@ class UniqueUser2 {
 
 @Suite()
 export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudSupport & ModelCrudSupport> {
-
   supportsUniqueIndexes = true;
 
-  @Test({ skip: (self) => !castTo<ModelQueryCrudSuite>(self).supportsUniqueIndexes })
+  @Test({ skip: self => !castTo<ModelQueryCrudSuite>(self).supportsUniqueIndexes })
   async testUnique() {
     const svc = await this.service;
     await svc.create(UniqueUser2, UniqueUser2.from({ name: 'bob' }));
-    await assert.rejects(() => svc.create(UniqueUser2, UniqueUser2.from({ name: 'bob' })), ExistsError);
+    await assert.rejects(() => svc.create(UniqueUser2, UniqueUser2.from({ name: 'bob' })), UniqueError);
   }
 
   @Test()
@@ -43,31 +41,44 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
     assert(todo1.id);
     assert(todo1.version === 0);
 
-    const todo1v2 = await svc.updateByQuery(Todo, Todo.from({
-      id: todo1.id,
-      text: `${todo1.text}!!`,
-      version: todo1.version + 1
-    }), { where: { id: todo1.id, version: todo1.version } },);
+    const todo1v2 = await svc.updateByQuery(
+      Todo,
+      Todo.from({
+        id: todo1.id,
+        text: `${todo1.text}!!`,
+        version: todo1.version + 1
+      }),
+      { where: { id: todo1.id, version: todo1.version } }
+    );
 
     assert(todo1v2.id === todo1.id);
     assert(todo1v2.version > todo1.version);
 
     await assert.rejects(
-      () => svc.updateByQuery(Todo, Todo.from({
-        id: todo1.id,
-        text: `${todo1.text}!!`,
-        version: todo1.version + 1
-      }), { where: { id: todo1.id, version: todo1.version } }),
+      () =>
+        svc.updateByQuery(
+          Todo,
+          Todo.from({
+            id: todo1.id,
+            text: `${todo1.text}!!`,
+            version: todo1.version + 1
+          }),
+          { where: { id: todo1.id, version: todo1.version } }
+        ),
       NotFoundError
     );
 
     const todo2 = await svc.create(Todo, Todo.from({ text: 'bob2' }));
 
-    const result = await svc.updateByQuery(Todo, Todo.from({
-      id: todo2.id,
-      text: `${todo1.text}!!`,
-      version: todo1.version + 1
-    }), { where: { id: todo2.id, text: 'bob2' } });
+    const result = await svc.updateByQuery(
+      Todo,
+      Todo.from({
+        id: todo2.id,
+        text: `${todo1.text}!!`,
+        version: todo1.version + 1
+      }),
+      { where: { id: todo2.id, text: 'bob2' } }
+    );
 
     assert(result.id === todo2.id);
   }
@@ -115,15 +126,20 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
   async testDeleteByQuery() {
     const svc = await this.service;
 
-    const count = await this.saveAll(Person, [1, 2, 3, 4, 5].map(d => Person.from({
-      age: d,
-      gender: 'm',
-      name: `Test ${d}`,
-      address: Address.from({
-        street1: 'street1',
-        street2: 'street2'
-      })
-    })));
+    const count = await this.saveAll(
+      Person,
+      [1, 2, 3, 4, 5].map(d =>
+        Person.from({
+          age: d,
+          gender: 'm',
+          name: `Test ${d}`,
+          address: Address.from({
+            street1: 'street1',
+            street2: 'street2'
+          })
+        })
+      )
+    );
 
     assert(count === 5);
 
@@ -131,33 +147,37 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
 
     assert(c === 2);
 
-    assert(await svc.queryCount(Person, {}) === 3);
+    assert((await svc.queryCount(Person, {})) === 3);
 
     const c2 = await svc.deleteByQuery(Person, { where: { age: { $lte: 3 } } });
 
     assert(c2 === 3);
 
-    assert(await svc.queryCount(Person, {}) === 0);
-
+    assert((await svc.queryCount(Person, {})) === 0);
   }
 
   @Test()
   async testUpdateByQuery() {
     const svc = await this.service;
 
-    const count = await this.saveAll(Person, [1, 2, 3, 4, 5].map(d => Person.from({
-      age: d,
-      gender: 'm',
-      name: `Test ${d}`,
-      address: Address.from({
-        street1: 'street1',
-        street2: 'street2'
-      })
-    })));
+    const count = await this.saveAll(
+      Person,
+      [1, 2, 3, 4, 5].map(d =>
+        Person.from({
+          age: d,
+          gender: 'm',
+          name: `Test ${d}`,
+          address: Address.from({
+            street1: 'street1',
+            street2: 'street2'
+          })
+        })
+      )
+    );
 
     assert(count === 5);
 
-    assert(await svc.queryCount(Person, { where: { gender: 'm' } }) === 5);
+    assert((await svc.queryCount(Person, { where: { gender: 'm' } })) === 5);
 
     const c = await svc.updatePartialByQuery(Person, { where: { age: { $gt: 3 } } }, { gender: 'f' });
 
@@ -165,15 +185,14 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
 
     assert(c === 2);
 
-    assert(await svc.queryCount(Person, { where: { gender: 'm' } }) === 3);
+    assert((await svc.queryCount(Person, { where: { gender: 'm' } })) === 3);
 
     const c2 = await svc.updatePartialByQuery(Person, { where: { gender: 'm' } }, { gender: 'f' });
 
     assert(c2 === 3);
 
-    assert(await svc.queryCount(Person, { where: { gender: 'f' } }) === 5);
-    assert(await svc.queryCount(Person, { where: { gender: 'm' } }) === 0);
-
+    assert((await svc.queryCount(Person, { where: { gender: 'f' } })) === 5);
+    assert((await svc.queryCount(Person, { where: { gender: 'm' } })) === 0);
   }
 
   @Test()
@@ -186,7 +205,7 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
       BigIntModel.from({ largeNumber: 200n, optionalBigInt: 2000n }),
       BigIntModel.from({ largeNumber: 300n }),
       BigIntModel.from({ largeNumber: 9007199254740991n, optionalBigInt: 1234567890123456789n }),
-      BigIntModel.from({ largeNumber: 18014398509481982n }),
+      BigIntModel.from({ largeNumber: 18014398509481982n })
     ]);
 
     assert(count === 5);
@@ -229,17 +248,13 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
     const count = await this.saveAll(BigIntModel, [
       BigIntModel.from({ largeNumber: 100n, optionalBigInt: 1000n }),
       BigIntModel.from({ largeNumber: 200n, optionalBigInt: 2000n }),
-      BigIntModel.from({ largeNumber: 300n }),
+      BigIntModel.from({ largeNumber: 300n })
     ]);
 
     assert(count === 3);
 
     // Update records with bigint condition
-    const updated = await svc.updatePartialByQuery(
-      BigIntModel,
-      { where: { largeNumber: { $lte: 200n } } },
-      { optionalBigInt: 5000n }
-    );
+    const updated = await svc.updatePartialByQuery(BigIntModel, { where: { largeNumber: { $lte: 200n } } }, { optionalBigInt: 5000n });
 
     assert(updated === 2);
 
@@ -259,7 +274,7 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
       BigIntModel.from({ largeNumber: 200n }),
       BigIntModel.from({ largeNumber: 300n }),
       BigIntModel.from({ largeNumber: 400n }),
-      BigIntModel.from({ largeNumber: 500n }),
+      BigIntModel.from({ largeNumber: 500n })
     ]);
 
     assert(count === 5);
@@ -277,4 +292,3 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
     assert(all.every(x => x.largeNumber <= 300n));
   }
 }
-

package/support/test/facet.ts

@@ -5,8 +5,8 @@ import { Suite, Test } from '@travetto/test';
 
 import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
 
-import { Person } from './model.ts';
 import type { ModelQueryFacetSupport } from '../../src/types/facet.ts';
+import { Person } from './model.ts';
 
 const pick = <T>(arr: T[] | readonly T[]): T => arr[Math.trunc(Math.random() * arr.length)]!;
 
@@ -17,19 +17,21 @@ const AGES = new Array(100).fill(0).map((x, i) => i + 10);
 
 @Suite()
 export abstract class ModelQueryFacetSuite extends BaseModelSuite<ModelQueryFacetSupport & ModelCrudSupport> {
-
   @Test('verify aggregations')
   async testFacet() {
-    const people = ' '.repeat(50)
+    const people = ' '
+      .repeat(50)
       .split('')
-      .map(() => Person.from({
-        age: pick(AGES),
-        gender: pick(GENDERS),
-        name: `${pick(FNAME)} ${pick(LNAME)}`,
-        address: {
-          street1: `${pick(AGES)} ${pick(LNAME)} Road`
-        }
-      }));
+      .map(() =>
+        Person.from({
+          age: pick(AGES),
+          gender: pick(GENDERS),
+          name: `${pick(FNAME)} ${pick(LNAME)}`,
+          address: {
+            street1: `${pick(AGES)} ${pick(LNAME)} Road`
+          }
+        })
+      );
 
     const svc = await this.service;
     const saved = await this.saveAll(Person, people);
@@ -41,7 +43,13 @@ export abstract class ModelQueryFacetSuite extends BaseModelSuite<ModelQueryFace
     assert(results.length === 2);
     assert(results[0].count >= results[1].count);
 
-    const genders = people.reduce((acc, p) => { (acc[p.gender] += 1); return acc; }, { m: 0, f: 0 });
+    const genders = people.reduce(
+      (acc, p) => {
+        acc[p.gender] += 1;
+        return acc;
+      },
+      { m: 0, f: 0 }
+    );
 
     assert(results.find(x => x.key === 'm')!.count === genders.m);
     assert(results.find(x => x.key === 'f')!.count === genders.f);
@@ -54,4 +62,4 @@ export abstract class ModelQueryFacetSuite extends BaseModelSuite<ModelQueryFace
     const nameFacet = await svc.facetByQuery(Person, 'name');
     assert(Object.keys(names).length === nameFacet.length);
   }
-}
+}

package/support/test/model.ts

@@ -1,5 +1,5 @@
-import { Precision, Schema, Text, type Point } from '@travetto/schema';
 import { Model, type ModelType } from '@travetto/model';
+import { type Point, Precision, Schema, Text } from '@travetto/schema';
 
 @Schema()
 export class Address {
@@ -98,4 +98,20 @@ export class BigIntModel {
   id: string;
   largeNumber: bigint;
   optionalBigInt?: bigint;
-}
+}
+
+@Schema()
+export class Child {
+  name: string;
+}
+
+@Schema()
+export class Family {
+  children?: Child[];
+}
+
+@Model()
+export class PersonFamily implements ModelType {
+  id: string;
+  family?: Family;
+}

package/support/test/polymorphism.ts

@@ -1,24 +1,22 @@
 import assert from 'node:assert';
 
-import { Suite, Test } from '@travetto/test';
-import { NotFoundError, type ModelCrudSupport } from '@travetto/model';
+import { type ModelCrudSupport, NotFoundError } from '@travetto/model';
 import { castTo } from '@travetto/runtime';
+import { Suite, Test } from '@travetto/test';
 
 import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
-import { Doctor, Engineer, Worker, Firefighter } from '@travetto/model/support/test/polymorphism.ts';
+import { Doctor, Engineer, Firefighter, Worker } from '@travetto/model/support/test/polymorphism.ts';
 
 import type { ModelQueryCrudSupport } from '../../src/types/crud.ts';
-import type { ModelQuerySupport } from '../../src/types/query.ts';
 import type { ModelQueryFacetSupport } from '../../src/types/facet.ts';
+import type { ModelQuerySupport } from '../../src/types/query.ts';
 import type { ModelQuerySuggestSupport } from '../../src/types/suggest.ts';
-
+import { ModelQueryCrudUtil } from '../../src/util/crud.ts';
 import { ModelQueryFacetUtil } from '../../src/util/facet.ts';
 import { ModelQuerySuggestUtil } from '../../src/util/suggest.ts';
-import { ModelQueryCrudUtil } from '../../src/util/crud.ts';
 
 @Suite()
 export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<ModelQuerySupport & ModelCrudSupport> {
-
   @Test()
   async testQuery() {
     const svc = await this.service;
@@ -36,9 +34,9 @@ export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<ModelQu
     assert((await svc.query(Doctor, {})).length === 2);
     assert((await svc.query(Engineer, {})).length === 1);
 
-    assert(await svc.queryCount(Worker, { where: { name: 'bob' } }) === 1);
-    assert(await svc.queryCount(Doctor, { where: { name: 'bob' } }) === 1);
-    assert(await svc.queryCount(Engineer, { where: { name: 'bob' } }) === 0);
+    assert((await svc.queryCount(Worker, { where: { name: 'bob' } })) === 1);
+    assert((await svc.queryCount(Doctor, { where: { name: 'bob' } })) === 1);
+    assert((await svc.queryCount(Engineer, { where: { name: 'bob' } })) === 0);
 
     assert((await svc.queryOne(Worker, { where: { name: 'bob' } })) instanceof Doctor);
     await assert.rejects(() => svc.queryOne(Firefighter, { where: { name: 'bob' } }), NotFoundError);
@@ -55,7 +53,7 @@ export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<ModelQu
     ];
 
     await this.saveAll(Worker, [doc, doc2, fire, eng]);
-    assert(await this.getSize(Worker) === 4);
+    assert((await this.getSize(Worker)) === 4);
 
     const c = await svc.updatePartialByQuery(Doctor, { where: { specialty: 'feet' } }, { specialty: 'eyes' });
     assert(c === 1);
@@ -66,8 +64,8 @@ export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<ModelQu
 
     assert(removed === 1);
 
-    assert(await this.getSize(Worker) === 3);
-    assert(await this.getSize(Firefighter) === 0);
+    assert((await this.getSize(Worker)) === 3);
+    assert((await this.getSize(Firefighter)) === 0);
   }
 
   @Test({ skip: ModelQueryPolymorphismSuite.ifNot(ModelQuerySuggestUtil.isSupported) })
@@ -81,7 +79,7 @@ export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<ModelQu
     ];
 
     await this.saveAll(Worker, [doc, doc2, fire, eng]);
-    assert(await this.getSize(Worker) === 4);
+    assert((await this.getSize(Worker)) === 4);
 
     assert((await svc.suggestByQuery(Worker, 'name', '')).length === 4);
     assert((await svc.suggestValuesByQuery(Worker, 'name', '')).length === 4);
@@ -105,10 +103,10 @@ export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<ModelQu
     ];
 
     await this.saveAll(Worker, [doc, doc2, fire, eng]);
-    assert(await this.getSize(Worker) === 4);
+    assert((await this.getSize(Worker)) === 4);
 
     assert((await svc.facetByQuery(Worker, 'name')).length === 4);
     const docFacet = await svc.facetByQuery(Doctor, 'specialty');
     assert.deepStrictEqual(docFacet, [{ count: 2, key: 'eyes' }]);
   }
-}
+}