@travetto/model-mongo 8.0.5 → 8.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-mongo",
-  "version": "8.0.5",
+  "version": "8.0.7",
   "description": "Mongo backing for the travetto model module.",
   "keywords": [
     "database",
@@ -30,9 +30,9 @@
   },
   "dependencies": {
     "@travetto/config": "^8.0.3",
-    "@travetto/model": "^8.0.3",
-    "@travetto/model-indexed": "^8.0.3",
-    "@travetto/model-query": "^8.0.5",
+    "@travetto/model": "^8.0.4",
+    "@travetto/model-indexed": "^8.0.4",
+    "@travetto/model-query": "^8.0.7",
     "mongodb": "^7.6.0"
   },
   "peerDependencies": {

package/src/service.ts

@@ -58,6 +58,7 @@ import {
   type ModelQueryCrudSupport,
   ModelQueryCrudUtil,
   type ModelQueryFacet,
+  type FacetModelQuery,
   type ModelQueryFacetSupport,
   type ModelQuerySuggestSupport,
   ModelQuerySuggestUtil,
@@ -66,6 +67,7 @@ import {
   type NumberFieldAggregateResult,
   type PageableModelQuery,
   QueryVerifier,
+  type SuggestModelQuery,
   type ValidComparableFields,
   type ValidStringFields,
   type WhereClause
@@ -104,6 +106,13 @@ const handleDuplicateKeyError = (cls: Class, id: string, error: unknown): unknow
   return error;
 };
 
+function isNotFoundError(error: unknown): error is MongoServerError {
+  return (
+    (error instanceof MongoServerError && (error.code === 26 || error.codeName === 'NamespaceNotFound')) ||
+    (error instanceof Error && /ns not found/i.test(error.message))
+  );
+}
+
 export const ModelBlobNamespace = '__blobs';
 
 /**
@@ -256,13 +265,15 @@ export class MongoModelService
   async createStorage(): Promise<void> {}
 
   async deleteStorage(): Promise<void> {
-    await this.#db.dropDatabase();
+    await ModelStorageUtil.runAndIgnoreNotFound(() => this.#db.dropDatabase(), isNotFoundError);
   }
 
   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 existingIndices = (await col.indexes().catch(() => [])).filter(idx => idx.name !== '_id_');
+    const existingIndices = ((await ModelStorageUtil.runAndIgnoreNotFound(() => col.indexes(), isNotFoundError)) ?? []).filter(
+      idx => idx.name !== '_id_'
+    );
 
     const pendingMap = Object.fromEntries(indices.map(pair => [pair[1].name!, pair]));
     const existingMap = Object.fromEntries(existingIndices.map(idx => [idx.name!, idx.key]));
@@ -289,13 +300,17 @@ export class MongoModelService
     }
   }
 
+  async deleteModel<T extends ModelType>(cls: Class<T>): Promise<void> {
+    await ModelStorageUtil.runAndIgnoreNotFound(() => this.#db.collection(ModelRegistryIndex.getStoreName(cls)).drop(), isNotFoundError);
+  }
+
   async truncateModel<T extends ModelType>(cls: Class<T>): Promise<void> {
     const col = await this.getStore(cls);
     await col.deleteMany({});
   }
 
   async truncateBlob(): Promise<void> {
-    await this.#bucket.drop().catch(() => {});
+    await this.#bucket.drop();
   }
 
   /**
@@ -700,13 +715,14 @@ export class MongoModelService
   }
 
   // Facet
-  async facetByQuery<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?: FacetModelQuery<T>
+  ): Promise<ModelQueryFacet[]> {
     await QueryVerifier.verify(cls, query);
 
     const col = await this.getStore(cls);
-    if (query) {
-      await QueryVerifier.verify(cls, query);
-    }
 
     let queryObject: Record<string, unknown> = { [field]: { $exists: true } };
 
@@ -723,17 +739,22 @@ export class MongoModelService
             $sum: 1
           }
         }
-      }
+      },
+      {
+        $sort: {
+          count: -1
+        }
+      },
+      ...(query?.offset !== undefined ? [{ $skip: query.offset }] : []),
+      ...(query?.limit !== undefined ? [{ $limit: query.limit }] : [])
     ];
 
     const result = await col.aggregate<{ _id: ObjectId; count: number }>(aggregations).toArray();
 
-    return result
-      .map(item => ({
-        key: MongoUtil.idToString(item._id),
-        count: item.count
-      }))
-      .toSorted((a, b) => b.count - a.count);
+    return result.map(item => ({
+      key: MongoUtil.idToString(item._id),
+      count: item.count
+    }));
   }
 
   // Aggregate
@@ -746,27 +767,26 @@ export class MongoModelService
 
     const collection = await this.getStore(cls);
 
-    const where = ModelQueryUtil.getWhereClause(cls, query?.where);
-    let queryObject: Record<string, unknown> = { [field]: { $exists: true, $ne: null } };
-
-    if (where) {
-      queryObject = { $and: [queryObject, MongoUtil.extractWhereFilter(cls, where)] };
-    }
+    const where = ModelQueryUtil.getWhereClause(cls, {
+      $and: [query?.where ?? {}, { [field]: { $exists: true } }]
+    });
 
-    const isDate = SchemaRegistryIndex.getNestedFieldConfig(cls, field)!.type === Date;
+    const isDate = SchemaRegistryIndex.getNestedFieldConfig(cls, field)?.type === Date;
 
     const groupFields: Record<string, unknown> = {
       _id: null,
       count: { $sum: 1 },
-      min: { $min: `$${String(field)}` },
-      max: { $max: `$${String(field)}` }
+      min: { $min: `$${field}` },
+      max: { $max: `$${field}` },
+      ...(isDate
+        ? {}
+        : {
+            avg: { $avg: `$${field}` },
+            sum: { $sum: `$${field}` }
+          })
     };
-    if (!isDate) {
-      groupFields.avg = { $avg: `$${String(field)}` };
-      groupFields.sum = { $sum: `$${String(field)}` };
-    }
 
-    const aggregations: object[] = [{ $match: queryObject }, { $group: groupFields }];
+    const aggregations: object[] = [{ $match: MongoUtil.extractWhereFilter(cls, where) }, { $group: groupFields }];
 
     const result = await collection.aggregate<NumberFieldAggregateResult>(aggregations).toArray();
 
@@ -779,24 +799,24 @@ export class MongoModelService
     cls: Class<T>,
     field: ValidStringFields<T>,
     prefix?: string,
-    query?: PageableModelQuery<T>
+    query?: SuggestModelQuery<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?.limit);
+    return ModelQuerySuggestUtil.combineSuggestResults<T, string>(cls, field, prefix, results, a => a, query);
   }
 
   async suggestByQuery<T extends ModelType>(
     cls: Class<T>,
     field: ValidStringFields<T>,
     prefix?: string,
-    query?: PageableModelQuery<T>
+    query?: SuggestModelQuery<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?.limit);
+    return ModelQuerySuggestUtil.combineSuggestResults(cls, field, prefix, results, (_, b) => b, query);
   }
 
   // Other