@travetto/model-query 8.0.0-alpha.8 → 8.0.0

package/README.md

@@ -13,7 +13,7 @@ npm install @travetto/model-query
 yarn add @travetto/model-query
 ```
 
-This module provides an enhanced query contract for [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") implementations.  This contract has been externalized due to it being more complex than many implementations can natively support.
+This module provides an enhanced query contract for [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") implementations. This contract has been externalized due to it being more complex than many implementations can natively support.
 
 ## Contracts
 
@@ -46,7 +46,7 @@ export interface ModelQuerySupport {
 ```
 
 ### Crud
-Reinforcing the complexity provided in these contracts, the [Query Crud](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/crud.ts#L11) contract allows for bulk update/deletion by query.  This requires the underlying implementation to support these operations.
+Reinforcing the complexity provided in these contracts, the [Query Crud](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/crud.ts#L11) contract allows for bulk update/deletion by query. This requires the underlying implementation to support these operations.
 
 **Code: Query Crud**
 ```typescript
@@ -56,7 +56,7 @@ export interface ModelQueryCrudSupport extends ModelCrudSupport, ModelQuerySuppo
    * @param cls The model class
    * @param data The data
    * @param query The additional query to validate
-  */
+   */
   updateByQuery<T extends ModelType>(cls: Class<T>, data: T, query: ModelQuery<T>): Promise<T>;
   /**
    * Update all with partial data, by query
@@ -86,7 +86,7 @@ export interface ModelQueryFacetSupport extends ModelQuerySupport {
    * @param field The field to facet on
    * @param query Additional query filtering
    */
-  facet<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, query?: ModelQuery<T>): Promise<ModelQueryFacet[]>;
+  facetByQuery<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, query?: ModelQuery<T>): Promise<ModelQueryFacet[]>;
 }
 ```
 
@@ -104,7 +104,12 @@ export interface ModelQuerySuggestSupport extends ModelQuerySupport {
    * @param prefix The search prefix for the given field
    * @param query A query to filter the search on, in addition to the prefix
    */
-  suggest<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: PageableModelQuery<T>): Promise<T[]>;
+  suggestByQuery<T extends ModelType>(
+    cls: Class<T>,
+    field: ValidStringFields<T>,
+    prefix?: string,
+    query?: PageableModelQuery<T>
+  ): Promise<T[]>;
   /**
    * Suggest distinct values for a given cls and a given field
    *
@@ -113,7 +118,12 @@ export interface ModelQuerySuggestSupport extends ModelQuerySupport {
    * @param prefix The search prefix for the given field
    * @param query A query to filter the search on, in addition to the prefix
    */
-  suggestValues<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: PageableModelQuery<T>): Promise<string[]>;
+  suggestValuesByQuery<T extends ModelType>(
+    cls: Class<T>,
+    field: ValidStringFields<T>,
+    prefix?: string,
+    query?: PageableModelQuery<T>
+  ): Promise<string[]>;
 }
 ```
 
@@ -125,7 +135,7 @@ export interface ModelQuerySuggestSupport extends ModelQuerySupport {
 |[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'|
 
 ## 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.
+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.
 
 ### General Fields
 
@@ -153,7 +163,7 @@ One of the complexities of abstracting multiple storage mechanisms, is providing
    *  `field: { $gt: Date | RelativeTime }` checks if value is greater than
    *  `field: { $gte: Date | RelativeTime }` checks if value is greater than or equal to
 
-**Note**: Relative times are strings consisting of a number and a unit.  e.g. -1w or 30d.  These times are always relative to Date.now, but should make building queries more natural.
+**Note**: Relative times are strings consisting of a number and a unit. e.g. -1w or 30d. These times are always relative to Date.now, but should make building queries more natural.
 
 ### Array Fields
 
@@ -179,6 +189,7 @@ A sample query for `User`'s might be:
 **Code: Using the query structure for specific queries**
 ```typescript
 import type { ModelQuerySupport } from '@travetto/model-query';
+
 import { User } from './user.ts';
 
 export class UserSearch {
@@ -214,25 +225,24 @@ In addition to the provided contracts, the module also provides common utilities
 
 **Code: MongoDB Service Test Configuration**
 ```typescript
-import { Suite } from '@travetto/test';
 import { Config } from '@travetto/config';
 import { Injectable } from '@travetto/di';
-import type { ModelQueryFacetSupport, ModelQuerySuggestSupport, ModelQueryCrudSupport } from '@travetto/model-query';
+import type { ModelQueryCrudSupport, ModelQueryFacetSupport, ModelQuerySuggestSupport } from '@travetto/model-query';
+import { Suite } from '@travetto/test';
 
-import { ModelQuerySuite } from '@travetto/model-query/support/test/query.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';
+import { ModelQuerySuite } from '@travetto/model-query/support/test/query.ts';
 import { ModelQuerySuggestSuite } from '@travetto/model-query/support/test/suggest.ts';
 
 import { QueryModelService } from './query-service.ts';
 
 @Config('model.custom')
-class CustomModelConfig { }
+class CustomModelConfig {}
 
 @Injectable()
-class CustomModelService extends QueryModelService implements ModelQueryCrudSupport, ModelQueryFacetSupport, ModelQuerySuggestSupport {
-}
+class CustomModelService extends QueryModelService implements ModelQueryCrudSupport, ModelQueryFacetSupport, ModelQuerySuggestSupport {}
 
 @Suite()
 class CustomQuerySuite extends ModelQuerySuite {

package/__index__.ts

@@ -1,13 +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/crud.ts';
-export * from './src/types/query.ts';
 export * from './src/types/facet.ts';
+export * from './src/types/query.ts';
 export * from './src/types/suggest.ts';
-
+export * from './src/util/crud.ts';
+export * from './src/util/facet.ts';
 export * from './src/util/query.ts';
 export * from './src/util/suggest.ts';
-export * from './src/util/facet.ts';
-export * from './src/util/crud.ts';
-
-export * from './src/verifier.ts';
+export * from './src/verifier.ts';

package/package.json

@@ -1,38 +1,41 @@
 {
   "name": "@travetto/model-query",
-  "version": "8.0.0-alpha.8",
-  "type": "module",
+  "version": "8.0.0",
   "description": "Datastore abstraction for advanced query support.",
   "keywords": [
     "datastore",
     "decorators",
     "schema",
-    "typescript",
-    "travetto"
+    "travetto",
+    "typescript"
   ],
   "homepage": "https://travetto.io",
   "license": "MIT",
   "author": {
-    "email": "travetto.framework@gmail.com",
-    "name": "Travetto Framework"
+    "name": "Travetto Framework",
+    "email": "travetto.framework@gmail.com"
+  },
+  "repository": {
+    "url": "git+https://github.com/travetto/travetto.git",
+    "directory": "module/model-query"
   },
   "files": [
     "__index__.ts",
     "src",
     "support"
   ],
+  "type": "module",
   "main": "__index__.ts",
-  "repository": {
-    "url": "git+https://github.com/travetto/travetto.git",
-    "directory": "module/model-query"
+  "publishConfig": {
+    "access": "public"
   },
   "dependencies": {
-    "@travetto/di": "^8.0.0-alpha.8",
-    "@travetto/model": "^8.0.0-alpha.8",
-    "@travetto/schema": "^8.0.0-alpha.8"
+    "@travetto/di": "^8.0.0",
+    "@travetto/model": "^8.0.0",
+    "@travetto/schema": "^8.0.0"
   },
   "peerDependencies": {
-    "@travetto/test": "^8.0.0-alpha.8"
+    "@travetto/test": "^8.0.0"
   },
   "peerDependenciesMeta": {
     "@travetto/test": {
@@ -41,8 +44,5 @@
   },
   "travetto": {
     "displayName": "Data Model Querying"
-  },
-  "publishConfig": {
-    "access": "public"
   }
 }

package/src/internal/types.ts

@@ -1,8 +1,8 @@
-import type { SchemaFieldConfig, Point } from '@travetto/schema';
-import { castTo, type Class, toConcrete } from '@travetto/runtime';
+import { type Class, castTo, toConcrete } from '@travetto/runtime';
+import type { Point, SchemaFieldConfig } from '@travetto/schema';
 
 const st = (value: string | string[], isArray: boolean = false): Set<string> =>
-  new Set((Array.isArray(value) ? value : [value]).map(item => isArray ? `${item}[]` : item));
+  new Set((Array.isArray(value) ? value : [value]).map(item => (isArray ? `${item}[]` : item)));
 
 const basic = (types: Set<string>): Record<string, Set<string>> => ({ $ne: types, $eq: types, $exists: st('boolean') });
 const scalar = (types: Set<string>): Record<string, Set<string>> => ({ $in: types, $nin: types });
@@ -42,12 +42,18 @@ export class TypeUtil {
   static getDeclaredType(field: SchemaFieldConfig | Function | Class): keyof typeof TypeUtil.OPERATORS | undefined {
     const type = 'type' in field ? field.type : field;
     switch (type) {
-      case String: return 'string';
-      case Number: return 'number';
-      case Boolean: return 'boolean';
-      case BigInt: return 'bigint';
-      case Date: return 'Date';
-      case PointConcrete: return 'Point';
+      case String:
+        return 'string';
+      case Number:
+        return 'number';
+      case Boolean:
+        return 'boolean';
+      case BigInt:
+        return 'bigint';
+      case Date:
+        return 'Date';
+      case PointConcrete:
+        return 'Point';
       default: {
         if ('type' in field && field.array) {
           return this.getDeclaredType(field.type);
@@ -77,4 +83,4 @@ export class TypeUtil {
     }
     throw new Error(`Unknown type for ${value}`);
   }
-}
+}

package/src/model/indexes.ts

@@ -0,0 +1,36 @@
+import { type IndexConfig, ModelRegistryIndex, type ModelType } from '@travetto/model';
+import { type Class, type Primitive, RuntimeError, type ValidFields } from '@travetto/runtime';
+
+type RetainPrimitiveFields<T> = Pick<T, ValidFields<T, Primitive | Date>>;
+
+type IndexClauseRaw<T> = {
+  [P in keyof T]?: T[P] extends object ? IndexClauseRaw<RetainPrimitiveFields<T[P]>> : 1 | -1 | true;
+};
+
+export type IndexField<T extends ModelType> = IndexClauseRaw<RetainPrimitiveFields<T>>;
+
+/**
+ * Index options
+ */
+export interface QueryIndexConfig<T extends ModelType> extends IndexConfig<'query', T> {
+  /**
+   * Fields and sort order
+   */
+  fields: IndexClauseRaw<RetainPrimitiveFields<T>>[];
+  /**
+   * Is this a unique index
+   */
+  unique?: boolean;
+}
+
+export function QueryIndex<T extends ModelType>(index: Omit<QueryIndexConfig<T>, 'class' | 'type'>) {
+  if (index.fields.some(field => field === 'id')) {
+    throw new RuntimeError('Cannot create an index with the id field');
+  }
+  return function (cls: Class<T>): void {
+    ModelRegistryIndex.getForRegister(cls).register({ indices: { [index.name]: { ...index, type: 'query', class: cls } } });
+  };
+}
+
+export const isModelQueryIndex = (idx: unknown): idx is QueryIndexConfig<ModelType> =>
+  typeof idx === 'object' && idx !== null && 'type' in idx && typeof idx.type === 'string' && idx.type === 'query';

package/src/model/query.ts

@@ -1,17 +1,15 @@
-import type { WhereClauseRaw, RetainQueryPrimitiveFields } from './where-clause.ts';
+import type { RetainQueryPrimitiveFields, WhereClauseRaw } from './where-clause.ts';
 
 type SelectClauseRaw<T> = {
-  [P in keyof T]?:
-  T[P] extends object ? SelectClauseRaw<RetainQueryPrimitiveFields<T[P]>> : (1 | 0 | boolean);
+  [P in keyof T]?: T[P] extends object ? SelectClauseRaw<RetainQueryPrimitiveFields<T[P]>> : 1 | 0 | boolean;
 };
 
 type GroupClauseRaw<T> = {
-  [P in keyof T]?: T[P] extends object ? GroupClauseRaw<RetainQueryPrimitiveFields<T[P]>> : (1 | 0 | boolean);
+  [P in keyof T]?: T[P] extends object ? GroupClauseRaw<RetainQueryPrimitiveFields<T[P]>> : 1 | 0 | boolean;
 };
 
 type SortClauseRaw<T> = {
-  [P in keyof T]?:
-  T[P] extends object ? SortClauseRaw<RetainQueryPrimitiveFields<T[P]>> : 1 | -1;
+  [P in keyof T]?: T[P] extends object ? SortClauseRaw<RetainQueryPrimitiveFields<T[P]>> : 1 | -1;
 };
 
 type QueryOptionsRaw<T> = {
@@ -58,4 +56,4 @@ export type GroupClause<T> = GroupClauseRaw<RetainQueryPrimitiveFields<T>>;
 /**
  * Model query, requiring a model object
  */
-export type ModelQuery<T> = ModelQueryRaw<RetainQueryPrimitiveFields<T>>;
+export type ModelQuery<T> = ModelQueryRaw<RetainQueryPrimitiveFields<T>>;

package/src/model/where-clause.ts

@@ -1,10 +1,11 @@
-import type { Primitive, ValidFields, TimeSpan } from '@travetto/runtime';
+import type { KeyPaths, Primitive, TimeSpan, ValidFields } from '@travetto/runtime';
 import type { Point } from '@travetto/schema';
 
 export type QueryPrimitive = Primitive | Date | Point;
 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>;
 
 type General<T> = {
   $eq?: T;
@@ -25,13 +26,14 @@ type ComparableField<T> = {
 };
 
 type ArrayField<T> =
-  { $exists?: boolean } |
-  { $eq?: T | T[] } |
-  { $ne?: T | T[] } |
-  { $all?: T[] } |
-  { $in?: T[] } |
-  PropWhereClause<RetainQueryPrimitiveFields<T>> |
-  T | T[];
+  | { $exists?: boolean }
+  | { $eq?: T | T[] }
+  | { $ne?: T | T[] }
+  | { $all?: T[] }
+  | { $in?: T[] }
+  | PropWhereClause<RetainQueryPrimitiveFields<T>>
+  | T
+  | T[];
 
 type StringField = { $regex?: RegExp | string };
 
@@ -43,35 +45,35 @@ type GeoField = {
 };
 
 export type PropWhereClause<T> = {
-  [P in keyof T]?:
-  (T[P] extends (number | undefined) ? (General<number> | ScalarField<number> | ComparableField<number> | number) :
-    (T[P] extends (bigint | undefined) ? (General<bigint> | ScalarField<bigint> | ComparableField<bigint> | bigint) :
-      (T[P] extends (string | undefined) ? (General<string> | ScalarField<string> | StringField | string) :
-        (T[P] extends (boolean | undefined) ? (General<boolean> | boolean) :
-          (T[P] extends (Date | undefined) ? (General<Date> | ScalarField<Date> | ComparableField<Date | TimeSpan> | Date) :
-            (T[P] extends (Point | undefined) ? (General<Point> | ScalarField<Point> | GeoField | Point) :
-              (T[P] extends ((infer U)[] | undefined) ? ArrayField<U> :
-                (T[P] extends (object | undefined) ? PropWhereClause<RetainQueryPrimitiveFields<T[P]>> : never))))))));
+  -readonly [P in keyof T]?: T[P] extends number | undefined
+    ? General<number> | ScalarField<number> | ComparableField<number> | number
+    : T[P] extends bigint | undefined
+      ? General<bigint> | ScalarField<bigint> | ComparableField<bigint> | bigint
+      : T[P] extends string | undefined
+        ? General<string> | ScalarField<string> | StringField | string
+        : T[P] extends boolean | undefined
+          ? General<boolean> | boolean
+          : T[P] extends Date | undefined
+            ? General<Date> | ScalarField<Date> | ComparableField<Date | TimeSpan> | Date
+            : T[P] extends Point | undefined
+              ? General<Point> | ScalarField<Point> | GeoField | Point
+              : T[P] extends (infer U)[] | undefined
+                ? ArrayField<U>
+                : T[P] extends object | undefined
+                  ? PropWhereClause<RetainQueryPrimitiveFields<T[P]>>
+                  : never;
 };
 
 /**
  * Raw query type
  */
 export type WhereClauseRaw<T> =
-  ({ $and: WhereClauseRaw<T>[] } & { [P in keyof T]?: never }) |
-  ({ $or: WhereClauseRaw<T>[] } & { [P in keyof T]?: never }) |
-  ({ $not: WhereClauseRaw<T> } & { [P in keyof T]?: never }) |
-  (PropWhereClause<T> & { $and?: never, $or?: never, $not?: never });
+  | ({ $and: WhereClauseRaw<T>[] } & { [P in keyof T]?: never })
+  | ({ $or: WhereClauseRaw<T>[] } & { [P in keyof T]?: never })
+  | ({ $not: WhereClauseRaw<T> } & { [P in keyof T]?: never })
+  | (PropWhereClause<T> & { $and?: never; $or?: never; $not?: never });
 
 /**
  * Full where clause, typed against the input type T
  */
 export type WhereClause<T> = WhereClauseRaw<RetainQueryPrimitiveFields<T>>;
-
-/**
- * Provides all the valid string type fields from a given type T
- */
-export type ValidStringFields<T> = {
-  [K in Extract<keyof T, string>]:
-  (T[K] extends (String | string | string[] | String[] | undefined) ? K : never)
-}[Extract<keyof T, string>];

package/src/types/crud.ts

@@ -1,8 +1,8 @@
-import type { Class } from '@travetto/runtime';
 import type { ModelCrudSupport, ModelType } from '@travetto/model';
+import type { Class } from '@travetto/runtime';
 
-import type { ModelQuerySupport } from './query.ts';
 import type { ModelQuery } from '../model/query.ts';
+import type { ModelQuerySupport } from './query.ts';
 
 /**
  * The contract for a model service with query support
@@ -14,7 +14,7 @@ export interface ModelQueryCrudSupport extends ModelCrudSupport, ModelQuerySuppo
    * @param cls The model class
    * @param data The data
    * @param query The additional query to validate
-  */
+   */
   updateByQuery<T extends ModelType>(cls: Class<T>, data: T, query: ModelQuery<T>): Promise<T>;
   /**
    * Update all with partial data, by query
@@ -29,4 +29,4 @@ export interface ModelQueryCrudSupport extends ModelCrudSupport, ModelQuerySuppo
    * @param query Query to search for deletable elements
    */
   deleteByQuery<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>): Promise<number>;
-}
+}

package/src/types/facet.ts

@@ -1,11 +1,11 @@
-import type { Class } from '@travetto/runtime';
 import type { ModelType } from '@travetto/model';
+import type { Class } from '@travetto/runtime';
 
 import type { ModelQuery } from '../model/query.ts';
-import type { ModelQuerySupport } from './query.ts';
 import type { ValidStringFields } from '../model/where-clause.ts';
+import type { ModelQuerySupport } from './query.ts';
 
-export type ModelQueryFacet = { key: string, count: number };
+export type ModelQueryFacet = { key: string; count: number };
 
 /**
  * The contract for a model service with faceting support
@@ -18,5 +18,5 @@ export interface ModelQueryFacetSupport extends ModelQuerySupport {
    * @param field The field to facet on
    * @param query Additional query filtering
    */
-  facet<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, query?: ModelQuery<T>): Promise<ModelQueryFacet[]>;
-}
+  facetByQuery<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, query?: ModelQuery<T>): Promise<ModelQueryFacet[]>;
+}

package/src/types/query.ts

@@ -1,5 +1,5 @@
-import type { Class } from '@travetto/runtime';
 import type { ModelType } from '@travetto/model';
+import type { Class } from '@travetto/runtime';
 
 import type { ModelQuery, PageableModelQuery } from '../model/query.ts';
 
@@ -27,4 +27,4 @@ export interface ModelQuerySupport {
    * @param query The query to count for
    */
   queryCount<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>): Promise<number>;
-}
+}

package/src/types/suggest.ts

@@ -1,9 +1,9 @@
-import type { Class } from '@travetto/runtime';
 import type { ModelType } from '@travetto/model';
+import type { Class } from '@travetto/runtime';
 
 import type { PageableModelQuery } from '../model/query.ts';
-import type { ModelQuerySupport } from './query.ts';
 import type { ValidStringFields } from '../model/where-clause.ts';
+import type { ModelQuerySupport } from './query.ts';
 
 /**
  * The contract for a model service with suggesting support
@@ -18,7 +18,12 @@ export interface ModelQuerySuggestSupport extends ModelQuerySupport {
    * @param prefix The search prefix for the given field
    * @param query A query to filter the search on, in addition to the prefix
    */
-  suggest<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: PageableModelQuery<T>): Promise<T[]>;
+  suggestByQuery<T extends ModelType>(
+    cls: Class<T>,
+    field: ValidStringFields<T>,
+    prefix?: string,
+    query?: PageableModelQuery<T>
+  ): Promise<T[]>;
   /**
    * Suggest distinct values for a given cls and a given field
    *
@@ -27,5 +32,10 @@ export interface ModelQuerySuggestSupport extends ModelQuerySupport {
    * @param prefix The search prefix for the given field
    * @param query A query to filter the search on, in addition to the prefix
    */
-  suggestValues<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: PageableModelQuery<T>): Promise<string[]>;
-}
+  suggestValuesByQuery<T extends ModelType>(
+    cls: Class<T>,
+    field: ValidStringFields<T>,
+    prefix?: string,
+    query?: PageableModelQuery<T>
+  ): Promise<string[]>;
+}

package/src/util/crud.ts

@@ -1,5 +1,5 @@
+import { type ModelCrudSupport, ModelRegistryIndex, type ModelType } from '@travetto/model';
 import { type Class, hasFunction } from '@travetto/runtime';
-import { type ModelType, type ModelCrudSupport, ModelRegistryIndex } from '@travetto/model';
 
 import type { ModelQueryCrudSupport } from '../types/crud.ts';
 
@@ -23,4 +23,4 @@ export class ModelQueryCrudUtil {
     });
     return count ?? 0;
   }
-}
+}

package/src/util/facet.ts

@@ -6,5 +6,5 @@ export class ModelQueryFacetUtil {
   /**
    * Type guard for determining if service supports query facet operations
    */
-  static isSupported = hasFunction<ModelQueryFacetSupport>('facet');
-}
+  static isSupported = hasFunction<ModelQueryFacetSupport>('facetByQuery');
+}

package/src/util/query.ts

@@ -1,5 +1,5 @@
-import { type Class, RuntimeError, TimeUtil, castTo, hasFunction } from '@travetto/runtime';
-import { type ModelType, NotFoundError, ModelRegistryIndex } from '@travetto/model';
+import { ModelRegistryIndex, type ModelType, NotFoundError } from '@travetto/model';
+import { type Class, castTo, hasFunction, RuntimeError, TimeUtil } from '@travetto/runtime';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
 import type { WhereClause, WhereClauseRaw } from '../model/where-clause.ts';
@@ -9,7 +9,6 @@ import type { ModelQuerySupport } from '../types/query.ts';
  * Common model utils, that should be usable by end users
  */
 export class ModelQueryUtil {
-
   /**
    * Type guard for determining if service supports query operations
    */
@@ -33,10 +32,10 @@ export class ModelQueryUtil {
    */
   static verifyGetSingleCounts<T extends ModelType>(cls: Class<T>, failOnMany: boolean, result?: T[], where?: WhereClause<T>): T {
     result = result ?? [];
-    if (result.length === 1 || result.length > 1 && !failOnMany) {
+    if (result.length === 1 || (result.length > 1 && !failOnMany)) {
       return result[0]!;
     }
-    const requestedId = ((where && 'id' in where && typeof where.id === 'string') ? where.id : undefined);
+    const requestedId = where && 'id' in where && typeof where.id === 'string' ? where.id : undefined;
     if (result.length === 0) {
       if (requestedId) {
         throw new NotFoundError(cls, requestedId);
@@ -54,27 +53,34 @@ export class ModelQueryUtil {
    * Get a where clause with type
    */
   static getWhereClause<T extends ModelType>(cls: Class<T>, where: WhereClause<T> | undefined, checkExpiry = true): WhereClause<T> {
-    const clauses: WhereClauseRaw<T>[] = (where ? [where] : []);
+    const clauses: WhereClauseRaw<T>[] = where ? [where] : [];
 
     const polymorphicConfig = SchemaRegistryIndex.getDiscriminatedConfig(cls);
     if (polymorphicConfig) {
-      clauses.push(castTo(polymorphicConfig.discriminatedBase ? {
-        [polymorphicConfig.discriminatedField]: { $in: SchemaRegistryIndex.getDiscriminatedTypes(cls) }
-      } : {
-        [polymorphicConfig.discriminatedField]: polymorphicConfig.discriminatedType
-      }
-      ));
+      clauses.push(
+        castTo(
+          polymorphicConfig.discriminatedBase
+            ? {
+                [polymorphicConfig.discriminatedField]: { $in: SchemaRegistryIndex.getDiscriminatedTypes(cls) }
+              }
+            : {
+                [polymorphicConfig.discriminatedField]: polymorphicConfig.discriminatedType
+              }
+        )
+      );
     }
 
     const indexConfig = ModelRegistryIndex.getConfig(cls);
     if (checkExpiry && indexConfig.expiresAt) {
-      clauses.push(castTo({
-        $or: [
-          { [indexConfig.expiresAt]: { $exists: false } },
-          { [indexConfig.expiresAt]: undefined },
-          { [indexConfig.expiresAt]: { $gte: new Date() } },
-        ]
-      }));
+      clauses.push(
+        castTo({
+          $or: [
+            { [indexConfig.expiresAt]: { $exists: false } },
+            { [indexConfig.expiresAt]: undefined },
+            { [indexConfig.expiresAt]: { $gte: new Date() } }
+          ]
+        })
+      );
     }
     if (clauses.length > 1) {
       where = { $and: clauses };
@@ -84,10 +90,7 @@ export class ModelQueryUtil {
     return where!;
   }
 
-  static has$And = (value: unknown): value is ({ $and: WhereClause<unknown>[] }) =>
-    !!value && typeof value === 'object' && '$and' in value;
-  static has$Or = (value: unknown): value is ({ $or: WhereClause<unknown>[] }) =>
-    !!value && typeof value === 'object' && '$or' in value;
-  static has$Not = (value: unknown): value is ({ $not: WhereClause<unknown> }) =>
-    !!value && typeof value === 'object' && '$not' in value;
-}
+  static has$And = (value: unknown): value is { $and: WhereClause<unknown>[] } => !!value && typeof value === 'object' && '$and' in value;
+  static has$Or = (value: unknown): value is { $or: WhereClause<unknown>[] } => !!value && typeof value === 'object' && '$or' in value;
+  static has$Not = (value: unknown): value is { $not: WhereClause<unknown> } => !!value && typeof value === 'object' && '$not' in value;
+}