@travetto/model-mongo 8.0.4 → 8.0.6

package/README.md

@@ -21,7 +21,7 @@ Supported features:
    *  [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)
-   *  [Aggregate](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/aggregate.ts#L43)
+   *  [Aggregate](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/aggregate.ts#L56)
    *  [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)
    *  [Suggest](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/suggest.ts#L12)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-mongo",
-  "version": "8.0.4",
+  "version": "8.0.6",
   "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.4",
+    "@travetto/model": "^8.0.4",
+    "@travetto/model-indexed": "^8.0.4",
+    "@travetto/model-query": "^8.0.6",
     "mongodb": "^7.6.0"
   },
   "peerDependencies": {

package/src/service.ts

@@ -63,10 +63,10 @@ import {
   ModelQuerySuggestUtil,
   type ModelQuerySupport,
   ModelQueryUtil,
+  type NumberFieldAggregateResult,
   type PageableModelQuery,
   QueryVerifier,
   type ValidComparableFields,
-  type ValidNumericFields,
   type ValidStringFields,
   type WhereClause
 } from '@travetto/model-query';
@@ -80,7 +80,6 @@ import {
   type Class,
   castTo,
   JSONUtil,
-  RuntimeError,
   ShutdownManager,
   TypedObject
 } from '@travetto/runtime';
@@ -105,6 +104,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';
 
 /**
@@ -257,13 +263,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]));
@@ -290,13 +298,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();
   }
 
   /**
@@ -738,7 +750,7 @@ export class MongoModelService
   }
 
   // Aggregate
-  async aggregateFieldByQuery<T extends ModelType, F extends ValidComparableFields<T>>(
+  async aggregateFieldByQuery<T extends ModelType, const F extends ValidComparableFields<T>>(
     cls: Class<T>,
     field: F,
     query?: ModelQuery<T>
@@ -747,38 +759,28 @@ 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 result = await collection
-      .aggregate<{
-        _id: null;
-        count?: number;
-        min?: unknown;
-        max?: unknown;
-        avg?: unknown;
-        sum?: unknown;
-      }>(aggregations)
-      .toArray();
+
+    const aggregations: object[] = [{ $match: MongoUtil.extractWhereFilter(cls, where) }, { $group: groupFields }];
+
+    const result = await collection.aggregate<NumberFieldAggregateResult>(aggregations).toArray();
 
     const row = result.length ? result[0] : { count: 0 };
     return ModelQueryAggregateUtil.resolveAggregate(cls, field, row);