@travetto/model 5.0.0-rc.8 → 5.0.0

package/README.md

@@ -16,7 +16,7 @@ yarn add @travetto/model
 This module provides a set of contracts/interfaces to data model persistence, modification and retrieval.  This module builds heavily upon the [Schema](https://github.com/travetto/travetto/tree/main/module/schema#readme "Data type registry for runtime validation, reflection and binding."), which is used for data model validation.
 
 ## Contracts
-The module is mainly composed of contracts.  The contracts define the expected interface for various model patterns. The primary contracts are [Basic](https://github.com/travetto/travetto/tree/main/module/model/src/service/basic.ts#L9), [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/service/crud.ts#L11), [Indexed](https://github.com/travetto/travetto/tree/main/module/model/src/service/indexed.ts#L12), [Expiry](https://github.com/travetto/travetto/tree/main/module/model/src/service/expiry.ts#L11), [Streaming](https://github.com/travetto/travetto/tree/main/module/model/src/service/stream.ts#L3) and [Bulk](https://github.com/travetto/travetto/tree/main/module/model/src/service/bulk.ts#L19).
+The module is mainly composed of contracts.  The contracts define the expected interface for various model patterns. The primary contracts are [Basic](https://github.com/travetto/travetto/tree/main/module/model/src/service/basic.ts#L9), [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/service/crud.ts#L11), [Indexed](https://github.com/travetto/travetto/tree/main/module/model/src/service/indexed.ts#L12), [Expiry](https://github.com/travetto/travetto/tree/main/module/model/src/service/expiry.ts#L11), [Blob](https://github.com/travetto/travetto/tree/main/module/model/src/service/blob.ts#L8) and [Bulk](https://github.com/travetto/travetto/tree/main/module/model/src/service/bulk.ts#L19).
 
 ### Basic
 All [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") implementations, must honor the [Basic](https://github.com/travetto/travetto/tree/main/module/model/src/service/basic.ts#L9) contract to be able to participate in the model ecosystem.  This contract represents the bare minimum for a model service.
@@ -153,38 +153,39 @@ export interface ModelExpirySupport extends ModelCrudSupport {
 }
 ```
 
-### Stream
-Some implementations also allow for the ability to read/write binary data as a [Streaming](https://github.com/travetto/travetto/tree/main/module/model/src/service/stream.ts#L3).  Given that all implementations can store [Base64](https://en.wikipedia.org/wiki/Base64) encoded data, the key differentiator here, is native support for streaming data, as well as being able to store binary data of significant sizes.  This pattern is currently used by [Asset](https://github.com/travetto/travetto/tree/main/module/asset#readme "Modular library for storing and retrieving binary assets") for reading and writing asset data.
+### Blob
+Some implementations also allow for the ability to read/write binary data as [Blob](https://github.com/travetto/travetto/tree/main/module/model/src/service/blob.ts#L8).  Given that all implementations can store [Base64](https://en.wikipedia.org/wiki/Base64) encoded data, the key differentiator here, is native support for streaming data, as well as being able to store binary data of significant sizes.
 
-**Code: Stream Contract**
+**Code: Blob Contract**
 ```typescript
-export interface ModelStreamSupport {
+export interface ModelBlobSupport {
 
   /**
-   * Upsert stream to storage
-   * @param location The location of the stream
-   * @param input The actual stream to write
-   * @param meta The stream metadata
+   * Upsert blob to storage
+   * @param location The location of the blob
+   * @param input The actual blob to write
+   * @param meta Additional metadata to store with the blob
+   * @param overwrite Should we replace content if already found, defaults to true
    */
-  upsertStream(location: string, input: Readable, meta: StreamMeta): Promise<void>;
+  upsertBlob(location: string, input: BinaryInput, meta?: BlobMeta, overwrite?: boolean): Promise<void>;
 
   /**
-   * Get stream from asset store
-   * @param location The location of the stream
+   * Get blob from storage
+   * @param location The location of the blob
    */
-  getStream(location: string, range?: StreamRange): Promise<Readable>;
+  getBlob(location: string, range?: ByteRange): Promise<Blob>;
 
   /**
-   * Get metadata for stream
-   * @param location The location of the stream
+   * Get metadata for blob
+   * @param location The location of the blob
    */
-  describeStream(location: string): Promise<StreamMeta>;
+  describeBlob(location: string): Promise<BlobMeta>;
 
   /**
-   * Delete stream by location
-   * @param location The location of the stream
+   * Delete blob by location
+   * @param location The location of the blob
    */
-  deleteStream(location: string): Promise<void>;
+  deleteBlob(location: string): Promise<void>;
 }
 ```
 
@@ -216,8 +217,8 @@ export interface ModelType {
 The `id` is the only required field for a model, as this is a hard requirement on naming and type.  This may make using existing data models impossible if types other than strings are required.  Additionally, the `type` field, is intended to record the base model type, but can be remapped. This is important to support polymorphism, not only in [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations."), but also in [Schema](https://github.com/travetto/travetto/tree/main/module/schema#readme "Data type registry for runtime validation, reflection and binding.").
 
 ## Implementations
-|Service|Basic|CRUD|Indexed|Expiry|Stream|Bulk|
-|-------|-----|----|-------|------|------|----|
+|Service|Basic|CRUD|Indexed|Expiry|Blob|Bulk|
+|-------|-----|----|-------|------|----|----|
 |[DynamoDB Model Support](https://github.com/travetto/travetto/tree/main/module/model-dynamodb#readme "DynamoDB backing for the travetto model module.")|X|X|X|X| | |
 |[Elasticsearch Model Source](https://github.com/travetto/travetto/tree/main/module/model-elasticsearch#readme "Elasticsearch backing for the travetto model module, with real-time modeling support for Elasticsearch mappings.")|X|X|X|X| |X|
 |[Firestore Model Support](https://github.com/travetto/travetto/tree/main/module/model-firestore#readme "Firestore backing for the travetto model module.")|X|X|X| | | |
@@ -225,142 +226,76 @@ The `id` is the only required field for a model, as this is a hard requirement o
 |[Redis Model Support](https://github.com/travetto/travetto/tree/main/module/model-redis#readme "Redis backing for the travetto model module.")|X|X|X|X| ||
 |[S3 Model Support](https://github.com/travetto/travetto/tree/main/module/model-s3#readme "S3 backing for the travetto model module.")|X|X| |X|X| |
 |[SQL Model Service](https://github.com/travetto/travetto/tree/main/module/model-sql#readme "SQL backing for the travetto model module, with real-time modeling support for SQL schemas.")|X|X|X|X| |X|
-|[MemoryModelService](https://github.com/travetto/travetto/tree/main/module/model/src/provider/memory.ts#L54)|X|X|X|X|X|X|
-|[FileModelService](https://github.com/travetto/travetto/tree/main/module/model/src/provider/file.ts#L49)|X|X| |X|X|X|
+|[Memory Model Support](https://github.com/travetto/travetto/tree/main/module/model-memory#readme "Memory backing for the travetto model module.")|X|X|X|X|X|X|
+|[File Model Support](https://github.com/travetto/travetto/tree/main/module/model-file#readme "File system backing for the travetto model module.")|X|X| |X|X|X|
 
 ## Custom Model Service
-In addition to the provided contracts, the module also provides common utilities and shared test suites.  The common utilities are useful for repetitive functionality, that is unable to be shared due to not relying upon inheritance (this was an intentional design decision).  This allows for all the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") implementations to completely own the functionality and also to be able to provide additional/unique functionality that goes beyond the interface.
-
-**Code: Memory Service**
-```typescript
-import { Readable } from 'node:stream';
-import { buffer as toBuffer } from 'node:stream/consumers';
-import { Class, TimeSpan, DeepPartial } from '@travetto/runtime';
-import { Injectable } from '@travetto/di';
-import { Config } from '@travetto/config';
-import { ModelCrudSupport } from '../service/crud';
-import { ModelStreamSupport, StreamMeta, StreamRange } from '../service/stream';
-import { ModelType, OptionalId } from '../types/model';
-import { ModelExpirySupport } from '../service/expiry';
-import { ModelRegistry } from '../registry/model';
-import { ModelStorageSupport } from '../service/storage';
-import { ModelCrudUtil } from '../internal/service/crud';
-import { ModelExpiryUtil } from '../internal/service/expiry';
-import { NotFoundError } from '../error/not-found';
-import { ExistsError } from '../error/exists';
-import { ModelIndexedSupport } from '../service/indexed';
-import { ModelIndexedUtil } from '../internal/service/indexed';
-import { ModelStorageUtil } from '../internal/service/storage';
-import { enforceRange, StreamModel, STREAMS } from '../internal/service/stream';
-import { IndexConfig } from '../registry/types';
-const STREAM_META = `${STREAMS}_meta`;
-type StoreType = Map<string, Buffer>;
-@Config('model.memory')
-export class MemoryModelConfig {
-  autoCreate?: boolean = true;
-  namespace?: string;
-  cullRate?: number | TimeSpan;
-}
-function indexName<T extends ModelType>(cls: Class<T>, idx: IndexConfig<T> | string, suffix?: string): string {
-  return [cls.Ⲑid, typeof idx === 'string' ? idx : idx.name, suffix].filter(x => !!x).join(':');
-}
-function getFirstId(data: Map<string, unknown> | Set<string>, value?: string | number): string | undefined {
-  let id: string | undefined;
-  if (data instanceof Set) {
-    id = data.values().next().value;
-  } else {
-    id = [...data.entries()].find(([k, v]) => value === undefined || v === value)?.[0];
-  }
-  return id;
-}
-/**
- * Standard in-memory support
- */
-@Injectable()
-export class MemoryModelService implements ModelCrudSupport, ModelStreamSupport, ModelExpirySupport, ModelStorageSupport, ModelIndexedSupport {
-    sorted: new Map<string, Map<string, Map<string, number>>>(),
-    unsorted: new Map<string, Map<string, Set<string>>>()
-  };
-  idSource = ModelCrudUtil.uuidSource();
-  get client(): Map<string, StoreType>;
-  constructor(public readonly config: MemoryModelConfig) { }
-  async postConstruct(): Promise<void>;
-  // CRUD Support
-  async get<T extends ModelType>(cls: Class<T>, id: string): Promise<T>;
-  async create<T extends ModelType>(cls: Class<T>, item: OptionalId<T>): Promise<T>;
-  async update<T extends ModelType>(cls: Class<T>, item: T): Promise<T>;
-  async upsert<T extends ModelType>(cls: Class<T>, item: OptionalId<T>): Promise<T>;
-  async updatePartial<T extends ModelType>(cls: Class<T>, item: Partial<T> & { id: string }, view?: string): Promise<T>;
-  async delete<T extends ModelType>(cls: Class<T>, id: string): Promise<void>;
-  async * list<T extends ModelType>(cls: Class<T>): AsyncIterable<T>;
-  // Stream Support
-  async upsertStream(location: string, input: Readable, meta: StreamMeta): Promise<void>;
-  async getStream(location: string, range?: StreamRange): Promise<Readable>;
-  async describeStream(location: string): Promise<StreamMeta>;
-  async deleteStream(location: string): Promise<void>;
-  // Expiry
-  async deleteExpired<T extends ModelType>(cls: Class<T>): Promise<number>;
-  // Storage Support
-  async createStorage(): Promise<void>;
-  async deleteStorage(): Promise<void>;
-  async createModel<T extends ModelType>(cls: Class<T>): Promise<void>;
-  async truncateModel<T extends ModelType>(cls: Class<T>): Promise<void>;
-  // Indexed
-  async getByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<T>;
-  async deleteByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<void>;
-  upsertByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: OptionalId<T>): Promise<T>;
-  async * listByIndex<T extends ModelType>(cls: Class<T>, idx: string, body?: DeepPartial<T>): AsyncIterable<T>;
-}
-```
+In addition to the provided contracts, the module also provides common utilities and shared test suites.  The common utilities are useful for repetitive functionality, that is unable to be shared due to not relying upon inheritance (this was an intentional design decision).  This allows for all the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") implementations to completely own the functionality and also to be able to provide additional/unique functionality that goes beyond the interface. [Memory Model Support](https://github.com/travetto/travetto/tree/main/module/model-memory#readme "Memory backing for the travetto model module.") serves as a great example of what a full featured implementation can look like.
 
 To enforce that these contracts are honored, the module provides shared test suites to allow for custom implementations to ensure they are adhering to the contract's expected behavior.
 
 **Code: Memory Service Test Configuration**
 ```typescript
-import { Suite } from '@travetto/test';
-
-import { MemoryModelConfig, MemoryModelService } from '../src/provider/memory';
-import { ModelCrudSuite } from '../support/test/crud';
-import { ModelExpirySuite } from '../support/test/expiry';
-import { ModelStreamSuite } from '../support/test/stream';
-import { ModelIndexedSuite } from '../support/test/indexed';
-import { ModelBasicSuite } from '../support/test/basic';
-import { ModelPolymorphismSuite } from '../support/test/polymorphism';
-
-@Suite()
-export class MemoryBasicSuite extends ModelBasicSuite {
-  serviceClass = MemoryModelService;
-  configClass = MemoryModelConfig;
-}
+import { DependencyRegistry } from '@travetto/di';
+import { AppError, castTo, Class, classConstruct } from '@travetto/runtime';
 
-@Suite()
-export class MemoryCrudSuite extends ModelCrudSuite {
-  serviceClass = MemoryModelService;
-  configClass = MemoryModelConfig;
-}
+import { isBulkSupported, isCrudSupported } from '../../src/internal/service/common';
+import { ModelType } from '../../src/types/model';
+import { ModelSuite } from './suite';
 
-@Suite()
-export class MemoryStreamSuite extends ModelStreamSuite {
-  serviceClass = MemoryModelService;
-  configClass = MemoryModelConfig;
-}
+type ServiceClass = { serviceClass: { new(): unknown } };
 
-@Suite()
-export class MemoryExpirySuite extends ModelExpirySuite {
-  serviceClass = MemoryModelService;
-  configClass = MemoryModelConfig;
-}
+@ModelSuite()
+export abstract class BaseModelSuite<T> {
 
-@Suite()
-export class MemoryIndexedSuite extends ModelIndexedSuite {
-  serviceClass = MemoryModelService;
-  configClass = MemoryModelConfig;
-}
+  static ifNot(pred: (svc: unknown) => boolean): (x: unknown) => Promise<boolean> {
+    return async (x: unknown) => !pred(classConstruct(castTo<ServiceClass>(x).serviceClass));
+  }
+
+  serviceClass: Class<T>;
+  configClass: Class;
+
+  async getSize<U extends ModelType>(cls: Class<U>): Promise<number> {
+    const svc = (await this.service);
+    if (isCrudSupported(svc)) {
+      let i = 0;
+      for await (const __el of svc.list(cls)) {
+        i += 1;
+      }
+      return i;
+    } else {
+      throw new AppError(`Size is not supported for this service: ${this.serviceClass.name}`);
+    }
+  }
 
-@Suite()
-export class MemoryPolymorphicSuite extends ModelPolymorphismSuite {
-  serviceClass = MemoryModelService;
-  configClass = MemoryModelConfig;
+  async saveAll<M extends ModelType>(cls: Class<M>, items: M[]): Promise<number> {
+    const svc = await this.service;
+    if (isBulkSupported(svc)) {
+      const res = await svc.processBulk(cls, items.map(x => ({ insert: x })));
+      return res.counts.insert;
+    } else if (isCrudSupported(svc)) {
+      const out: Promise<M>[] = [];
+      for (const el of items) {
+        out.push(svc.create(cls, el));
+      }
+      await Promise.all(out);
+      return out.length;
+    } else {
+      throw new Error('Service does not support crud operations');
+    }
+  }
+
+  get service(): Promise<T> {
+    return DependencyRegistry.getInstance(this.serviceClass);
+  }
+
+  async toArray<U>(src: AsyncIterable<U> | AsyncGenerator<U>): Promise<U[]> {
+    const out: U[] = [];
+    for await (const el of src) {
+      out.push(el);
+    }
+    return out;
+  }
 }
 ```
 
@@ -403,7 +338,6 @@ Options:
 
 Providers
 --------------------
-  * Memory
   * SQL
 
 Models

package/__index__.ts

@@ -3,15 +3,12 @@ export * from './src/registry/model';
 export * from './src/registry/types';
 export * from './src/types/model';
 export * from './src/service/basic';
+export * from './src/service/blob';
 export * from './src/service/bulk';
 export * from './src/service/crud';
 export * from './src/service/indexed';
 export * from './src/service/expiry';
 export * from './src/service/storage';
-export * from './src/service/stream';
-
-export * from './src/provider/file';
-export * from './src/provider/memory';
 
 export * from './src/error/exists';
 export * from './src/error/not-found';

package/package.json

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

package/src/internal/service/blob.ts

@@ -0,0 +1,47 @@
+import { Readable } from 'node:stream';
+import { Class, AppError, BinaryInput, BinaryUtil, BlobMeta, ByteRange } from '@travetto/runtime';
+import { ModelType } from '../../types/model';
+
+export const ModelBlobNamespace = '__blobs';
+export const MODEL_BLOB: Class<ModelType> = class { id: string; };
+
+/**
+ * Utilities for processing assets
+ */
+export class ModelBlobUtil {
+
+  /**
+   * Convert input to a Readable, and get what metadata is available
+   */
+  static async getInput(src: BinaryInput, metadata: BlobMeta = {}): Promise<[Readable, BlobMeta]> {
+    let input: Readable;
+    if (src instanceof Blob) {
+      metadata = { ...BinaryUtil.getBlobMeta(src), ...metadata };
+      metadata.size ??= src.size;
+      input = Readable.fromWeb(src.stream());
+    } else if (typeof src === 'object' && 'pipeThrough' in src) {
+      input = Readable.fromWeb(src);
+    } else if (typeof src === 'object' && 'pipe' in src) {
+      input = src;
+    } else {
+      metadata.size = src.length;
+      input = Readable.from(src);
+    }
+
+    return [input, metadata ?? {}];
+  }
+
+  /**
+   * Enforce byte range for stream stream/file of a certain size
+   */
+  static enforceRange({ start, end }: ByteRange, size: number): Required<ByteRange> {
+    // End is inclusive
+    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');
+    }
+
+    return { start, end };
+  }
+}

package/src/internal/service/common.ts

@@ -1,78 +1,72 @@
+import { ClassInstance } from '@travetto/runtime';
 import type { ModelBulkSupport } from '../../service/bulk';
 import { ModelCrudSupport } from '../../service/crud';
 import type { ModelExpirySupport } from '../../service/expiry';
 import { ModelIndexedSupport } from '../../service/indexed';
 import type { ModelStorageSupport } from '../../service/storage';
-import type { ModelStreamSupport } from '../../service/stream';
+import { ModelBlobSupport } from '../../service/blob';
 
 export class ModelBasicSupportTarget { }
 export class ModelCrudSupportTarget { }
 export class ModelBulkSupportTarget { }
 export class ModelStorageSupportTarget { }
+export class ModelBlobSupportTarget { }
 export class ModelExpirySupportTarget { }
-export class ModelStreamSupportTarget { }
 export class ModelIndexedSupportTarget { }
 
 /**
  * Type guard for determining if service supports basic operations
  * @param o
  */
-export function isBasicSupported(o: unknown): o is ModelBulkSupport {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return !!o && !!(o as Record<string, unknown>)['create'];
+export function isBasicSupported(o: ClassInstance): o is ModelBulkSupport {
+  return !!o && 'create' in o;
 }
 
 /**
  * Type guard for determining if service supports crud operations
  * @param o
  */
-export function isCrudSupported(o: unknown): o is ModelCrudSupport {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return !!o && !!(o as Record<string, unknown>)['upsert'];
+export function isCrudSupported(o: ClassInstance): o is ModelCrudSupport {
+  return !!o && 'upsert' in o;
 }
 
 /**
- * Type guard for determining if model is expirable
+ * Type guard for determining if model supports expiry
  * @param o
  */
-export function isExpirySupported(o: unknown): o is ModelExpirySupport {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return !!o && !!(o as Record<string, unknown>)['deleteExpired'];
+export function isExpirySupported(o: ClassInstance): o is ModelExpirySupport {
+  return !!o && 'deleteExpired' in o;
 }
 
 /**
- * Type guard for determining if service supports storage operation
+ * Type guard for determining if service supports streaming operation
  * @param o
  */
-export function isStorageSupported(o: unknown): o is ModelStorageSupport {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return !!o && !!(o as Record<string, unknown>)['createStorage'];
+export function isBlobSupported(o: ClassInstance): o is ModelBlobSupport {
+  return !!o && 'getBlob' in o;
 }
 
 /**
- * Type guard for determining if service supports streaming operation
+ * Type guard for determining if service supports storage operation
  * @param o
  */
-export function isStreamSupported(o: unknown): o is ModelStreamSupport {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return !!o && !!(o as Record<string, unknown>)['getStream'];
+export function isStorageSupported(o: ClassInstance): o is ModelStorageSupport {
+  return !!o && 'createStorage' in o;
 }
 
 /**
  * Type guard for determining if service supports streaming operation
  * @param o
  */
-export function isBulkSupported(o: unknown): o is ModelBulkSupport {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return !!o && !!(o as Record<string, unknown>)['processBulk'];
+export function isBulkSupported(o: ClassInstance): o is ModelBulkSupport {
+  return !!o && 'processBulk' in o;
 }
 
 /**
  * Type guard for determining if service supports indexed operation
  * @param o
  */
-export function isIndexedSupported(o: unknown): o is ModelIndexedSupport {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return !!o && !!(o as Record<string, unknown>)['getByIndex'];
+export function isIndexedSupported(o: ClassInstance): o is ModelIndexedSupport {
+  return !!o && 'getByIndex' in o;
 }
 

package/src/internal/service/crud.ts

@@ -1,6 +1,6 @@
 import crypto from 'node:crypto';
 
-import { Class, Util } from '@travetto/runtime';
+import { castTo, Class, asFull, Util, asConstructable } from '@travetto/runtime';
 import { DataUtil, SchemaRegistry, SchemaValidator, ValidationError, ValidationResultError } from '@travetto/schema';
 
 import { ModelRegistry } from '../../registry/model';
@@ -46,14 +46,16 @@ export class ModelCrudUtil {
    * @param input Input as string or plain object
    */
   static async load<T extends ModelType>(cls: Class<T>, input: Buffer | string | object, onTypeMismatch: 'notfound' | 'exists' = 'notfound'): Promise<T> {
+    let resolvedInput: object;
     if (typeof input === 'string') {
-      input = JSON.parse(input);
+      resolvedInput = JSON.parse(input);
     } else if (input instanceof Buffer) {
-      input = JSON.parse(input.toString('utf8'));
+      resolvedInput = JSON.parse(input.toString('utf8'));
+    } else {
+      resolvedInput = input;
     }
 
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const result = ModelRegistry.getBaseModel(cls).from(input as object) as T;
+    const result = ModelRegistry.getBaseModel(cls).from(resolvedInput);
 
     if (!(result instanceof cls || result.constructor.Ⲑid === cls.Ⲑid)) {
       if (onTypeMismatch === 'notfound') {
@@ -78,12 +80,10 @@ export class ModelCrudUtil {
     }
 
     if (DataUtil.isPlainObject(item)) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      item = cls.from(item as object);
+      item = cls.from(castTo(item));
     }
 
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const config = ModelRegistry.get(item.constructor as Class<T>);
+    const config = ModelRegistry.get(asConstructable(item).constructor);
     if (config.subType) { // Sub-typing, assign type
       SchemaRegistry.ensureInstanceTypeField(cls, item);
     }
@@ -106,8 +106,7 @@ export class ModelCrudUtil {
     if (errors.length) {
       throw new ValidationResultError(errors);
     }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return item as T;
+    return castTo(item);
   }
 
   /**
@@ -119,12 +118,10 @@ export class ModelCrudUtil {
    */
   static async naivePartialUpdate<T extends ModelType>(cls: Class<T>, item: Partial<T>, view: undefined | string, getExisting: () => Promise<T>): Promise<T> {
     if (DataUtil.isPlainObject(item)) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      item = cls.from(item as object);
+      item = cls.from(castTo(item));
     }
 
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const config = ModelRegistry.get(item.constructor as Class<T>);
+    const config = ModelRegistry.get(asConstructable(item).constructor);
     if (config.subType) { // Sub-typing, assign type
       SchemaRegistry.ensureInstanceTypeField(cls, item);
     }
@@ -139,8 +136,7 @@ export class ModelCrudUtil {
 
     item = await this.prePersist(cls, item, 'partial');
 
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return item as T;
+    return asFull(item);
   }
 
   /**
@@ -159,8 +155,7 @@ export class ModelCrudUtil {
     const config = ModelRegistry.get(cls);
     for (const state of (config.prePersist ?? [])) {
       if (state.scope === scope || scope === 'all' || state.scope === 'all') {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const handler = state.handler as unknown as DataHandler<T>;
+        const handler: DataHandler<T> = castTo(state.handler);
         item = await handler(item) ?? item;
       }
     }
@@ -175,8 +170,7 @@ export class ModelCrudUtil {
    */
   static async postLoad<T>(cls: Class<T>, item: T): Promise<T> {
     const config = ModelRegistry.get(cls);
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    for (const handler of (config.postLoad ?? []) as unknown as DataHandler<T>[]) {
+    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') {

package/src/internal/service/expiry.ts

@@ -1,4 +1,4 @@
-import { ShutdownManager, Class, TimeSpan, TimeUtil, Util } from '@travetto/runtime';
+import { ShutdownManager, Class, TimeSpan, TimeUtil, Util, castTo } from '@travetto/runtime';
 
 import { ModelRegistry } from '../../registry/model';
 import { ModelExpirySupport } from '../../service/expiry';
@@ -15,10 +15,7 @@ export class ModelExpiryUtil {
    */
   static getExpiryState<T extends ModelType>(cls: Class<T>, item: T): { expiresAt?: Date, expired?: boolean } {
     const expKey = ModelRegistry.getExpiry(cls);
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const keyAsT = expKey as keyof T;
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const expiresAt = item[keyAsT] ? item[keyAsT] as unknown as Date : undefined;
+    const expiresAt: Date = castTo(item[expKey]);
 
     return {
       expiresAt,