@travetto/model 5.0.0-rc.9 → 5.0.1

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, castTo } 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.9",
+  "version": "5.0.1",
   "description": "Datastore abstraction for core operations.",
   "keywords": [
     "datastore",
@@ -26,14 +26,14 @@
     "directory": "module/model"
   },
   "dependencies": {
-    "@travetto/config": "^5.0.0-rc.9",
-    "@travetto/di": "^5.0.0-rc.9",
-    "@travetto/registry": "^5.0.0-rc.9",
-    "@travetto/schema": "^5.0.0-rc.9"
+    "@travetto/config": "^5.0.1",
+    "@travetto/di": "^5.0.1",
+    "@travetto/registry": "^5.0.1",
+    "@travetto/schema": "^5.0.1"
   },
   "peerDependencies": {
-    "@travetto/cli": "^5.0.0-rc.9",
-    "@travetto/test": "^5.0.0-rc.9"
+    "@travetto/cli": "^5.0.1",
+    "@travetto/test": "^5.0.1"
   },
   "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,72 +1,50 @@
-import { ClassInstance } from '@travetto/runtime';
+import { hasFunction } from '@travetto/runtime';
 import type { ModelBulkSupport } from '../../service/bulk';
-import { ModelCrudSupport } from '../../service/crud';
+import type { ModelCrudSupport } from '../../service/crud';
 import type { ModelExpirySupport } from '../../service/expiry';
-import { ModelIndexedSupport } from '../../service/indexed';
+import type { ModelIndexedSupport } from '../../service/indexed';
 import type { ModelStorageSupport } from '../../service/storage';
-import type { ModelStreamSupport } from '../../service/stream';
+import type { 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: ClassInstance): o is ModelBulkSupport {
-  return !!o && 'create' in o;
-}
+export const isBasicSupported = hasFunction<ModelBulkSupport>('create');
 
 /**
  * Type guard for determining if service supports crud operations
- * @param o
  */
-export function isCrudSupported(o: ClassInstance): o is ModelCrudSupport {
-  return !!o && 'upsert' in o;
-}
+export const isCrudSupported = hasFunction<ModelCrudSupport>('upsert');
 
 /**
  * Type guard for determining if model supports expiry
- * @param o
  */
-export function isExpirySupported(o: ClassInstance): o is ModelExpirySupport {
-  return !!o && 'deleteExpired' in o;
-}
+export const isExpirySupported = hasFunction<ModelExpirySupport>('deleteExpired');
 
 /**
- * Type guard for determining if service supports storage operation
- * @param o
+ * Type guard for determining if service supports streaming operation
  */
-export function isStorageSupported(o: ClassInstance): o is ModelStorageSupport {
-  return !!o && 'createStorage' in o;
-}
+export const isBlobSupported = hasFunction<ModelBlobSupport>('getBlob');
 
 /**
- * Type guard for determining if service supports streaming operation
- * @param o
+ * Type guard for determining if service supports storage operation
  */
-export function isStreamSupported(o: ClassInstance): o is ModelStreamSupport {
-  return !!o && 'getStream' in o;
-}
+export const isStorageSupported = hasFunction<ModelStorageSupport>('createStorage');
 
 /**
  * Type guard for determining if service supports streaming operation
- * @param o
  */
-export function isBulkSupported(o: ClassInstance): o is ModelBulkSupport {
-  return !!o && 'processBulk' in o;
-}
+export const isBulkSupported = hasFunction<ModelBulkSupport>('processBulk');
 
 /**
  * Type guard for determining if service supports indexed operation
- * @param o
  */
-export function isIndexedSupported(o: ClassInstance): o is ModelIndexedSupport {
-  return !!o && 'getByIndex' in o;
-}
-
+export const isIndexedSupported = hasFunction<ModelIndexedSupport>('getByIndex');

package/src/internal/service/crud.ts

@@ -1,6 +1,4 @@
-import crypto from 'node:crypto';
-
-import { castTo, Class, asFull, Util, asConstructable } from '@travetto/runtime';
+import { castTo, Class, Util, asConstructable, AppError } from '@travetto/runtime';
 import { DataUtil, SchemaRegistry, SchemaValidator, ValidationError, ValidationResultError } from '@travetto/schema';
 
 import { ModelRegistry } from '../../registry/model';
@@ -28,18 +26,6 @@ export class ModelCrudUtil {
     return { create, valid };
   }
 
-  /**
-   * Provide hash value
-   * @param value Input value
-   * @param length Number of characters to produce
-   */
-  static hashValue(value: string, length = 32): string {
-    if (value.length < 32) {
-      value = value.padEnd(32, ' ');
-    }
-    return crypto.createHash('sha1').update(value).digest('hex').substring(0, length);
-  }
-
   /**
    * Load model
    * @param cls Class to load model for
@@ -109,36 +95,6 @@ export class ModelCrudUtil {
     return castTo(item);
   }
 
-  /**
-   * Performs a naive partial update by fetching, patching, and then storing
-   * @param cls Type to store for
-   * @param item The object to use for a partial update
-   * @param view The schema view to validate against
-   * @param getExisting How to fetch an existing item
-   */
-  static async naivePartialUpdate<T extends ModelType>(cls: Class<T>, item: Partial<T>, view: undefined | string, getExisting: () => Promise<T>): Promise<T> {
-    if (DataUtil.isPlainObject(item)) {
-      item = cls.from(castTo(item));
-    }
-
-    const config = ModelRegistry.get(asConstructable(item).constructor);
-    if (config.subType) { // Sub-typing, assign type
-      SchemaRegistry.ensureInstanceTypeField(cls, item);
-    }
-
-    if (view) {
-      await SchemaValidator.validate(cls, item, view);
-    }
-
-    const existing = await getExisting();
-
-    item = Object.assign(existing, item);
-
-    item = await this.prePersist(cls, item, 'partial');
-
-    return asFull(item);
-  }
-
   /**
    * Ensure subtype is not supported
    */
@@ -178,4 +134,25 @@ export class ModelCrudUtil {
     }
     return item;
   }
+
+  /**
+   * Ensure everything is correct for a partial update
+   */
+  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');
+    }
+    const res = await this.prePersist(cls, castTo(item), 'partial');
+    await SchemaValidator.validatePartial(cls, item, view);
+    return res;
+  }
+
+  /**
+   * Ensure everything is correct for a partial update
+   */
+  static async naivePartialUpdate<T extends ModelType>(cls: Class<T>, get: () => Promise<T>, item: Partial<T>, view?: string): Promise<T> {
+    const prepared = await this.prePartialUpdate(cls, item, view);
+    const full = await get();
+    return cls.from(castTo({ ...full, ...prepared }));
+  }
 }

package/src/internal/service/indexed.ts

@@ -75,7 +75,6 @@ export class ModelIndexedUtil {
     return { fields, sorted };
   }
 
-
   /**
    * Project item via index
    * @param cls Type to get index for

package/src/service/blob.ts

@@ -0,0 +1,36 @@
+import { BinaryInput, BlobMeta, ByteRange } from '@travetto/runtime';
+
+/**
+ * Support for Blobs CRUD.
+ *
+ * @concrete ../internal/service/common#ModelBlobSupportTarget
+ */
+export interface ModelBlobSupport {
+
+  /**
+   * 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
+   */
+  upsertBlob(location: string, input: BinaryInput, meta?: BlobMeta, overwrite?: boolean): Promise<void>;
+
+  /**
+   * Get blob from storage
+   * @param location The location of the blob
+   */
+  getBlob(location: string, range?: ByteRange): Promise<Blob>;
+
+  /**
+   * Get metadata for blob
+   * @param location The location of the blob
+   */
+  describeBlob(location: string): Promise<BlobMeta>;
+
+  /**
+   * Delete blob by location
+   * @param location The location of the blob
+   */
+  deleteBlob(location: string): Promise<void>;
+}

package/support/doc.support.tsx

@@ -8,14 +8,14 @@ export const Links = {
   Expiry: d.codeLink('Expiry', '@travetto/model/src/service/expiry.ts', /export interface/),
   Indexed: d.codeLink('Indexed', '@travetto/model/src/service/indexed.ts', /export interface/),
   Bulk: d.codeLink('Bulk', '@travetto/model/src/service/bulk.ts', /export interface/),
-  Stream: d.codeLink('Streaming', '@travetto/model/src/service/stream.ts', /export interface/),
+  Blob: d.codeLink('Blob', '@travetto/model/src/service/blob.ts', /export interface/),
 };
 
 export const ModelTypes = (fn: | Function): DocJSXElement[] => {
   const { content } = DocFileUtil.readSource(fn);
   const found: DocJSXElementByFn<'CodeLink'>[] = [];
   const seen = new Set();
-  for (const [, key] of content.matchAll(/Model(Crud|Expiry|Indexed|Bulk|Stream)Support/g)) {
+  for (const [, key] of content.matchAll(/Model(Crud|Expiry|Indexed|Bulk|Blob)Support/g)) {
     if (!seen.has(key)) {
       seen.add(key);
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions

package/support/fixtures/alpha.txt

@@ -0,0 +1 @@
+abcdefghijklmnopqrstuvwxyz