@travetto/model-elasticsearch 8.0.0-alpha.16 → 8.0.0-alpha.17

package/README.md

@@ -13,13 +13,13 @@ npm install @travetto/model-elasticsearch
 yarn add @travetto/model-elasticsearch
 ```
 
-This module provides an [elasticsearch](https://elastic.co)-based implementation of the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.").  This source allows the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") module to read, write and query against [elasticsearch](https://elastic.co). In development mode, [ElasticsearchModelService](https://github.com/travetto/travetto/tree/main/module/model-elasticsearch/src/service.ts#L40) will also modify the [elasticsearch](https://elastic.co) schema in real time to minimize impact to development. 
+This module provides an [elasticsearch](https://elastic.co)-based implementation of the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.").  This source allows the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") module to read, write and query against [elasticsearch](https://elastic.co). In development mode, [ElasticsearchModelService](https://github.com/travetto/travetto/tree/main/module/model-elasticsearch/src/service.ts#L41) will also modify the [elasticsearch](https://elastic.co) schema in real time to minimize impact to development. 
 
 Supported features:
    *  [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/types/crud.ts#L11)
    *  [Bulk](https://github.com/travetto/travetto/tree/main/module/model/src/types/bulk.ts#L64)
    *  [Expiry](https://github.com/travetto/travetto/tree/main/module/model/src/types/expiry.ts#L10)
-   *  [Indexed](https://github.com/travetto/travetto/tree/main/module/model-indexed/src/types/service.ts#L15)
+   *  [Indexed](https://github.com/travetto/travetto/tree/main/module/model-indexed/src/types/service.ts#L16)
    *  [Query Crud](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/crud.ts#L11)
    *  [Facet](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/facet.ts#L14)
    *  [Query](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/query.ts#L10)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-elasticsearch",
-  "version": "8.0.0-alpha.16",
+  "version": "8.0.0-alpha.17",
   "type": "module",
   "description": "Elasticsearch backing for the travetto model module, with real-time modeling support for Elasticsearch mappings.",
   "keywords": [
@@ -29,13 +29,13 @@
   },
   "dependencies": {
     "@elastic/elasticsearch": "^9.3.4",
-    "@travetto/config": "^8.0.0-alpha.14",
-    "@travetto/model": "^8.0.0-alpha.14",
-    "@travetto/model-indexed": "^8.0.0-alpha.16",
-    "@travetto/model-query": "^8.0.0-alpha.15"
+    "@travetto/config": "^8.0.0-alpha.15",
+    "@travetto/model": "^8.0.0-alpha.15",
+    "@travetto/model-indexed": "^8.0.0-alpha.17",
+    "@travetto/model-query": "^8.0.0-alpha.16"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.19"
+    "@travetto/cli": "^8.0.0-alpha.20"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/index-manager.ts

@@ -144,8 +144,8 @@ export class IndexManager implements ModelStorageSupport {
 
   async deleteStorage(): Promise<void> {
     console.debug('Deleting storage', { idx: this.getNamespacedIndex('*') });
-    await this.#client.indices.delete({
-      index: this.getNamespacedIndex('*')
-    });
+    // await this.#client.indices.delete({
+    //   index: this.getNamespacedIndex('*')
+    // });
   }
 }

package/src/internal/query.ts

@@ -141,7 +141,13 @@ export class ElasticsearchQueryUtil {
             }
             case '$regex': {
               const pattern = DataUtil.toRegex(castTo(value));
-              if (pattern.source.startsWith('\\b') && pattern.source.endsWith('.*')) {
+              if (pattern.source.startsWith('^')) { // We have a prefix query
+                if (/^\^[A-Za-z0-9_\-]+/.test(pattern.source)) {
+                  items.push({ prefix: { [subPath]: pattern.source.substring(1) } });
+                } else {
+                  items.push({ regexp: { [subPath]: pattern.source.substring(1) } });
+                }
+              } else if (pattern.source.startsWith('\\b') && pattern.source.endsWith('.*') && declaredSchema.specifiers?.includes('text')) {
                 const textField = !pattern.flags.includes('i') && config && config.caseSensitive ?
                   `${subPath}.text_cs` :
                   `${subPath}.text`;
@@ -198,7 +204,7 @@ export class ElasticsearchQueryUtil {
     if (ModelQueryUtil.has$And(clause)) {
       return { bool: { must: clause.$and.map(item => this.extractWhereQuery<T>(cls, item, config)) } };
     } else if (ModelQueryUtil.has$Or(clause)) {
-      return { bool: { should: clause.$or.map(item => this.extractWhereQuery<T>(cls, item, config)), ['minimum_should_match']: 1 } };
+      return { bool: { should: clause.$or.map(item => this.extractWhereQuery<T>(cls, item, config)), minimum_should_match: 1 } };
     } else if (ModelQueryUtil.has$Not(clause)) {
       return { bool: { ['must_not']: this.extractWhereQuery<T>(cls, clause.$not, config) } };
     } else {

package/src/service.ts

@@ -14,11 +14,12 @@ import {
   type ModelQuery, type ModelQueryCrudSupport, type ModelQueryFacetSupport, type ModelQuerySupport, type PageableModelQuery,
   type Query, type ValidStringFields, QueryVerifier, type ModelQuerySuggestSupport, ModelQueryUtil, ModelQuerySuggestUtil,
   ModelQueryCrudUtil, type ModelQueryFacet,
+  type WhereClause,
 } from '@travetto/model-query';
 import {
   type ModelIndexedSupport, type KeyedIndexSelection, type KeyedIndexBody, type ModelPageOptions, ModelIndexedUtil,
   type SingleItemIndex, type SortedIndexSelection, type ModelPageResult, type SortedIndex, type FullKeyedIndexBody,
-  type FullKeyedIndexWithPartialBody, ModelIndexedComputedIndex
+  type FullKeyedIndexWithPartialBody, ModelIndexedComputedIndex, type ModelIndexedSearchOptions, type SortedIndexSelectionType
 } from '@travetto/model-indexed';
 
 import type { ElasticsearchModelConfig } from './config.ts';
@@ -119,27 +120,32 @@ export class ElasticsearchModelService implements
     }
   }
 
-  async * #scrollIndex<
-    T extends ModelType,
-    K extends KeyedIndexSelection<T>,
-    S extends SortedIndexSelection<T>
-  >(
+  async * #scrollIndex<T extends ModelType>(
     cls: Class<T>,
-    idx: SortedIndex<T, K, S>,
-    body: KeyedIndexBody<T, K>,
-    options?: ModelPageOptions<estypes.SortResults> & ModelListOptions
+    idx: SortedIndex<T>,
+    body: KeyedIndexBody<T>,
+    options?: ModelPageOptions<estypes.SortResults> & ModelListOptions,
+    transformWhere?: (where: WhereClause<T>) => WhereClause<T>
   ): AsyncIterable<{
     items: T[];
     nextOffset?: estypes.SortResults | undefined;
   }> {
     const computed = ModelIndexedComputedIndex.get(idx, body).validate();
-    yield* this.#scrollCollection(cls, (offset) => ({
-      query: ElasticsearchQueryUtil.getSearchQuery(cls,
-        ElasticsearchQueryUtil.extractWhereTermQuery(cls, computed.project())
-      ),
-      search_after: offset,
-      sort: ElasticsearchQueryUtil.getSort(idx)
-    }), options);
+    let whereClause: WhereClause<T> = castTo(computed.project());
+    if (transformWhere) {
+      whereClause = transformWhere(whereClause);
+    }
+
+    yield* this.#scrollCollection(cls, (offset) => {
+      const result = {
+        query: ElasticsearchQueryUtil.getSearchQuery(cls,
+          ElasticsearchQueryUtil.extractWhereQuery(cls, whereClause)
+        ),
+        ...(offset ? { search_after: offset } : {}),
+        sort: ElasticsearchQueryUtil.getSort(idx)
+      };
+      return result;
+    }, options);
   }
 
   @PostConstruct()
@@ -415,19 +421,19 @@ export class ElasticsearchModelService implements
     S extends SortedIndexSelection<T>
   >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: FullKeyedIndexBody<T, K, S>): Promise<T> {
     const computed = ModelIndexedComputedIndex.get(idx, body).validate({ sort: true });
+    const projected = computed.project({
+      sort: true,
+      includeId: true,
+      emptyValue: { $exists: true }
+    });
 
     const result = await this.execSearch<T>(cls, {
       query: ElasticsearchQueryUtil.getSearchQuery(cls,
-        ElasticsearchQueryUtil.extractWhereTermQuery(cls, computed.project({
-          sort: true,
-          includeId: true,
-          emptyValue: { $exists: true }
-        }))
-
+        ElasticsearchQueryUtil.extractWhereTermQuery(cls, projected)
       )
     });
     if (!result.hits.hits.length) {
-      throw new NotFoundError(`${cls.name}: ${idx}`, computed.getKey({ sort: true }));
+      throw new NotFoundError(`${cls.name}: ${idx.name}`, computed.getKey({ sort: true }));
     }
     return this.#postLoad(cls, result.hits.hits[0]);
 
@@ -515,6 +521,25 @@ export class ElasticsearchModelService implements
     }
   }
 
+  async suggestByIndex<
+    T extends ModelType,
+    S extends SortedIndexSelection<T>,
+    K extends KeyedIndexSelection<T>,
+    B extends SortedIndexSelectionType<T, S> & string
+  >(cls: Class<T>, idx: SortedIndex<T, K, S>, body: KeyedIndexBody<T, K>, prefix: B, options?: ModelIndexedSearchOptions): Promise<T[]> {
+    const items: T[] = [];
+    for await (const { items: fetched } of this.#scrollIndex(cls, idx, body, { limit: 10, ...options },
+      where => castTo({
+        $and: [where, {
+          [idx.sortTemplate[0].path.join('.')]: { $regex: ModelIndexedUtil.getSuggestRegex(prefix) }
+        }]
+      })
+    )) {
+      items.push(...fetched);
+    }
+    return items;
+  }
+
   // Query
   async query<T extends ModelType>(cls: Class<T>, query: PageableModelQuery<T>): Promise<T[]> {
     await QueryVerifier.verify(cls, query);
@@ -618,7 +643,7 @@ export class ElasticsearchModelService implements
   }
 
   // Query Facet
-  async suggest<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: PageableModelQuery<T>): Promise<T[]> {
+  async suggestByQuery<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: PageableModelQuery<T>): Promise<T[]> {
     await QueryVerifier.verify(cls, query);
 
     const resolvedQuery = ModelQuerySuggestUtil.getSuggestQuery<T>(cls, field, prefix, query);
@@ -628,7 +653,7 @@ export class ElasticsearchModelService implements
     return ModelQuerySuggestUtil.combineSuggestResults(cls, field, prefix, all, (_, value) => value, query && query.limit);
   }
 
-  async suggestValues<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: PageableModelQuery<T>): Promise<string[]> {
+  async suggestValuesByQuery<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: PageableModelQuery<T>): Promise<string[]> {
     await QueryVerifier.verify(cls, query);
 
     const resolvedQuery = ModelQuerySuggestUtil.getSuggestQuery<T>(cls, field, prefix, {
@@ -642,7 +667,7 @@ export class ElasticsearchModelService implements
   }
 
   // Facet
-  async facet<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, query?: ModelQuery<T>): Promise<ModelQueryFacet[]> {
+  async facetByQuery<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, query?: ModelQuery<T>): Promise<ModelQueryFacet[]> {
     await QueryVerifier.verify(cls, query);
 
     const resolvedSearch = ElasticsearchQueryUtil.getSearchObject(cls, query ?? {}, this.config.schemaConfig);