@travetto/model 5.0.0-rc.9 → 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, 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.0",
   "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.0",
+    "@travetto/di": "^5.0.0",
+    "@travetto/registry": "^5.0.0",
+    "@travetto/schema": "^5.0.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^5.0.0-rc.9",
-    "@travetto/test": "^5.0.0-rc.9"
+    "@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

@@ -4,14 +4,14 @@ 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 { }
 
 /**
@@ -39,19 +39,19 @@ export function isExpirySupported(o: ClassInstance): o is ModelExpirySupport {
 }
 
 /**
- * Type guard for determining if service supports storage operation
+ * Type guard for determining if service supports streaming operation
  * @param o
  */
-export function isStorageSupported(o: ClassInstance): o is ModelStorageSupport {
-  return !!o && 'createStorage' in o;
+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: ClassInstance): o is ModelStreamSupport {
-  return !!o && 'getStream' in o;
+export function isStorageSupported(o: ClassInstance): o is ModelStorageSupport {
+  return !!o && 'createStorage' in o;
 }
 
 /**

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

package/support/test/blob.ts

@@ -0,0 +1,136 @@
+import assert from 'node:assert';
+
+import { Suite, Test, TestFixtures } from '@travetto/test';
+import { BaseModelSuite } from '@travetto/model/support/test/base';
+import { BinaryUtil, Util } from '@travetto/runtime';
+
+import { ModelBlobSupport } from '../../src/service/blob';
+import { ModelBlobUtil } from '../../src/internal/service/blob';
+
+const meta = BinaryUtil.getBlobMeta;
+
+@Suite()
+export abstract class ModelBlobSuite extends BaseModelSuite<ModelBlobSupport> {
+
+  fixture = new TestFixtures(['@travetto/model']);
+
+  @Test()
+  async writeBasic(): Promise<void> {
+    const service = await this.service;
+    const buffer = await this.fixture.read('/asset.yml', true);
+
+    const id = Util.uuid();
+
+    await service.upsertBlob(id, buffer);
+    const m = await service.describeBlob(id);
+    const retrieved = await service.describeBlob(id);
+    assert.deepStrictEqual(m, retrieved);
+  }
+
+  @Test()
+  async upsert(): Promise<void> {
+    const service = await this.service;
+    const buffer = await this.fixture.read('/asset.yml', true);
+
+    const id = Util.uuid();
+
+    await service.upsertBlob(id, buffer, { hash: '10' });
+    assert((await service.describeBlob(id)).hash === '10');
+
+    await service.upsertBlob(id, buffer, { hash: '20' });
+    assert((await service.describeBlob(id)).hash === '20');
+
+    await service.upsertBlob(id, buffer, { hash: '30' }, false);
+    assert((await service.describeBlob(id)).hash === '20');
+  }
+
+  @Test()
+  async writeStream(): Promise<void> {
+    const service = await this.service;
+    const buffer = await this.fixture.read('/asset.yml', true);
+
+    const id = Util.uuid();
+    await service.upsertBlob(id, buffer);
+    const { hash } = await service.describeBlob(id);
+
+    const retrieved = await service.getBlob(id);
+    const { hash: received } = meta(retrieved)!;
+    assert(hash === received);
+  }
+
+  @Test()
+  async writeAndDelete(): Promise<void> {
+    const service = await this.service;
+    const buffer = await this.fixture.read('/asset.yml', true);
+
+    const id = Util.uuid();
+    await service.upsertBlob(id, buffer);
+
+    await service.deleteBlob(id);
+
+    await assert.rejects(async () => {
+      await service.getBlob(id);
+    });
+  }
+
+  @Test()
+  async partialStream(): Promise<void> {
+    const service = await this.service;
+    const buffer = await this.fixture.read('/text.txt', true);
+
+    const id = Util.uuid();
+    await service.upsertBlob(id, buffer);
+
+    const retrieved = await service.getBlob(id);
+    const content = await retrieved.text();
+    assert(content.startsWith('abc'));
+    assert(content.endsWith('xyz'));
+
+    const partial = await service.getBlob(id, { start: 10, end: 20 });
+    assert(partial.size === 11);
+    const partialMeta = meta(partial)!;
+    const subContent = await partial.text();
+    const range = await ModelBlobUtil.enforceRange({ start: 10, end: 20 }, partialMeta.size!);
+    assert(subContent.length === (range.end - range.start) + 1);
+
+    const og = await this.fixture.read('/text.txt');
+
+    assert(subContent === og.substring(10, 21));
+
+    const partialUnbounded = await service.getBlob(id, { start: 10 });
+    const partialUnboundedMeta = meta(partial)!;
+    const subContent2 = await partialUnbounded.text();
+    const range2 = await ModelBlobUtil.enforceRange({ start: 10 }, partialUnboundedMeta.size!);
+    assert(subContent2.length === (range2.end - range2.start) + 1);
+    assert(subContent2.startsWith('klm'));
+    assert(subContent2.endsWith('xyz'));
+
+    const partialSingle = await service.getBlob(id, { start: 10, end: 10 });
+    const subContent3 = await partialSingle.text();
+    assert(subContent3.length === 1);
+    assert(subContent3 === 'k');
+
+    const partialOverBounded = await service.getBlob(id, { start: 20, end: 40 });
+    const subContent4 = await partialOverBounded.text();
+    assert(subContent4.length === 6);
+    assert(subContent4.endsWith('xyz'));
+
+    await assert.rejects(() => service.getBlob(id, { start: -10, end: 10 }));
+    await assert.rejects(() => service.getBlob(id, { start: 30, end: 37 }));
+  }
+
+
+  @Test()
+  async writeAndGet() {
+    const service = await this.service;
+    const buffer = await this.fixture.read('/asset.yml', true);
+    await service.upsertBlob('orange', buffer, { contentType: 'text/yaml', filename: 'asset.yml' });
+    const saved = await service.getBlob('orange');
+    const savedMeta = meta(saved)!;
+
+    assert('text/yaml' === savedMeta.contentType);
+    assert(buffer.length === savedMeta.size);
+    assert('asset.yml' === savedMeta.filename);
+    assert(undefined === savedMeta.hash);
+  }
+}