@travetto/model-query 2.1.5 → 2.2.0

package/README.md

@@ -8,7 +8,7 @@
 npm install @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 implemenations can natively support.  In addition to the contract, this module provides support for textual query language that can be checked and parsed into the proper query structure.
+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.  In addition to the contract, this module provides support for textual query language that can be checked and parsed into the proper query structure.
 
 ## Contracts
 
@@ -41,7 +41,7 @@ export interface ModelQuerySupport {
 ```
 
 ### [Query Crud](https://github.com/travetto/travetto/tree/main/module/model-query/src/service/crud.ts#L11)
-Reinforcing the complexity provided in these contracts, the [Query Crud](https://github.com/travetto/travetto/tree/main/module/model-query/src/service/crud.ts#L11) contract allows for bulk update/deletion by query.  This requires the underlying implentation 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/service/crud.ts#L11) contract allows for bulk update/deletion by query.  This requires the underlying implementation to support these operations.
 
 **Code: Query Crud**
 ```typescript
@@ -79,7 +79,7 @@ export interface ModelQueryFacetSupport extends ModelQuerySupport {
 ```
 
 ### [Suggest](https://github.com/travetto/travetto/tree/main/module/model-query/src/service/suggest.ts#L12)
-Additionally, this same pattern avails it self in a set of suggestion methods that allow for powering auto completion and typeahead functionalities.
+Additionally, this same pattern avails it self in a set of suggestion methods that allow for powering auto completion and type-ahead functionalities.
 
 **Code: Suggest**
 ```typescript
@@ -129,7 +129,7 @@ One of the complexities of abstracting multiple storage mechanisms, is providing
    *  `field: { $in: T[] }` to see if a record's value appears in the array provided to `$in`
    *  `field: { $nin: T[] }` to see if a record's value does not appear in the array provided to `$in`
 
-### Ordered Numberic Fields
+### Ordered Numeric Fields
    
    *  `field: { $lt: number }` checks if value is less than
    *  `field: { $lte: number }` checks if value is less than or equal to
@@ -142,7 +142,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  quieries 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
    

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/model-query",
   "displayName": "Data Model Querying",
-  "version": "2.1.5",
+  "version": "2.2.0",
   "description": "Datastore abstraction for advanced query support.",
   "keywords": [
     "datastore",
@@ -28,9 +28,9 @@
     "directory": "module/model-query"
   },
   "dependencies": {
-    "@travetto/di": "^2.1.5",
-    "@travetto/model": "^2.1.5",
-    "@travetto/schema": "^2.1.5"
+    "@travetto/di": "^2.2.0",
+    "@travetto/model": "^2.2.0",
+    "@travetto/schema": "^2.2.0"
   },
   "docDependencies": {
     "@travetto/model-mongo": true,

package/src/internal/model/point.ts

@@ -1,12 +1,13 @@
 import { Util } from '@travetto/base';
 
 export class PointImpl {
-  static validateSchema(input: unknown) {
+  static validateSchema(input: unknown): 'type' | undefined {
     const ret = this.bindSchema(input);
     return ret && !isNaN(ret[0]) && !isNaN(ret[1]) ? undefined : 'type';
   }
   static bindSchema(input: unknown): [number, number] | undefined {
     if (Array.isArray(input) && input.length === 2) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       return input.map(x => Util.coerceType(x, Number, false)) as [number, number];
     }
   }

package/src/internal/query/parser.ts

@@ -1,11 +1,12 @@
 import { WhereClauseRaw } from '../../model/where-clause';
 import { QueryLanguageTokenizer } from './tokenizer';
-import { Node, Token, ClauseNode, UnaryNode, Literal, GroupNode, OP_TRANSLATION, ArrayNode } from './types';
+import { Token, Literal, GroupNode, OP_TRANSLATION, ArrayNode, AllNode } from './types';
 
 /**
  * Determine if a token is boolean
  */
 function isBoolean(o: unknown): o is Token & { type: 'boolean' } {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return !!o && (o as { type: string }).type === 'boolean';
 }
 
@@ -17,9 +18,12 @@ export class QueryLanguageParser {
   /**
    * Handle all clauses
    */
-  static handleClause(nodes: (Node | Token)[]) {
+  static handleClause(nodes: (AllNode | Token)[]): void {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const val = nodes.pop()! as Token | ArrayNode;
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const op = nodes.pop()! as Token;
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const ident = nodes.pop()! as Token;
 
     // value isn't a literal or a list, bail
@@ -33,6 +37,7 @@ export class QueryLanguageParser {
     }
 
     // If operator is not known, bail
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const finalOp = OP_TRANSLATION[op.value as string];
     if (!finalOp) {
       throw new Error(`Unexpected operator: ${op.value}`);
@@ -40,10 +45,11 @@ export class QueryLanguageParser {
 
     nodes.push({
       type: 'clause',
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       field: ident.value as string,
       op: finalOp,
       value: val.value
-    } as ClauseNode);
+    });
 
     // Handle unary support
     this.unary(nodes);
@@ -55,13 +61,16 @@ export class QueryLanguageParser {
    * Condense nodes to remove unnecessary groupings
    * (a AND (b AND (c AND d))) => (a AND b AND c)
    */
-  static condense(nodes: (Node | Token)[], op: string) {
+  static condense(nodes: (AllNode | Token)[], op: 'and' | 'or'): void {
     let second = nodes[nodes.length - 2];
 
     while (isBoolean(second) && second.value === op) {
-      const right = nodes.pop()!;
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      const right = nodes.pop()! as AllNode;
       nodes.pop()!;
-      const left = nodes.pop()!;
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      const left = nodes.pop()! as AllNode;
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const rg = right as GroupNode;
       if (rg.type === 'group' && rg.op === op) {
         rg.value.unshift(left);
@@ -71,7 +80,7 @@ export class QueryLanguageParser {
           type: 'group',
           op,
           value: [left, right]
-        } as GroupNode);
+        });
       }
       second = nodes[nodes.length - 2];
     }
@@ -81,25 +90,27 @@ export class QueryLanguageParser {
    * Remove unnecessary unary nodes
    * (((5))) => 5
    */
-  static unary(nodes: (Node | Token)[]) {
+  static unary(nodes: (AllNode | Token)[]): void {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const second = nodes[nodes.length - 2] as Token;
     if (second && second.type === 'unary' && second.value === 'not') {
-      const node = nodes.pop()!;
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      const node = nodes.pop()! as AllNode;
       nodes.pop();
       nodes.push({
         type: 'unary',
         op: 'not',
         value: node
-      } as UnaryNode);
+      });
     }
   }
 
   /**
    * Parse all tokens
    */
-  static parse(tokens: Token[], pos: number = 0): Node {
+  static parse(tokens: Token[], pos: number = 0): AllNode {
 
-    let top: (Node | Token)[] = [];
+    let top: (AllNode | Token)[] = [];
     const stack: (typeof top)[] = [top];
     let arr: Literal[] | undefined;
 
@@ -122,7 +133,8 @@ export class QueryLanguageParser {
           if (token.value === 'start') {
             arr = [];
           } else {
-            top.push({ type: 'list', value: arr! } as ArrayNode);
+            const arrNode: ArrayNode = { type: 'list', value: arr! };
+            top.push(arrNode);
             arr = undefined;
             this.handleClause(top);
           }
@@ -148,38 +160,38 @@ export class QueryLanguageParser {
 
     this.condense(top, 'or');
 
-    return top[0];
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return top[0] as AllNode;
   }
 
   /**
    * Convert Query AST to output
    */
-  static convert<T = unknown>(node: Node): WhereClauseRaw<T> {
+  static convert<T = unknown>(node: AllNode): WhereClauseRaw<T> {
     switch (node.type) {
       case 'unary': {
-        const un = node as UnaryNode;
-        return { [`$${un.op!}`]: this.convert(un.value) } as WhereClauseRaw<T>;
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        return { [`$${node.op!}`]: this.convert(node.value) } as WhereClauseRaw<T>;
       }
       case 'group': {
-        const gn = node as GroupNode;
-        return { [`$${gn.op!}`]: gn.value.map(x => this.convert(x)) } as WhereClauseRaw<T>;
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        return { [`$${node.op!}`]: node.value.map(x => this.convert(x)) } as WhereClauseRaw<T>;
       }
       case 'clause': {
-        const cn = node as ClauseNode;
-        const parts = cn.field!.split('.');
+        const parts = node.field!.split('.');
         const top: WhereClauseRaw<T> = {};
-        let sub = top as Record<string, unknown>;
+        let sub: Record<string, unknown> = top;
         for (const p of parts) {
           sub = sub[p] = {};
         }
-        if (cn.op === '$regex' && typeof cn.value === 'string') {
-          sub[cn.op!] = new RegExp(`^${cn.value}`);
-        } else if ((cn.op === '$eq' || cn.op === '$ne') && cn.value === null) {
-          sub.$exists = cn.op !== '$eq';
-        } else if ((cn.op === '$in' || cn.op === '$nin') && !Array.isArray(cn.value)) {
-          throw new Error(`Expected array literal for ${cn.op}`);
+        if (node.op === '$regex' && typeof node.value === 'string') {
+          sub[node.op!] = new RegExp(`^${node.value}`);
+        } else if ((node.op === '$eq' || node.op === '$ne') && node.value === null) {
+          sub.$exists = node.op !== '$eq';
+        } else if ((node.op === '$in' || node.op === '$nin') && !Array.isArray(node.value)) {
+          throw new Error(`Expected array literal for ${node.op}`);
         } else {
-          sub[cn.op!] = cn.value;
+          sub[node.op!] = node.value;
         }
         return top;
       }

package/src/internal/query/tokenizer.ts

@@ -5,7 +5,7 @@ const OPEN_PARENS = 0x28, CLOSE_PARENS = 0x29, OPEN_BRACKET = 0x5b, CLOSE_BRACKE
 const GREATER_THAN = 0x3e, LESS_THAN = 0x3c, EQUAL = 0x3d, NOT = 0x21, MODULO = 0x25, TILDE = 0x7e, AND = 0x26, OR = 0x7c;
 const SPACE = 0x20, TAB = 0x09;
 const DBL_QUOTE = 0x22, SGL_QUOTE = 0x27, FORWARD_SLASH = 0x2f, BACKSLASH = 0x5c;
-const PERIOD = 0x2e, UNDERSCORE = 0x54, DOLLARSIGN = 0x24, DASH = 0x2d;
+const PERIOD = 0x2e, UNDERSCORE = 0x54, DOLLAR_SIGN = 0x24, DASH = 0x2d;
 const ZERO = 0x30, NINE = 0x39, UPPER_A = 0x41, UPPER_Z = 0x5a, LOWER_A = 0x61, LOWER_Z = 0x7a;
 const LOWER_I = 0x69, LOWER_G = 0x67, LOWER_M = 0x6d, LOWER_S = 0x73;
 
@@ -45,7 +45,7 @@ export class QueryLanguageTokenizer {
   /**
    * Process the next token.  Can specify expected type as needed
    */
-  static #processToken(state: TokenizeState, mode?: TokenType) {
+  static #processToken(state: TokenizeState, mode?: TokenType): Token {
     const text = state.text.substring(state.start, state.pos);
     const res = TOKEN_MAPPING[text.toLowerCase()];
     let value: unknown = text;
@@ -73,7 +73,7 @@ export class QueryLanguageTokenizer {
   /**
    * Flush state to output
    */
-  static #flush(state: TokenizeState, mode?: TokenType) {
+  static #flush(state: TokenizeState, mode?: TokenType): void {
     if ((!mode || !state.mode || mode !== state.mode) && state.start !== state.pos) {
       if (state.mode !== 'whitespace') {
         state.out.push(this.#processToken(state, mode));
@@ -86,27 +86,27 @@ export class QueryLanguageTokenizer {
   /**
    * Determine if valid regex flag
    */
-  static #isValidRegexFlag(ch: number) {
+  static #isValidRegexFlag(ch: number): boolean {
     return ch === LOWER_I || ch === LOWER_G || ch === LOWER_M || ch === LOWER_S;
   }
 
   /**
    * Determine if valid token identifier
    */
-  static #isValidIdentToken(ch: number) {
+  static #isValidIdentToken(ch: number): boolean {
     return (ch >= ZERO && ch <= NINE) ||
       (ch >= UPPER_A && ch <= UPPER_Z) ||
       (ch >= LOWER_A && ch <= LOWER_Z) ||
       (ch === UNDERSCORE) ||
       (ch === DASH) ||
-      (ch === DOLLARSIGN) ||
+      (ch === DOLLAR_SIGN) ||
       (ch === PERIOD);
   }
 
   /**
    * Read string until quote
    */
-  static readString(text: string, pos: number) {
+  static readString(text: string, pos: number): number {
     const len = text.length;
     const ch = text.charCodeAt(pos);
     const q = ch;
@@ -130,10 +130,11 @@ export class QueryLanguageTokenizer {
    */
   static tokenize(text: string): Token[] {
     const state: TokenizeState = {
-      out: [] as Token[],
+      out: [],
       pos: 0,
       start: 0,
       text,
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       mode: undefined! as TokenType
     };
     const len = text.length;

package/src/internal/query/types.ts

@@ -33,15 +33,14 @@ export interface Token {
 /**
  * Base AST Node
  */
-export interface Node {
-  type: string;
+export interface Node<T extends string = string> {
+  type: T;
 }
 
 /**
  * Simple clause
  */
-export interface ClauseNode extends Node {
-  type: 'clause';
+export interface ClauseNode extends Node<'clause'> {
   field?: string;
   op?: string;
   value?: Literal | Literal[];
@@ -50,30 +49,29 @@ export interface ClauseNode extends Node {
 /**
  * Grouping
  */
-export interface GroupNode extends Node {
-  type: 'group';
+export interface GroupNode extends Node<'group'> {
   op?: 'and' | 'or';
-  value: Node[];
+  value: AllNode[];
 }
 
 /**
  * Unary node
  */
-export interface UnaryNode extends Node {
-  type: 'unary';
+export interface UnaryNode extends Node<'unary'> {
   op?: 'not';
-  value: Node;
+  value: AllNode;
 }
 
 /**
  * Array node
  */
-export interface ArrayNode extends Node {
-  type: 'list';
+export interface ArrayNode extends Node<'list'> {
   op?: 'not';
   value: Literal[];
 }
 
+export type AllNode = ArrayNode | UnaryNode | GroupNode | ClauseNode;
+
 /**
  * Translation of operators to model query keys
  */

package/src/internal/query/verifier.ts

@@ -51,7 +51,7 @@ class $QueryVerifier {
   /**
    * Handle generic clauses
    */
-  processGenericClause<T>(state: State, cls: Class<T>, val: object, handler: ProcessingHandler) {
+  processGenericClause<T>(state: State, cls: Class<T>, val: object, handler: ProcessingHandler): void {
     const view = SchemaRegistry.getViewSchema(cls);
 
     if (val === undefined || val === null) {
@@ -102,14 +102,14 @@ class $QueryVerifier {
   /**
    * Ensure types match
    */
-  typesMatch(declared: string, actual: string | undefined) {
+  typesMatch(declared: string, actual: string | undefined): boolean {
     return declared === actual;
   }
 
   /**
    * Check operator clause
    */
-  checkOperatorClause(state: State, declaredType: SimpleType, value: unknown, allowed: Record<string, Set<string>>, isArray: boolean) {
+  checkOperatorClause(state: State, declaredType: SimpleType, value: unknown, allowed: Record<string, Set<string>>, isArray: boolean): void {
     if (isArray) {
       if (Array.isArray(value)) {
         // Handle array literal
@@ -173,7 +173,7 @@ class $QueryVerifier {
   /**
    * Process where clause
    */
-  processWhereClause<T>(st: State, cls: Class<T>, passed: object) {
+  processWhereClause<T>(st: State, cls: Class<T>, passed: object): void {
     return this.processGenericClause(st, cls, passed, {
       preMember: (state: State, value: Record<string, unknown>) => {
         const keys = Object.keys(value);
@@ -215,14 +215,14 @@ class $QueryVerifier {
   /**
    * Handle group by clause
    */
-  processGroupByClause(state: State, value: object) {
+  processGroupByClause(state: State, value: object): void {
 
   }
 
   /**
    * Handle sort clause
    */
-  processSortClause<T>(st: State, cls: Class<T>, passed: object) {
+  processSortClause<T>(st: State, cls: Class<T>, passed: object): void {
     return this.processGenericClause(st, cls, passed, {
       onSimpleType: (state, type, value) => {
         if (value === 1 || value === -1 || typeof value === 'boolean') {
@@ -236,7 +236,7 @@ class $QueryVerifier {
   /**
    * Handle select clause
    */
-  processSelectClause<T>(st: State, cls: Class<T>, passed: object) {
+  processSelectClause<T>(st: State, cls: Class<T>, passed: object): void {
     return this.processGenericClause(st, cls, passed, {
       onSimpleType: (state, type, value) => {
         const actual = TypeUtil.getActualType(value);
@@ -269,32 +269,35 @@ class $QueryVerifier {
   /**
    * Verify the query
    */
-  verify<T>(cls: Class<T>, query: ModelQuery<T> | Query<T> | PageableModelQuery<T>) {
+  verify<T>(cls: Class<T>, query: ModelQuery<T> | Query<T> | PageableModelQuery<T>): void {
     const errors: ValidationError[] = [];
 
     const state = {
       path: '',
-      collect(path: string, message: string) {
+      collect(path: string, message: string): void {
         errors.push({ message: `${path}: ${message}`, path, kind: 'model' });
       },
-      log(err: string) {
+      log(err: string): void {
         this.collect(this.path, err);
       },
-      extend(sub: string) {
+      extend<S extends { path: string }>(this: S, sub: string): S {
         return { ...this, path: !this.path ? sub : `${this.path}.${sub}` };
       }
     };
 
     // Check all the clauses
     for (const [key, fn] of this.#mapping) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      const queryKey = key as keyof typeof query;
+
       if (!(key in query)
-        || query[key as keyof typeof query] === undefined
-        || query[key as keyof typeof query] === null
+        || query[queryKey] === undefined
+        || query[queryKey] === null
       ) {
         continue;
       }
 
-      const val = (query as Query<unknown>)[key];
+      const val = query[queryKey];
       const subState = state.extend(key);
 
       if (Array.isArray(val)) {
@@ -302,6 +305,7 @@ class $QueryVerifier {
           this[fn](subState, cls, el);
         }
       } else {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         this[fn](subState, cls, val as object);
       }
     }

package/src/internal/service/common.ts

@@ -13,6 +13,7 @@ export class ModelQuerySuggestSupportTarget { }
  * @param o
  */
 export function isQuerySupported(o: unknown): o is ModelQuerySupport {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return !!o && !!(o as Record<string, unknown>)['query'];
 }
 
@@ -21,6 +22,7 @@ export function isQuerySupported(o: unknown): o is ModelQuerySupport {
  * @param o
  */
 export function isQueryCrudSupported(o: unknown): o is ModelQueryCrudSupport {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return !!o && !!(o as Record<string, unknown>)['deleteByQuery'];
 }
 
@@ -29,6 +31,7 @@ export function isQueryCrudSupported(o: unknown): o is ModelQueryCrudSupport {
  * @param o
  */
 export function isQueryFacetSupported(o: unknown): o is ModelQueryFacetSupport {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return !!o && !!(o as Record<string, unknown>)['facet'];
 }
 
@@ -37,5 +40,6 @@ export function isQueryFacetSupported(o: unknown): o is ModelQueryFacetSupport {
  * @param o
  */
 export function isQuerySuggestSupported(o: unknown): o is ModelQuerySuggestSupport {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return !!o && !!(o as Record<string, unknown>)['suggest'];
 }

package/src/internal/service/expiry.ts

@@ -12,7 +12,7 @@ export class ModelQueryExpiryUtil {
   /**
    * Delete all expired
    */
-  static async deleteExpired<T extends ModelType>(svc: ModelQueryCrudSupport & ModelCrudSupport, cls: Class<T>) {
+  static async deleteExpired<T extends ModelType>(svc: ModelQueryCrudSupport & ModelCrudSupport, cls: Class<T>): Promise<number> {
     const expiry = await ModelRegistry.getExpiry(cls);
     const res = await svc.deleteByQuery<ModelType>(cls, {
       where: {

package/src/internal/service/query.ts

@@ -18,8 +18,9 @@ export class ModelQueryUtil {
    * @param val
    * @returns
    */
-  static resolveComparator(val: unknown) {
+  static resolveComparator(val: unknown): unknown {
     if (typeof val === 'string') {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       return Util.timeFromNow(val as '1m');
     } else {
       return val;
@@ -29,10 +30,10 @@ export class ModelQueryUtil {
   /**
    * Verify result set is singular, and decide if failing on many should happen
    */
-  static verifyGetSingleCounts<T>(cls: Class<T>, res?: T[], failOnMany = true) {
+  static verifyGetSingleCounts<T>(cls: Class<T>, res?: T[], failOnMany = true): T {
     res = res ?? [];
     if (res.length === 1 || res.length > 1 && !failOnMany) {
-      return res[0] as T;
+      return res[0]!;
     }
     throw res.length === 0 ? new NotFoundError(cls, 'none') : new AppError(`Invalid number of results for find by id: ${res.length}`, 'data');
   }
@@ -41,14 +42,16 @@ export class ModelQueryUtil {
    * Get a where clause with type
    */
   static getWhereClause<T extends ModelType>(cls: Class<T>, o: WhereClause<T> | string | undefined, checkExpiry = true): WhereClause<T> {
-    let q = o ? (typeof o === 'string' ? QueryLanguageParser.parseToQuery(o) as WhereClause<T> : o) : undefined;
-    const clauses = (q ? [q] : []) as WhereClauseRaw<T>[];
+    let q: WhereClause<T> | undefined = o ? (typeof o === 'string' ? QueryLanguageParser.parseToQuery(o) : o) : undefined;
+    const clauses: WhereClauseRaw<T>[] = (q ? [q] : []);
 
     const conf = ModelRegistry.get(cls);
     if (conf.subType) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       clauses.push({ type: SchemaRegistry.getSubTypeName(cls) } as WhereClauseRaw<T>);
     }
     if (checkExpiry && conf.expiresAt) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       clauses.push({
         $or: [
           { [conf.expiresAt]: { $exists: false } },
@@ -67,9 +70,12 @@ export class ModelQueryUtil {
   /**
    * Enrich query where clause, and verify query is correct
    */
-  static getQueryAndVerify<T extends ModelType, U extends Query<T> | ModelQuery<T>>(cls: Class<T>, query: U, checkExpiry = true) {
+  static getQueryAndVerify<T extends ModelType, U extends Query<T> | ModelQuery<T>>(
+    cls: Class<T>, query: U, checkExpiry = true
+  ): U & { where: WhereClause<T> } {
     query.where = this.getWhereClause(cls, query.where, checkExpiry);
     QueryVerifier.verify(cls, query);
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return query as U & { where: WhereClause<T> };
   }
 }

package/src/internal/service/suggest.ts

@@ -13,14 +13,14 @@ export class ModelQuerySuggestUtil {
   /**
    * Build regex for suggesting
    */
-  static getSuggestRegex(prefix?: string) {
+  static getSuggestRegex(prefix?: string): RegExp {
     return prefix ? new RegExp(`\\b${prefix}.*`, 'i') : /./;
   }
 
   /**
    * Build suggest query on top of query language
    */
-  static getSuggestQuery<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: Query<T>) {
+  static getSuggestQuery<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: Query<T>): Query<T> {
     const config = ModelRegistry.get(cls);
     const limit = query?.limit ?? 10;
     const clauses: WhereClauseRaw<ModelType>[] = prefix ? [{ [field]: { $regex: this.getSuggestRegex(prefix) } }] : [];
@@ -34,6 +34,7 @@ export class ModelQuerySuggestUtil {
     }
 
     if (query?.where) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       clauses.push(query.where! as WhereClauseRaw<ModelType>);
     }
 
@@ -41,15 +42,17 @@ export class ModelQuerySuggestUtil {
       where: clauses.length ? (clauses.length > 1 ? { $and: clauses } : clauses[0]) : {},
       limit,
       select: query?.select
-    } as Query<T>;
+    };
   }
 
   /**
    * Join suggestion results
    */
   static combineSuggestResults<T extends ModelType, U>(
-    cls: Class<T>, field: ValidStringFields<T>,
-    prefix: string = '', results: T[],
+    cls: Class<T>,
+    field: ValidStringFields<T>,
+    prefix: string = '',
+    results: T[],
     transform: (value: string, entity: T) => U,
     limit?: number
   ): U[] {
@@ -59,7 +62,8 @@ export class ModelQuerySuggestUtil {
     for (const r of results) {
       const val = r[field];
       if (Array.isArray(val)) {
-        out.push(...val.filter(f => pattern.test(f)).map(f => [f, transform(f, r)] as [string, U]));
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        out.push(...val.filter(f => pattern.test(f)).map((f: string) => [f, transform(f, r)] as [string, U]));
       } else if (typeof val === 'string') {
         out.push([val, transform(val, r)]);
       }
@@ -74,11 +78,12 @@ export class ModelQuerySuggestUtil {
   /**
    * Build suggestion query
    */
-  static getSuggestFieldQuery<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: PageableModelQuery<T>) {
+  static getSuggestFieldQuery<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: PageableModelQuery<T>): Query<T> {
     const config = ModelRegistry.get(cls);
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return this.getSuggestQuery<ModelType>(cls, field as ValidStringFields<ModelType>, prefix, {
       ...(query ?? {}),
       select: { [field]: true, ...(config.subType ? { type: true } : {}) }
-    });
+    }) as Query<T>;
   }
 }

package/src/internal/util/types.ts

@@ -3,14 +3,14 @@ import { Class } from '@travetto/base';
 
 import { PointImpl } from '../model/point';
 
-const st = (t: string | string[], arr: boolean = false) =>
+const st = (t: string | string[], arr: boolean = false): Set<string> =>
   new Set((Array.isArray(t) ? t : [t]).map(v => arr ? `${v}[]` : v));
 
-const basic = (types: Set<string>) => ({ $ne: types, $eq: types, $exists: st('boolean') });
-const scalar = (types: Set<string>) => ({ $in: types, $nin: types });
-const str = () => ({ $regex: st(['RegExp', 'string']) });
-const comp = (types: Set<string>) => ({ $lt: types, $lte: types, $gt: types, $gte: types });
-const geo = (type: string) => ({
+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 });
+const str = (): Record<string, Set<string>> => ({ $regex: st(['RegExp', 'string']) });
+const comp = (types: Set<string>): Record<string, Set<string>> => ({ $lt: types, $lte: types, $gt: types, $gte: types });
+const geo = (type: string): Record<string, Set<string>> => ({
   $near: st(type),
   $maxDistance: st('number'),
   $unit: st('string'),
@@ -26,11 +26,11 @@ export class TypeUtil {
    * Mapping types to various operators
    */
   static OPERATORS = {
-    string: { ...basic(st('string')), ...scalar(st('string', true)), ...str() } as Record<string, Set<string>>,
-    number: { ...basic(st('number')), ...scalar(st('number', true)), ...comp(st('number')) } as Record<string, Set<string>>,
-    boolean: { ...basic(st('boolean')), ...scalar(st('boolean', true)) } as Record<string, Set<string>>,
-    Date: { ...basic(st('Date')), ...scalar(st('Date', true)), ...comp(st(['string', 'Date'])) } as Record<string, Set<string>>,
-    Point: { ...basic(st('Point')), ...geo('Point') } as Record<string, Set<string>>,
+    string: { ...basic(st('string')), ...scalar(st('string', true)), ...str() },
+    number: { ...basic(st('number')), ...scalar(st('number', true)), ...comp(st('number')) },
+    boolean: { ...basic(st('boolean')), ...scalar(st('boolean', true)) },
+    Date: { ...basic(st('Date')), ...scalar(st('Date', true)), ...comp(st(['string', 'Date'])) },
+    Point: { ...basic(st('Point')), ...geo('Point') }
   };
 
   /**

package/src/model/where-clause.ts

@@ -86,7 +86,7 @@ export type WhereClause<T> = WhereClauseRaw<RetainFields<T>>;
  * Provides all the valid string type fields from a given type T
  */
 export type ValidStringFields<T> = {
-  [K in keyof T]:
+  [K in Extract<keyof T, string>]:
   (T[K] extends (String | string | string[] | String[] | undefined) ? K : never) // eslint-disable-line @typescript-eslint/ban-types
-}[keyof T];
+}[Extract<keyof T, string>];