@travetto/model-query 5.0.0-rc.7 → 5.0.0-rc.9

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.  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.
 
 ## Contracts
 
@@ -208,33 +208,6 @@ export class UserSearch {
 
 This would find all users who are over `35` and that have the `contact` field specified.
 
-## Query Language
-In addition to the standard query interface, the module also supports querying by query language to facilitate end - user queries.This is meant to act as an interface that is simpler to write than the default object structure. The language itself is fairly simple, boolean logic, with parenthetical support.The operators supported are:
-   *  `<`, `<=` - Less than, and less than or equal to
-   *  `>`, `>=` - Greater than, and greater than or equal to
-   *  `!=`, `==` - Not equal to, and equal to
-   *  `~` - Matches regular expression, supports the `i` flag to trigger case insensitive searches
-   *  `!`, `not` - Negates a clause
-   *  `in`, `not-in` - Supports checking if a field is in a list of literal values
-   *  `and`, `&&` - Intersection of clauses
-   *  `or`, `||` - Union of clauses
-All sub fields are dot separated for access, e.g. `user.address.city`.A query language version of the previous query could look like:
-
-**Code: Query language with boolean checks and exists check**
-```sql
-not (age < 35) and contact != null
-```
-
-A more complex query would look like:
-
-**Code: Query language with more complex needs**
-```sql
-user.role in ['admin', 'root'] && (user.address.state == 'VA' || user.address.city == 'Springfield')
-```
-
-### Regular Expression
-When querying with regular expressions, patterns can be specified as `'strings'` or as `/patterns/`.  The latter allows for the case insensitive modifier: `/pattern/i`.  Supporting the insensitive flag is up to the underlying model implementation.
-
 ## Custom Model Query Service
 In addition to the provided contracts, the module also provides common utilities and shared test suites.The common utilities are useful for repetitive functionality, that is unable to be shared due to not relying upon inheritance(this was an intentional design decision).This allows for all the [Data Model Querying](https://github.com/travetto/travetto/tree/main/module/model-query#readme "Datastore abstraction for advanced query support.") implementations to completely own the functionality and also to be able to provide additional / unique functionality that goes beyond the interface. To enforce that these contracts are honored, the module provides shared test suites to allow for custom implementations to ensure they are adhering to the contract's expected behavior.
 

package/__index__.ts

@@ -3,4 +3,5 @@ export * from './src/model/where-clause';
 export * from './src/service/crud';
 export * from './src/service/query';
 export * from './src/service/facet';
-export * from './src/service/suggest';
+export * from './src/service/suggest';
+export * from './src/verifier';

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "@travetto/model-query",
-  "version": "5.0.0-rc.7",
+  "version": "5.0.0-rc.9",
   "description": "Datastore abstraction for advanced query support.",
   "keywords": [
     "datastore",
     "decorators",
     "schema",
     "typescript",
-    "travetto",
-    "query-language"
+    "travetto"
   ],
   "homepage": "https://travetto.io",
   "license": "MIT",
@@ -27,12 +26,12 @@
     "directory": "module/model-query"
   },
   "dependencies": {
-    "@travetto/di": "^5.0.0-rc.7",
-    "@travetto/model": "^5.0.0-rc.7",
-    "@travetto/schema": "^5.0.0-rc.7"
+    "@travetto/di": "^5.0.0-rc.9",
+    "@travetto/model": "^5.0.0-rc.9",
+    "@travetto/schema": "^5.0.0-rc.9"
   },
   "peerDependencies": {
-    "@travetto/test": "^5.0.0-rc.7"
+    "@travetto/test": "^5.0.0-rc.9"
   },
   "peerDependenciesMeta": {
     "@travetto/test": {

package/src/internal/service/common.ts

@@ -13,8 +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'];
+  return !!o && typeof o === 'object' && 'query' in o && !!o.query;
 }
 
 /**
@@ -22,8 +21,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'];
+  return !!o && typeof o === 'object' && 'deleteByQuery' in o && !!o.deleteByQuery;
 }
 
 /**
@@ -31,8 +29,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'];
+  return !!o && typeof o === 'object' && 'facet' in o && !!o.facet;
 }
 
 /**
@@ -40,6 +37,5 @@ 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'];
+  return !!o && typeof o === 'object' && 'suggest' in o && !!o.suggest;
 }

package/src/internal/service/query.ts

@@ -1,12 +1,9 @@
-import { Class, AppError, TimeUtil } from '@travetto/runtime';
+import { Class, AppError, TimeUtil, castTo } from '@travetto/runtime';
 import { ModelRegistry, NotFoundError } from '@travetto/model';
 import { ModelType } from '@travetto/model/src/types/model';
 import { SchemaRegistry } from '@travetto/schema';
 
-import { ModelQuery, Query } from '../../model/query';
 import { WhereClause, WhereClauseRaw } from '../../model/where-clause';
-import { QueryLanguageParser } from '../query/parser';
-import { QueryVerifier } from '../query/verifier';
 
 /**
  * Common model utils, that should be usable by end users
@@ -40,24 +37,21 @@ 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: WhereClause<T> | undefined = o ? (typeof o === 'string' ? QueryLanguageParser.parseToQuery(o) : o) : undefined;
+  static getWhereClause<T extends ModelType>(cls: Class<T>, q: WhereClause<T> | undefined, checkExpiry = true): WhereClause<T> {
     const clauses: WhereClauseRaw<T>[] = (q ? [q] : []);
 
     const conf = ModelRegistry.get(cls);
     if (conf.subType) {
       const { subTypeField, subTypeName } = SchemaRegistry.get(cls);
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      clauses.push({ [subTypeField]: subTypeName } as WhereClauseRaw<T>);
+      clauses.push(castTo({ [subTypeField]: subTypeName }));
     }
     if (checkExpiry && conf.expiresAt) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      clauses.push({
+      clauses.push(castTo({
         $or: [
           { [conf.expiresAt]: { $exists: false } },
           { [conf.expiresAt]: { $gte: new Date() } },
         ]
-      } as WhereClauseRaw<T>);
+      }));
     }
     if (clauses.length > 1) {
       q = { $and: clauses };
@@ -67,30 +61,10 @@ export class ModelQueryUtil {
     return q!;
   }
 
-  /**
-   * 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
-  ): 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> };
-  }
-
-  /**
-   * Get query with an id enforced
-   */
-  static getQueryWithId<T extends ModelType, U extends Query<T> | ModelQuery<T>>(
-    cls: Class<T>,
-    item: T,
-    query: U
-  ): U & { where: WhereClause<T> & { id: string } } {
-    query.where = this.getWhereClause(cls, query.where);
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    (query.where as WhereClauseRaw<ModelType>).id = item.id;
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return query as U & { where: WhereClause<T> & { id: string } };
-  }
+  static has$And = (o: unknown): o is ({ $and: WhereClause<unknown>[] }) =>
+    !!o && typeof o === 'object' && '$and' in o;
+  static has$Or = (o: unknown): o is ({ $or: WhereClause<unknown>[] }) =>
+    !!o && typeof o === 'object' && '$or' in o;
+  static has$Not = (o: unknown): o is ({ $not: WhereClause<unknown> }) =>
+    !!o && typeof o === 'object' && '$not' in o;
 }

package/src/internal/service/suggest.ts

@@ -1,5 +1,5 @@
 import { ModelRegistry, ModelType } from '@travetto/model';
-import { Class } from '@travetto/runtime';
+import { castTo, Class } from '@travetto/runtime';
 import { SchemaRegistry } from '@travetto/schema';
 
 import { PageableModelQuery, Query } from '../../model/query';
@@ -35,8 +35,7 @@ export class ModelQuerySuggestUtil {
     }
 
     if (query?.where) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      clauses.push(query.where! as WhereClauseRaw<ModelType>);
+      clauses.push(query.where);
     }
 
     return {
@@ -59,12 +58,11 @@ export class ModelQuerySuggestUtil {
   ): U[] {
     const pattern = this.getSuggestRegex(prefix);
 
-    const out: [string, U][] = [];
+    const out: ([string, U] | readonly [string, U])[] = [];
     for (const r of results) {
       const val = r[field];
       if (Array.isArray(val)) {
-        // 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]));
+        out.push(...val.filter(f => pattern.test(f)).map((f: string) => [f, transform(f, r)] as const));
       } else if (typeof val === 'string') {
         out.push([val, transform(val, r)]);
       }
@@ -81,10 +79,9 @@ export class ModelQuerySuggestUtil {
    */
   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, {
+    return this.getSuggestQuery<T>(cls, castTo(field), prefix, {
       ...(query ?? {}),
-      select: { [field]: true, ...(config.subType ? { [SchemaRegistry.get(cls).subTypeField]: true } : {}) }
-    }) as Query<T>;
+      select: castTo({ [field]: true, ...(config.subType ? { [SchemaRegistry.get(cls).subTypeField]: true } : {}) })
+    });
   }
 }

package/src/model/query.ts

@@ -22,7 +22,7 @@ type QueryOptionsRaw<T> = {
 
 type QueryMain<T> = {
   select?: SelectClauseRaw<T>;
-  where?: WhereClauseRaw<T> | string;
+  where?: WhereClauseRaw<T>;
   // TODO: Add grouping in later
   // group?: GroupClauseRaw<T>;
 };

package/src/model/where-clause.ts

@@ -87,5 +87,4 @@ export type WhereClause<T> = WhereClauseRaw<RetainFields<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>];
-
+}[Extract<keyof T, string>];

package/src/{internal/query/verifier.ts → verifier.ts}

@@ -1,9 +1,9 @@
 import { DataUtil, SchemaRegistry, ValidationResultError, ValidationError } from '@travetto/schema';
 import { Class } from '@travetto/runtime';
 
-import { ModelQuery, Query, PageableModelQuery } from '../../model/query';
+import { ModelQuery, Query, PageableModelQuery } from './model/query';
 
-import { TypeUtil } from '../util/types';
+import { TypeUtil } from './internal/util/types';
 
 
 type SimpleType = keyof typeof TypeUtil.OPERATORS;
@@ -269,7 +269,11 @@ export class QueryVerifier {
   /**
    * Verify the query
    */
-  static verify<T>(cls: Class<T>, query: ModelQuery<T> | Query<T> | PageableModelQuery<T>): void {
+  static verify<T>(cls: Class<T>, query?: ModelQuery<T> | Query<T> | PageableModelQuery<T>): void {
+    if (!query) {
+      return;
+    }
+
     const errors: ValidationError[] = [];
 
     const state = {
@@ -287,26 +291,26 @@ export class QueryVerifier {
 
     // 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 === 'sort') {
+        continue;
+      }
 
       if (!(key in query)
-        || query[queryKey] === undefined
-        || query[queryKey] === null
+        || query[key] === undefined
+        || query[key] === null
       ) {
         continue;
       }
 
-      const val = query[queryKey];
+      const val = query[key];
       const subState = state.extend(key);
 
       if (Array.isArray(val)) {
         for (const el of val) {
           this[fn](subState, cls, el);
         }
-      } else {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        this[fn](subState, cls, val as object);
+      } else if (typeof val !== 'string') {
+        this[fn](subState, cls, val);
       }
     }
 

package/support/test/crud.ts

@@ -111,7 +111,7 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
 
     assert(await svc.queryCount(Person, {}) === 3);
 
-    const c2 = await svc.deleteByQuery(Person, { where: 'age <= 3' });
+    const c2 = await svc.deleteByQuery(Person, { where: { age: { $lte: 3 } } });
 
     assert(c2 === 3);
 
@@ -135,7 +135,7 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
 
     assert(count === 5);
 
-    assert(await svc.queryCount(Person, { where: 'gender == "m"' }) === 5);
+    assert(await svc.queryCount(Person, { where: { gender: 'm' } }) === 5);
 
     const c = await svc.updateByQuery(Person, { where: { age: { $gt: 3 } } }, { gender: 'f' });
 
@@ -145,12 +145,12 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
 
     assert(await svc.queryCount(Person, { where: { gender: 'm' } }) === 3);
 
-    const c2 = await svc.updateByQuery(Person, { where: 'gender == "m"' }, { gender: 'f' });
+    const c2 = await svc.updateByQuery(Person, { where: { gender: 'm' } }, { gender: 'f' });
 
     assert(c2 === 3);
 
     assert(await svc.queryCount(Person, { where: { gender: 'f' } }) === 5);
-    assert(await svc.queryCount(Person, { where: 'gender == "m"' }) === 0);
+    assert(await svc.queryCount(Person, { where: { gender: 'm' } }) === 0);
 
   }
 }

package/support/test/facet.ts

@@ -7,11 +7,11 @@ import { Suite, Test } from '@travetto/test';
 import { Person } from './types';
 import { ModelQueryFacetSupport } from '../../src/service/facet';
 
-const pick = <T>(arr: T[]): T => arr[Math.trunc(Math.random() * arr.length)]!;
+const pick = <T>(arr: T[] | readonly T[]): T => arr[Math.trunc(Math.random() * arr.length)]!;
 
-const GENDERS = ['m', 'f'] as ['m', 'f'];
+const GENDERS = ['m', 'f'] as const;
 const FNAME = ['Bob', 'Tom', 'Sarah', 'Leo', 'Alice', 'Jennifer', 'Tommy', 'George', 'Paula', 'Sam'];
-const LNAME = ['Smith', 'Sampson', 'Thompson', 'Oscar', 'Washington', 'Jefferson', 'Samuels'];
+const LNAME = ['Smith', 'Sampson', 'Thompson', 'Oscar', 'Washington', 'Jefferson', 'Samuel'];
 const AGES = new Array(100).fill(0).map((x, i) => i + 10);
 
 @Suite()

package/support/test/polymorphism.ts

@@ -12,6 +12,7 @@ import { ModelQueryFacetSupport } from '../../src/service/facet';
 import { ModelQuerySuggestSupport } from '../../src/service/suggest';
 
 import { isQueryCrudSupported, isQueryFacetSupported, isQuerySuggestSupported } from '../../src/internal/service/common';
+import { castTo } from '@travetto/runtime';
 
 @Suite()
 export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<ModelQuerySupport & ModelCrudSupport> {
@@ -33,9 +34,9 @@ export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<ModelQu
     assert((await svc.query(Doctor, {})).length === 2);
     assert((await svc.query(Engineer, {})).length === 1);
 
-    assert(await svc.queryCount(Worker, { where: 'name == "bob"' }) === 1);
-    assert(await svc.queryCount(Doctor, { where: 'name == "bob"' }) === 1);
-    assert(await svc.queryCount(Engineer, { where: 'name == "bob"' }) === 0);
+    assert(await svc.queryCount(Worker, { where: { name: 'bob' } }) === 1);
+    assert(await svc.queryCount(Doctor, { where: { name: 'bob' } }) === 1);
+    assert(await svc.queryCount(Engineer, { where: { name: 'bob' } }) === 0);
 
     assert((await svc.queryOne(Worker, { where: { name: 'bob' } })) instanceof Doctor);
     await assert.rejects(() => svc.queryOne(Firefighter, { where: { name: 'bob' } }), NotFoundError);
@@ -43,7 +44,7 @@ export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<ModelQu
 
   @Test({ skip: ModelQueryPolymorphismSuite.ifNot(isQueryCrudSupported) })
   async testCrudQuery() {
-    const svc = await this.service as unknown as ModelQueryCrudSupport & ModelQuerySupport;
+    const svc: ModelQueryCrudSupport & ModelQuerySupport = castTo(await this.service);
     const [doc, doc2, fire, eng] = [
       Doctor.from({ name: 'bob', specialty: 'feet' }),
       Doctor.from({ name: 'nob', specialty: 'eyes' }),
@@ -69,7 +70,7 @@ export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<ModelQu
 
   @Test({ skip: ModelQueryPolymorphismSuite.ifNot(isQuerySuggestSupported) })
   async testSuggestQuery() {
-    const svc = await this.service as unknown as ModelQuerySuggestSupport & ModelQuerySupport;
+    const svc: ModelQuerySuggestSupport & ModelQuerySupport = castTo(await this.service);
     const [doc, doc2, fire, eng] = [
       Doctor.from({ name: 'bob', specialty: 'eyes' }),
       Doctor.from({ name: 'nob', specialty: 'eyes' }),
@@ -93,7 +94,7 @@ export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<ModelQu
 
   @Test({ skip: ModelQueryPolymorphismSuite.ifNot(isQueryFacetSupported) })
   async testFacetQuery() {
-    const svc = await this.service as unknown as ModelQueryFacetSupport & ModelQuerySupport;
+    const svc: ModelQueryFacetSupport & ModelQuerySupport = castTo(await this.service);
     const [doc, doc2, fire, eng] = [
       Doctor.from({ name: 'bob', specialty: 'eyes' }),
       Doctor.from({ name: 'nob', specialty: 'eyes' }),

package/support/test/query.ts

@@ -18,7 +18,7 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
   async testWordBoundary() {
     const service = await this.service;
     await this.saveAll(Person, [1, 2, 3, 8].map(x => Person.from({
-      name: 'Bob Ombo',
+      name: 'Bob Omber',
       age: 20 + x,
       gender: 'm',
       address: {
@@ -27,13 +27,13 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
       }
     })));
 
-    const results = await service.query(Person, { where: 'name ~ /\\bomb.*/i' });
+    const results = await service.query(Person, { where: { name: { $regex: /\bomb.*/i } } });
     assert(results.length === 4);
 
-    const results2 = await service.query(Person, { where: 'name ~ /\\bmbo.*/i' });
+    const results2 = await service.query(Person, { where: { name: { $regex: /\bmbo.*/i } } });
     assert(results2.length === 0);
 
-    const results3 = await service.query(Person, { where: 'name ~ /\\bomb.*/' });
+    const results3 = await service.query(Person, { where: { name: { $regex: /\bomb.*/ } } });
     assert(results3.length === 0);
   }
 

package/src/internal/query/parser.ts

@@ -1,210 +0,0 @@
-import { WhereClauseRaw } from '../../model/where-clause';
-import { QueryLanguageTokenizer } from './tokenizer';
-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';
-}
-
-/**
- * Language parser
- */
-export class QueryLanguageParser {
-
-  /**
-   * Handle all clauses
-   */
-  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
-    if (val.type !== 'literal' && val.type !== 'list') {
-      throw new Error(`Unexpected token: ${val.value}`);
-    }
-
-    // If operator is not an operator, bail
-    if (op.type !== 'operator') {
-      throw new Error(`Unexpected token: ${op.value}`);
-    }
-
-    // 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}`);
-    }
-
-    nodes.push({
-      type: 'clause',
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      field: ident.value as string,
-      op: finalOp,
-      value: val.value
-    });
-
-    // Handle unary support
-    this.unary(nodes);
-    // Simplify as we go along
-    this.condense(nodes, 'and');
-  }
-
-  /**
-   * Condense nodes to remove unnecessary groupings
-   * (a AND (b AND (c AND d))) => (a AND b AND c)
-   */
-  static condense(nodes: (AllNode | Token)[], op: 'and' | 'or'): void {
-    let second = nodes[nodes.length - 2];
-
-    while (isBoolean(second) && second.value === op) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const right = nodes.pop()! as AllNode;
-      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);
-        nodes.push(rg);
-      } else {
-        nodes.push({
-          type: 'group',
-          op,
-          value: [left, right]
-        });
-      }
-      second = nodes[nodes.length - 2];
-    }
-  }
-
-  /**
-   * Remove unnecessary unary nodes
-   * (((5))) => 5
-   */
-  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') {
-      // 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
-      });
-    }
-  }
-
-  /**
-   * Parse all tokens
-   */
-  static parse(tokens: Token[], pos: number = 0): AllNode {
-
-    let top: (AllNode | Token)[] = [];
-    const stack: (typeof top)[] = [top];
-    let arr: Literal[] | undefined;
-
-    let token = tokens[pos];
-    while (token) {
-      switch (token.type) {
-        case 'grouping':
-          if (token.value === 'start') {
-            stack.push(top = []);
-          } else {
-            const group = stack.pop()!;
-            top = stack[stack.length - 1];
-            this.condense(group, 'or');
-            top.push(group[0]);
-            this.unary(top);
-            this.condense(top, 'and');
-          }
-          break;
-        case 'array':
-          if (token.value === 'start') {
-            arr = [];
-          } else {
-            const arrNode: ArrayNode = { type: 'list', value: arr! };
-            top.push(arrNode);
-            arr = undefined;
-            this.handleClause(top);
-          }
-          break;
-        case 'literal':
-          if (arr !== undefined) {
-            arr.push(token.value);
-          } else {
-            top.push(token);
-            this.handleClause(top);
-          }
-          break;
-        case 'punctuation':
-          if (!arr) {
-            throw new Error(`Invalid token: ${token.value}`);
-          }
-          break;
-        default:
-          top.push(token);
-      }
-      token = tokens[++pos];
-    }
-
-    this.condense(top, 'or');
-
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return top[0] as AllNode;
-  }
-
-  /**
-   * Convert Query AST to output
-   */
-  static convert<T = unknown>(node: AllNode): WhereClauseRaw<T> {
-    switch (node.type) {
-      case 'unary': {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        return { [`$${node.op!}`]: this.convert(node.value) } as WhereClauseRaw<T>;
-      }
-      case 'group': {
-        // 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 parts = node.field!.split('.');
-        const top: WhereClauseRaw<T> = {};
-        let sub: Record<string, unknown> = top;
-        for (const p of parts) {
-          sub = sub[p] = {};
-        }
-        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[node.op!] = node.value;
-        }
-        return top;
-      }
-      default: throw new Error(`Unexpected node type: ${node.type}`);
-    }
-  }
-
-  /**
-   * Tokenize and parse text
-   */
-  static parseToQuery<T = unknown>(text: string): WhereClauseRaw<T> {
-    const tokens = QueryLanguageTokenizer.tokenize(text);
-    const node = this.parse(tokens);
-    return this.convert(node);
-  }
-}

package/src/internal/query/tokenizer.ts

@@ -1,187 +0,0 @@
-import { TimeUtil } from '@travetto/runtime';
-import { Token, TokenizeState, TokenType } from './types';
-
-const OPEN_PARENS = 0x28, CLOSE_PARENS = 0x29, OPEN_BRACKET = 0x5b, CLOSE_BRACKET = 0x5d, COMMA = 0x2c;
-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, 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;
-
-const ESCAPE: Record<string, string> = {
-  '\\n': '\n',
-  '\\r': '\r',
-  '\\t': '\t',
-  '\\"': '"',
-  "\\'": "'"
-};
-
-/**
- * Mapping of keywords to node types and values
- */
-const TOKEN_MAPPING: Record<string, Token> = {
-  and: { type: 'boolean', value: 'and' },
-  '&&': { type: 'boolean', value: 'and' },
-  or: { type: 'boolean', value: 'or' },
-  '||': { type: 'boolean', value: 'or' },
-  in: { type: 'operator', value: 'in' },
-  ['not-in']: { type: 'operator', value: 'not-in' },
-  not: { type: 'unary', value: 'not' },
-  '[': { type: 'array', value: 'start' },
-  ']': { type: 'array', value: 'end' },
-  '(': { type: 'grouping', value: 'start' },
-  ')': { type: 'grouping', value: 'end' },
-  null: { type: 'literal', value: null },
-  true: { type: 'literal', value: true },
-  false: { type: 'literal', value: false },
-};
-
-/**
- * Tokenizer for the query language
- */
-export class QueryLanguageTokenizer {
-
-  /**
-   * Process the next token.  Can specify expected type as needed
-   */
-  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;
-    if (!res && state.mode === 'literal') {
-      if (/^["']/.test(text)) {
-        value = text.substring(1, text.length - 1)
-          .replace(/\\[.]/g, (a, b) => ESCAPE[a] || b);
-      } else if (/^\//.test(text)) {
-        const start = 1;
-        const end = text.lastIndexOf('/');
-        value = new RegExp(text.substring(start, end), text.substring(end + 1));
-      } else if (/^-?\d+$/.test(text)) {
-        value = parseInt(text, 10);
-      } else if (/^-?\d+[.]\d+$/.test(text)) {
-        value = parseFloat(text);
-      } else if (TimeUtil.isTimeSpan(text)) {
-        value = text;
-      } else {
-        state.mode = 'identifier';
-      }
-    }
-    return res ?? { value, type: state.mode || mode };
-  }
-
-  /**
-   * Flush state to output
-   */
-  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));
-      }
-      state.start = state.pos;
-    }
-    state.mode = mode || state.mode;
-  }
-
-  /**
-   * Determine if valid regex flag
-   */
-  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): boolean {
-    return (ch >= ZERO && ch <= NINE) ||
-      (ch >= UPPER_A && ch <= UPPER_Z) ||
-      (ch >= LOWER_A && ch <= LOWER_Z) ||
-      (ch === UNDERSCORE) ||
-      (ch === DASH) ||
-      (ch === DOLLAR_SIGN) ||
-      (ch === PERIOD);
-  }
-
-  /**
-   * Read string until quote
-   */
-  static readString(text: string, pos: number): number {
-    const len = text.length;
-    const ch = text.charCodeAt(pos);
-    const q = ch;
-    pos += 1;
-    while (pos < len) {
-      if (text.charCodeAt(pos) === q) {
-        break;
-      } else if (text.charCodeAt(pos) === BACKSLASH) {
-        pos += 1;
-      }
-      pos += 1;
-    }
-    if (pos === len && text.charCodeAt(pos) !== q) {
-      throw new Error('Unterminated string literal');
-    }
-    return pos;
-  }
-
-  /**
-   * Tokenize a text string
-   */
-  static tokenize(text: string): Token[] {
-    const state: TokenizeState = {
-      out: [],
-      pos: 0,
-      start: 0,
-      text,
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      mode: undefined! as TokenType
-    };
-    const len = text.length;
-    // Loop through each char
-    while (state.pos < len) {
-      // Read code as a number, more efficient
-      const ch = text.charCodeAt(state.pos);
-      switch (ch) {
-        // Handle punctuation
-        case OPEN_PARENS: case CLOSE_PARENS: case OPEN_BRACKET: case CLOSE_BRACKET: case COMMA:
-          this.#flush(state);
-          state.mode = 'punctuation';
-          break;
-        // Handle operator
-        case GREATER_THAN: case LESS_THAN: case EQUAL:
-        case MODULO: case NOT: case TILDE: case AND: case OR:
-          this.#flush(state, 'operator');
-          break;
-        // Handle whitespace
-        case SPACE: case TAB:
-          this.#flush(state, 'whitespace');
-          break;
-        // Handle quotes and slashes
-        case DBL_QUOTE: case SGL_QUOTE: case FORWARD_SLASH:
-          this.#flush(state);
-          state.mode = 'literal';
-          state.pos = this.readString(text, state.pos) + 1;
-          if (ch === FORWARD_SLASH) { // Read modifiers, not used by all, but useful in general
-            while (this.#isValidRegexFlag(text.charCodeAt(state.pos))) {
-              state.pos += 1;
-            }
-          }
-          this.#flush(state);
-          continue;
-        // Handle literal
-        default:
-          if (this.#isValidIdentToken(ch)) {
-            this.#flush(state, 'literal');
-          } else {
-            throw new Error(`Invalid character: ${text.substring(Math.max(0, state.pos - 10), state.pos + 1)}`);
-          }
-      }
-      state.pos += 1;
-    }
-
-    this.#flush(state);
-
-    return state.out;
-  }
-}

package/src/internal/query/types.ts

@@ -1,86 +0,0 @@
-/**
- * Supported token types
- */
-export type TokenType =
-  'literal' | 'identifier' | 'boolean' |
-  'operator' | 'grouping' | 'array' |
-  'whitespace' | 'punctuation' | 'unary';
-
-/**
- * Tokenization state
- */
-export interface TokenizeState {
-  out: Token[];
-  pos: number;
-  start: number;
-  text: string;
-  mode: TokenType;
-}
-
-/**
- * Literal types
- */
-export type Literal = boolean | null | string | number | RegExp | Date;
-
-/**
- * Token
- */
-export interface Token {
-  type: TokenType;
-  value: Literal;
-}
-
-/**
- * Base AST Node
- */
-export interface Node<T extends string = string> {
-  type: T;
-}
-
-/**
- * Simple clause
- */
-export interface ClauseNode extends Node<'clause'> {
-  field?: string;
-  op?: string;
-  value?: Literal | Literal[];
-}
-
-/**
- * Grouping
- */
-export interface GroupNode extends Node<'group'> {
-  op?: 'and' | 'or';
-  value: AllNode[];
-}
-
-/**
- * Unary node
- */
-export interface UnaryNode extends Node<'unary'> {
-  op?: 'not';
-  value: AllNode;
-}
-
-/**
- * Array node
- */
-export interface ArrayNode extends Node<'list'> {
-  op?: 'not';
-  value: Literal[];
-}
-
-export type AllNode = ArrayNode | UnaryNode | GroupNode | ClauseNode;
-
-/**
- * Translation of operators to model query keys
- */
-export const OP_TRANSLATION: Record<string, string> = {
-  '<': '$lt', '<=': '$lte',
-  '>': '$gt', '>=': '$gte',
-  '!=': '$ne', '==': '$eq',
-  '~': '$regex', '!': '$not',
-  in: '$in', 'not-in': '$nin'
-};
-
-export const VALID_OPS = new Set(Object.keys(OP_TRANSLATION));