@travetto/model-mongo 8.0.0-alpha.24 → 8.0.0-alpha.26

package/README.md

@@ -13,25 +13,25 @@ npm install @travetto/model-mongo
 yarn add @travetto/model-mongo
 ```
 
-This module provides an [mongodb](https://mongodb.com)-based implementation for 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 [mongodb](https://mongodb.com).. Given the dynamic nature of [mongodb](https://mongodb.com), during development when models are modified, nothing needs to be done to adapt to the latest schema. 
+This module provides an [mongodb](https://mongodb.com)-based implementation for 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 [mongodb](https://mongodb.com).. Given the dynamic nature of [mongodb](https://mongodb.com), during development when models are modified, nothing needs to be done to adapt to the latest schema. 
 
 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)
    *  [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)
+   *  [Bulk](https://github.com/travetto/travetto/tree/main/module/model/src/types/bulk.ts#L60)
+   *  [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/types/crud.ts#L10)
+   *  [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#L21)
    *  [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)
    *  [Suggest](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/suggest.ts#L12)
+   *  [Query](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/query.ts#L10)
 
 Out of the box, by installing the module, everything should be wired up by default.If you need to customize any aspect of the source or config, you can override and register it with the [Dependency Injection](https://github.com/travetto/travetto/tree/main/module/di#readme "Dependency registration/management and injection support.") module.
 
 **Code: Wiring up a custom Model Source**
 ```typescript
 import { InjectableFactory } from '@travetto/di';
-import { MongoModelService, type MongoModelConfig } from '@travetto/model-mongo';
+import { type MongoModelConfig, MongoModelService } from '@travetto/model-mongo';
 
 export class Init {
   @InjectableFactory({
@@ -82,7 +82,7 @@ export class MongoModelConfig {
    */
   @Field({ type: Object })
   options: Omit<mongo.MongoClientOptions, 'cert'> & {
-    cert?: | Buffer | string | BinaryType | (BinaryType | Buffer | string)[];
+    cert?: Buffer | string | BinaryType | (BinaryType | Buffer | string)[];
   } = {};
   /**
    * Allow storage modification at runtime
@@ -124,15 +124,14 @@ export class MongoModelConfig {
     if (!this.port || Number.isNaN(this.port)) {
       this.port = 27017;
     }
-    if (!this.hosts || !this.hosts.length) {
+    if (!this.hosts?.length) {
       this.hosts = ['localhost'];
     }
 
     const options = this.options;
     if (options.ssl) {
       if (options.cert) {
-        options.cert = (await Promise.all([options.cert].flat(2).map(readCert)))
-          .map(BinaryUtil.binaryArrayToUint8Array);
+        options.cert = (await Promise.all([options.cert].flat(2).map(readCert))).map(BinaryUtil.binaryArrayToUint8Array);
       }
       if (options.tlsCertificateKeyFile) {
         options.tlsCertificateKeyFile = await RuntimeResources.resolve(options.tlsCertificateKeyFile);
@@ -155,15 +154,12 @@ export class MongoModelConfig {
    * Build connection URLs
    */
   get url(): string {
-    const hosts = this.hosts!
-      .map(host => (this.srvRecord || host.includes(':')) ? host : `${host}:${this.port ?? 27017}`)
-      .join(',');
+    const hosts = this.hosts!.map(host => (this.srvRecord || host.includes(':') ? host : `${host}:${this.port ?? 27017}`)).join(',');
     const optionString = new URLSearchParams(
       Object.entries(this.options)
         .filter((pair): pair is [string, string | number | boolean] => ['string', 'number', 'boolean'].includes(typeof pair[1]))
         .map(([k, v]) => [k, `${v}`])
-    )
-      .toString();
+    ).toString();
     let creds = '';
     if (this.username) {
       creds = `${[this.username, this.password].filter(part => !!part).join(':')}@`;
@@ -174,4 +170,4 @@ export class MongoModelConfig {
 }
 ```
 
-Additionally, you can see that the class is registered with the [@Config](https://github.com/travetto/travetto/tree/main/module/config/src/decorator.ts#L13) annotation, and so these values can be overridden using the standard [Configuration](https://github.com/travetto/travetto/tree/main/module/config#readme "Configuration support") resolution paths.The SSL file options in `clientOptions` will automatically be resolved to files when given a path.  This path can be a resource path (will attempt to lookup using [RuntimeResources](https://github.com/travetto/travetto/tree/main/module/runtime/src/resources.ts#L8)) or just a standard file path.
+Additionally, you can see that the class is registered with the [@Config](https://github.com/travetto/travetto/tree/main/module/config/src/decorator.ts#L13) annotation, and so these values can be overridden using the standard [Configuration](https://github.com/travetto/travetto/tree/main/module/config#readme "Configuration support") resolution paths.The SSL file options in `clientOptions` will automatically be resolved to files when given a path. This path can be a resource path (will attempt to lookup using [RuntimeResources](https://github.com/travetto/travetto/tree/main/module/runtime/src/resources.ts#L8)) or just a standard file path.

package/__index__.ts

@@ -1,2 +1,2 @@
+export * from './src/config.ts';
 export * from './src/service.ts';
-export * from './src/config.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-mongo",
-  "version": "8.0.0-alpha.24",
+  "version": "8.0.0-alpha.26",
   "type": "module",
   "description": "Mongo backing for the travetto model module.",
   "keywords": [
@@ -26,14 +26,14 @@
     "directory": "module/model-mongo"
   },
   "dependencies": {
-    "@travetto/config": "^8.0.0-alpha.21",
-    "@travetto/model": "^8.0.0-alpha.22",
-    "@travetto/model-indexed": "^8.0.0-alpha.24",
-    "@travetto/model-query": "^8.0.0-alpha.23",
+    "@travetto/config": "^8.0.0-alpha.23",
+    "@travetto/model": "^8.0.0-alpha.24",
+    "@travetto/model-indexed": "^8.0.0-alpha.26",
+    "@travetto/model-query": "^8.0.0-alpha.25",
     "mongodb": "^7.5.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.27"
+    "@travetto/cli": "^8.0.0-alpha.29"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/config.ts

@@ -1,9 +1,9 @@
 import type mongo from 'mongodb';
 
-import { type TimeSpan, Runtime, RuntimeResources, BinaryUtil, CodecUtil, type BinaryType, type BinaryArray } from '@travetto/runtime';
 import { Config } from '@travetto/config';
-import { Field } from '@travetto/schema';
 import { PostConstruct } from '@travetto/di';
+import { type BinaryArray, type BinaryType, BinaryUtil, CodecUtil, Runtime, RuntimeResources, type TimeSpan } from '@travetto/runtime';
+import { Field } from '@travetto/schema';
 
 const readCert = async (input: BinaryType | string): Promise<BinaryArray> => {
   if (BinaryUtil.isBinaryType(input)) {
@@ -55,7 +55,7 @@ export class MongoModelConfig {
    */
   @Field({ type: Object })
   options: Omit<mongo.MongoClientOptions, 'cert'> & {
-    cert?: | Buffer | string | BinaryType | (BinaryType | Buffer | string)[];
+    cert?: Buffer | string | BinaryType | (BinaryType | Buffer | string)[];
   } = {};
   /**
    * Allow storage modification at runtime
@@ -97,15 +97,14 @@ export class MongoModelConfig {
     if (!this.port || Number.isNaN(this.port)) {
       this.port = 27017;
     }
-    if (!this.hosts || !this.hosts.length) {
+    if (!this.hosts?.length) {
       this.hosts = ['localhost'];
     }
 
     const options = this.options;
     if (options.ssl) {
       if (options.cert) {
-        options.cert = (await Promise.all([options.cert].flat(2).map(readCert)))
-          .map(BinaryUtil.binaryArrayToUint8Array);
+        options.cert = (await Promise.all([options.cert].flat(2).map(readCert))).map(BinaryUtil.binaryArrayToUint8Array);
       }
       if (options.tlsCertificateKeyFile) {
         options.tlsCertificateKeyFile = await RuntimeResources.resolve(options.tlsCertificateKeyFile);
@@ -128,15 +127,12 @@ export class MongoModelConfig {
    * Build connection URLs
    */
   get url(): string {
-    const hosts = this.hosts!
-      .map(host => (this.srvRecord || host.includes(':')) ? host : `${host}:${this.port ?? 27017}`)
-      .join(',');
+    const hosts = this.hosts!.map(host => (this.srvRecord || host.includes(':') ? host : `${host}:${this.port ?? 27017}`)).join(',');
     const optionString = new URLSearchParams(
       Object.entries(this.options)
         .filter((pair): pair is [string, string | number | boolean] => ['string', 'number', 'boolean'].includes(typeof pair[1]))
         .map(([k, v]) => [k, `${v}`])
-    )
-      .toString();
+    ).toString();
     let creds = '';
     if (this.username) {
       creds = `${[this.username, this.password].filter(part => !!part).join(':')}@`;
@@ -144,4 +140,4 @@ export class MongoModelConfig {
     const url = `mongodb${this.srvRecord ? '+srv' : ''}://${creds}${hosts}/${this.namespace}?${optionString}`;
     return url;
   }
-}
+}

package/src/internal/util.ts

@@ -1,13 +1,19 @@
 import {
-  Binary, type CreateIndexesOptions, type Filter, type FindCursor, type IndexDirection, ObjectId, type WithId as MongoWithId,
-  type IndexDescriptionInfo
+  Binary,
+  type CreateIndexesOptions,
+  type Filter,
+  type FindCursor,
+  type IndexDescriptionInfo,
+  type IndexDirection,
+  type WithId as MongoWithId,
+  ObjectId
 } from 'mongodb';
 
-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 { type IndexConfig, IndexNotSupported, type ModelType } from '@travetto/model';
 import { isModelIndexedIndex } from '@travetto/model-indexed';
+import { type DistanceUnit, isModelQueryIndex, ModelQueryUtil, type PageableModelQuery, type WhereClause } from '@travetto/model-query';
+import { BinaryUtil, type Class, CodecUtil, castTo, RuntimeError, toConcrete } from '@travetto/runtime';
+import { DataUtil, type Point, SchemaRegistryIndex } from '@travetto/schema';
 
 const PointConcrete = toConcrete<Point>();
 
@@ -42,19 +48,13 @@ function flattenKeys(obj: Record<string, unknown>, prefix = ''): Record<string,
  * Basic mongo utils for conforming to the model module
  */
 export class MongoUtil {
-
   static namespaceIndex(cls: Class, name: string): string {
     return `${cls.Ⲑid}__${name}`.replace(/[^a-zA-Z0-9_]+/g, '_');
   }
 
   static uuid(value: string): Binary {
     try {
-      return new Binary(
-        BinaryUtil.binaryArrayToUint8Array(
-          CodecUtil.fromHexString(value.replaceAll('-', ''))
-        ),
-        Binary.SUBTYPE_UUID
-      );
+      return new Binary(BinaryUtil.binaryArrayToUint8Array(CodecUtil.fromHexString(value.replaceAll('-', ''))), Binary.SUBTYPE_UUID);
     } catch (err) {
       if (err instanceof RuntimeError && err.message === 'Invalid hex string') {
         return null!;
@@ -94,7 +94,12 @@ export class MongoUtil {
   }
 
   /**/
-  static extractSimple<T>(base: Class<T> | undefined, item: Record<string, unknown>, path: string = '', recursive: boolean = true): Record<string, unknown> {
+  static extractSimple<T>(
+    base: Class<T> | undefined,
+    item: Record<string, unknown>,
+    path: string = '',
+    recursive: boolean = true
+  ): Record<string, unknown> {
     const fields = base ? SchemaRegistryIndex.getOptional(base)?.getFields() : undefined;
     const out: Record<string, unknown> = {};
     const sub = item;
@@ -140,7 +145,7 @@ export class MongoUtil {
           value.$regex = DataUtil.toRegex(castTo(value.$regex));
         } else if (firstKey && '$near' in value) {
           const dist: number = castTo(value.$maxDistance);
-          const distance = dist / RADIANS_TO[(castTo<DistanceUnit>(value.$unit) ?? 'km')];
+          const distance = dist / RADIANS_TO[castTo<DistanceUnit>(value.$unit) ?? 'km'];
           value.$maxDistance = distance;
           delete value.$unit;
         } else if (firstKey && '$geoWithin' in value) {
@@ -187,8 +192,9 @@ export class MongoUtil {
     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>>({}));
+        (acc, field) => Object.assign(acc, { ...flattenKeys(castTo(field)) }),
+        castTo<Record<string, -1 | 0 | 1>>({})
+      );
 
       return [out, { name, unique: !!idx.unique }];
     } else if (isModelIndexedIndex(idx)) {
@@ -197,23 +203,29 @@ export class MongoUtil {
         ...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 }];
+        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> {
+  static prepareCursor<T extends ModelType>(
+    cls: Class<T>,
+    cursor: FindCursor<T | MongoWithId<T>>,
+    query: PageableModelQuery<T>
+  ): FindCursor<T> {
     if (query.select) {
       const selectKey = Object.keys(query.select)[0];
       const select = typeof selectKey === 'string' && selectKey.startsWith('$') ? query.select : this.extractSimple(cls, query.select);
       // Remove id if not explicitly defined, and selecting fields directly
-      if (!select['_id']) {
+      if (!select._id) {
         const values = new Set([...Object.values(select)]);
         if (values.has(1) || values.has(true)) {
-          select['_id'] = false;
+          select._id = false;
         }
       }
       cursor.project(select);
@@ -241,9 +253,9 @@ export class MongoUtil {
       existing.expireAfterSeconds !== pendingOptions.expireAfterSeconds ||
       existing.bucketSize !== pendingOptions.bucketSize;
 
-    const existingFields = existing.textIndexVersion ?
-      Object.fromEntries(Object.entries(existing.weights ?? {}).map(([key]) => [key, 'text'])) :
-      existing.key;
+    const existingFields = existing.textIndexVersion
+      ? Object.fromEntries(Object.entries(existing.weights ?? {}).map(([key]) => [key, 'text']))
+      : existing.key;
 
     const pendingKeySet = new Set(Object.keys(pendingKey));
     const existingKeySet = new Set(Object.keys(existingFields));
@@ -253,10 +265,10 @@ export class MongoUtil {
     const overlap = [...pendingKeySet.intersection(existingKeySet)];
     changed ||= overlap.length !== pendingKeySet.size;
 
-    for (let i = 0; i < overlap.length && !changed; i++) {
+    for (let i = 0; i < overlap.length && !changed; i += 1) {
       changed ||= existingFields[overlap[i]] !== pendingKey[overlap[i]];
     }
 
     return changed;
   }
-}
+}

package/src/service.ts

@@ -1,40 +1,102 @@
 import {
-  type Binary, type Db, GridFSBucket, MongoClient, type GridFSFile, type Collection,
-  type ObjectId, type RootFilterOperators, type Filter, type WithId as MongoWithId, type FindCursor,
+  type Binary,
+  type Collection,
+  type Db,
+  type Filter,
+  type FindCursor,
+  GridFSBucket,
+  type GridFSFile,
+  MongoClient,
   MongoServerError,
+  type WithId as MongoWithId,
+  type ObjectId,
+  type RootFilterOperators
 } from 'mongodb';
 
+import { Injectable, PostConstruct } from '@travetto/di';
 import {
-  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,
+  type BulkOperation,
+  type BulkResponse,
+  ExistsError,
+  type ModelBlobSupport,
+  type ModelBulkSupport,
+  ModelBulkUtil,
+  type ModelCrudSupport,
+  ModelCrudUtil,
+  type ModelExpirySupport,
+  ModelExpiryUtil,
+  type ModelListOptions,
+  ModelRegistryIndex,
+  type ModelStorageSupport,
+  ModelStorageUtil,
+  type ModelType,
+  NotFoundError,
+  type OptionalId,
+  UniqueError
 } 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,
-} 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,
+  type FullKeyedIndexBody,
+  type FullKeyedIndexWithPartialBody,
+  type KeyedIndexBody,
+  type KeyedIndexSelection,
+  ModelIndexedComputedIndex,
+  type ModelIndexedSearchOptions,
+  type ModelIndexedSupport,
+  ModelIndexedUtil,
+  type ModelPageOptions,
+  type ModelPageResult,
+  type SingleItemIndex,
+  type SortedIndex,
+  type SortedIndexSelection,
+  type SortedIndexSelectionType
 } from '@travetto/model-indexed';
-
 import {
-  ShutdownManager, type Class, TypedObject, castTo, asFull, type BinaryMetadata, type ByteRange, type BinaryType,
-  BinaryUtil, BinaryMetadataUtil, JSONUtil,
+  type ModelQuery,
+  type ModelQueryCrudSupport,
+  ModelQueryCrudUtil,
+  type ModelQueryFacet,
+  type ModelQueryFacetSupport,
+  type ModelQuerySuggestSupport,
+  ModelQuerySuggestUtil,
+  type ModelQuerySupport,
+  ModelQueryUtil,
+  type PageableModelQuery,
+  QueryVerifier,
+  type ValidStringFields,
+  type WhereClause
+} from '@travetto/model-query';
+import {
+  asFull,
+  type BinaryMetadata,
+  BinaryMetadataUtil,
+  type BinaryType,
+  BinaryUtil,
+  type ByteRange,
+  type Class,
+  castTo,
+  JSONUtil,
+  ShutdownManager,
+  TypedObject
 } from '@travetto/runtime';
-import { Injectable, PostConstruct } from '@travetto/di';
 
-import { MongoUtil, type WithId } from './internal/util.ts';
 import type { MongoModelConfig } from './config.ts';
+import { MongoUtil, type WithId } from './internal/util.ts';
 
 type BlobRaw = GridFSFile & { metadata?: BinaryMetadata };
 
 type MongoTextSearch = RootFilterOperators<unknown>['$text'];
 
-const isDuplicateKeyError = (error: unknown): boolean =>
-  error instanceof MongoServerError && error.message.includes('duplicate key error');
+const handleDuplicateKeyError = (cls: Class, id: string, error: unknown): unknown => {
+  if (error instanceof MongoServerError && error.message.includes('duplicate key error')) {
+    if (error.message.includes('_id_') || (error.keyPattern && '_id' in error.keyPattern)) {
+      return new ExistsError(cls, id);
+    }
+    const match = error.message.match(/index: ([\w$]+)/);
+    const constraint = match ? match[1] : error.keyPattern ? Object.keys(error.keyPattern).join(',') : 'unique';
+    return new UniqueError(cls, constraint, { detail: error.message });
+  }
+  return error;
+};
 
 export const ModelBlobNamespace = '__blobs';
 
@@ -42,30 +104,41 @@ export const ModelBlobNamespace = '__blobs';
  * Mongo-based model source
  */
 @Injectable()
-export class MongoModelService implements
-  ModelCrudSupport, ModelStorageSupport,
-  ModelBulkSupport, ModelBlobSupport,
-  ModelIndexedSupport, ModelQuerySupport,
-  ModelQueryCrudSupport, ModelQueryFacetSupport,
-  ModelQuerySuggestSupport, ModelExpirySupport {
-
+export class MongoModelService
+  implements
+    ModelCrudSupport,
+    ModelStorageSupport,
+    ModelBulkSupport,
+    ModelBlobSupport,
+    ModelIndexedSupport,
+    ModelQuerySupport,
+    ModelQueryCrudSupport,
+    ModelQueryFacetSupport,
+    ModelQuerySuggestSupport,
+    ModelExpirySupport
+{
   #db: Db;
   #bucket: GridFSBucket;
   idSource = ModelCrudUtil.uuidSource();
   client: MongoClient;
   config: MongoModelConfig;
 
-  constructor(config: MongoModelConfig) { this.config = config; }
+  constructor(config: MongoModelConfig) {
+    this.config = config;
+  }
 
-  async * #iterateCursor<T extends ModelType>(cls: Class<T>, cursor: FindCursor, options?: ModelListOptions & ModelPageOptions<number>): AsyncGenerator<T[]> {
+  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)
-    ) {
+      .skip(options?.offset ?? 0)) {
       if (options?.abort?.aborted) {
         cursor.close();
         break;
@@ -95,8 +168,7 @@ export class MongoModelService implements
     }
 
     const where = this.getWhereFilter(cls, whereClause);
-    let q = store.find(where, { timeout: true })
-      .batchSize(100);
+    let q = store.find(where, { timeout: true }).batchSize(100);
 
     // TODO: We could cache this
     if ('sort' in idx) {
@@ -105,7 +177,7 @@ export class MongoModelService implements
     return q;
   }
 
-  restoreId(item: { id?: string, _id?: unknown }): void {
+  restoreId(item: { id?: string; _id?: unknown }): void {
     if (item._id) {
       item.id ??= MongoUtil.idToString(castTo(item._id));
       delete item._id;
@@ -125,11 +197,11 @@ export class MongoModelService implements
     return item;
   }
 
-  preUpdate<T extends OptionalId<ModelType>>(item: T & { _id?: Binary, id: string }): string;
+  preUpdate<T extends OptionalId<ModelType>>(item: T & { _id?: Binary; id: string }): string;
   preUpdate<T extends OptionalId<ModelType>>(item: Omit<T, 'id'> & { _id?: Binary }): undefined;
-  preUpdate<T extends OptionalId<ModelType>>(item: T & { _id?: Binary, id: undefined }): undefined;
-  preUpdate<T extends OptionalId<ModelType>>(item: T & { _id?: Binary, id?: string }): string | undefined {
-    if (item && item.id) {
+  preUpdate<T extends OptionalId<ModelType>>(item: T & { _id?: Binary; id: undefined }): undefined;
+  preUpdate<T extends OptionalId<ModelType>>(item: T & { _id?: Binary; id?: string }): string | undefined {
+    if (item?.id) {
       const id = item.id;
       item._id = MongoUtil.uuid(id);
       if (!this.config.storeId) {
@@ -153,7 +225,7 @@ export class MongoModelService implements
   async initializeClient(): Promise<void> {
     this.client = await MongoClient.connect(this.config.url, {
       ...this.config.connectionOptions,
-      useBigInt64: true,
+      useBigInt64: true
     });
     this.#db = this.client.db(this.config.namespace);
     this.#bucket = new GridFSBucket(this.#db, {
@@ -174,7 +246,7 @@ export class MongoModelService implements
   }
 
   // Storage
-  async createStorage(): Promise<void> { }
+  async createStorage(): Promise<void> {}
 
   async deleteStorage(): Promise<void> {
     await this.#db.dropDatabase();
@@ -182,10 +254,7 @@ export class MongoModelService implements
 
   async upsertModel(cls: Class): Promise<void> {
     const col = await this.getStore(cls);
-    const indices = [
-      ...ModelRegistryIndex.getIndices(cls).map(idx => MongoUtil.getIndex(cls, idx)),
-      ...MongoUtil.getExtraIndices(cls)
-    ];
+    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]));
@@ -219,7 +288,7 @@ export class MongoModelService implements
   }
 
   async truncateBlob(): Promise<void> {
-    await this.#bucket.drop().catch(() => { });
+    await this.#bucket.drop().catch(() => {});
   }
 
   /**
@@ -254,7 +323,7 @@ export class MongoModelService implements
       }
       return this.postUpdate(cleaned, id);
     } catch (error) {
-      throw isDuplicateKeyError(error) ? new ExistsError(cls, id) : error;
+      throw handleDuplicateKeyError(cls, id, error);
     }
   }
 
@@ -275,13 +344,9 @@ export class MongoModelService implements
     const store = await this.getStore(cls);
 
     try {
-      await store.updateOne(
-        this.getIdFilter(cls, id, false),
-        { $set: cleaned },
-        { upsert: true }
-      );
+      await store.updateOne(this.getIdFilter(cls, id, false), { $set: cleaned }, { upsert: true });
     } catch (error) {
-      throw isDuplicateKeyError(error) ? new ExistsError(cls, id) : error;
+      throw handleDuplicateKeyError(cls, id, error);
     }
     return this.postUpdate(cleaned, id);
   }
@@ -292,24 +357,23 @@ export class MongoModelService implements
     const final = await ModelCrudUtil.prePartialUpdate(cls, item, view);
     const simple = MongoUtil.extractSimple(cls, final, undefined, false);
 
-    const operation: Partial<T> = castTo(Object
-      .entries(simple)
-      .reduce<Partial<Record<'$unset' | '$set', Record<string, unknown>>>>((document, [key, value]) => {
+    const operation: Partial<T> = castTo(
+      Object.entries(simple).reduce<Partial<Record<'$unset' | '$set', Record<string, unknown>>>>((document, [key, value]) => {
         if (value === null || value === undefined) {
           (document.$unset ??= {})[key] = value;
         } else {
           (document.$set ??= {})[key] = value;
         }
         return document;
-      }, {}));
+      }, {})
+    );
 
     const id = item.id;
 
-    const result = await store.findOneAndUpdate(
-      this.getIdFilter(cls, id),
-      operation,
-      { returnDocument: 'after', includeResultMetadata: true }
-    );
+    const result = await store.findOneAndUpdate(this.getIdFilter(cls, id), operation, {
+      returnDocument: 'after',
+      includeResultMetadata: true
+    });
 
     if (!result.value) {
       throw new NotFoundError(cls, id);
@@ -326,7 +390,7 @@ export class MongoModelService implements
     }
   }
 
-  async * list<T extends ModelType>(cls: Class<T>, options?: ModelListOptions): 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 });
     yield* this.#iterateCursor(cls, cursor, options);
@@ -334,7 +398,10 @@ export class MongoModelService implements
 
   // Blob
   async upsertBlob(location: string, input: BinaryType, metadata?: BinaryMetadata, overwrite = true): Promise<void> {
-    const existing = await this.getBlobMetadata(location).then(() => true, () => false);
+    const existing = await this.getBlobMetadata(location).then(
+      () => true,
+      () => false
+    );
     if (!overwrite && existing) {
       return;
     }
@@ -366,10 +433,9 @@ export class MongoModelService implements
   }
 
   async updateBlobMetadata(location: string, metadata: BinaryMetadata): Promise<void> {
-    await this.#db.collection<{ metadata: BinaryMetadata }>(`${ModelBlobNamespace}.files`).findOneAndUpdate(
-      { filename: location },
-      { $set: { metadata, contentType: metadata.contentType! } },
-    );
+    await this.#db
+      .collection<{ metadata: BinaryMetadata }>(`${ModelBlobNamespace}.files`)
+      .findOneAndUpdate({ filename: location }, { $set: { metadata, contentType: metadata.contentType! } });
   }
 
   // Bulk
@@ -402,7 +468,10 @@ export class MongoModelService implements
         bulk.insert(operation.insert);
       } else if (operation.upsert) {
         const id = this.preUpdate(operation.upsert);
-        bulk.find({ _id: MongoUtil.uuid(id!) }).upsert().updateOne({ $set: operation.upsert });
+        bulk
+          .find({ _id: MongoUtil.uuid(id!) })
+          .upsert()
+          .updateOne({ $set: operation.upsert });
       } else if (operation.update) {
         const id = this.preUpdate(operation.update);
         bulk.find({ _id: MongoUtil.uuid(id) }).update({ $set: operation.update });
@@ -451,89 +520,77 @@ export class MongoModelService implements
   }
 
   // Indexed
-  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> {
+  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(computed.project({ sort: true, includeId: true })))
-    );
+    const result = await store.findOne(this.getWhereFilter(cls, castTo(computed.project({ sort: true, includeId: true }))));
     if (!result) {
       throw new NotFoundError(`${cls.name}: ${idx}`, computed.getKey({ sort: true }));
     }
     return await this.postLoad(cls, result);
   }
 
-  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> {
+  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(computed.project({ sort: true, includeId: true })))
-    );
+    const result = await store.deleteOne(this.getWhereFilter(cls, castTo(computed.project({ sort: true, includeId: true }))));
     if (!result.deletedCount) {
       throw new NotFoundError(`${cls.name}: ${idx}`, computed.getKey({ sort: true }));
     }
   }
 
-  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> {
+  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);
   }
 
-  updateByIndex<
-    T extends ModelType,
-    K extends KeyedIndexSelection<T>,
-    S extends SortedIndexSelection<T>
-  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: T): Promise<T> {
+  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> {
+  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>
-  >(
+  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,
+    options?: ModelPageOptions
   ): Promise<ModelPageResult<T>> {
     {
       const offset = options?.offset ? JSONUtil.fromBase64<number>(options.offset) : 0;
-      const cursor = (await this.#buildIndexQuery(cls, idx, body));
+      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>
-  >(
+  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>,
@@ -548,18 +605,17 @@ export class MongoModelService implements
     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)
-      }]
-    })));
+  >(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();
@@ -622,15 +678,14 @@ export class MongoModelService implements
     const item = await ModelCrudUtil.prePartialUpdate(cls, data);
     const col = await this.getStore(cls);
     const items = MongoUtil.extractSimple(cls, item);
-    const final = Object.entries(items).reduce<Partial<Record<'$unset' | '$set', Record<string, unknown>>>>(
-      (document, [key, value]) => {
-        if (value === null || value === undefined) {
-          (document.$unset ??= {})[key] = value;
-        } else {
-          (document.$set ??= {})[key] = value;
-        }
-        return document;
-      }, {});
+    const final = Object.entries(items).reduce<Partial<Record<'$unset' | '$set', Record<string, unknown>>>>((document, [key, value]) => {
+      if (value === null || value === undefined) {
+        (document.$unset ??= {})[key] = value;
+      } else {
+        (document.$set ??= {})[key] = value;
+      }
+      return document;
+    }, {});
 
     const filter = MongoUtil.extractWhereFilter(cls, query.where);
     const result = await col.updateMany(filter, castTo(final));
@@ -664,7 +719,7 @@ export class MongoModelService implements
       }
     ];
 
-    const result = await col.aggregate<{ _id: ObjectId, count: number }>(aggregations).toArray();
+    const result = await col.aggregate<{ _id: ObjectId; count: number }>(aggregations).toArray();
 
     return result
       .map(item => ({
@@ -675,18 +730,28 @@ export class MongoModelService implements
   }
 
   // Suggest
-  async suggestValuesByQuery<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);
+    return ModelQuerySuggestUtil.combineSuggestResults<T, string>(cls, field, prefix, results, a => a, query?.limit);
   }
 
-  async suggestByQuery<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);
-    return ModelQuerySuggestUtil.combineSuggestResults(cls, field, prefix, results, (_, b) => b, query && query.limit);
+    return ModelQuerySuggestUtil.combineSuggestResults(cls, field, prefix, results, (_, b) => b, query?.limit);
   }
 
   // Other
@@ -699,12 +764,14 @@ export class MongoModelService implements
       search = { $search: search, $language: 'en' };
     }
 
-    (query.sort ??= []).unshift(castTo<(typeof query.sort[0])>({
-      score: { $meta: 'textScore' }
-    }));
+    (query.sort ??= []).unshift(
+      castTo<(typeof query.sort)[0]>({
+        score: { $meta: 'textScore' }
+      })
+    );
 
     const cursor = col.find(castTo({ $and: [{ $text: search }, filter] }), {});
     const items = await MongoUtil.prepareCursor(cls, cursor, query).toArray();
     return await Promise.all(items.map(item => this.postLoad(cls, item)));
   }
-}
+}

package/support/service.mongo.ts

@@ -11,4 +11,4 @@ export const service: ServiceDescriptor = {
     // Temp until mongo image fixes orbstack issue
     GLIBC_TUNABLES: 'glibc.pthread.rseq=1'
   }
-};
+};