@travetto/model-mongo 8.0.1 → 8.0.3

package/README.md

@@ -21,6 +21,7 @@ Supported features:
    *  [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/types/crud.ts#L10)
    *  [Expiry](https://github.com/travetto/travetto/tree/main/module/model/src/types/expiry.ts#L10)
    *  [Indexed](https://github.com/travetto/travetto/tree/main/module/model-indexed/src/types/service.ts#L21)
+   *  [Aggregate](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/aggregate.ts#L30)
    *  [Query Crud](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/crud.ts#L11)
    *  [Facet](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/facet.ts#L14)
    *  [Suggest](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/suggest.ts#L12)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-mongo",
-  "version": "8.0.1",
+  "version": "8.0.3",
   "description": "Mongo backing for the travetto model module.",
   "keywords": [
     "database",
@@ -29,14 +29,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@travetto/config": "^8.0.1",
-    "@travetto/model": "^8.0.1",
-    "@travetto/model-indexed": "^8.0.1",
-    "@travetto/model-query": "^8.0.1",
+    "@travetto/config": "^8.0.3",
+    "@travetto/model": "^8.0.3",
+    "@travetto/model-indexed": "^8.0.3",
+    "@travetto/model-query": "^8.0.3",
     "mongodb": "^7.6.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.1"
+    "@travetto/cli": "^8.0.2"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/service.ts

@@ -51,7 +51,12 @@ import {
   type SortedIndexSelectionType
 } from '@travetto/model-indexed';
 import {
+  type AggregateNumericOperation,
+  type AggregateOperation,
+  type AggregateResultType,
   type ModelQuery,
+  type ModelQueryAggregateSupport,
+  ModelQueryAggregateUtil,
   type ModelQueryCrudSupport,
   ModelQueryCrudUtil,
   type ModelQueryFacet,
@@ -62,6 +67,8 @@ import {
   ModelQueryUtil,
   type PageableModelQuery,
   QueryVerifier,
+  type ValidComparableFields,
+  type ValidNumericFields,
   type ValidStringFields,
   type WhereClause
 } from '@travetto/model-query';
@@ -75,6 +82,7 @@ import {
   type Class,
   castTo,
   JSONUtil,
+  RuntimeError,
   ShutdownManager,
   TypedObject
 } from '@travetto/runtime';
@@ -112,6 +120,7 @@ export class MongoModelService
     ModelBlobSupport,
     ModelIndexedSupport,
     ModelQuerySupport,
+    ModelQueryAggregateSupport,
     ModelQueryCrudSupport,
     ModelQueryFacetSupport,
     ModelQuerySuggestSupport,
@@ -632,14 +641,6 @@ export class MongoModelService
     return await Promise.all(items.map(item => this.postLoad(cls, item)));
   }
 
-  async queryCount<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>): Promise<number> {
-    await QueryVerifier.verify(cls, query);
-
-    const col = await this.getStore(cls);
-    const filter = MongoUtil.extractWhereFilter(cls, query.where);
-    return col.countDocuments(filter);
-  }
-
   async queryOne<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>, failOnMany = true): Promise<T> {
     const results = await this.query<T>(cls, { ...query, limit: failOnMany ? 2 : 1 });
     return ModelQueryUtil.verifyGetSingleCounts<T>(cls, failOnMany, results, query.where);
@@ -729,6 +730,61 @@ export class MongoModelService
       .toSorted((a, b) => b.count - a.count);
   }
 
+  static readonly AGGREGATE_OPERATION_MAPPING: Record<AggregateOperation, '$sum' | '$avg' | '$min' | '$max'> = {
+    sum: '$sum',
+    avg: '$avg',
+    min: '$min',
+    max: '$max'
+  };
+
+  // Aggregate
+  async 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>> {
+    await QueryVerifier.verify(modelClass, query);
+
+    const collection = await this.getStore(modelClass);
+
+    const where = ModelQueryUtil.getWhereClause(modelClass, query?.where);
+    let queryObject: Record<string, unknown> = { [field]: { $exists: true, $ne: null } };
+
+    if (where) {
+      queryObject = { $and: [queryObject, MongoUtil.extractWhereFilter(modelClass, where)] };
+    }
+
+    const aggregateOperator = MongoModelService.AGGREGATE_OPERATION_MAPPING[operation];
+    if (!aggregateOperator) {
+      throw new RuntimeError(`Unsupported aggregate operation: ${operation}`);
+    }
+
+    const aggregations: object[] = [
+      { $match: queryObject },
+      {
+        $group: {
+          _id: null,
+          value: {
+            [aggregateOperator]: `$${String(field)}`
+          }
+        }
+      }
+    ];
+
+    const result = await collection.aggregate<{ _id: null; value: unknown }>(aggregations).toArray();
+    const rawValue = result.length ? result[0].value : undefined;
+
+    return ModelQueryAggregateUtil.resolveResult(modelClass, operation, field, rawValue);
+  }
+
+  async countByQuery<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>): Promise<number> {
+    await QueryVerifier.verify(cls, query);
+
+    const col = await this.getStore(cls);
+    const filter = MongoUtil.extractWhereFilter(cls, query.where);
+    return col.countDocuments(filter);
+  }
+
   // Suggest
   async suggestValuesByQuery<T extends ModelType>(
     cls: Class<T>,