@travetto/model-query 8.0.4 → 8.0.6

package/README.md

@@ -141,7 +141,7 @@ export interface ModelQueryAggregateSupport extends ModelQuerySupport {
    * @param field The field to aggregate on
    * @param query Additional query filtering
    */
-  aggregateFieldByQuery<T extends ModelType, F extends ValidComparableFields<T>>(
+  aggregateFieldByQuery<T extends ModelType, const F extends ValidComparableFields<T>>(
     modelClass: Class<T>,
     field: F,
     query?: ModelQuery<T>

package/package.json

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

package/src/types/aggregate.ts

@@ -16,7 +16,7 @@ export type PathType<T, Path extends string> = Path extends `${infer Head}.${inf
     : never;
 
 export type AggregateResultType<T, F extends string> = [PathType<T, F>] extends [never]
-  ? number | Date | bigint | undefined
+  ? number | bigint | undefined
   : PathType<T, F> | undefined;
 
 export type DateFieldAggregateResult = {
@@ -25,16 +25,29 @@ export type DateFieldAggregateResult = {
   max?: Date;
 };
 
-export type NumericFieldAggregateResult<T, F extends string> = {
+export type NumberFieldAggregateResult = {
   count: number;
-  min?: AggregateResultType<T, F>;
-  max?: AggregateResultType<T, F>;
-  avg?: AggregateResultType<T, F>;
-  sum?: AggregateResultType<T, F>;
+  min?: number;
+  max?: number;
+  avg?: number;
+  sum?: number;
 };
 
-export type FieldAggregateResult<T, F extends string> =
-  NonNullable<PathType<T, F>> extends Date ? DateFieldAggregateResult : NumericFieldAggregateResult<T, F>;
+export type BigIntFieldAggregateResult = {
+  count: number;
+  min?: bigint;
+  max?: bigint;
+  avg?: bigint;
+  sum?: bigint;
+};
+
+export type FieldAggregateResult<T, F extends string> = F extends any
+  ? NonNullable<PathType<T, F>> extends Date
+    ? DateFieldAggregateResult
+    : NonNullable<PathType<T, F>> extends bigint
+      ? BigIntFieldAggregateResult
+      : NumberFieldAggregateResult
+  : never;
 
 /**
  * The contract for a model service with aggregate support
@@ -49,7 +62,7 @@ export interface ModelQueryAggregateSupport extends ModelQuerySupport {
    * @param field The field to aggregate on
    * @param query Additional query filtering
    */
-  aggregateFieldByQuery<T extends ModelType, F extends ValidComparableFields<T>>(
+  aggregateFieldByQuery<T extends ModelType, const F extends ValidComparableFields<T>>(
     modelClass: Class<T>,
     field: F,
     query?: ModelQuery<T>

package/src/util/aggregate.ts

@@ -3,7 +3,7 @@ import { castTo, type Class, hasFunction } from '@travetto/runtime';
 import { DataUtil, SchemaRegistryIndex } from '@travetto/schema';
 
 import type { ValidComparableFields } from '../model/where-clause.ts';
-import type { AggregateResultType, FieldAggregateResult, ModelQueryAggregateSupport } from '../types/aggregate.ts';
+import type { FieldAggregateResult, ModelQueryAggregateSupport, NumberFieldAggregateResult } from '../types/aggregate.ts';
 
 export class ModelQueryAggregateUtil {
   /**
@@ -17,32 +17,31 @@ export class ModelQueryAggregateUtil {
    * @param field The field being aggregated
    * @param rawValues The raw result values from the datastore
    */
-  static resolveAggregate<T extends ModelType, F extends ValidComparableFields<T>>(
+  static resolveAggregate<T extends ModelType, const F extends ValidComparableFields<T>>(
     modelClass: Class<T>,
     field: F,
-    rawValues: { count?: unknown; min?: unknown; max?: unknown; avg?: unknown; sum?: unknown }
+    rawValues: Partial<Record<keyof NumberFieldAggregateResult, unknown>>
   ): FieldAggregateResult<T, F> {
     const count = Number(rawValues.count ?? 0);
     if (count === 0) {
       return castTo({ count: 0 });
     }
     const leafFieldType = SchemaRegistryIndex.getNestedFieldConfig(modelClass, field)!.type;
-    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)
+        min: DataUtil.coerceType(rawValues.min, leafFieldType, true),
+        max: DataUtil.coerceType(rawValues.max, leafFieldType, true)
       });
     }
 
     return castTo({
       count,
-      min: coerce(rawValues.min),
-      max: coerce(rawValues.max),
-      avg: coerce(rawValues.avg),
-      sum: coerce(rawValues.sum)
+      min: DataUtil.coerceType(rawValues.min, leafFieldType, true),
+      max: DataUtil.coerceType(rawValues.max, leafFieldType, true),
+      avg: DataUtil.coerceType(rawValues.avg, leafFieldType, true),
+      sum: DataUtil.coerceType(rawValues.sum, leafFieldType, true)
     });
   }
 }

package/support/test/aggregate.ts

@@ -1,12 +1,12 @@
 import assert from 'node:assert';
 
-import type { ModelCrudSupport } from '@travetto/model';
+import type { ModelCrudSupport, ModelType } 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';
+import type { DateFieldAggregateResult, ModelQueryAggregateSupport, NumberFieldAggregateResult } from '../../src/types/aggregate.ts';
+import { Aged, BigIntModel, MultiFieldModel, Person } from './model.ts';
 
 @Suite()
 export abstract class ModelQueryAggregateSuite extends BaseModelSuite<ModelQueryAggregateSupport & ModelCrudSupport> {
@@ -32,6 +32,27 @@ export abstract class ModelQueryAggregateSuite extends BaseModelSuite<ModelQuery
     assert(aggregate.max.getTime() === thirdDate.getTime());
   }
 
+  @Test('verify model with multiple field types aggregate')
+  async testMultiFieldModelAggregate() {
+    const service = await this.service;
+    const now = new Date();
+    await this.saveAll(MultiFieldModel, [
+      MultiFieldModel.from({ createdAt: now, score: 10 }),
+      MultiFieldModel.from({ createdAt: now, score: 20 })
+    ]);
+
+    const dateStats = await service.aggregateFieldByQuery(MultiFieldModel, 'createdAt');
+    const dateCheck: DateFieldAggregateResult = dateStats;
+    assert(dateCheck.count === 2);
+    assert(dateCheck.min instanceof Date);
+
+    const numberStats = await service.aggregateFieldByQuery(MultiFieldModel, 'score');
+    const numberCheck: NumberFieldAggregateResult = numberStats;
+    assert(numberCheck.count === 2);
+    assert(numberCheck.min === 10);
+    assert(numberCheck.avg === 15);
+  }
+
   @Test('verify field aggregate')
   async testFieldAggregate() {
     const people = [

package/support/test/model.ts

@@ -74,6 +74,13 @@ export class Aged {
   createdAt: Date;
 }
 
+@Model()
+export class MultiFieldModel {
+  id: string;
+  createdAt: Date;
+  score: number;
+}
+
 @Model()
 export class WithNestedLists {
   id: string;