@travetto/model-query 8.0.2 → 8.0.4

package/README.md

@@ -35,13 +35,13 @@ export interface ModelQuerySupport {
    * @param query The query to search for
    * @param failOnMany Should the query fail on more than one result found, defaults to true
    */
-  queryOne<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>, failOnMany?: boolean): Promise<T>;
+  getByQuery<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>, failOnMany?: boolean): Promise<T>;
   /**
    * Find the count of matching documents by query.
    * @param cls The model class
    * @param query The query to count for
    */
-  queryCount<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>): Promise<number>;
+  countByQuery<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>): Promise<number>;
 }
 ```
 
@@ -128,28 +128,24 @@ export interface ModelQuerySuggestSupport extends ModelQuerySupport {
 ```
 
 ### Aggregate
-This contract provides the ability to run strongly-typed field-level aggregations (such as sum, avg, min, and max) on models with optional query filtering.
+This contract provides the ability to run strongly-typed field-level statistics (such as min, max, count, avg, and sum) on models with optional query filtering.
 
 **Code: Query Aggregate**
 ```typescript
 export interface ModelQueryAggregateSupport extends ModelQuerySupport {
   /**
-   * Run an aggregation on a field
+   * Run an aggregation on a comparable field.
+   * For numeric fields (number/bigint), returns count, min, max, avg, and sum.
+   * For date fields, returns count, min, and max.
    * @param modelClass The model class to aggregate
-   * @param operation The operation to perform ('sum', 'avg', 'min', 'max')
    * @param field The field to aggregate on
    * @param query Additional query filtering
    */
-  aggregateFieldByQuery<
-    T extends ModelType,
-    Op extends AggregateOperation,
-    F extends (Op extends AggregateNumericOperation ? ValidNumericFields<T> : ValidComparableFields<T>)
-  >(
+  aggregateFieldByQuery<T extends ModelType, F extends ValidComparableFields<T>>(
     modelClass: Class<T>,
-    operation: Op,
     field: F,
     query?: ModelQuery<T>
-  ): Promise<AggregateResultType<T, F>>;
+  ): Promise<FieldAggregateResult<T, F>>;
 }
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-query",
-  "version": "8.0.2",
+  "version": "8.0.4",
   "description": "Datastore abstraction for advanced query support.",
   "keywords": [
     "datastore",
@@ -31,11 +31,11 @@
   },
   "dependencies": {
     "@travetto/di": "^8.0.1",
-    "@travetto/model": "^8.0.2",
+    "@travetto/model": "^8.0.3",
     "@travetto/schema": "^8.0.2"
   },
   "peerDependencies": {
-    "@travetto/test": "^8.0.1"
+    "@travetto/test": "^8.0.2"
   },
   "peerDependenciesMeta": {
     "@travetto/test": {

package/src/types/aggregate.ts

@@ -2,13 +2,9 @@ import type { ModelType } from '@travetto/model';
 import type { Class } from '@travetto/runtime';
 
 import type { ModelQuery } from '../model/query.ts';
-import type { ValidComparableFields, ValidNumericFields } from '../model/where-clause.ts';
+import type { ValidComparableFields } from '../model/where-clause.ts';
 import type { ModelQuerySupport } from './query.ts';
 
-export type AggregateNumericOperation = 'sum' | 'avg';
-export type AggregateComparableOperation = 'min' | 'max';
-export type AggregateOperation = AggregateNumericOperation | AggregateComparableOperation;
-
 export type PathType<T, Path extends string> = Path extends `${infer Head}.${infer Tail}`
   ? Head extends keyof T
     ? PathType<NonNullable<T[Head]> extends (infer Element)[] ? Element : NonNullable<T[Head]>, Tail>
@@ -23,26 +19,39 @@ export type AggregateResultType<T, F extends string> = [PathType<T, F>] extends
   ? number | Date | bigint | undefined
   : PathType<T, F> | undefined;
 
+export type DateFieldAggregateResult = {
+  count: number;
+  min?: Date;
+  max?: Date;
+};
+
+export type NumericFieldAggregateResult<T, F extends string> = {
+  count: number;
+  min?: AggregateResultType<T, F>;
+  max?: AggregateResultType<T, F>;
+  avg?: AggregateResultType<T, F>;
+  sum?: AggregateResultType<T, F>;
+};
+
+export type FieldAggregateResult<T, F extends string> =
+  NonNullable<PathType<T, F>> extends Date ? DateFieldAggregateResult : NumericFieldAggregateResult<T, F>;
+
 /**
  * The contract for a model service with aggregate support
  * @concrete
  */
 export interface ModelQueryAggregateSupport extends ModelQuerySupport {
   /**
-   * Run an aggregation on a field
+   * Run an aggregation on a comparable field.
+   * For numeric fields (number/bigint), returns count, min, max, avg, and sum.
+   * For date fields, returns count, min, and max.
    * @param modelClass The model class to aggregate
-   * @param operation The operation to perform ('sum', 'avg', 'min', 'max')
    * @param field The field to aggregate on
    * @param query Additional query filtering
    */
-  aggregateFieldByQuery<
-    T extends ModelType,
-    Op extends AggregateOperation,
-    F extends (Op extends AggregateNumericOperation ? ValidNumericFields<T> : ValidComparableFields<T>)
-  >(
+  aggregateFieldByQuery<T extends ModelType, F extends ValidComparableFields<T>>(
     modelClass: Class<T>,
-    operation: Op,
     field: F,
     query?: ModelQuery<T>
-  ): Promise<AggregateResultType<T, F>>;
+  ): Promise<FieldAggregateResult<T, F>>;
 }

package/src/types/query.ts

@@ -20,11 +20,11 @@ export interface ModelQuerySupport {
    * @param query The query to search for
    * @param failOnMany Should the query fail on more than one result found, defaults to true
    */
-  queryOne<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>, failOnMany?: boolean): Promise<T>;
+  getByQuery<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>, failOnMany?: boolean): Promise<T>;
   /**
    * Find the count of matching documents by query.
    * @param cls The model class
    * @param query The query to count for
    */
-  queryCount<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>): Promise<number>;
+  countByQuery<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>): Promise<number>;
 }

package/src/util/aggregate.ts

@@ -2,7 +2,8 @@ import type { ModelType } from '@travetto/model';
 import { castTo, type Class, hasFunction } from '@travetto/runtime';
 import { DataUtil, SchemaRegistryIndex } from '@travetto/schema';
 
-import type { AggregateOperation, AggregateResultType, ModelQueryAggregateSupport } from '../types/aggregate.ts';
+import type { ValidComparableFields } from '../model/where-clause.ts';
+import type { AggregateResultType, FieldAggregateResult, ModelQueryAggregateSupport } from '../types/aggregate.ts';
 
 export class ModelQueryAggregateUtil {
   /**
@@ -11,19 +12,37 @@ export class ModelQueryAggregateUtil {
   static isSupported = hasFunction<ModelQueryAggregateSupport>('aggregateFieldByQuery');
 
   /**
-   * Resolve and coerce the aggregate query result using DataUtil.coerceType
+   * Resolve and coerce aggregate query results
    * @param modelClass The model class being queried
-   * @param operation The aggregate operation
    * @param field The field being aggregated
-   * @param rawValue The raw result value from the datastore
+   * @param rawValues The raw result values from the datastore
    */
-  static resolveResult<T extends ModelType, Op extends AggregateOperation, F extends string>(
+  static resolveAggregate<T extends ModelType, F extends ValidComparableFields<T>>(
     modelClass: Class<T>,
-    operation: Op,
     field: F,
-    rawValue: unknown
-  ): AggregateResultType<T, F> {
+    rawValues: { count?: unknown; min?: unknown; max?: unknown; avg?: unknown; sum?: unknown }
+  ): FieldAggregateResult<T, F> {
+    const count = Number(rawValues.count ?? 0);
+    if (count === 0) {
+      return castTo({ count: 0 });
+    }
     const leafFieldType = SchemaRegistryIndex.getNestedFieldConfig(modelClass, field)!.type;
-    return castTo(DataUtil.coerceType(rawValue, leafFieldType, false) ?? undefined);
+    const coerce = (value: unknown): AggregateResultType<T, F> => castTo(DataUtil.coerceType(value, leafFieldType, false) ?? undefined);
+
+    if (leafFieldType === Date) {
+      return castTo({
+        count,
+        min: coerce(rawValues.min),
+        max: coerce(rawValues.max)
+      });
+    }
+
+    return castTo({
+      count,
+      min: coerce(rawValues.min),
+      max: coerce(rawValues.max),
+      avg: coerce(rawValues.avg),
+      sum: coerce(rawValues.sum)
+    });
   }
 }

package/support/test/aggregate.ts

@@ -10,8 +10,30 @@ import { Aged, BigIntModel, Person } from './model.ts';
 
 @Suite()
 export abstract class ModelQueryAggregateSuite extends BaseModelSuite<ModelQueryAggregateSupport & ModelCrudSupport> {
-  @Test('verify basic aggregations')
-  async testAggregate() {
+  @Test('verify date field aggregate')
+  async testDateFieldAggregate() {
+    const service = await this.service;
+
+    const firstDate = new Date(2020, 0, 1);
+    const secondDate = new Date(2021, 0, 1);
+    const thirdDate = new Date(2022, 0, 1);
+
+    await this.saveAll(Aged, [
+      Aged.from({ createdAt: firstDate }),
+      Aged.from({ createdAt: secondDate }),
+      Aged.from({ createdAt: thirdDate })
+    ]);
+
+    const aggregate = await service.aggregateFieldByQuery(Aged, 'createdAt');
+    assert(aggregate.count === 3);
+    assert(aggregate.min instanceof Date);
+    assert(aggregate.min.getTime() === firstDate.getTime());
+    assert(aggregate.max instanceof Date);
+    assert(aggregate.max.getTime() === thirdDate.getTime());
+  }
+
+  @Test('verify field aggregate')
+  async testFieldAggregate() {
     const people = [
       Person.from({ name: 'Bob', age: 20, gender: 'm', address: { street1: '1st St' } }),
       Person.from({ name: 'Alice', age: 30, gender: 'f', address: { street1: '2nd St' } }),
@@ -23,67 +45,38 @@ export abstract class ModelQueryAggregateSuite extends BaseModelSuite<ModelQuery
     const saved = await this.saveAll(Person, people);
     assert(saved === 4);
 
-    const sumResult = await service.aggregateFieldByQuery(Person, 'sum', 'age');
-    assert(sumResult === 140);
-
-    const averageResult = await service.aggregateFieldByQuery(Person, 'avg', 'age');
-    assert(averageResult === 35);
+    const aggregate = await service.aggregateFieldByQuery(Person, 'age');
+    assert(aggregate.count === 4);
+    assert(aggregate.min === 20);
+    assert(aggregate.max === 50);
+    assert(aggregate.avg === 35);
+    assert(aggregate.sum === 140);
 
-    const minimumResult = await service.aggregateFieldByQuery(Person, 'min', 'age');
-    assert(minimumResult === 20);
-
-    const maximumResult = await service.aggregateFieldByQuery(Person, 'max', 'age');
-    assert(maximumResult === 50);
-
-    // Filtered aggregations
-    const filteredSumResult = await service.aggregateFieldByQuery(Person, 'sum', 'age', {
+    const filteredAggregate = await service.aggregateFieldByQuery(Person, 'age', {
       where: {
         age: { $gte: 30 }
       }
     });
-    assert(filteredSumResult === 120);
+    assert(filteredAggregate.count === 3);
+    assert(filteredAggregate.min === 30);
+    assert(filteredAggregate.max === 50);
+    assert(filteredAggregate.avg === 40);
+    assert(filteredAggregate.sum === 120);
 
-    const filteredAverageResult = await service.aggregateFieldByQuery(Person, 'avg', 'age', {
-      where: {
-        gender: 'f'
-      }
-    });
-    assert(filteredAverageResult === 40);
-
-    // No matches
-    const noMatchResult = await service.aggregateFieldByQuery(Person, 'sum', 'age', {
+    const emptyAggregate = await service.aggregateFieldByQuery(Person, 'age', {
       where: {
         age: { $gt: 1000 }
       }
     });
-    assert(noMatchResult === undefined);
+    assert(emptyAggregate.count === 0);
+    assert(emptyAggregate.min === undefined);
+    assert(emptyAggregate.max === undefined);
+    assert(emptyAggregate.avg === undefined);
+    assert(emptyAggregate.sum === undefined);
   }
 
-  @Test('verify date aggregations')
-  async testDateAggregate() {
-    const service = await this.service;
-
-    const firstDate = new Date(2020, 0, 1);
-    const secondDate = new Date(2021, 0, 1);
-    const thirdDate = new Date(2022, 0, 1);
-
-    await this.saveAll(Aged, [
-      Aged.from({ createdAt: firstDate }),
-      Aged.from({ createdAt: secondDate }),
-      Aged.from({ createdAt: thirdDate })
-    ]);
-
-    const minimumDateResult = await service.aggregateFieldByQuery(Aged, 'min', 'createdAt');
-    assert(minimumDateResult instanceof Date);
-    assert(minimumDateResult.getTime() === firstDate.getTime());
-
-    const maximumDateResult = await service.aggregateFieldByQuery(Aged, 'max', 'createdAt');
-    assert(maximumDateResult instanceof Date);
-    assert(maximumDateResult.getTime() === thirdDate.getTime());
-  }
-
-  @Test('verify bigint aggregations')
-  async testBigIntAggregate() {
+  @Test('verify bigint field aggregate')
+  async testBigIntFieldAggregate() {
     const service = await this.service;
 
     await this.saveAll(BigIntModel, [
@@ -92,16 +85,11 @@ export abstract class ModelQueryAggregateSuite extends BaseModelSuite<ModelQuery
       BigIntModel.from({ largeNumber: 300n })
     ]);
 
-    const sumResult = await service.aggregateFieldByQuery(BigIntModel, 'sum', 'largeNumber');
-    assert(sumResult === 600n);
-
-    const minimumResult = await service.aggregateFieldByQuery(BigIntModel, 'min', 'largeNumber');
-    assert(minimumResult === 100n);
-
-    const maximumResult = await service.aggregateFieldByQuery(BigIntModel, 'max', 'largeNumber');
-    assert(maximumResult === 300n);
-
-    const averageResult = await service.aggregateFieldByQuery(BigIntModel, 'avg', 'largeNumber');
-    assert(averageResult === 200n);
+    const aggregate = await service.aggregateFieldByQuery(BigIntModel, 'largeNumber');
+    assert(aggregate.count === 3);
+    assert(aggregate.min === 100n);
+    assert(aggregate.max === 300n);
+    assert(aggregate.avg === 200n);
+    assert(aggregate.sum === 600n);
   }
 }

package/support/test/crud.ts

@@ -1,12 +1,13 @@
 import assert from 'node:assert';
 
-import { Model, type ModelCrudSupport, NotFoundError, UniqueError } from '@travetto/model';
-import { castTo } from '@travetto/runtime';
+import { Model, type ModelCrudSupport, type ModelType, NotFoundError, UniqueError } from '@travetto/model';
+import { castTo, type Class } from '@travetto/runtime';
 import { Suite, Test } from '@travetto/test';
 
 import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
 
-import { QueryIndex } from '../../__index__.ts';
+import type { WhereClause } from '../../__index__.ts';
+import { QueryIndex } from '../../src/model/indexes.ts';
 import type { ModelQueryCrudSupport } from '../../src/types/crud.ts';
 import { Address, BigIntModel, Person, Todo } from './model.ts';
 
@@ -25,6 +26,11 @@ class UniqueUser2 {
 export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudSupport & ModelCrudSupport> {
   supportsUniqueIndexes = true;
 
+  async countByQuery<T extends ModelType>(cls: Class<T>, query: WhereClause<T>): Promise<number> {
+    const svc = await this.service;
+    return svc.query(cls, { where: query, limit: 10000 }).then(v => v.length);
+  }
+
   @Test({ skip: self => !castTo<ModelQueryCrudSuite>(self).supportsUniqueIndexes })
   async testUnique() {
     const svc = await this.service;
@@ -147,13 +153,13 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
 
     assert(c === 2);
 
-    assert((await svc.queryCount(Person, {})) === 3);
+    assert((await this.countByQuery(Person, {})) === 3);
 
     const c2 = await svc.deleteByQuery(Person, { where: { age: { $lte: 3 } } });
 
     assert(c2 === 3);
 
-    assert((await svc.queryCount(Person, {})) === 0);
+    assert((await this.countByQuery(Person, {})) === 0);
   }
 
   @Test()
@@ -177,7 +183,7 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
 
     assert(count === 5);
 
-    assert((await svc.queryCount(Person, { where: { gender: 'm' } })) === 5);
+    assert((await this.countByQuery(Person, { gender: 'm' })) === 5);
 
     const c = await svc.updatePartialByQuery(Person, { where: { age: { $gt: 3 } } }, { gender: 'f' });
 
@@ -185,14 +191,14 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
 
     assert(c === 2);
 
-    assert((await svc.queryCount(Person, { where: { gender: 'm' } })) === 3);
+    assert((await this.countByQuery(Person, { 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 this.countByQuery(Person, { gender: 'f' })) === 5);
+    assert((await this.countByQuery(Person, { gender: 'm' })) === 0);
   }
 
   @Test()
@@ -237,7 +243,7 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
     assert(withOptional.every(x => x.optionalBigInt !== undefined));
 
     // Test count with bigint condition
-    const countResult = await svc.queryCount(BigIntModel, { where: { largeNumber: { $gte: 1000n } } });
+    const countResult = await this.countByQuery(BigIntModel, { largeNumber: { $gte: 1000n } });
     assert(countResult === 2);
   }
 
@@ -285,7 +291,7 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
     assert(deleted === 2);
 
     // Verify deletions
-    const remaining = await svc.queryCount(BigIntModel, {});
+    const remaining = await this.countByQuery(BigIntModel, {});
     assert(remaining === 3);
 
     const all = await svc.query(BigIntModel, {});

package/support/test/polymorphism.ts

@@ -36,12 +36,12 @@ 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.countByQuery(Worker, { where: { name: 'bob' } })) === 1);
+    assert((await svc.countByQuery(Doctor, { where: { name: 'bob' } })) === 1);
+    assert((await svc.countByQuery(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);
+    assert((await svc.getByQuery(Worker, { where: { name: 'bob' } })) instanceof Doctor);
+    await assert.rejects(() => svc.getByQuery(Firefighter, { where: { name: 'bob' } }), NotFoundError);
   }
 
   @Test({ skip: ModelQueryPolymorphismSuite.ifNot(ModelQueryCrudUtil.isSupported) })
@@ -60,7 +60,7 @@ export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<ModelQu
     const c = await svc.updatePartialByQuery(Doctor, { where: { specialty: 'feet' } }, { specialty: 'eyes' });
     assert(c === 1);
 
-    assert((await svc.queryCount(Doctor, { where: { specialty: 'eyes' } })) === 2);
+    assert((await svc.countByQuery(Doctor, { where: { specialty: 'eyes' } })) === 2);
 
     const removed = await svc.deleteByQuery(Worker, { where: { name: 'rob' } });
 
@@ -125,10 +125,11 @@ export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<ModelQu
     await this.saveAll(Worker, [doctorOne, doctorTwo, firefighterOne, firefighterTwo]);
     assert((await this.getSize(Worker)) === 4);
 
-    const sumFirehouse = await service.aggregateFieldByQuery(Firefighter, 'sum', 'firehouse');
-    assert(sumFirehouse === 50);
-
-    const averageFirehouse = await service.aggregateFieldByQuery(Firefighter, 'avg', 'firehouse');
-    assert(averageFirehouse === 25);
+    const aggregate = await service.aggregateFieldByQuery(Firefighter, 'firehouse');
+    assert(aggregate.count === 2);
+    assert(aggregate.min === 20);
+    assert(aggregate.max === 30);
+    assert(aggregate.avg === 25);
+    assert(aggregate.sum === 50);
   }
 }

package/support/test/query.ts

@@ -32,13 +32,13 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
 
     await this.saveAll(Person, people);
 
-    const one = await svc.queryOne(Person, { where: { id: people[0].id } });
+    const one = await svc.getByQuery(Person, { where: { id: people[0].id } });
     assert(one.id === people[0].id);
 
-    const one2 = await svc.queryOne(Person, { where: { id: { $eq: people[0].id } } });
+    const one2 = await svc.getByQuery(Person, { where: { id: { $eq: people[0].id } } });
     assert(one2.id === people[0].id);
 
-    const none = await svc.queryCount(Person, { where: { id: { $ne: people[0].id } } });
+    const none = await svc.countByQuery(Person, { where: { id: { $ne: people[0].id } } });
     assert(none === 3);
 
     const noneIds = await svc.query(Person, { where: { id: { $ne: people[0].id } } });
@@ -91,11 +91,11 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
       )
     );
 
-    await assert.rejects(() => service.queryOne(Person, { where: { gender: 'm' } }), /Invalid number of results/);
-    await assert.rejects(() => service.queryOne(Person, { where: { gender: 'z' } }), NotFoundError);
-    await assert.rejects(() => service.queryOne(Person, { where: { gender: 'z' } }), /No results found for query/);
-    await assert.rejects(() => service.queryOne(Person, { where: { id: 'orange' } }), NotFoundError);
-    await assert.rejects(() => service.queryOne(Person, { where: { id: 'orange' } }), /orange/);
+    await assert.rejects(() => service.getByQuery(Person, { where: { gender: 'm' } }), /Invalid number of results/);
+    await assert.rejects(() => service.getByQuery(Person, { where: { gender: 'z' } }), NotFoundError);
+    await assert.rejects(() => service.getByQuery(Person, { where: { gender: 'z' } }), /No results found for query/);
+    await assert.rejects(() => service.getByQuery(Person, { where: { id: 'orange' } }), NotFoundError);
+    await assert.rejects(() => service.getByQuery(Person, { where: { id: 'orange' } }), /orange/);
   }
 
   @Test('Verify array $in queries work properly')
@@ -331,7 +331,7 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
 
     await this.saveAll(Location, toAdd);
 
-    assert((await svc.queryCount(Location, {})) === 25);
+    assert((await svc.countByQuery(Location, {})) === 25);
 
     const result = await svc.query(Location, {
       limit: 100,
@@ -382,7 +382,7 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
       })
     );
 
-    const out = await service.queryCount(Note, {
+    const out = await service.countByQuery(Note, {
       where: {
         entities: {
           id
@@ -413,7 +413,7 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
       )
     );
 
-    const simple = await service.queryCount(Aged, {
+    const simple = await service.countByQuery(Aged, {
       where: {
         createdAt: {
           $gt: new Date()
@@ -422,7 +422,7 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
     });
     assert(simple === 5);
 
-    const simple2 = await service.queryCount(Aged, {
+    const simple2 = await service.countByQuery(Aged, {
       where: {
         createdAt: {
           $gt: '-1d'
@@ -431,7 +431,7 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
     });
     assert(simple2 === 6);
 
-    const simple3 = await service.queryCount(Aged, {
+    const simple3 = await service.countByQuery(Aged, {
       where: {
         createdAt: {
           $gt: '-1296m', // -1.9d
@@ -441,7 +441,7 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
     });
     assert(simple3 === 3);
 
-    const simple4 = await service.queryCount(Aged, {
+    const simple4 = await service.countByQuery(Aged, {
       where: {
         createdAt: {
           $gt: TimeUtil.fromNow('-144m'), // -0.1d
@@ -463,35 +463,35 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
       WithNestedLists.from({ names: [], tags: [] })
     ]);
 
-    let total = await service.queryCount(WithNestedLists, {
+    let total = await service.countByQuery(WithNestedLists, {
       where: {
         names: { $exists: true }
       }
     });
     assert(total === 3);
 
-    total = await service.queryCount(WithNestedLists, {
+    total = await service.countByQuery(WithNestedLists, {
       where: {
         names: { $exists: false }
       }
     });
     assert(total === 2);
 
-    total = await service.queryCount(WithNestedLists, {
+    total = await service.countByQuery(WithNestedLists, {
       where: {
         tags: { $exists: false }
       }
     });
     assert(total === 3);
 
-    total = await service.queryCount(WithNestedLists, {
+    total = await service.countByQuery(WithNestedLists, {
       where: {
         tags: { $exists: true }
       }
     });
     assert(total === 2);
 
-    total = await service.queryCount(WithNestedLists, {
+    total = await service.countByQuery(WithNestedLists, {
       where: {
         tags: { $exists: false },
         names: { $exists: false }
@@ -499,7 +499,7 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
     });
     assert(total === 1);
 
-    total = await service.queryCount(WithNestedLists, {
+    total = await service.countByQuery(WithNestedLists, {
       where: {
         tags: { $exists: true },
         names: { $exists: true }
@@ -520,35 +520,35 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
       WithNestedNestedLists.from({ sub: {}, tags: [] })
     ]);
 
-    let total = await service.queryCount(WithNestedNestedLists, {
+    let total = await service.countByQuery(WithNestedNestedLists, {
       where: {
         sub: { names: { $exists: true } }
       }
     });
     assert(total === 3);
 
-    total = await service.queryCount(WithNestedNestedLists, {
+    total = await service.countByQuery(WithNestedNestedLists, {
       where: {
         sub: { names: { $exists: false } }
       }
     });
     assert(total === 2);
 
-    total = await service.queryCount(WithNestedNestedLists, {
+    total = await service.countByQuery(WithNestedNestedLists, {
       where: {
         tags: { $exists: false }
       }
     });
     assert(total === 3);
 
-    total = await service.queryCount(WithNestedNestedLists, {
+    total = await service.countByQuery(WithNestedNestedLists, {
       where: {
         tags: { $exists: true }
       }
     });
     assert(total === 2);
 
-    total = await service.queryCount(WithNestedNestedLists, {
+    total = await service.countByQuery(WithNestedNestedLists, {
       where: {
         tags: { $exists: false },
         sub: { names: { $exists: false } }
@@ -556,7 +556,7 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
     });
     assert(total === 1);
 
-    total = await service.queryCount(WithNestedNestedLists, {
+    total = await service.countByQuery(WithNestedNestedLists, {
       where: {
         tags: { $exists: true },
         sub: { names: { $exists: true } }