@travetto/model-query 8.0.1 → 8.0.3

package/README.md

@@ -36,12 +36,6 @@ export interface ModelQuerySupport {
    * @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>;
-  /**
-   * 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>;
 }
 ```
 
@@ -127,12 +121,45 @@ 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.
+
+**Code: Query Aggregate**
+```typescript
+export interface ModelQueryAggregateSupport extends ModelQuerySupport {
+  /**
+   * Run an aggregation on a field
+   * @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>)
+  >(
+    modelClass: Class<T>,
+    operation: Op,
+    field: F,
+    query?: ModelQuery<T>
+  ): Promise<AggregateResultType<T, F>>;
+
+  /**
+   * Find the count of matching documents by query.
+   * @param cls The model class
+   * @param query The query to count for
+   */
+  countByQuery<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>): Promise<number>;
+}
+```
+
 ## Implementations
-|Service|Query|QueryCrud|QueryFacet|
-|-------|-----|---------|----------|
-|[Elasticsearch Model Source](https://github.com/travetto/travetto/tree/main/module/model-elasticsearch#readme "Elasticsearch backing for the travetto model module, with real-time modeling support for Elasticsearch mappings.")|X|X|X|
-|[MongoDB Model Support](https://github.com/travetto/travetto/tree/main/module/model-mongo#readme "Mongo backing for the travetto model module.")|X'|X'|X'|
-|[SQL Model Service](https://github.com/travetto/travetto/tree/main/module/model-sql#readme "SQL backing for the travetto model module, with real-time modeling support for SQL schemas.")|X'|X'|X'|
+|Service|Query|QueryCrud|QueryFacet|QueryAggregate|
+|-------|-----|---------|----------|--------------|
+|[Elasticsearch Model Source](https://github.com/travetto/travetto/tree/main/module/model-elasticsearch#readme "Elasticsearch backing for the travetto model module, with real-time modeling support for Elasticsearch mappings.")|X|X|X|X|
+|[MongoDB Model Support](https://github.com/travetto/travetto/tree/main/module/model-mongo#readme "Mongo backing for the travetto model module.")|X'|X'|X'|X'|
+|[SQL Model Service](https://github.com/travetto/travetto/tree/main/module/model-sql#readme "SQL backing for the travetto model module, with real-time modeling support for SQL schemas.")|X'|X'|X'|X'|
 
 ## Querying
 One of the complexities of abstracting multiple storage mechanisms, is providing a consistent query language. The query language the module uses is a derivation of [mongodb](https://mongodb.com)'s query language, with some restrictions, additions, and caveats. Additionally, given the nature of typescript, all queries are statically typed, and will catch type errors at compile time.
@@ -227,9 +254,15 @@ In addition to the provided contracts, the module also provides common utilities
 ```typescript
 import { Config } from '@travetto/config';
 import { Injectable } from '@travetto/di';
-import type { ModelQueryCrudSupport, ModelQueryFacetSupport, ModelQuerySuggestSupport } from '@travetto/model-query';
+import type {
+  ModelQueryAggregateSupport,
+  ModelQueryCrudSupport,
+  ModelQueryFacetSupport,
+  ModelQuerySuggestSupport
+} from '@travetto/model-query';
 import { Suite } from '@travetto/test';
 
+import { ModelQueryAggregateSuite } from '@travetto/model-query/support/test/aggregate.ts';
 import { ModelQueryCrudSuite } from '@travetto/model-query/support/test/crud.ts';
 import { ModelQueryFacetSuite } from '@travetto/model-query/support/test/facet.ts';
 import { ModelQueryPolymorphismSuite } from '@travetto/model-query/support/test/polymorphism.ts';
@@ -242,7 +275,9 @@ import { QueryModelService } from './query-service.ts';
 class CustomModelConfig {}
 
 @Injectable()
-class CustomModelService extends QueryModelService implements ModelQueryCrudSupport, ModelQueryFacetSupport, ModelQuerySuggestSupport {}
+class CustomModelService
+  extends QueryModelService
+  implements ModelQueryAggregateSupport, ModelQueryCrudSupport, ModelQueryFacetSupport, ModelQuerySuggestSupport {}
 
 @Suite()
 class CustomQuerySuite extends ModelQuerySuite {
@@ -250,6 +285,12 @@ class CustomQuerySuite extends ModelQuerySuite {
   configClass = CustomModelConfig;
 }
 
+@Suite()
+class CustomQueryAggregateSuite extends ModelQueryAggregateSuite {
+  serviceClass = CustomModelService;
+  configClass = CustomModelConfig;
+}
+
 @Suite()
 class CustomQueryCrudSuite extends ModelQueryCrudSuite {
   serviceClass = CustomModelService;

package/__index__.ts

@@ -1,10 +1,12 @@
 export * from './src/model/indexes.ts';
 export * from './src/model/query.ts';
 export * from './src/model/where-clause.ts';
+export * from './src/types/aggregate.ts';
 export * from './src/types/crud.ts';
 export * from './src/types/facet.ts';
 export * from './src/types/query.ts';
 export * from './src/types/suggest.ts';
+export * from './src/util/aggregate.ts';
 export * from './src/util/crud.ts';
 export * from './src/util/facet.ts';
 export * from './src/util/query.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-query",
-  "version": "8.0.1",
+  "version": "8.0.3",
   "description": "Datastore abstraction for advanced query support.",
   "keywords": [
     "datastore",
@@ -31,11 +31,11 @@
   },
   "dependencies": {
     "@travetto/di": "^8.0.1",
-    "@travetto/model": "^8.0.1",
-    "@travetto/schema": "^8.0.1"
+    "@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/model/where-clause.ts

@@ -6,6 +6,8 @@ export type QueryPrimitiveArray = QueryPrimitive[];
 export type DistanceUnit = 'mi' | 'm' | 'km' | 'ft' | 'rad';
 export type RetainQueryPrimitiveFields<T> = Pick<T, ValidFields<T, QueryPrimitive>>;
 export type ValidStringFields<T> = KeyPaths<T, String | string | string[] | String[] | undefined>;
+export type ValidNumericFields<T> = KeyPaths<T, number | bigint | Number | undefined>;
+export type ValidComparableFields<T> = KeyPaths<T, number | bigint | Number | Date | undefined>;
 
 type General<T> = {
   $eq?: T;

package/src/types/aggregate.ts

@@ -0,0 +1,55 @@
+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 { 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>
+    : never
+  : Path extends keyof T
+    ? NonNullable<T[Path]> extends (infer Element)[]
+      ? Element
+      : NonNullable<T[Path]>
+    : never;
+
+export type AggregateResultType<T, F extends string> = [PathType<T, F>] extends [never]
+  ? number | Date | bigint | undefined
+  : PathType<T, F> | undefined;
+
+/**
+ * The contract for a model service with aggregate support
+ * @concrete
+ */
+export interface ModelQueryAggregateSupport extends ModelQuerySupport {
+  /**
+   * Run an aggregation on a field
+   * @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>)
+  >(
+    modelClass: Class<T>,
+    operation: Op,
+    field: F,
+    query?: ModelQuery<T>
+  ): Promise<AggregateResultType<T, F>>;
+
+  /**
+   * Find the count of matching documents by query.
+   * @param cls The model class
+   * @param query The query to count for
+   */
+  countByQuery<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>): Promise<number>;
+}

package/src/types/query.ts

@@ -21,10 +21,4 @@ export interface ModelQuerySupport {
    * @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>;
-  /**
-   * 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>;
 }

package/src/util/aggregate.ts

@@ -0,0 +1,29 @@
+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';
+
+export class ModelQueryAggregateUtil {
+  /**
+   * Type guard for determining if service supports query aggregate operations
+   */
+  static isSupported = hasFunction<ModelQueryAggregateSupport>('aggregateFieldByQuery');
+
+  /**
+   * Resolve and coerce the aggregate query result using DataUtil.coerceType
+   * @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
+   */
+  static resolveResult<T extends ModelType, Op extends AggregateOperation, F extends string>(
+    modelClass: Class<T>,
+    operation: Op,
+    field: F,
+    rawValue: unknown
+  ): AggregateResultType<T, F> {
+    const leafFieldType = SchemaRegistryIndex.getNestedFieldConfig(modelClass, field)!.type;
+    return castTo(DataUtil.coerceType(rawValue, leafFieldType, false) ?? undefined);
+  }
+}

package/support/doc.support.tsx

@@ -2,6 +2,7 @@
 import { DocFileUtil, type DocJSXElement, type DocJSXElementByFn, d } from '@travetto/doc';
 import { castKey, Runtime, toConcrete } from '@travetto/runtime';
 
+import type { ModelQueryAggregateSupport } from '../src/types/aggregate.ts';
 import type { ModelQueryCrudSupport } from '../src/types/crud.ts';
 import type { ModelQueryFacetSupport } from '../src/types/facet.ts';
 import type { ModelQuerySupport } from '../src/types/query.ts';
@@ -11,6 +12,7 @@ const toLink = (title: string, target: Function): DocJSXElementByFn<'CodeLink'>
   d.codeLink(title, Runtime.getSourceFile(target), new RegExp(`\\binterface\\s+${target.name}`));
 
 export const Links = {
+  QueryAggregate: toLink('Aggregate', toConcrete<ModelQueryAggregateSupport>()),
   QueryCrud: toLink('Query Crud', toConcrete<ModelQueryCrudSupport>()),
   QueryFacet: toLink('Facet', toConcrete<ModelQueryFacetSupport>()),
   QuerySuggest: toLink('Suggest', toConcrete<ModelQuerySuggestSupport>()),
@@ -21,7 +23,7 @@ export const ModelQueryTypes = (fn: Function): DocJSXElement[] => {
   const { content } = DocFileUtil.readSource(fn);
   const found: DocJSXElementByFn<'CodeLink'>[] = [];
   const seen = new Set<string>();
-  for (const [, key] of content.matchAll(/Model(Query(Suggest|Facet|Crud)?)Support/g)) {
+  for (const [, key] of content.matchAll(/Model(Query(Aggregate|Suggest|Facet|Crud)?)Support/g)) {
     if (!seen.has(key) && key in Links) {
       seen.add(key);
       const link = Links[castKey(key)];

package/support/test/aggregate.ts

@@ -0,0 +1,107 @@
+import assert from 'node:assert';
+
+import type { ModelCrudSupport } from '@travetto/model';
+import { Suite, Test } from '@travetto/test';
+
+import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
+
+import type { ModelQueryAggregateSupport } from '../../src/types/aggregate.ts';
+import { Aged, BigIntModel, Person } from './model.ts';
+
+@Suite()
+export abstract class ModelQueryAggregateSuite extends BaseModelSuite<ModelQueryAggregateSupport & ModelCrudSupport> {
+  @Test('verify basic aggregations')
+  async testAggregate() {
+    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' } }),
+      Person.from({ name: 'Charlie', age: 40, gender: 'm', address: { street1: '3rd St' } }),
+      Person.from({ name: 'Dana', age: 50, gender: 'f', address: { street1: '4th St' } })
+    ];
+
+    const service = await this.service;
+    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 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', {
+      where: {
+        age: { $gte: 30 }
+      }
+    });
+    assert(filteredSumResult === 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', {
+      where: {
+        age: { $gt: 1000 }
+      }
+    });
+    assert(noMatchResult === 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() {
+    const service = await this.service;
+
+    await this.saveAll(BigIntModel, [
+      BigIntModel.from({ largeNumber: 100n }),
+      BigIntModel.from({ largeNumber: 200n }),
+      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);
+  }
+}

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

@@ -7,16 +7,20 @@ import { Suite, Test } from '@travetto/test';
 import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
 import { Doctor, Engineer, Firefighter, Worker } from '@travetto/model/support/test/polymorphism.ts';
 
+import type { ModelQueryAggregateSupport } from '../../src/types/aggregate.ts';
 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 { ModelQuerySuggestSupport } from '../../src/types/suggest.ts';
+import { ModelQueryAggregateUtil } from '../../src/util/aggregate.ts';
 import { ModelQueryCrudUtil } from '../../src/util/crud.ts';
 import { ModelQueryFacetUtil } from '../../src/util/facet.ts';
 import { ModelQuerySuggestUtil } from '../../src/util/suggest.ts';
 
 @Suite()
-export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<ModelQuerySupport & ModelCrudSupport> {
+export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<
+  ModelQuerySupport & ModelQueryAggregateSupport & ModelCrudSupport
+> {
   @Test()
   async testQuery() {
     const svc = await this.service;
@@ -34,9 +38,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.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);
@@ -44,7 +48,7 @@ export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<ModelQu
 
   @Test({ skip: ModelQueryPolymorphismSuite.ifNot(ModelQueryCrudUtil.isSupported) })
   async testCrudQuery() {
-    const svc: ModelQueryCrudSupport & ModelQuerySupport = castTo(await this.service);
+    const svc: ModelQueryCrudSupport & ModelQueryAggregateSupport & ModelQuerySupport = castTo(await this.service);
     const [doc, doc2, fire, eng] = [
       Doctor.from({ name: 'bob', specialty: 'feet' }),
       Doctor.from({ name: 'nob', specialty: 'eyes' }),
@@ -58,7 +62,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' } });
 
@@ -109,4 +113,24 @@ export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<ModelQu
     const docFacet = await svc.facetByQuery(Doctor, 'specialty');
     assert.deepStrictEqual(docFacet, [{ count: 2, key: 'eyes' }]);
   }
+
+  @Test({ skip: ModelQueryPolymorphismSuite.ifNot(ModelQueryAggregateUtil.isSupported) })
+  async testAggregateQuery() {
+    const service: ModelQueryAggregateSupport & ModelQuerySupport = castTo(await this.service);
+    const [doctorOne, doctorTwo, firefighterOne, firefighterTwo] = [
+      Doctor.from({ name: 'bob', specialty: 'eyes' }),
+      Doctor.from({ name: 'nob', specialty: 'eyes' }),
+      Firefighter.from({ name: 'rob', firehouse: 20 }),
+      Firefighter.from({ name: 'fob', firehouse: 30 })
+    ];
+
+    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);
+  }
 }

package/support/test/query.ts

@@ -6,11 +6,12 @@ import { Suite, Test } from '@travetto/test';
 
 import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
 
+import type { ModelQueryAggregateSupport } from '../../__index__.ts';
 import type { ModelQuerySupport } from '../../src/types/query.ts';
 import { Aged, Location, Names, Note, Person, PersonFamily, Recipe, SimpleList, WithNestedLists, WithNestedNestedLists } from './model.ts';
 
 @Suite()
-export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport & ModelCrudSupport> {
+export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport & ModelQueryAggregateSupport & ModelCrudSupport> {
   supportsGeo = true;
 
   @Test()
@@ -38,7 +39,7 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
     const one2 = await svc.queryOne(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 } } });
@@ -331,7 +332,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 +383,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 +414,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 +423,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 +432,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 +442,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 +464,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 +500,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 +521,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 +557,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 } }