@travetto/model-query 8.0.6 → 8.0.7

package/README.md

@@ -86,7 +86,7 @@ export interface ModelQueryFacetSupport extends ModelQuerySupport {
    * @param field The field to facet on
    * @param query Additional query filtering
    */
-  facetByQuery<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?: FacetModelQuery<T>): Promise<ModelQueryFacet[]>;
 }
 ```
 
@@ -108,7 +108,7 @@ export interface ModelQuerySuggestSupport extends ModelQuerySupport {
     cls: Class<T>,
     field: ValidStringFields<T>,
     prefix?: string,
-    query?: PageableModelQuery<T>
+    query?: SuggestModelQuery<T>
   ): Promise<T[]>;
   /**
    * Suggest distinct values for a given cls and a given field
@@ -122,7 +122,7 @@ export interface ModelQuerySuggestSupport extends ModelQuerySupport {
     cls: Class<T>,
     field: ValidStringFields<T>,
     prefix?: string,
-    query?: PageableModelQuery<T>
+    query?: SuggestModelQuery<T>
   ): Promise<string[]>;
 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-query",
-  "version": "8.0.6",
+  "version": "8.0.7",
   "description": "Datastore abstraction for advanced query support.",
   "keywords": [
     "datastore",

package/src/model/query.ts

@@ -37,6 +37,19 @@ export type Query<T> = QueryRaw<RetainQueryPrimitiveFields<T>>;
  * Query with support for pagination (limit, offset)
  */
 export type PageableModelQuery<T> = PageableModelQueryRaw<RetainQueryPrimitiveFields<T>>;
+/**
+ * Query with support for pagination and suggestion options
+ */
+export type SuggestModelQuery<T> = PageableModelQuery<T> & {
+  caseInsensitive?: boolean;
+};
+/**
+ * Query with support for faceting options
+ */
+export type FacetModelQuery<T> = ModelQuery<T> & {
+  limit?: number;
+  offset?: number;
+};
 /**
  * Standard query options (limit, offset)
  */

package/src/types/facet.ts

@@ -1,7 +1,7 @@
 import type { ModelType } from '@travetto/model';
 import type { Class } from '@travetto/runtime';
 
-import type { ModelQuery } from '../model/query.ts';
+import type { FacetModelQuery } from '../model/query.ts';
 import type { ValidStringFields } from '../model/where-clause.ts';
 import type { ModelQuerySupport } from './query.ts';
 
@@ -18,5 +18,5 @@ export interface ModelQueryFacetSupport extends ModelQuerySupport {
    * @param field The field to facet on
    * @param query Additional query filtering
    */
-  facetByQuery<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?: FacetModelQuery<T>): Promise<ModelQueryFacet[]>;
 }

package/src/types/suggest.ts

@@ -1,7 +1,7 @@
 import type { ModelType } from '@travetto/model';
 import type { Class } from '@travetto/runtime';
 
-import type { PageableModelQuery } from '../model/query.ts';
+import type { SuggestModelQuery } from '../model/query.ts';
 import type { ValidStringFields } from '../model/where-clause.ts';
 import type { ModelQuerySupport } from './query.ts';
 
@@ -22,7 +22,7 @@ export interface ModelQuerySuggestSupport extends ModelQuerySupport {
     cls: Class<T>,
     field: ValidStringFields<T>,
     prefix?: string,
-    query?: PageableModelQuery<T>
+    query?: SuggestModelQuery<T>
   ): Promise<T[]>;
   /**
    * Suggest distinct values for a given cls and a given field
@@ -36,6 +36,6 @@ export interface ModelQuerySuggestSupport extends ModelQuerySupport {
     cls: Class<T>,
     field: ValidStringFields<T>,
     prefix?: string,
-    query?: PageableModelQuery<T>
+    query?: SuggestModelQuery<T>
   ): Promise<string[]>;
 }

package/src/util/suggest.ts

@@ -2,7 +2,7 @@ import { ModelRegistryIndex, type ModelType } from '@travetto/model';
 import { type Class, castKey, castTo, hasFunction } from '@travetto/runtime';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
-import type { PageableModelQuery, Query } from '../model/query.ts';
+import type { Query, SuggestModelQuery } from '../model/query.ts';
 import type { ValidStringFields, WhereClauseRaw } from '../model/where-clause.ts';
 import type { ModelQuerySuggestSupport } from '../types/suggest.ts';
 
@@ -18,19 +18,25 @@ export class ModelQuerySuggestUtil {
   /**
    * Build regex for suggesting
    */
-  static getSuggestRegex(prefix?: string): RegExp {
-    return prefix ? new RegExp(`\\b${prefix}.*`, 'i') : /./;
+  static getSuggestRegex(prefix?: string, caseInsensitive = true): RegExp {
+    return prefix ? new RegExp(`\\b${prefix}.*`, caseInsensitive ? 'i' : undefined) : /./;
   }
 
   /**
    * Build suggest query on top of query language
    */
-  static getSuggestQuery<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: Query<T>): Query<T> {
+  static getSuggestQuery<T extends ModelType>(
+    cls: Class<T>,
+    field: ValidStringFields<T>,
+    prefix?: string,
+    query?: SuggestModelQuery<T>
+  ): Query<T> {
     const limit = query?.limit ?? 10;
+    const caseInsensitive = query?.caseInsensitive ?? true;
     const clauses: WhereClauseRaw<ModelType>[] = [];
     if (prefix) {
       const parts = `${field}`.split('.');
-      let o: WhereClauseRaw<ModelType> = { [parts.at(-1)!]: { $regex: this.getSuggestRegex(prefix) } };
+      let o: WhereClauseRaw<ModelType> = { [parts.at(-1)!]: { $regex: this.getSuggestRegex(prefix, caseInsensitive) } };
       for (let i = parts.length - 2; i >= 0; i -= 1) {
         o = { [parts[i]]: o };
       }
@@ -77,9 +83,11 @@ export class ModelQuerySuggestUtil {
     prefix: string = '',
     results: T[],
     transform: (value: string, entity: T) => U,
-    limit?: number
+    query?: SuggestModelQuery<T>
   ): U[] {
-    const pattern = this.getSuggestRegex(prefix);
+    const limit = query?.limit ?? 10;
+    const caseInsensitive = query?.caseInsensitive ?? true;
+    const pattern = this.getSuggestRegex(prefix, caseInsensitive);
 
     const out: ([string, U] | readonly [string, U])[] = [];
     const parts = `${field}`.split('.');
@@ -109,7 +117,7 @@ export class ModelQuerySuggestUtil {
     cls: Class<T>,
     field: ValidStringFields<T>,
     prefix?: string,
-    query?: PageableModelQuery<T>
+    query?: SuggestModelQuery<T>
   ): Query<T> {
     return this.getSuggestQuery<T>(cls, castTo(field), prefix, query);
   }

package/support/test/facet.ts

@@ -61,5 +61,18 @@ export abstract class ModelQueryFacetSuite extends BaseModelSuite<ModelQueryFace
 
     const nameFacet = await svc.facetByQuery(Person, 'name');
     assert(Object.keys(names).length === nameFacet.length);
+
+    const limitedResults = await svc.facetByQuery(Person, 'gender', { limit: 1 });
+    assert(limitedResults.length === 1);
+    assert(limitedResults[0].count === Math.max(genders.m, genders.f));
+
+    const offsetGender = await svc.facetByQuery(Person, 'gender', { limit: 1, offset: 1 });
+    assert(offsetGender.length === 1);
+    assert(offsetGender[0].count === Math.min(genders.m, genders.f));
+    assert(offsetGender[0].key !== limitedResults[0].key);
+
+    const topNames = await svc.facetByQuery(Person, 'name', { limit: 5 });
+    assert(topNames.length === Math.min(5, Object.keys(names).length));
+    assert(topNames[0].count >= (topNames[1]?.count ?? 0));
   }
 }

package/support/test/suggest.ts

@@ -68,6 +68,45 @@ export abstract class ModelQuerySuggestSuite extends BaseModelSuite<ModelQuerySu
     assert(suggested.length === 1);
   }
 
+  @Test('Verify case insensitivity option')
+  async testCaseSensitivity() {
+    const service = await this.service;
+
+    await this.#loadPeople();
+
+    // Default is case-insensitive
+    let suggested = await service.suggestValuesByQuery(Person, 'name', 'bo');
+    assert(suggested.length === 2);
+
+    // Explicitly case-insensitive
+    suggested = await service.suggestValuesByQuery(Person, 'name', 'bo', { caseInsensitive: true });
+    assert(suggested.length === 2);
+
+    // Case-sensitive mismatch
+    suggested = await service.suggestValuesByQuery(Person, 'name', 'bo', { caseInsensitive: false });
+    assert(suggested.length === 0);
+
+    // Case-sensitive match
+    suggested = await service.suggestValuesByQuery(Person, 'name', 'Bo', { caseInsensitive: false });
+    assert(suggested.length === 2);
+    assert(suggested[0] === 'Bo');
+    assert(suggested[1] === 'Bob');
+
+    // Case-sensitive entities mismatch
+    let suggestedEntities = await service.suggestByQuery(Person, 'name', 'bo', { caseInsensitive: false });
+    assert(suggestedEntities.length === 0);
+
+    // Case-sensitive entities match
+    suggestedEntities = await service.suggestByQuery(Person, 'name', 'Bo', { caseInsensitive: false });
+    assert(suggestedEntities.length === 2);
+    assert(suggestedEntities[0].name === 'Bo');
+    assert(suggestedEntities[1].name === 'Bob');
+
+    // Case-insensitive entities match
+    suggestedEntities = await service.suggestByQuery(Person, 'name', 'bo', { caseInsensitive: true });
+    assert(suggestedEntities.length === 2);
+  }
+
   @Test('Verify suggested entities')
   async verifyEntities() {
     const service = await this.service;
@@ -98,6 +137,14 @@ export abstract class ModelQuerySuggestSuite extends BaseModelSuite<ModelQuerySu
     assert(suggestedEntities.length === 1);
     assert(suggestedEntities[0] instanceof WithNestedLists);
     assert(suggestedEntities[0].tags?.includes('apple'));
+
+    // Case-sensitive mismatch on array
+    const caseSensitiveValues = await service.suggestValuesByQuery(WithNestedLists, 'tags', 'AP', { caseInsensitive: false });
+    assert(caseSensitiveValues.length === 0);
+
+    // Case-insensitive match on array
+    const caseInsensitiveValues = await service.suggestValuesByQuery(WithNestedLists, 'tags', 'AP', { caseInsensitive: true });
+    assert(caseInsensitiveValues.length === 2);
   }
 
   @Test('Verify suggestion on nested string arrays')