@travetto/model 8.0.0-alpha.8 → 8.0.0

package/src/registry/registry-adapter.ts

@@ -7,9 +7,10 @@ import type { ModelConfig } from './types.ts';
 function combineClasses(target: ModelConfig, sources: Partial<ModelConfig>[]): ModelConfig {
   for (const source of sources) {
     Object.assign(target, source, {
-      indices: [...(target.indices || []), ...(source.indices || [])],
+      indices: { ...(target.indices || {}), ...(source.indices || {}) },
       postLoad: [...(target.postLoad || []), ...(source.postLoad || [])],
       prePersist: [...(target.prePersist || []), ...(source.prePersist || [])],
+      transientFields: [...(target.transientFields || []), ...(source.transientFields || [])]
     });
   }
   if (target.store) {
@@ -27,14 +28,15 @@ export class ModelRegistryAdapter implements RegistryAdapter<ModelConfig> {
   }
 
   register(...data: Partial<ModelConfig>[]): ModelConfig {
-    const config = this.#config ??= {
+    const config = (this.#config ??= {
       class: this.#cls,
-      indices: [],
+      indices: {},
       autoCreate: 'development',
       store: this.#cls.name,
       postLoad: [],
-      prePersist: []
-    };
+      prePersist: [],
+      transientFields: []
+    });
     combineClasses(config, data);
     return config;
   }
@@ -48,12 +50,13 @@ export class ModelRegistryAdapter implements RegistryAdapter<ModelConfig> {
         config.store = parent.store;
       }
 
-      config.postLoad = [...parent.postLoad ?? [], ...config.postLoad ?? []];
-      config.prePersist = [...parent.prePersist ?? [], ...config.prePersist ?? []];
+      config.postLoad = [...(parent.postLoad ?? []), ...(config.postLoad ?? [])];
+      config.prePersist = [...(parent.prePersist ?? []), ...(config.prePersist ?? [])];
+      config.transientFields = [...(parent.transientFields ?? []), ...(config.transientFields ?? [])];
     }
   }
 
   get(): ModelConfig {
     return this.#config;
   }
-}
+}

package/src/registry/registry-index.ts

@@ -1,20 +1,15 @@
-import { type RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
-import { RuntimeError, castTo, type Class } from '@travetto/runtime';
+import { Registry, type RegistryIndex, RegistryIndexStore } from '@travetto/registry';
+import { type Class, castTo, RuntimeError } from '@travetto/runtime';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
-import type { IndexConfig, IndexType, ModelConfig } from './types.ts';
 import type { ModelType } from '../types/model.ts';
 import { ModelRegistryAdapter } from './registry-adapter.ts';
-import { IndexNotSupported } from '../error/invalid-index.ts';
-import { NotFoundError } from '../error/not-found.ts';
-
-type IndexResult<T extends ModelType, K extends IndexType[]> = IndexConfig<T> & { type: K[number] };
+import type { IndexConfig, ModelConfig } from './types.ts';
 
 /**
  * Model registry index for managing model configurations across classes
  */
 export class ModelRegistryIndex implements RegistryIndex {
-
   static #instance = Registry.registerIndex(this);
 
   static getForRegister(cls: Class): ModelRegistryAdapter {
@@ -33,12 +28,8 @@ export class ModelRegistryIndex implements RegistryIndex {
     return this.#instance.getStoreName(cls);
   }
 
-  static getIndices<T extends ModelType, K extends IndexType[]>(cls: Class<T>, supportedTypes?: K): IndexResult<T, K>[] {
-    return this.#instance.getIndices(cls, supportedTypes);
-  }
-
-  static getIndex<T extends ModelType, K extends IndexType[]>(cls: Class<T>, name: string, supportedTypes?: K): IndexResult<T, K> {
-    return this.#instance.getIndex(cls, name, supportedTypes);
+  static getIndices<T extends ModelType>(cls: Class<T>): IndexConfig[] {
+    return this.#instance.getIndices(cls);
   }
 
   static getExpiryFieldName<T extends ModelType>(cls: Class<T>): keyof T {
@@ -58,7 +49,9 @@ export class ModelRegistryIndex implements RegistryIndex {
 
   store = new RegistryIndexStore(ModelRegistryAdapter);
 
-  /** @private */ constructor(source: unknown) { Registry.validateConstructor(source); }
+  /** @private */ constructor(source: unknown) {
+    Registry.validateConstructor(source);
+  }
 
   onCreate(cls: Class): void {
     const schema = SchemaRegistryIndex.getConfig(cls);
@@ -71,7 +64,7 @@ export class ModelRegistryIndex implements RegistryIndex {
     const { store } = this.getConfig(cls);
     let classes = this.#modelNameMapping.get(store);
     if (!classes) {
-      this.#modelNameMapping.set(store, classes = new Set());
+      this.#modelNameMapping.set(store, (classes = new Set()));
     }
     classes.add(cls.Ⲑid);
 
@@ -94,25 +87,11 @@ export class ModelRegistryIndex implements RegistryIndex {
     return this.store.get(cls).get().store;
   }
 
-  /**
-   * Get Index
-   */
-  getIndex<T extends ModelType, K extends IndexType[]>(cls: Class<T>, name: string, supportedTypes?: K): IndexResult<T, K> {
-    const config = this.getConfig(cls).indices?.find((idx): idx is IndexConfig<T> => idx.name === name);
-    if (!config) {
-      throw new NotFoundError(`${cls.name} Index`, `${name}`);
-    }
-    if (supportedTypes && !supportedTypes.includes(config.type)) {
-      throw new IndexNotSupported(cls, config, `${config.type} indices are not supported.`);
-    }
-    return config;
-  }
-
   /**
    * Get Indices
    */
-  getIndices<T extends ModelType, K extends IndexType[]>(cls: Class<T>, supportedTypes?: K): IndexResult<T, K>[] {
-    return (this.getConfig(cls).indices ?? []).filter((idx): idx is IndexConfig<T> => !supportedTypes || supportedTypes.includes(idx.type));
+  getIndices<T extends ModelType>(cls: Class<T>): IndexConfig[] {
+    return Object.values(this.getConfig(cls).indices ?? []);
   }
 
   /**
@@ -126,4 +105,4 @@ export class ModelRegistryIndex implements RegistryIndex {
     }
     return castTo(expiry);
   }
-}
+}

package/src/registry/types.ts

@@ -1,23 +1,29 @@
-import type { Class, Primitive, ValidFields } from '@travetto/runtime';
+import type { Class } from '@travetto/runtime';
 
 import type { ModelType } from '../types/model.ts';
 
-type RetainPrimitiveFields<T> = Pick<T, ValidFields<T, Primitive | Date>>;
+export type DataHandler<T = unknown> = (inst: T) => Promise<T | void> | T | void;
 
-export type SortClauseRaw<T> = {
-  [P in keyof T]?:
-  T[P] extends object ? SortClauseRaw<RetainPrimitiveFields<T[P]>> : 1 | -1;
-};
+export type PrePersistScope = 'full' | 'partial' | 'all';
 
-type IndexClauseRaw<T> = {
-  [P in keyof T]?:
-  T[P] extends object ? IndexClauseRaw<RetainPrimitiveFields<T[P]>> : 1 | -1 | true;
+/**
+ * Index options
+ */
+export type IndexConfig<V extends string = string, T extends ModelType = ModelType> = {
+  /**
+   * Index name
+   */
+  name: string;
+  /**
+   * Type
+   */
+  type: V;
+  /**
+   * Class the index belongs to
+   */
+  class: Class<T>;
 };
 
-export type DataHandler<T = unknown> = (inst: T) => (Promise<T | void> | T | void);
-
-export type PrePersistScope = 'full' | 'partial' | 'all';
-
 /**
  * Model config
  */
@@ -33,7 +39,7 @@ export class ModelConfig<T extends ModelType = ModelType> {
   /**
    * Indices
    */
-  indices?: IndexConfig<T>[];
+  indices?: Record<string, IndexConfig>;
   /**
    * Vendor specific extras
    */
@@ -49,34 +55,13 @@ export class ModelConfig<T extends ModelType = ModelType> {
   /**
    * Pre-persist handlers
    */
-  prePersist?: { scope: PrePersistScope, handler: DataHandler<unknown> }[];
+  prePersist?: { scope: PrePersistScope; handler: DataHandler<unknown> }[];
   /**
    * Post-load handlers
    */
   postLoad?: DataHandler<unknown>[];
-}
-
-/**
- * Supported index types
- */
-export type IndexType = 'unique' | 'unsorted' | 'sorted';
-
-/**
- * Index options
- */
-export type IndexConfig<T extends ModelType> = {
-  /**
-   * Index name
-   */
-  name: string;
   /**
-   * Fields and sort order
+   * Fields to ignore during persistence
    */
-  fields: IndexClauseRaw<RetainPrimitiveFields<T>>[];
-  /**
-   * Type
-   */
-  type: IndexType;
-};
-
-export type IndexField<T extends ModelType> = IndexClauseRaw<RetainPrimitiveFields<T>>;
+  transientFields?: string[];
+}

package/src/types/basic.ts

@@ -1,12 +1,12 @@
 import type { Class } from '@travetto/runtime';
-import type { ModelIdSource, ModelType, OptionalId } from '../types/model.ts';
+
+import type { ModelIdSource, ModelType, OptionalId } from './model.ts';
 
 /**
  * Interface for basic data interface
  * @concrete
  */
 export interface ModelBasicSupport<C = unknown> {
-
   /**
    * Id Source
    */
@@ -37,4 +37,4 @@ export interface ModelBasicSupport<C = unknown> {
    * @throws {NotFoundError} When an item is not found
    */
   delete<T extends ModelType>(cls: Class<T>, id: string): Promise<void>;
-}
+}

package/src/types/blob.ts

@@ -1,4 +1,4 @@
-import type { BinaryType, BinaryMetadata, ByteRange, TimeSpan } from '@travetto/runtime';
+import type { BinaryMetadata, BinaryType, ByteRange, TimeSpan } from '@travetto/runtime';
 
 /**
  * Support for Blobs CRUD.
@@ -6,7 +6,6 @@ import type { BinaryType, BinaryMetadata, ByteRange, TimeSpan } from '@travetto/
  * @concrete
  */
 export interface ModelBlobSupport {
-
   /**
    * Upsert blob to storage
    * @param location The location of the blob
@@ -42,12 +41,13 @@ export interface ModelBlobSupport {
   updateBlobMetadata(location: string, metadata: BinaryMetadata): Promise<void>;
 
   /**
-   * Produces an externally usable URL for sharing limited read access to a specific resource
+   * Produces an externally usable URL for sharing limited read access to a specific resource.
+   * If expiresIn is explicitly set to false, returns a direct/public URL.
    *
    * @param location The asset location to read from
-   * @param expiresIn Expiry
+   * @param expiresIn Expiry or false for public/direct URL
    */
-  getBlobReadUrl?(location: string, expiresIn?: TimeSpan): Promise<string>;
+  getBlobReadUrl?(location: string, expiresIn?: TimeSpan | false): Promise<string>;
 
   /**
    * Produces an externally usable URL for sharing allowing direct write access
@@ -57,4 +57,4 @@ export interface ModelBlobSupport {
    * @param expiresIn Expiry
    */
   getBlobWriteUrl?(location: string, metadata: BinaryMetadata, expiresIn?: TimeSpan): Promise<string>;
-}
+}

package/src/types/bulk.ts

@@ -2,16 +2,12 @@ import { type Class, RuntimeError } from '@travetto/runtime';
 import type { ValidationError, ValidationResultError } from '@travetto/schema';
 
 import type { ModelCrudSupport } from './crud.ts';
-import type { ModelType, OptionalId } from '../types/model.ts';
+import type { ModelType, OptionalId } from './model.ts';
 
 /**
  * Bulk operation. Each operation has a single action and payload
  */
-export type BulkOperation<T extends ModelType> =
-  { delete?: T } &
-  { insert?: OptionalId<T> } &
-  { update?: T } &
-  { upsert?: OptionalId<T> };
+export type BulkOperation<T extends ModelType> = { delete?: T } & { insert?: OptionalId<T> } & { update?: T } & { upsert?: OptionalId<T> };
 
 /**
  * Bulk response provides a summary of all the operations
@@ -37,13 +33,13 @@ export interface BulkResponse<E = unknown> {
   };
 }
 
-type BulkErrorItem = { message: string, type: string, errors?: ValidationError[], idx: number };
+type BulkErrorItem = { message: string; type: string; errors?: ValidationError[]; idx: number };
 
 /**
  * Bulk processing error
  */
 export class BulkProcessError extends RuntimeError<{ errors: BulkErrorItem[] }> {
-  constructor(errors: { idx: number, error: ValidationResultError }[]) {
+  constructor(errors: { idx: number; error: ValidationResultError }[]) {
     super('Bulk processing errors have occurred', {
       category: 'data',
       details: {
@@ -63,4 +59,4 @@ export class BulkProcessError extends RuntimeError<{ errors: BulkErrorItem[] }>
  */
 export interface ModelBulkSupport extends ModelCrudSupport {
   processBulk<T extends ModelType>(cls: Class<T>, operations: BulkOperation<T>[]): Promise<BulkResponse>;
-}
+}

package/src/types/crud.ts

@@ -1,15 +1,13 @@
 import type { Class } from '@travetto/runtime';
 
-import type { ModelType, OptionalId } from '../types/model.ts';
-
 import type { ModelBasicSupport } from './basic.ts';
+import type { ModelListOptions, ModelType, OptionalId } from './model.ts';
 
 /**
  * Interface for simple CRUD
  * @concrete
  */
 export interface ModelCrudSupport extends ModelBasicSupport {
-
   /**
    * Update an item
    * @param item The document to update.
@@ -38,7 +36,12 @@ export interface ModelCrudSupport extends ModelBasicSupport {
   updatePartial<T extends ModelType>(cls: Class<T>, item: Partial<T> & { id: string }, view?: string): Promise<T>;
 
   /**
-   * List all items
+   * List all items of a collection, results returned in batches of items.
+   *
+   * Note: Batch size hint can be used to optimize batch size, but is not guaranteed.
+   *
+   * @param cls The class to list
+   * @param options Options for listing
    */
-  list<T extends ModelType>(cls: Class<T>): AsyncIterable<T>;
-}
+  list<T extends ModelType>(cls: Class<T>, options?: ModelListOptions): AsyncIterable<T[]>;
+}

package/src/types/expiry.ts

@@ -1,7 +1,7 @@
 import type { Class } from '@travetto/runtime';
 
-import type { ModelType } from '../types/model.ts';
 import type { ModelCrudSupport } from './crud.ts';
+import type { ModelType } from './model.ts';
 
 /**
  * Support for managing expiration of data
@@ -14,4 +14,4 @@ export interface ModelExpirySupport extends ModelCrudSupport {
    * @returns Returns the number of documents expired
    */
   deleteExpired<T extends ModelType>(cls: Class<T>): Promise<number>;
-}
+}

package/src/types/model.ts

@@ -1,7 +1,7 @@
 /**
  * Model Id Source
  */
-export type ModelIdSource = { create: () => string, valid: (id: string) => boolean };
+export type ModelIdSource = { create: () => string; valid: (id: string) => boolean };
 
 /**
  * Simple model interface
@@ -16,4 +16,13 @@ export interface ModelType {
   id: string;
 }
 
-export type OptionalId<T extends ModelType> = Omit<T, 'id'> & { id?: string };
+export type OptionalId<T extends ModelType> = Omit<T, 'id'> & { id?: string };
+
+/**
+ * Options for listing items
+ */
+export interface ModelListOptions {
+  abort?: AbortSignal;
+  limit?: number;
+  batchSizeHint?: number;
+}

package/src/types/storage.ts

@@ -1,6 +1,6 @@
 import type { Class } from '@travetto/runtime';
 
-import type { ModelType } from '../types/model.ts';
+import type { ModelType } from './model.ts';
 
 /**
  * This interface defines the behavior for dealing with the
@@ -12,7 +12,6 @@ import type { ModelType } from '../types/model.ts';
  * @concrete
  */
 export interface ModelStorageSupport {
-
   /**
    * Should storage modification be allowed
    */
@@ -48,4 +47,4 @@ export interface ModelStorageSupport {
    * Truncate blob storage data
    */
   truncateBlob?(): Promise<void>;
-}
+}

package/src/util/blob.ts

@@ -1,11 +1,11 @@
 import { hasFunction } from '@travetto/runtime';
+
 import type { ModelBlobSupport } from '../types/blob.ts';
 
 /**
  * Utilities for processing blobs
  */
 export class ModelBlobUtil {
-
   /**
    * Type guard for determining if service supports blob operations
    */
@@ -15,4 +15,4 @@ export class ModelBlobUtil {
    * Type guard for determining if service supports blob write urls
    */
   static isWriteUrlSupported = hasFunction<ModelBlobSupport>('getBlobWriteUrl');
-}
+}

package/src/util/bulk.ts

@@ -13,7 +13,6 @@ export type BulkPreStore<T extends ModelType> = {
 };
 
 export class ModelBulkUtil {
-
   /**
    * Type guard for determining if service supports bulk operation
    */
@@ -25,7 +24,11 @@ export class ModelBulkUtil {
    * @param operations
    * @param provider
    */
-  static async preStore<T extends ModelType>(cls: Class<T>, operations: BulkOperation<T>[], provider: ModelCrudProvider): Promise<BulkPreStore<T>> {
+  static async preStore<T extends ModelType>(
+    cls: Class<T>,
+    operations: BulkOperation<T>[],
+    provider: ModelCrudProvider
+  ): Promise<BulkPreStore<T>> {
     const insertedIds = new Map<number, string>();
     const upsertedIds = new Map<number, string>();
     const updatedIds = new Map<number, string>();
@@ -53,4 +56,4 @@ export class ModelBulkUtil {
     }
     return { insertedIds, upsertedIds, updatedIds, existingUpsertedIds, operations };
   }
-}
+}

package/src/util/crud.ts

@@ -1,13 +1,13 @@
-import { castTo, type Class, Util, RuntimeError, hasFunction, BinaryUtil, type BinaryArray, JSONUtil } from '@travetto/runtime';
+import { type BinaryArray, BinaryUtil, type Class, castKey, castTo, hasFunction, JSONUtil, RuntimeError, Util } from '@travetto/runtime';
 import { DataUtil, SchemaRegistryIndex, SchemaValidator, type ValidationError, ValidationResultError } from '@travetto/schema';
 
-import { ModelRegistryIndex } from '../registry/registry-index.ts';
-import type { ModelIdSource, ModelType, OptionalId } from '../types/model.ts';
-import { NotFoundError } from '../error/not-found.ts';
 import { ExistsError } from '../error/exists.ts';
 import { SubTypeNotSupportedError } from '../error/invalid-sub-type.ts';
+import { NotFoundError } from '../error/not-found.ts';
+import { ModelRegistryIndex } from '../registry/registry-index.ts';
 import type { DataHandler, PrePersistScope } from '../registry/types.ts';
 import type { ModelCrudSupport } from '../types/crud.ts';
+import type { ModelIdSource, ModelType, OptionalId } from '../types/model.ts';
 
 type ModelLoadInput = string | BinaryArray | object;
 
@@ -19,7 +19,6 @@ export type ModelCrudProvider = {
  * Crud utilities
  */
 export class ModelCrudUtil {
-
   /**
    * Type guard for determining if service supports crud operations
    */
@@ -34,16 +33,35 @@ export class ModelCrudUtil {
     return { create, valid };
   }
 
+  static async filterOutNotFound<T extends ModelType>(actions: Promise<T>[] | undefined): Promise<T[]> {
+    if (!actions) {
+      return [];
+    }
+    return (await Promise.allSettled(actions))
+      .map(p => {
+        if (p.status === 'fulfilled') {
+          return p.value;
+        } else if (p.reason instanceof NotFoundError) {
+          return undefined!;
+        } else {
+          throw p.reason;
+        }
+      })
+      .filter(item => !!item);
+  }
+
   /**
    * Load model
    * @param cls Class to load model for
    * @param input Input as string or plain object
    */
-  static async load<T extends ModelType>(cls: Class<T>, input: ModelLoadInput, onTypeMismatch: 'notfound' | 'exists' = 'notfound'): Promise<T> {
+  static async load<T extends ModelType>(
+    cls: Class<T>,
+    input: ModelLoadInput,
+    onTypeMismatch: 'notfound' | 'exists' = 'notfound'
+  ): Promise<T> {
     const resolvedInput: object =
-      typeof input === 'string' ? JSONUtil.fromUTF8(input) :
-        BinaryUtil.isBinaryArray(input) ? JSONUtil.fromBinaryArray(input) :
-          input;
+      typeof input === 'string' ? JSONUtil.fromUTF8(input) : BinaryUtil.isBinaryArray(input) ? JSONUtil.fromBinaryArray(input) : input;
 
     const result = SchemaRegistryIndex.getBaseClass(cls).from(resolvedInput);
 
@@ -64,7 +82,12 @@ export class ModelCrudUtil {
    * @param cls Type to store for
    * @param item Item to store
    */
-  static async preStore<T extends ModelType>(cls: Class<T>, item: Partial<OptionalId<T>>, provider: ModelCrudProvider, scope: PrePersistScope = 'all'): Promise<T> {
+  static async preStore<T extends ModelType>(
+    cls: Class<T>,
+    item: Partial<OptionalId<T>>,
+    provider: ModelCrudProvider,
+    scope: PrePersistScope = 'all'
+  ): Promise<T> {
     if (!item.id) {
       item.id = provider.idSource.create();
     }
@@ -96,6 +119,70 @@ export class ModelCrudUtil {
     return castTo(item);
   }
 
+  /**
+   * Recursively deletes or masks transient fields from an object based on its Model config.
+   * If transient fields are present, returns a copy with those fields set to undefined.
+   */
+  static cleanTransientFields<T>(cls: Class<T>, item: T): T {
+    if (!item || typeof item !== 'object') {
+      return item;
+    }
+    if (SchemaRegistryIndex.has(cls)) {
+      const schema = SchemaRegistryIndex.get(cls).get();
+      const transientFields = ModelRegistryIndex.has(cls) ? ModelRegistryIndex.getConfig(cls).transientFields : undefined;
+
+      const isCleanTarget = (key: string): boolean => {
+        return transientFields?.includes(key) ?? false;
+      };
+
+      const hasTargets = Object.keys(schema.fields).some(key => isCleanTarget(key));
+
+      let res = item;
+      if (hasTargets) {
+        res = { ...item };
+        for (const key of Object.keys(schema.fields)) {
+          if (isCleanTarget(key)) {
+            res[castKey<T>(key)] = undefined!;
+          }
+        }
+      }
+
+      for (const [key, field] of Object.entries(schema.fields)) {
+        const fieldKey = castKey<typeof res>(key);
+        if (!isCleanTarget(key) && res[fieldKey] !== undefined && res[fieldKey] !== null) {
+          if (field.array && Array.isArray(res[fieldKey])) {
+            const arr = res[fieldKey];
+            let changed = false;
+            const newArray = arr.map(subItem => {
+              const cleaned = this.cleanTransientFields(field.type, subItem);
+              if (cleaned !== subItem) {
+                changed = true;
+              }
+              return cleaned;
+            });
+            if (changed) {
+              if (res === item) {
+                res = { ...item };
+              }
+              res[fieldKey] = castTo(newArray);
+            }
+          } else {
+            const val = res[fieldKey];
+            const cleaned = this.cleanTransientFields(field.type, val);
+            if (cleaned !== val) {
+              if (res === item) {
+                res = { ...item };
+              }
+              res[fieldKey] = cleaned;
+            }
+          }
+        }
+      }
+      return res;
+    }
+    return item;
+  }
+
   /**
    * Ensure subtype is not supported
    */
@@ -111,16 +198,13 @@ export class ModelCrudUtil {
    */
   static async prePersist<T>(cls: Class<T>, item: T, scope: PrePersistScope): Promise<T> {
     const config = ModelRegistryIndex.getConfig(cls);
-    for (const state of (config.prePersist ?? [])) {
+    for (const state of config.prePersist ?? []) {
       if (state.scope === scope || scope === 'all' || state.scope === 'all') {
         const handler: DataHandler<T> = castTo(state.handler);
-        item = await handler(item) ?? item;
+        item = (await handler(item)) ?? item;
       }
     }
-    if (typeof item === 'object' && item && 'prePersist' in item && typeof item['prePersist'] === 'function') {
-      item = await item.prePersist() ?? item;
-    }
-    return item;
+    return this.cleanTransientFields(cls, item);
   }
 
   /**
@@ -129,10 +213,7 @@ export class ModelCrudUtil {
   static async postLoad<T>(cls: Class<T>, item: T): Promise<T> {
     const config = ModelRegistryIndex.getConfig(cls);
     for (const handler of castTo<DataHandler<T>[]>(config.postLoad ?? [])) {
-      item = await handler(item) ?? item;
-    }
-    if (typeof item === 'object' && item && 'postLoad' in item && typeof item['postLoad'] === 'function') {
-      item = await item.postLoad() ?? item;
+      item = (await handler(item)) ?? item;
     }
     return item;
   }
@@ -142,7 +223,9 @@ 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 RuntimeError(`A partial update requires a plain object, not an instance of ${castTo<Function>(item).constructor.name}`, { category: 'data' });
+      throw new RuntimeError(`A partial update requires a plain object, not an instance of ${castTo<Function>(item).constructor.name}`, {
+        category: 'data'
+      });
     }
     const keys = Object.keys(item);
     if ((keys.length === 1 && item.id) || keys.length === 0) {
@@ -164,4 +247,4 @@ export class ModelCrudUtil {
     const full = await get();
     return cls.from(castTo({ ...full, ...prepared }));
   }
-}
+}