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

package/README.md

@@ -19,8 +19,8 @@ Supported features:
    *  [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/types/crud.ts#L11)
    *  [Expiry](https://github.com/travetto/travetto/tree/main/module/model/src/types/expiry.ts#L10)
    *  [Bulk](https://github.com/travetto/travetto/tree/main/module/model/src/types/bulk.ts#L64)
-   *  [Indexed](https://github.com/travetto/travetto/tree/main/module/model/src/types/indexed.ts#L11)
    *  [Blob](https://github.com/travetto/travetto/tree/main/module/model/src/types/blob.ts#L8)
+   *  [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-mongo",
-  "version": "8.0.0-alpha.2",
+  "version": "8.0.0-alpha.21",
   "type": "module",
   "description": "Mongo backing for the travetto model module.",
   "keywords": [
@@ -26,13 +26,14 @@
     "directory": "module/model-mongo"
   },
   "dependencies": {
-    "@travetto/config": "^8.0.0-alpha.2",
-    "@travetto/model": "^8.0.0-alpha.2",
-    "@travetto/model-query": "^8.0.0-alpha.2",
-    "mongodb": "^7.1.0"
+    "@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",
+    "mongodb": "^7.2.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.3"
+    "@travetto/cli": "^8.0.0-alpha.24"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/internal/util.ts

@@ -3,15 +3,14 @@ import {
   type IndexDescriptionInfo
 } from 'mongodb';
 
-import { RuntimeError, CodecUtil, castTo, type Class, toConcrete, TypedObject, BinaryUtil } from '@travetto/runtime';
-import { type DistanceUnit, type PageableModelQuery, type WhereClause, ModelQueryUtil } from '@travetto/model-query';
-import type { ModelType, IndexField, IndexConfig } from '@travetto/model';
+import { RuntimeError, CodecUtil, castTo, type Class, toConcrete, BinaryUtil } from '@travetto/runtime';
+import { type DistanceUnit, type PageableModelQuery, type WhereClause, isModelQueryIndex, ModelQueryUtil } from '@travetto/model-query';
+import { type ModelType, type IndexConfig, IndexNotSupported } from '@travetto/model';
 import { DataUtil, SchemaRegistryIndex, type Point } from '@travetto/schema';
+import { isModelIndexedIndex } from '@travetto/model-indexed';
 
 const PointConcrete = toConcrete<Point>();
 
-type IdxConfig = CreateIndexesOptions;
-
 /**
  * Converting units to various radians
  */
@@ -25,7 +24,19 @@ const RADIANS_TO: Record<DistanceUnit, number> = {
 
 export type WithId<T, I = unknown> = T & { _id?: I };
 export type BasicIdx = Record<string, IndexDirection>;
-export type PlainIdx = Record<string, -1 | 0 | 1>;
+
+function flattenKeys(obj: Record<string, unknown>, prefix = ''): Record<string, 1 | -1> {
+  const out: Record<string, 1 | -1> = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (typeof value === 'object' && value !== null) {
+      Object.assign(out, flattenKeys(castTo(value), path));
+    } else {
+      out[path] = typeof value === 'boolean' ? (value ? 1 : -1) : castTo<-1 | 1>(value);
+    }
+  }
+  return out;
+}
 
 /**
  * Basic mongo utils for conforming to the model module
@@ -36,19 +47,6 @@ export class MongoUtil {
     return `${cls.Ⲑid}__${name}`.replace(/[^a-zA-Z0-9_]+/g, '_');
   }
 
-  static toIndex<T extends ModelType>(field: IndexField<T>): PlainIdx {
-    const keys = [];
-    while (typeof field !== 'number' && typeof field !== 'boolean' && Object.keys(field)) {
-      const key = TypedObject.keys(field)[0];
-      field = castTo(field[key]);
-      keys.push(key);
-    }
-    const rf: number | boolean = castTo(field);
-    return {
-      [keys.join('.')]: typeof rf === 'boolean' ? (rf ? 1 : 0) : castTo<-1 | 1 | 0>(rf)
-    };
-  }
-
   static uuid(value: string): Binary {
     try {
       return new Binary(
@@ -166,8 +164,8 @@ export class MongoUtil {
     return out;
   }
 
-  static getExtraIndices<T extends ModelType>(cls: Class<T>): [BasicIdx, IdxConfig][] {
-    const out: [BasicIdx, IdxConfig][] = [];
+  static getExtraIndices<T extends ModelType>(cls: Class<T>): [BasicIdx, CreateIndexesOptions][] {
+    const out: [BasicIdx, CreateIndexesOptions][] = [];
     const textFields: string[] = [];
     SchemaRegistryIndex.visitFields(cls, (field, path) => {
       if (field.type === PointConcrete) {
@@ -185,19 +183,26 @@ export class MongoUtil {
     return out;
   }
 
-  static getPlainIndex(idx: IndexConfig<ModelType>): PlainIdx {
-    let out: PlainIdx = {};
-    for (const config of idx.fields.map(value => this.toIndex(value))) {
-      out = Object.assign(out, config);
-    }
-    return out;
-  }
+  static getIndex(cls: Class, idx: IndexConfig): [BasicIdx, CreateIndexesOptions] {
+    const name = this.namespaceIndex(cls, idx.name);
+    if (isModelQueryIndex(idx)) {
+      const out = idx.fields.reduce(
+        (acc, field) => ({ ...acc, ...flattenKeys(castTo(field)) }),
+        castTo<Record<string, -1 | 0 | 1>>({}));
 
-  static getIndices<T extends ModelType>(cls: Class<T>, indices: IndexConfig<ModelType>[] = []): [BasicIdx, IdxConfig][] {
-    return [
-      ...indices.map(idx => [this.getPlainIndex(idx), { ...(idx.type === 'unique' ? { unique: true } : {}), name: this.namespaceIndex(cls, idx.name) }] as const),
-      ...this.getExtraIndices(cls)
-    ].map(idx => [...idx]);
+      return [out, { name, unique: !!idx.unique }];
+    } else if (isModelIndexedIndex(idx)) {
+      const filter = Object.fromEntries([
+        ...idx.keyTemplate.map(({ path }) => [path.join('.'), 1]),
+        ...idx.sortTemplate.map(({ path, value }) => [path.join('.'), value === -1 ? -1 : 1])
+      ]);
+      switch (idx.type) {
+        case 'indexed:keyed': return [filter, { name, unique: idx.unique }];
+        case 'indexed:sorted': return [filter, { name }];
+      }
+    } else {
+      throw new IndexNotSupported(cls, idx);
+    }
   }
 
   static prepareCursor<T extends ModelType>(cls: Class<T>, cursor: FindCursor<T | MongoWithId<T>>, query: PageableModelQuery<T>): FindCursor<T> {

package/src/service.ts

@@ -1,38 +1,41 @@
 import {
-  type Binary,
-  type Db, GridFSBucket, MongoClient, type GridFSFile, type Collection,
-  type ObjectId, type RootFilterOperators, type Filter,
-  type WithId as MongoWithId,
+  type Binary, type Db, GridFSBucket, MongoClient, type GridFSFile, type Collection,
+  type ObjectId, type RootFilterOperators, type Filter, type WithId as MongoWithId, type FindCursor,
+  MongoServerError,
 } from 'mongodb';
 
 import {
-  ModelRegistryIndex, type ModelType, type OptionalId, type ModelCrudSupport, type ModelStorageSupport,
-  type ModelExpirySupport, type ModelBulkSupport, type ModelIndexedSupport, type BulkOperation, type BulkResponse,
-  NotFoundError, ExistsError, type ModelBlobSupport,
-  ModelCrudUtil, ModelIndexedUtil, ModelStorageUtil, ModelExpiryUtil, ModelBulkUtil
+  ModelRegistryIndex, type ModelType, type OptionalId, type ModelCrudSupport, type ModelStorageSupport, type ModelExpirySupport,
+  type ModelBulkSupport, type BulkOperation, type BulkResponse, NotFoundError, ExistsError, type ModelBlobSupport,
+  ModelCrudUtil, ModelStorageUtil, ModelExpiryUtil, ModelBulkUtil, type ModelListOptions,
 } from '@travetto/model';
 import {
   type ModelQuery, type ModelQueryCrudSupport, type ModelQueryFacetSupport, type ModelQuerySupport,
   type PageableModelQuery, type ValidStringFields, type WhereClause, type ModelQuerySuggestSupport,
-  QueryVerifier, ModelQueryUtil, ModelQuerySuggestUtil, ModelQueryCrudUtil,
-  type ModelQueryFacet,
+  QueryVerifier, ModelQueryUtil, ModelQuerySuggestUtil, ModelQueryCrudUtil, type ModelQueryFacet,
 } 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 {
-  ShutdownManager, type Class, type DeepPartial, TypedObject,
-  castTo, asFull, type BinaryMetadata, type ByteRange, type BinaryType, BinaryUtil, BinaryMetadataUtil,
+  ShutdownManager, type Class, TypedObject, castTo, asFull, type BinaryMetadata, type ByteRange, type BinaryType,
+  BinaryUtil, BinaryMetadataUtil, JSONUtil,
 } from '@travetto/runtime';
 import { Injectable, PostConstruct } from '@travetto/di';
 
-import { MongoUtil, type PlainIdx, type WithId } from './internal/util.ts';
+import { MongoUtil, type WithId } from './internal/util.ts';
 import type { MongoModelConfig } from './config.ts';
 
-const ListIndexSymbol = Symbol();
-
 type BlobRaw = GridFSFile & { metadata?: BinaryMetadata };
 
 type MongoTextSearch = RootFilterOperators<unknown>['$text'];
 
+const isDuplicateKeyError = (error: unknown): boolean =>
+  error instanceof MongoServerError && error.message.includes('duplicate key error');
+
 export const ModelBlobNamespace = '__blobs';
 
 /**
@@ -54,6 +57,54 @@ export class MongoModelService implements
 
   constructor(config: MongoModelConfig) { this.config = config; }
 
+  async * #iterateCursor<T extends ModelType>(cls: Class<T>, cursor: FindCursor, options?: ModelListOptions & ModelPageOptions<number>): AsyncGenerator<T[]> {
+    const batchSize = options?.batchSizeHint ?? 100;
+    let batch: T[] = [];
+    const maxCount = options?.limit ?? Number.MAX_SAFE_INTEGER;
+    for await (const item of cursor
+      .batchSize(batchSize)
+      .limit(maxCount)
+      .skip(options?.offset ?? 0)
+    ) {
+      if (options?.abort?.aborted) {
+        cursor.close();
+        break;
+      }
+      batch.push(item);
+      if (batch.length >= batchSize) {
+        yield await ModelCrudUtil.filterOutNotFound(batch.map(i => this.postLoad(cls, i)));
+        batch = [];
+      }
+    }
+    if (batch.length) {
+      yield await ModelCrudUtil.filterOutNotFound(batch.map(i => this.postLoad(cls, i)));
+    }
+  }
+
+  async #buildIndexQuery<T extends ModelType>(
+    cls: Class<T>,
+    idx: SortedIndex<T>,
+    body: KeyedIndexBody<T>,
+    transformWhere?: (where: WhereClause<T>) => WhereClause<T>
+  ): Promise<FindCursor> {
+    const store = await this.getStore(cls);
+    const computed = ModelIndexedComputedIndex.get(idx, body).validate();
+    let whereClause: WhereClause<T> = castTo(computed.project());
+    if (transformWhere) {
+      whereClause = transformWhere(whereClause);
+    }
+
+    const where = this.getWhereFilter(cls, whereClause);
+    let q = store.find(where, { timeout: true })
+      .batchSize(100);
+
+    // TODO: We could cache this
+    if ('sort' in idx) {
+      q = q.sort(idx.sortTemplate.map(({ path, value }) => [path.join('.'), value] as const));
+    }
+    return q;
+  }
+
   restoreId(item: { id?: string, _id?: unknown }): void {
     if (item._id) {
       item.id ??= MongoUtil.idToString(castTo(item._id));
@@ -131,7 +182,10 @@ export class MongoModelService implements
 
   async upsertModel(cls: Class): Promise<void> {
     const col = await this.getStore(cls);
-    const indices = MongoUtil.getIndices(cls, ModelRegistryIndex.getConfig(cls).indices);
+    const indices = [
+      ...ModelRegistryIndex.getIndices(cls).map(idx => MongoUtil.getIndex(cls, idx)),
+      ...MongoUtil.getExtraIndices(cls)
+    ];
     const existingIndices = (await col.indexes().catch(() => [])).filter(idx => idx.name !== '_id_');
 
     const pendingMap = Object.fromEntries(indices.map(pair => [pair[1].name!, pair]));
@@ -193,11 +247,15 @@ export class MongoModelService implements
     const id = this.preUpdate(cleaned);
 
     const store = await this.getStore(cls);
-    const result = await store.insertOne(castTo(cleaned));
-    if (!result.insertedId) {
-      throw new ExistsError(cls, id);
+    try {
+      const result = await store.insertOne(castTo(cleaned));
+      if (!result.insertedId) {
+        throw new ExistsError(cls, id);
+      }
+      return this.postUpdate(cleaned, id);
+    } catch (error) {
+      throw isDuplicateKeyError(error) ? new ExistsError(cls, id) : error;
     }
-    return this.postUpdate(cleaned, id);
   }
 
   async update<T extends ModelType>(cls: Class<T>, item: T): Promise<T> {
@@ -223,11 +281,7 @@ export class MongoModelService implements
         { upsert: true }
       );
     } catch (error) {
-      if (error instanceof Error && error.message.includes('duplicate key error')) {
-        throw new ExistsError(cls, id);
-      } else {
-        throw error;
-      }
+      throw isDuplicateKeyError(error) ? new ExistsError(cls, id) : error;
     }
     return this.postUpdate(cleaned, id);
   }
@@ -272,18 +326,10 @@ export class MongoModelService implements
     }
   }
 
-  async * list<T extends ModelType>(cls: Class<T>): AsyncIterable<T> {
+  async * list<T extends ModelType>(cls: Class<T>, options?: ModelListOptions): AsyncIterable<T[]> {
     const store = await this.getStore(cls);
-    const cursor = store.find(this.getWhereFilter(cls, {}), { timeout: true }).batchSize(100);
-    for await (const item of cursor) {
-      try {
-        yield await this.postLoad(cls, item);
-      } catch (error) {
-        if (!(error instanceof NotFoundError)) {
-          throw error;
-        }
-      }
-    }
+    const cursor = store.find(this.getWhereFilter(cls, {}), { timeout: true });
+    yield* this.#iterateCursor(cls, cursor, options);
   }
 
   // Blob
@@ -405,57 +451,120 @@ export class MongoModelService 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 store = await this.getStore(cls);
+
+    const computed = ModelIndexedComputedIndex.get(idx, body).validate({ sort: true });
+
     const result = await store.findOne(
-      this.getWhereFilter(
-        cls,
-        castTo(ModelIndexedUtil.projectIndex(cls, idx, body))
-      )
+      this.getWhereFilter(cls, castTo(computed.project({ sort: true, includeId: true })))
     );
     if (!result) {
-      throw new NotFoundError(`${cls.name}: ${idx}`, key);
+      throw new NotFoundError(`${cls.name}: ${idx}`, computed.getKey({ sort: true }));
     }
     return await this.postLoad(cls, result);
   }
 
-  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 store = await this.getStore(cls);
+    const computed = ModelIndexedComputedIndex.get(idx, body).validate({ sort: true });
+
     const result = await store.deleteOne(
-      this.getWhereFilter(
-        cls,
-        castTo(ModelIndexedUtil.projectIndex(cls, idx, body))
-      )
+      this.getWhereFilter(cls, castTo(computed.project({ sort: true, includeId: true })))
     );
-    if (result.deletedCount) {
-      return;
+    if (!result.deletedCount) {
+      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 store = await this.getStore(cls);
-    const idxConfig = ModelRegistryIndex.getIndex(cls, idx, ['sorted', 'unsorted']);
-
-    const where = this.getWhereFilter(
-      cls,
-      castTo(ModelIndexedUtil.projectIndex(cls, idx, body, { emptySortValue: { $exists: true } }))
-    );
-
-    const sort = castTo<{ [ListIndexSymbol]: PlainIdx }>(idxConfig)[ListIndexSymbol] ??= MongoUtil.getPlainIndex(idxConfig);
-    const cursor = store.find(where, { timeout: true }).batchSize(100).sort(castTo(sort));
-
-    for await (const item of cursor) {
-      yield await this.postLoad(cls, item);
+  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);
+  }
+
+  async updatePartialByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(cls: Class<T>, idx: SingleItemIndex<T, K>, 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<number>(options.offset) : 0;
+      const cursor = (await this.#buildIndexQuery(cls, idx, body));
+      const batches = await Array.fromAsync(this.#iterateCursor(cls, cursor, { limit: 100, ...options, offset }));
+      const items = batches.flat();
+      return { items, nextOffset: items.length ? JSONUtil.toBase64(offset + items.length) : 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[]> {
+    const cursor = await this.#buildIndexQuery(cls, idx, body);
+    yield* this.#iterateCursor(cls, cursor, options);
+  }
+
+  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 cursor = (await this.#buildIndexQuery(cls, idx, body, (where) => castTo({
+      $and: [where, {
+        [idx.sortTemplate[0].path.join('.')]: ModelIndexedUtil.getSuggestRegex(prefix)
+      }]
+    })));
+    const batches = await Array.fromAsync(this.#iterateCursor(cls, cursor, { limit: 10, ...options }));
+
+    return batches.flat();
+  }
+
   // Query
   async query<T extends ModelType>(cls: Class<T>, query: PageableModelQuery<T>): Promise<T[]> {
     await QueryVerifier.verify(cls, query);
@@ -529,7 +638,7 @@ export class MongoModelService 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 col = await this.getStore(cls);
@@ -566,14 +675,14 @@ export class MongoModelService implements
   }
 
   // Suggest
-  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.getSuggestFieldQuery<T>(cls, field, prefix, query);
     const results = await this.query<T>(cls, resolvedQuery);
     return ModelQuerySuggestUtil.combineSuggestResults<T, string>(cls, field, prefix, results, (a) => a, query && query.limit);
   }
 
-  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 results = await this.query<T>(cls, resolvedQuery);

package/support/service.mongo.ts

@@ -1,10 +1,14 @@
 import type { ServiceDescriptor } from '@travetto/cli';
 
-const version = process.env.MONGO_VERSION || '8.2';
+const version = process.env.MONGO_VERSION || '8.3';
 
 export const service: ServiceDescriptor = {
   name: 'mongodb',
   version,
   port: 27017,
-  image: `mongo:${version}`
+  image: `mongo:${version}`,
+  env: {
+    // Temp until mongo image fixes orbstack issue
+    GLIBC_TUNABLES: 'glibc.pthread.rseq=1'
+  }
 };