@travetto/model-elasticsearch 8.0.0-alpha.2 → 8.0.0-alpha.21

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#L36) 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/src/types/indexed.ts#L11)
+   *  [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.2",
+  "version": "8.0.0-alpha.21",
   "type": "module",
   "description": "Elasticsearch backing for the travetto model module, with real-time modeling support for Elasticsearch mappings.",
   "keywords": [
@@ -28,13 +28,14 @@
     "directory": "module/model-elasticsearch"
   },
   "dependencies": {
-    "@elastic/elasticsearch": "^9.3.4",
-    "@travetto/config": "^8.0.0-alpha.2",
-    "@travetto/model": "^8.0.0-alpha.2",
-    "@travetto/model-query": "^8.0.0-alpha.2"
+    "@elastic/elasticsearch": "^9.4.2",
+    "@travetto/config": "^8.0.0-alpha.18",
+    "@travetto/model": "^8.0.0-alpha.19",
+    "@travetto/model-indexed": "^8.0.0-alpha.21",
+    "@travetto/model-query": "^8.0.0-alpha.20"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.3"
+    "@travetto/cli": "^8.0.0-alpha.24"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/index-manager.ts

@@ -3,6 +3,7 @@ import type * as estypes from '@elastic/elasticsearch/api/types';
 
 import { JSONUtil, type Class } from '@travetto/runtime';
 import { ModelRegistryIndex, type ModelType, type ModelStorageSupport } from '@travetto/model';
+import { warnIfIndexedUniqueIndex } from '@travetto/model-indexed';
 
 import type { ElasticsearchModelConfig } from './config.ts';
 import { ElasticsearchSchemaUtil } from './internal/schema.ts';
@@ -103,6 +104,8 @@ export class IndexManager implements ModelStorageSupport {
     const { index } = this.getIdentity(cls);
     const resolvedAlias = await this.#client.indices.getMapping({ index }).catch(() => undefined);
 
+    warnIfIndexedUniqueIndex(this, cls, ModelRegistryIndex.getIndices(cls));
+
     if (resolvedAlias) {
       const [currentIndex] = Object.keys(resolvedAlias ?? {});
       const pendingMapping = ElasticsearchSchemaUtil.generateSchemaMapping(cls, this.config.schemaConfig);
@@ -141,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

@@ -1,9 +1,10 @@
 import type * as estypes from '@elastic/elasticsearch/api/types';
 
-import { castTo, type Class, TypedObject } from '@travetto/runtime';
+import { type Any, castTo, type Class, TypedObject } from '@travetto/runtime';
 import { type WhereClause, type SelectClause, type SortClause, type Query, ModelQueryUtil } from '@travetto/model-query';
-import { type IndexConfig, type ModelType, ModelRegistryIndex } from '@travetto/model';
+import { type ModelType, ModelRegistryIndex } from '@travetto/model';
 import { DataUtil, SchemaRegistryIndex } from '@travetto/schema';
+import type { SortedIndex } from '@travetto/model-indexed';
 
 import { type EsSchemaConfig } from './types.ts';
 
@@ -13,7 +14,7 @@ import { type EsSchemaConfig } from './types.ts';
 export class ElasticsearchQueryUtil {
 
   /**
-   * Convert `a.b.c` to `a : { b : { c : ... }}`
+   * Convert `a : { b : { c : ... }}` to `a.b.c`
    */
   static extractSimple<T>(input: T, path: string = ''): Record<string, unknown> {
     const out: Record<string, unknown> = {};
@@ -51,13 +52,19 @@ export class ElasticsearchQueryUtil {
   /**
    * Build sort mechanism
    */
-  static getSort<T extends ModelType>(sort: SortClause<T>[] | IndexConfig<T>['fields']): estypes.Sort {
-    return sort.map<estypes.SortOptions>(option => {
-      const item = this.extractSimple(option);
-      const key = Object.keys(item)[0];
-      const value: boolean | -1 | 1 = castTo(item[key]);
-      return { [key]: { order: value === 1 || value === true ? 'asc' : 'desc' } };
-    });
+  static getSort<T extends ModelType>(sort: SortClause<T>[] | SortedIndex<T, Any, Any>): estypes.Sort {
+    if (Array.isArray(sort)) {
+      return sort.map<estypes.SortOptions>(option => {
+        const item = this.extractSimple(option);
+        const key = Object.keys(item)[0];
+        const value: boolean | -1 | 1 = castTo(item[key]);
+        return { [key]: { order: value === 1 || value === true ? 'asc' : 'desc' } };
+      });
+    } else {
+      return sort.sortTemplate.map<estypes.SortOptions>(field =>
+        ({ [field.path.join('.')]: { order: field.value === 1 ? 'asc' : 'desc' } })
+      );
+    }
   }
 
   /**
@@ -134,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`;
@@ -191,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/internal/schema.ts

@@ -7,8 +7,8 @@ import type { EsSchemaConfig } from './types.ts';
 
 const PointConcrete = toConcrete<Point>();
 
-const isMappingType = (input: estypes.MappingProperty): input is estypes.MappingTypeMapping =>
-  (input.type === 'object' || input.type === 'nested') && 'properties' in input && !!input.properties;
+const isMappingType = (input: estypes.MappingProperty): input is estypes.MappingTypeMapping & estypes.MappingProperty =>
+  !!input && !!input.type && (input.type === 'object' || input.type === 'nested');
 
 /**
  * Utils for ES Schema management
@@ -163,14 +163,20 @@ export class ElasticsearchSchemaUtil {
       const currentProperty = currentProperties[key];
       const neededProperty = neededProperties[key];
 
-      if (!currentProperty || !neededProperty || currentProperty.type !== neededProperty.type) {
-        changed.push(path);
+      if (isMappingType(currentProperty) && isMappingType(neededProperty)) {
+        if (currentProperty.type !== neededProperty.type) {
+          changed.push(path);
+        } else {
+          changed.push(...this.getChangedFields(
+            'properties' in currentProperty ? currentProperty : { properties: {} },
+            'properties' in neededProperty ? neededProperty : { properties: {} },
+            path
+          ));
+        }
       } else if (isMappingType(currentProperty) || isMappingType(neededProperty)) {
-        changed.push(...this.getChangedFields(
-          'properties' in currentProperty ? currentProperty : { properties: {} },
-          'properties' in neededProperty ? neededProperty : { properties: {} },
-          path
-        ));
+        changed.push(path);
+      } else if (!currentProperty || !neededProperty || currentProperty.type !== neededProperty.type) {
+        changed.push(path);
       }
     }
     return changed;

package/src/service.ts

@@ -3,19 +3,24 @@ import type * as estypes from '@elastic/elasticsearch/api/types';
 
 import {
   type ModelCrudSupport, type BulkOperation, type BulkResponse, type ModelBulkSupport, type ModelExpirySupport,
-  type ModelIndexedSupport, type ModelType, type ModelStorageSupport, NotFoundError, ModelRegistryIndex, type OptionalId,
-  ModelCrudUtil, ModelIndexedUtil, ModelStorageUtil, ModelExpiryUtil, ModelBulkUtil,
+  type ModelType, type ModelStorageSupport, NotFoundError, ModelRegistryIndex, type OptionalId,
+  ModelCrudUtil, ModelStorageUtil, ModelExpiryUtil, ModelBulkUtil,
+  type ModelListOptions
 } from '@travetto/model';
-import { ShutdownManager, type DeepPartial, type Class, castTo, asFull, TypedObject, asConstructable, JSONUtil } from '@travetto/runtime';
+import { ShutdownManager, type Class, castTo, asFull, TypedObject, asConstructable, JSONUtil } from '@travetto/runtime';
 import { BindUtil } from '@travetto/schema';
 import { Injectable, PostConstruct } from '@travetto/di';
 import {
-  type ModelQuery, type ModelQueryCrudSupport, type ModelQueryFacetSupport,
-  type ModelQuerySupport, type PageableModelQuery, type Query, type ValidStringFields,
-  QueryVerifier, type ModelQuerySuggestSupport,
-  ModelQueryUtil, ModelQuerySuggestUtil, ModelQueryCrudUtil,
-  type ModelQueryFacet,
+  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 ModelIndexedSearchOptions, type SortedIndexSelectionType
+} from '@travetto/model-indexed';
 
 import type { ElasticsearchModelConfig } from './config.ts';
 import type { EsBulkError } from './internal/types.ts';
@@ -48,6 +53,101 @@ export class ElasticsearchModelService implements
 
   constructor(config: ElasticsearchModelConfig) { this.config = config; }
 
+  /**
+ * Convert _id to id
+ */
+  async #postLoad<T extends ModelType>(cls: Class<T>, input: estypes.SearchHit<T> | estypes.GetGetResult<T>): Promise<T> {
+    let item = {
+      ...(input._id ? { id: input._id } : {}),
+      ...input._source!,
+    };
+
+    item = await ModelCrudUtil.load(cls, item);
+
+    const { expiresAt } = ModelRegistryIndex.getConfig(cls);
+
+    if (expiresAt) {
+      const expiry = ModelExpiryUtil.getExpiryState(cls, item);
+      if (!expiry.expired) {
+        return item;
+      }
+      throw new NotFoundError(cls, item.id);
+    } else {
+      return item;
+    }
+  }
+
+  async * #scrollCollection<T extends ModelType>(
+    cls: Class<T>,
+    buildSearch: (offset?: estypes.SortResults) => estypes.SearchRequest,
+    options?: ModelPageOptions<estypes.SortResults> & ModelListOptions
+  ): AsyncIterable<{ items: T[], nextOffset?: estypes.SortResults | undefined }> {
+    const limit = options?.limit ?? Number.MAX_SAFE_INTEGER;
+    const batchSize = Math.min(limit, options?.batchSizeHint ?? 100);
+
+    let search: estypes.SearchResponse<T> = await this.execSearch<T>(cls, {
+      size: batchSize,
+      ...buildSearch(options?.offset),
+    });
+
+    let hits = search.hits.hits;
+    let produced = 0;
+
+    while (produced < limit && hits.length && !(options?.abort?.aborted)) {
+      hits = search.hits.hits;
+      produced += hits.length;
+      if (produced > limit) {
+        hits = hits.slice(0, limit - (produced - hits.length));
+      }
+      const items = await ModelCrudUtil.filterOutNotFound(
+        hits.map(hit => this.#postLoad(cls, hit))
+      );
+      const nextOffset = hits.at(-1)?.sort;
+      yield { items, nextOffset };
+      if (search._scroll_id) {
+        search = await this.client.scroll({ scroll_id: search._scroll_id });
+      } else if (nextOffset) {
+        search = await this.execSearch<T>(cls, {
+          size: batchSize,
+          ...buildSearch(nextOffset),
+        });
+      } else {
+        hits = [];
+      }
+    }
+    if (search._scroll_id) {
+      await this.client.clearScroll({ scroll_id: search._scroll_id }).catch(() => { });
+    }
+  }
+
+  async * #scrollIndex<T extends ModelType>(
+    cls: Class<T>,
+    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();
+    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()
   async initializeClient(this: ElasticsearchModelService): Promise<void> {
     this.client = new Client({
@@ -109,30 +209,6 @@ export class ElasticsearchModelService implements
     return item;
   }
 
-  /**
-   * Convert _id to id
-   */
-  async postLoad<T extends ModelType>(cls: Class<T>, input: estypes.SearchHit<T> | estypes.GetGetResult<T>): Promise<T> {
-    let item = {
-      ...(input._id ? { id: input._id } : {}),
-      ...input._source!,
-    };
-
-    item = await ModelCrudUtil.load(cls, item);
-
-    const { expiresAt } = ModelRegistryIndex.getConfig(cls);
-
-    if (expiresAt) {
-      const expiry = ModelExpiryUtil.getExpiryState(cls, item);
-      if (!expiry.expired) {
-        return item;
-      }
-      throw new NotFoundError(cls, item.id);
-    } else {
-      return item;
-    }
-  }
-
   createStorage(): Promise<void> { return this.manager.createStorage(); }
   deleteStorage(): Promise<void> { return this.manager.deleteStorage(); }
   upsertModel(cls: Class): Promise<void> { return this.manager.upsertModel(cls); }
@@ -143,7 +219,7 @@ export class ElasticsearchModelService implements
   async get<T extends ModelType>(cls: Class<T>, id: string): Promise<T> {
     try {
       const result = await this.client.get<T>({ ...this.manager.getIdentity(cls), id });
-      return this.postLoad(cls, result);
+      return this.#postLoad(cls, result);
     } catch {
       throw new NotFoundError(cls, id);
     }
@@ -246,27 +322,12 @@ export class ElasticsearchModelService implements
     return this.get(cls, id);
   }
 
-  async * list<T extends ModelType>(cls: Class<T>): AsyncIterable<T> {
-    let search: estypes.SearchResponse<T> = await this.execSearch<T>(cls, {
-      scroll: '2m',
-      size: 100,
-      query: ElasticsearchQueryUtil.getSearchQuery(cls, {})
-    });
-
-    while (search.hits.hits.length > 0) {
-      for (const hit of search.hits.hits) {
-        try {
-          yield this.postLoad(cls, hit);
-        } catch (error) {
-          if (!(error instanceof NotFoundError)) {
-            throw error;
-          }
-        }
-        search = await this.client.scroll({
-          scroll_id: search._scroll_id,
-          scroll: '2m'
-        });
-      }
+  async * list<T extends ModelType>(cls: Class<T>, options?: ModelListOptions): AsyncIterable<T[]> {
+    for await (const batch of this.#scrollCollection(cls, () => ({
+      query: ElasticsearchQueryUtil.getSearchQuery(cls, {}),
+      scroll: '2m'
+    }), options)) {
+      yield batch.items;
     }
   }
 
@@ -354,67 +415,129 @@ export class ElasticsearchModelService implements
   }
 
   // Indexed
-  async getByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<T> {
-    const { key } = ModelIndexedUtil.computeIndexKey(cls, idx, body);
+  async getByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    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,
-          ModelIndexedUtil.projectIndex(cls, idx, body))
+        ElasticsearchQueryUtil.extractWhereTermQuery(cls, projected)
       )
     });
     if (!result.hits.hits.length) {
-      throw new NotFoundError(`${cls.name}: ${idx}`, key);
+      throw new NotFoundError(`${cls.name}: ${idx.name}`, computed.getKey({ sort: true }));
     }
-    return this.postLoad(cls, result.hits.hits[0]);
+    return this.#postLoad(cls, result.hits.hits[0]);
+
   }
 
-  async deleteByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<void> {
-    const { key } = ModelIndexedUtil.computeIndexKey(cls, idx, body);
+  async deleteByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: FullKeyedIndexBody<T, K, S>): Promise<void> {
+    const computed = ModelIndexedComputedIndex.get(idx, body).validate({ sort: true });
     const result = await this.client.deleteByQuery({
       index: this.manager.getIdentity(cls).index,
       query: ElasticsearchQueryUtil.getSearchQuery(cls,
-        ElasticsearchQueryUtil.extractWhereTermQuery(cls,
-          ModelIndexedUtil.projectIndex(cls, idx, body))
+        ElasticsearchQueryUtil.extractWhereTermQuery(cls, computed.project({
+          sort: true,
+          includeId: true,
+          emptyValue: { $exists: true }
+        }))
       ),
       refresh: true
     });
-    if (result.deleted) {
-      return;
+    if (!result.deleted) {
+      throw new NotFoundError(`${cls.name}: ${idx}`, computed.getKey({ sort: true }));
     }
-    throw new NotFoundError(`${cls.name}: ${idx}`, key);
   }
 
-  async upsertByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: OptionalId<T>): Promise<T> {
+  upsertByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: OptionalId<T>): Promise<T> {
     return ModelIndexedUtil.naiveUpsert(this, cls, idx, body);
   }
 
-  async * listByIndex<T extends ModelType>(cls: Class<T>, idx: string, body?: DeepPartial<T>): AsyncIterable<T> {
-    const config = ModelRegistryIndex.getIndex(cls, idx, ['sorted', 'unsorted']);
-    let search = await this.execSearch<T>(cls, {
-      scroll: '2m',
-      size: 100,
-      query: ElasticsearchQueryUtil.getSearchQuery(cls,
-        ElasticsearchQueryUtil.extractWhereTermQuery(cls,
-          ModelIndexedUtil.projectIndex(cls, idx, body, { emptySortValue: { $exists: true } }))
-      ),
-      sort: ElasticsearchQueryUtil.getSort(config.fields)
-    });
+  updateByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: T): Promise<T> {
+    return ModelIndexedUtil.naiveUpdate(this, cls, idx, body);
+  }
 
-    while (search.hits.hits.length > 0) {
-      for (const hit of search.hits.hits) {
-        try {
-          yield this.postLoad(cls, hit);
-        } catch (error) {
-          if (!(error instanceof NotFoundError)) {
-            throw error;
-          }
-        }
-        search = await this.client.scroll({
-          scroll_id: search._scroll_id,
-          scroll: '2m'
-        });
-      }
+  async updatePartialByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: FullKeyedIndexWithPartialBody<T, K, S>): Promise<T> {
+    const item = await ModelCrudUtil.naivePartialUpdate(cls, () => this.getByIndex(cls, idx, castTo(body)), castTo(body));
+    return this.update(cls, item);
+  }
+
+  async pageByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(
+    cls: Class<T>,
+    idx: SortedIndex<T, K, S>,
+    body: KeyedIndexBody<T, K>,
+    options?: ModelPageOptions,
+  ): Promise<ModelPageResult<T>> {
+    const offset = options?.offset ? JSONUtil.fromBase64<estypes.SortResults>(options.offset) : undefined;
+    const items: T[] = [];
+    let lastNextOffset: estypes.SortResults | undefined;
+    for await (const { items: fetched, nextOffset } of this.#scrollIndex(cls, idx, body, { limit: 100, ...options, offset })) {
+      lastNextOffset = nextOffset;
+      items.push(...fetched);
+    }
+    return { items, nextOffset: lastNextOffset ? JSONUtil.toBase64(lastNextOffset) : undefined };
+  }
+
+  async * listByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(
+    cls: Class<T>,
+    idx: SortedIndex<T, K, S>,
+    body: KeyedIndexBody<T, K>,
+    options?: ModelListOptions
+  ): AsyncIterable<T[]> {
+    for await (const { items } of this.#scrollIndex(cls, idx, body, options)) {
+      yield items;
+    }
+  }
+
+  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
@@ -424,7 +547,7 @@ export class ElasticsearchModelService implements
     const search = ElasticsearchQueryUtil.getSearchObject(cls, query, this.config.schemaConfig);
     const results = await this.execSearch(cls, search);
     const shouldRemoveIds = query.select && 'id' in query.select && !query.select.id;
-    return Promise.all(results.hits.hits.map(hit => this.postLoad(cls, hit).then(item => {
+    return Promise.all(results.hits.hits.map(hit => this.#postLoad(cls, hit).then(item => {
       if (shouldRemoveIds) {
         delete castTo<OptionalId<T>>(item).id;
       }
@@ -520,17 +643,17 @@ 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);
     const search = ElasticsearchQueryUtil.getSearchObject(cls, resolvedQuery);
     const result = await this.execSearch(cls, search);
-    const all = await Promise.all(result.hits.hits.map(hit => this.postLoad(cls, hit)));
+    const all = await Promise.all(result.hits.hits.map(hit => this.#postLoad(cls, hit)));
     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, {
@@ -539,12 +662,12 @@ export class ElasticsearchModelService implements
     });
     const search = ElasticsearchQueryUtil.getSearchObject(cls, resolvedQuery);
     const result = await this.execSearch(cls, search);
-    const all = result.hits.hits.map(hit => castTo<T>(({ [field]: field === 'id' ? hit._id : hit._source![field] })));
+    const all = result.hits.hits.map(hit => castTo<T>((field === 'id' ? { id: hit._id } : hit._source)));
     return ModelQuerySuggestUtil.combineSuggestResults(cls, field, prefix, all, item => item, query && query.limit);
   }
 
   // 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);

package/support/service.elasticsearch.ts

@@ -1,6 +1,6 @@
 import type { ServiceDescriptor } from '@travetto/cli';
 
-const version = '9.2.4';
+const version = '9.2.8';
 
 const port = 9200;