@travetto/model 5.0.0-rc.10 → 5.0.0-rc.11

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,44 @@ 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
+   * Insert blob to storage
+   * @param location The location of the blob
+   * @param input The actual blob to write
    */
-  upsertStream(location: string, input: Readable, meta: StreamMeta): Promise<void>;
+  insertBlob(location: string, input: BinaryInput, meta?: BlobMeta, errorIfExisting?: boolean): Promise<void>;
 
   /**
-   * Get stream from asset store
-   * @param location The location of the stream
+   * Upsert blob to storage
+   * @param location The location of the blob
+   * @param input The actual blob to write
    */
-  getStream(location: string, range?: StreamRange): Promise<Readable>;
+  upsertBlob(location: string, input: BinaryInput, meta?: BlobMeta): Promise<void>;
 
   /**
-   * Get metadata for stream
-   * @param location The location of the stream
+   * Get blob from storage
+   * @param location The location of the blob
    */
-  describeStream(location: string): Promise<StreamMeta>;
+  getBlob(location: string, range?: ByteRange): Promise<Blob>;
 
   /**
-   * Delete stream by location
-   * @param location The location of the stream
+   * Get metadata for blob
+   * @param location The location of the blob
    */
-  deleteStream(location: string): Promise<void>;
+  describeBlob(location: string): Promise<BlobMeta>;
+
+  /**
+   * Delete blob by location
+   * @param location The location of the blob
+   */
+  deleteBlob(location: string): Promise<void>;
 }
 ```
 
@@ -216,8 +222,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 +231,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}`);
+    }
+  }
+
+  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');
+    }
+  }
 
-@Suite()
-export class MemoryPolymorphicSuite extends ModelPolymorphismSuite {
-  serviceClass = MemoryModelService;
-  configClass = MemoryModelConfig;
+  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 +343,6 @@ Options:
 
 Providers
 --------------------
-  * Memory
   * SQL
 
 Models

package/__index__.ts

@@ -3,15 +3,13 @@ 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/util/blob';
 
 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.10",
+  "version": "5.0.0-rc.11",
   "description": "Datastore abstraction for core operations.",
   "keywords": [
     "datastore",
@@ -26,14 +26,14 @@
     "directory": "module/model"
   },
   "dependencies": {
-    "@travetto/config": "^5.0.0-rc.10",
-    "@travetto/di": "^5.0.0-rc.9",
-    "@travetto/registry": "^5.0.0-rc.9",
-    "@travetto/schema": "^5.0.0-rc.10"
+    "@travetto/config": "^5.0.0-rc.11",
+    "@travetto/di": "^5.0.0-rc.10",
+    "@travetto/registry": "^5.0.0-rc.10",
+    "@travetto/schema": "^5.0.0-rc.11"
   },
   "peerDependencies": {
-    "@travetto/cli": "^5.0.0-rc.10",
-    "@travetto/test": "^5.0.0-rc.9"
+    "@travetto/cli": "^5.0.0-rc.11",
+    "@travetto/test": "^5.0.0-rc.10"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/internal/service/blob.ts

@@ -0,0 +1,5 @@
+import { Class } from '@travetto/runtime';
+import { ModelType } from '../../types/model';
+
+export const ModelBlobNamespace = '__blobs';
+export const MODEL_BLOB: Class<ModelType> = class { id: string; };

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,41 @@
+import { BinaryInput, BlobMeta, ByteRange } from '@travetto/runtime';
+
+/**
+ * Support for Blobs CRD.  Blob update is not supported.
+ *
+ * @concrete ../internal/service/common#ModelBlobSupportTarget
+ */
+export interface ModelBlobSupport {
+
+  /**
+   * Insert blob to storage
+   * @param location The location of the blob
+   * @param input The actual blob to write
+   */
+  insertBlob(location: string, input: BinaryInput, meta?: BlobMeta, errorIfExisting?: boolean): Promise<void>;
+
+  /**
+   * Upsert blob to storage
+   * @param location The location of the blob
+   * @param input The actual blob to write
+   */
+  upsertBlob(location: string, input: BinaryInput, meta?: BlobMeta): 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/src/util/blob.ts

@@ -0,0 +1,60 @@
+import { Readable } from 'node:stream';
+import path from 'node:path';
+
+import { AppError, BinaryInput, BlobMeta, ByteRange, Util } from '@travetto/runtime';
+
+/**
+ * Utilities for processing assets
+ */
+export class ModelBlobUtil {
+
+  /**
+   * Get a hashed location/path for a blob
+   */
+  static getHashedLocation(meta: BlobMeta, prefix = ''): string {
+    const hash = meta.hash ?? Util.uuid();
+
+    let parts = hash.match(/(.{1,4})/g)!.slice();
+    if (parts.length > 4) {
+      parts = [...parts.slice(0, 4), parts.slice(4).join('')];
+    }
+
+    const ext = path.extname(meta.filename ?? '') || '.bin';
+    return `${parts.join('/')}${ext}`;
+  }
+
+  /**
+   * Convert input to a blob, containing all data in memory
+   */
+  static async getInput(src: BinaryInput, metadata: BlobMeta = {}): Promise<[Readable, BlobMeta]> {
+    let input: Readable;
+    if (src instanceof Blob) {
+      metadata = { ...src.meta, ...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/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