@travetto/model 8.0.3 → 8.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model",
-  "version": "8.0.3",
+  "version": "8.0.4",
   "description": "Datastore abstraction for core operations.",
   "keywords": [
     "datastore",

package/src/types/storage.ts

@@ -38,11 +38,11 @@ export interface ModelStorageSupport {
   /**
    * Deletes model
    */
-  deleteModel?<T extends ModelType>(cls: Class<T>): Promise<void>;
+  deleteModel<T extends ModelType>(cls: Class<T>): Promise<void>;
   /**
    * Removes all data from a model, but leaving the structure in place
    */
-  truncateModel?<T extends ModelType>(cls: Class<T>): Promise<void>;
+  truncateModel<T extends ModelType>(cls: Class<T>): Promise<void>;
   /**
    * Truncate blob storage data
    */

package/src/util/storage.ts

@@ -46,4 +46,21 @@ export class ModelStorageUtil {
       }
     }
   }
+
+  /**
+   * Runs a storage operation and ignores errors matching the not-found predicate
+   */
+  static async runAndIgnoreNotFound<T = unknown>(
+    operation: () => Promise<T>,
+    notFoundPredicate: (error: unknown) => boolean
+  ): Promise<T | undefined> {
+    try {
+      return await operation();
+    } catch (error) {
+      if (notFoundPredicate(error)) {
+        return undefined;
+      }
+      throw error;
+    }
+  }
 }

package/support/test/basic.ts

@@ -1,6 +1,15 @@
 import assert from 'node:assert';
 
-import { Model, type ModelCrudSupport, ModelCrudUtil, NotFoundError, TransientField } from '@travetto/model';
+import {
+  Model,
+  type ModelCrudSupport,
+  ModelCrudUtil,
+  ModelRegistryIndex,
+  ModelStorageUtil,
+  NotFoundError,
+  TransientField
+} from '@travetto/model';
+import { SchemaRegistryIndex } from '@travetto/schema';
 import { Suite, Test } from '@travetto/test';
 
 import { BaseModelSuite } from './base.ts';
@@ -25,6 +34,11 @@ class Person {
   gender: 'm' | 'f';
 }
 
+@Model('basic_person_temp')
+export class TempPerson {
+  id: string;
+}
+
 @Suite()
 export abstract class ModelBasicSuite extends BaseModelSuite<ModelCrudSupport> {
   @Test('create, read, delete')
@@ -100,4 +114,33 @@ export abstract class ModelBasicSuite extends BaseModelSuite<ModelCrudSupport> {
     assert(prepared.nameUpper === undefined);
     assert(prepared.ignoredField === undefined);
   }
+
+  @Test('deleteModel should not fail when underlying storage item is not found')
+  async testDeleteModelNotExists() {
+    const service = await this.service;
+    if (ModelStorageUtil.isSupported(service)) {
+      await service.deleteModel(TempPerson);
+      // Run it again now that the storage item is definitely deleted/not found
+      await service.deleteModel(TempPerson);
+      if (service.upsertModel) {
+        await service.upsertModel(TempPerson);
+      }
+    }
+  }
+
+  @Test('deleteStorage should not fail when underlying storage is not found')
+  async testDeleteStorageNotExists() {
+    const service = await this.service;
+    if (ModelStorageUtil.isSupported(service)) {
+      await service.deleteStorage();
+      // Run it again now that storage has been deleted
+      await service.deleteStorage();
+      await service.createStorage();
+      if (service.upsertModel) {
+        for (const modelClass of ModelRegistryIndex.getClasses().filter(model => model === SchemaRegistryIndex.getBaseClass(model))) {
+          await service.upsertModel(modelClass);
+        }
+      }
+    }
+  }
 }

package/support/test/suite.ts

@@ -53,26 +53,18 @@ class ModelSuiteHandler<T extends { configClass: Class<ConfigType>; serviceClass
         await service.truncateBlob();
       }
 
-      if (service.truncateModel) {
-        await Promise.all(models.map(model => service.truncateModel!(model)));
-      } else if (service.deleteModel) {
-        await Promise.all(models.map(model => service.deleteModel!(model)));
-      } else {
-        await service.deleteStorage(); // Purge it all
-      }
+      await Promise.all(models.map(model => service.truncateModel(model)));
     }
   }
 
   async afterAll(instance: T) {
     const service = await DependencyRegistryIndex.getInstance<T>(instance.serviceClass, this.qualifier);
     if (ModelStorageUtil.isSupported(service)) {
-      if (service.deleteModel) {
-        for (const model of ModelRegistryIndex.getClasses()) {
-          if (model === SchemaRegistryIndex.getBaseClass(model)) {
-            await service.deleteModel(model);
-          }
-        }
-      }
+      await Promise.all(
+        ModelRegistryIndex.getClasses()
+          .filter(model => model === SchemaRegistryIndex.getBaseClass(model))
+          .map(model => service.deleteModel(model))
+      );
       await service.deleteStorage();
     }
   }