@travetto/model 5.0.11 → 5.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model",
-  "version": "5.0.11",
+  "version": "5.0.13",
   "description": "Datastore abstraction for core operations.",
   "keywords": [
     "datastore",
@@ -26,14 +26,14 @@
     "directory": "module/model"
   },
   "dependencies": {
-    "@travetto/config": "^5.0.10",
-    "@travetto/di": "^5.0.10",
-    "@travetto/registry": "^5.0.10",
-    "@travetto/schema": "^5.0.10"
+    "@travetto/config": "^5.0.12",
+    "@travetto/di": "^5.0.12",
+    "@travetto/registry": "^5.0.12",
+    "@travetto/schema": "^5.0.12"
   },
   "peerDependencies": {
-    "@travetto/cli": "^5.0.10",
-    "@travetto/test": "^5.0.10"
+    "@travetto/cli": "^5.0.15",
+    "@travetto/test": "^5.0.14"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/error/exists.ts

@@ -5,6 +5,6 @@ import { Class, AppError } from '@travetto/runtime';
  */
 export class ExistsError extends AppError {
   constructor(cls: Class | string, id: string) {
-    super(`${typeof cls === 'string' ? cls : cls.name} with id ${id} already exists`, 'data');
+    super(`${typeof cls === 'string' ? cls : cls.name} with id ${id} already exists`, { category: 'data' });
   }
 }

package/src/error/invalid-index.ts

@@ -8,6 +8,6 @@ import { ModelType } from '../types/model';
  */
 export class IndexNotSupported<T extends ModelType> extends AppError {
   constructor(cls: Class<T>, idx: IndexConfig<T>, message: string = '') {
-    super(`${typeof cls === 'string' ? cls : cls.name} and index ${idx.name} of type ${idx.type} is not supported. ${message}`.trim(), 'data');
+    super(`${typeof cls === 'string' ? cls : cls.name} and index ${idx.name} of type ${idx.type} is not supported. ${message}`.trim(), { category: 'data' });
   }
 }

package/src/error/invalid-sub-type.ts

@@ -5,6 +5,6 @@ import { Class, AppError } from '@travetto/runtime';
  */
 export class SubTypeNotSupportedError extends AppError {
   constructor(cls: Class | string) {
-    super(`${typeof cls === 'string' ? cls : cls.name} cannot be used for this operation`, 'data');
+    super(`${typeof cls === 'string' ? cls : cls.name} cannot be used for this operation`, { category: 'data' });
   }
 }

package/src/error/not-found.ts

@@ -4,7 +4,7 @@ import { Class, AppError } from '@travetto/runtime';
  * Represents when a model of cls and id cannot be found
  */
 export class NotFoundError extends AppError {
-  constructor(cls: Class | string, id: string, details?: unknown) {
-    super(`${typeof cls === 'string' ? cls : cls.name} with id ${id} not found`, 'notfound', details);
+  constructor(cls: Class | string, id: string, details?: Record<string, unknown>) {
+    super(`${typeof cls === 'string' ? cls : cls.name} with id ${id} not found`, { category: 'notfound', details });
   }
 }

package/src/internal/service/blob.ts

@@ -39,7 +39,7 @@ export class ModelBlobUtil {
     end = Math.min(end ?? (size - 1), size - 1);
 
     if (Number.isNaN(start) || Number.isNaN(end) || !Number.isFinite(start) || start >= size || start < 0 || start > end) {
-      throw new AppError('Invalid position, out of range', 'data');
+      throw new AppError('Invalid position, out of range', { category: 'data' });
     }
 
     return { start, end };

package/src/internal/service/crud.ts

@@ -140,7 +140,7 @@ export class ModelCrudUtil {
    */
   static async prePartialUpdate<T extends ModelType>(cls: Class<T>, item: Partial<T>, view?: string): Promise<Partial<T>> {
     if (!DataUtil.isPlainObject(item)) {
-      throw new AppError(`A partial update requires a plain object, not an instance of ${castTo<Function>(item).constructor.name}`, 'data');
+      throw new AppError(`A partial update requires a plain object, not an instance of ${castTo<Function>(item).constructor.name}`, { category: 'data' });
     }
     const res = await this.prePersist(cls, castTo(item), 'partial');
     await SchemaValidator.validatePartial(cls, item, view);

package/src/registry/model.ts

@@ -167,12 +167,12 @@ class $ModelRegistry extends MetadataRegistry<ModelOptions<ModelType>> {
       // Don't allow two models with same class name, or same store name
       if (candidates.length > 1) {
         if (config.store) {
-          throw new AppError('Duplicate models with same store name', 'general', {
-            classes: candidates.map(x => x.Ⲑid)
+          throw new AppError('Duplicate models with same store name', {
+            details: { classes: candidates.map(x => x.Ⲑid) }
           });
         } else {
-          throw new AppError('Duplicate models with same class name, but no store name provided', 'general', {
-            classes: candidates.map(x => x.Ⲑid)
+          throw new AppError('Duplicate models with same class name, but no store name provided', {
+            details: { classes: candidates.map(x => x.Ⲑid) }
           });
         }
       }
@@ -210,7 +210,7 @@ class $ModelRegistry extends MetadataRegistry<ModelOptions<ModelType>> {
   getExpiry<T extends ModelType>(cls: Class<T>): keyof T {
     const expiry = this.get(cls).expiresAt;
     if (!expiry) {
-      throw new AppError(`${cls.name} is not configured with expiry support, please use @ExpiresAt to declare expiration behavior`, 'general');
+      throw new AppError(`${cls.name} is not configured with expiry support, please use @ExpiresAt to declare expiration behavior`);
     }
     return castTo(expiry);
   }

package/src/service/bulk.ts

@@ -1,5 +1,5 @@
 import { Class, AppError } from '@travetto/runtime';
-import { ValidationResultError } from '@travetto/schema';
+import { ValidationError, ValidationResultError } from '@travetto/schema';
 
 import { ModelCrudSupport } from './crud';
 import { ModelType, OptionalId } from '../types/model';
@@ -37,16 +37,21 @@ export interface BulkResponse<E = unknown> {
   };
 }
 
+type BulkErrorItem = { message: string, type: string, errors?: ValidationError[], idx: number };
+
 /**
  * Bulk processing error
  */
-export class BulkProcessError extends AppError {
+export class BulkProcessError extends AppError<{ errors: BulkErrorItem[] }> {
   constructor(public errors: { idx: number, error: ValidationResultError }[]) {
-    super('Bulk processing errors have occurred', 'data', {
-      errors: errors.map(x => {
-        const { message, type, details: { errors: subErrors } = {}, details } = x.error;
-        return { message, type, errors: subErrors ?? details, idx: x.idx };
-      })
+    super('Bulk processing errors have occurred', {
+      category: 'data',
+      details: {
+        errors: errors.map(x => {
+          const { message, type, details: { errors: subErrors } = {} } = x.error;
+          return { message, type, errors: subErrors, idx: x.idx };
+        })
+      }
     });
   }
 }