@travetto/model-mongo 8.0.3 → 8.0.5

package/README.md

@@ -21,7 +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)
+   *  [Aggregate](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/aggregate.ts#L56)
    *  [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.3",
+  "version": "8.0.5",
   "description": "Mongo backing for the travetto model module.",
   "keywords": [
     "database",
@@ -32,7 +32,7 @@
     "@travetto/config": "^8.0.3",
     "@travetto/model": "^8.0.3",
     "@travetto/model-indexed": "^8.0.3",
-    "@travetto/model-query": "^8.0.3",
+    "@travetto/model-query": "^8.0.5",
     "mongodb": "^7.6.0"
   },
   "peerDependencies": {

package/src/service.ts

@@ -51,9 +51,7 @@ import {
   type SortedIndexSelectionType
 } from '@travetto/model-indexed';
 import {
-  type AggregateNumericOperation,
-  type AggregateOperation,
-  type AggregateResultType,
+  type FieldAggregateResult,
   type ModelQuery,
   type ModelQueryAggregateSupport,
   ModelQueryAggregateUtil,
@@ -65,10 +63,10 @@ import {
   ModelQuerySuggestUtil,
   type ModelQuerySupport,
   ModelQueryUtil,
+  type NumberFieldAggregateResult,
   type PageableModelQuery,
   QueryVerifier,
   type ValidComparableFields,
-  type ValidNumericFields,
   type ValidStringFields,
   type WhereClause
 } from '@travetto/model-query';
@@ -82,10 +80,10 @@ import {
   type Class,
   castTo,
   JSONUtil,
-  RuntimeError,
   ShutdownManager,
   TypedObject
 } from '@travetto/runtime';
+import { SchemaRegistryIndex } from '@travetto/schema';
 
 import type { MongoModelConfig } from './config.ts';
 import { MongoUtil, type WithId } from './internal/util.ts';
@@ -641,11 +639,19 @@ export class MongoModelService
     return await Promise.all(items.map(item => this.postLoad(cls, item)));
   }
 
-  async queryOne<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>, failOnMany = true): Promise<T> {
+  async getByQuery<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);
   }
 
+  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);
+  }
+
   // Query Crud
   async updateByQuery<T extends ModelType>(cls: Class<T>, data: T, query: ModelQuery<T>): Promise<T> {
     await QueryVerifier.verify(cls, query);
@@ -730,59 +736,42 @@ 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);
+  async aggregateFieldByQuery<T extends ModelType, const F extends ValidComparableFields<T>>(
+    cls: Class<T>,
+    field: F,
+    query?: ModelQuery<T>
+  ): Promise<FieldAggregateResult<T, F>> {
+    await QueryVerifier.verify(cls, query);
 
-    const collection = await this.getStore(modelClass);
+    const collection = await this.getStore(cls);
 
-    const where = ModelQueryUtil.getWhereClause(modelClass, query?.where);
+    const where = ModelQueryUtil.getWhereClause(cls, query?.where);
     let queryObject: Record<string, unknown> = { [field]: { $exists: true, $ne: null } };
 
     if (where) {
-      queryObject = { $and: [queryObject, MongoUtil.extractWhereFilter(modelClass, where)] };
+      queryObject = { $and: [queryObject, MongoUtil.extractWhereFilter(cls, 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 isDate = SchemaRegistryIndex.getNestedFieldConfig(cls, field)!.type === Date;
 
-    const result = await collection.aggregate<{ _id: null; value: unknown }>(aggregations).toArray();
-    const rawValue = result.length ? result[0].value : undefined;
+    const groupFields: Record<string, unknown> = {
+      _id: null,
+      count: { $sum: 1 },
+      min: { $min: `$${String(field)}` },
+      max: { $max: `$${String(field)}` }
+    };
+    if (!isDate) {
+      groupFields.avg = { $avg: `$${String(field)}` };
+      groupFields.sum = { $sum: `$${String(field)}` };
+    }
 
-    return ModelQueryAggregateUtil.resolveResult(modelClass, operation, field, rawValue);
-  }
+    const aggregations: object[] = [{ $match: queryObject }, { $group: groupFields }];
 
-  async countByQuery<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>): Promise<number> {
-    await QueryVerifier.verify(cls, query);
+    const result = await collection.aggregate<NumberFieldAggregateResult>(aggregations).toArray();
 
-    const col = await this.getStore(cls);
-    const filter = MongoUtil.extractWhereFilter(cls, query.where);
-    return col.countDocuments(filter);
+    const row = result.length ? result[0] : { count: 0 };
+    return ModelQueryAggregateUtil.resolveAggregate(cls, field, row);
   }
 
   // Suggest