@travetto/model 5.0.0-rc.8 → 5.0.0

package/src/internal/service/indexed.ts

@@ -1,4 +1,4 @@
-import { Class, DeepPartial } from '@travetto/runtime';
+import { castTo, Class, DeepPartial, TypedObject } from '@travetto/runtime';
 
 import { IndexNotSupported } from '../../error/invalid-index';
 import { NotFoundError } from '../../error/not-found';
@@ -44,38 +44,30 @@ export class ModelIndexedUtil {
       const parts = [];
 
       while (o !== undefined && o !== null) {
-        const k = Object.keys(f)[0];
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        o = (o[k] as Record<string, unknown>);
+        const k = TypedObject.keys(f)[0];
+        o = castTo(o[k]);
         parts.push(k);
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const fk = k as (keyof typeof f);
-        if (typeof f[fk] === 'boolean' || typeof f[fk] === 'number') {
+        if (typeof f[k] === 'boolean' || typeof f[k] === 'number') {
           if (cfg.type === 'sorted') {
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            sortDir = f[fk] === true ? 1 : f[fk] as number;
+            sortDir = f[k] === true ? 1 : f[k] === false ? 0 : f[k];
           }
           break; // At the bottom
         } else {
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          f = f[fk] as Record<string, unknown>;
+          f = castTo(f[k]);
         }
       }
       if (field === sortField) {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        sorted = { path: parts, dir: sortDir, value: o as unknown as number | Date };
+        sorted = { path: parts, dir: sortDir, value: castTo(o) };
       }
       if (o === undefined || o === null) {
         const empty = field === sortField ? opts.emptySortValue : opts.emptyValue;
         if (empty === undefined || empty === Error) {
           throw new IndexNotSupported(cls, cfg, `Missing field value for ${parts.join('.')}`);
         }
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        o = empty as Record<string, unknown>;
+        o = castTo(empty!);
       } else {
         if (field !== sortField || (opts.includeSortInFields ?? true)) {
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          fields.push({ path: parts, value: o as unknown as string | boolean | Date | number });
+          fields.push({ path: parts, value: castTo(o) });
         }
       }
     }
@@ -83,7 +75,6 @@ export class ModelIndexedUtil {
     return { fields, sorted };
   }
 
-
   /**
    * Project item via index
    * @param cls Type to get index for
@@ -92,12 +83,11 @@ export class ModelIndexedUtil {
   static projectIndex<T extends ModelType>(cls: Class<T>, idx: IndexConfig<T> | string, item?: DeepPartial<T>, cfg?: ComputeConfig): Record<string, unknown> {
     const res: Record<string, unknown> = {};
     for (const { path, value } of this.computeIndexParts(cls, idx, item ?? {}, cfg).fields) {
-      let sub = res;
+      let sub: Record<string, unknown> = res;
       const all = path.slice(0);
       const last = all.pop()!;
       for (const k of all) {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        sub = (sub[k] ??= {}) as typeof res;
+        sub = castTo(sub[k] ??= {});
       }
       sub[last] = value;
     }
@@ -134,11 +124,9 @@ export class ModelIndexedUtil {
     cls: Class<T>, idx: string, body: OptionalId<T>
   ): Promise<T> {
     try {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const { id } = await service.getByIndex(cls, idx, body as DeepPartial<T>);
+      const { id } = await service.getByIndex(cls, idx, castTo(body));
       body.id = id;
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return await service.update(cls, body as T);
+      return await service.update(cls, castTo(body));
     } catch (err) {
       if (err instanceof NotFoundError) {
         return await service.create(cls, body);

package/src/internal/service/storage.ts

@@ -12,14 +12,11 @@ export class ModelStorageUtil {
   /**
    * Register change listener on startup
    */
-  static async registerModelChangeListener(storage: ModelStorageSupport, target?: Class): Promise<void> {
+  static async registerModelChangeListener(storage: ModelStorageSupport): Promise<void> {
     if (!Runtime.dynamic || !(storage?.config?.autoCreate ?? !Runtime.production)) {
       return;
     }
 
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    target = target ?? storage.constructor as Class<ModelStorageSupport>;
-
     const checkType = (cls: Class, enforceBase = true): boolean => {
       if (enforceBase && ModelRegistry.getBaseModel(cls) !== cls) {
         return false;

package/src/registry/decorator.ts

@@ -1,4 +1,4 @@
-import { Class } from '@travetto/runtime';
+import { asConstructable, castTo, Class } from '@travetto/runtime';
 import { SchemaRegistry } from '@travetto/schema';
 
 import { ModelType } from '../types/model';
@@ -25,7 +25,7 @@ export function Model(conf: Partial<ModelOptions<ModelType>> | string = {}) {
  * Defines an index on a model
  */
 export function Index<T extends ModelType>(...indices: IndexConfig<T>[]) {
-  return function (target: Class<T>) {
+  return function (target: Class<T>): void {
     ModelRegistry.getOrCreatePending(target).indices!.push(...indices);
   };
 }
@@ -36,8 +36,7 @@ export function Index<T extends ModelType>(...indices: IndexConfig<T>[]) {
  */
 export function ExpiresAt() {
   return <K extends string, T extends Partial<Record<K, Date>>>(tgt: T, prop: K): void => {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    ModelRegistry.register(tgt.constructor as Class<T>, { expiresAt: prop });
+    ModelRegistry.register(asConstructable(tgt).constructor, { expiresAt: prop });
   };
 }
 
@@ -49,8 +48,7 @@ export function PrePersist<T>(handler: DataHandler<T>, scope: PrePersistScope =
     ModelRegistry.registerDataHandlers(tgt, {
       prePersist: [{
         scope,
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        handler: handler as DataHandler
+        handler: castTo(handler)
       }]
     });
   };
@@ -61,13 +59,11 @@ export function PrePersist<T>(handler: DataHandler<T>, scope: PrePersistScope =
  */
 export function PersistValue<T>(handler: (curr: T | undefined) => T, scope: PrePersistScope = 'all') {
   return function <K extends string, C extends Partial<Record<K, T>>>(tgt: C, prop: K): void {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    ModelRegistry.registerDataHandlers(tgt.constructor as Class<C>, {
+    ModelRegistry.registerDataHandlers(asConstructable(tgt).constructor, {
       prePersist: [{
         scope,
         handler: (inst): void => {
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          const cInst = (inst as unknown as Record<K, T>);
+          const cInst: Record<K, T> = castTo(inst);
           cInst[prop] = handler(cInst[prop]);
         }
       }]
@@ -81,7 +77,6 @@ export function PersistValue<T>(handler: (curr: T | undefined) => T, scope: PreP
  */
 export function PostLoad<T>(handler: DataHandler<T>) {
   return function (tgt: Class<T>): void {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    ModelRegistry.registerDataHandlers(tgt, { postLoad: [handler as DataHandler] });
+    ModelRegistry.registerDataHandlers(tgt, { postLoad: [castTo(handler)] });
   };
 }

package/src/registry/model.ts

@@ -1,7 +1,7 @@
 import { SchemaRegistry } from '@travetto/schema';
 import { MetadataRegistry } from '@travetto/registry';
 import { DependencyRegistry } from '@travetto/di';
-import { AppError, Class, describeFunction } from '@travetto/runtime';
+import { AppError, castTo, Class, describeFunction, asFull } from '@travetto/runtime';
 import { AllViewⲐ } from '@travetto/schema/src/internal/types';
 
 import { IndexConfig, IndexType, ModelOptions } from './types';
@@ -71,8 +71,7 @@ class $ModelRegistry extends MetadataRegistry<ModelOptions<ModelType>> {
   }
 
   onInstallFinalize(cls: Class): ModelOptions<ModelType> {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const config = this.pending.get(cls.Ⲑid)! as ModelOptions<ModelType>;
+    const config = asFull(this.pending.get(cls.Ⲑid)!);
 
     const schema = SchemaRegistry.get(cls);
     const view = schema.views[AllViewⲐ].schema;
@@ -103,7 +102,7 @@ class $ModelRegistry extends MetadataRegistry<ModelOptions<ModelType>> {
   /**
    * Find base class for a given model
    */
-  getBaseModel(cls: Class): Class<ModelType> {
+  getBaseModel<T extends ModelType>(cls: Class<T>): Class<T> {
     if (!this.baseModels.has(cls)) {
       let conf = this.get(cls) ?? this.getOrCreatePending(cls);
       let parent = cls;
@@ -208,12 +207,12 @@ class $ModelRegistry extends MetadataRegistry<ModelOptions<ModelType>> {
    * Get expiry field
    * @param cls
    */
-  getExpiry(cls: Class): string {
+  getExpiry<T extends ModelType>(cls: Class<T>): keyof T {
     const expiry = this.get(cls).expiresAt;
     if (!expiry) {
       throw new AppError(`${cls.name} is not configured with expiry support, please use @ExpiresAt to declare expiration behavior`, 'general');
     }
-    return expiry;
+    return castTo(expiry);
   }
 }
 

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/bin/candidate.ts

@@ -1,4 +1,4 @@
-import { Class } from '@travetto/runtime';
+import { castTo, Class } from '@travetto/runtime';
 import { ModelRegistry } from '@travetto/model/src/registry/model';
 import { InjectableConfig, DependencyRegistry } from '@travetto/di';
 import { ModelStorageSupportTarget } from '@travetto/model/src/internal/service/common';
@@ -40,8 +40,7 @@ export class ModelCandidateUtil {
    * Get all providers that are viable candidates
    */
   static async getProviders(op?: keyof ModelStorageSupport): Promise<InjectableConfig[]> {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const types = DependencyRegistry.getCandidateTypes<ModelStorageSupport>(ModelStorageSupportTarget as unknown as Class<ModelStorageSupport>);
+    const types = DependencyRegistry.getCandidateTypes<ModelStorageSupport>(castTo(ModelStorageSupportTarget));
     return types.filter(x => !op || x.class.prototype?.[op]);
   }
 

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/base.ts

@@ -1,5 +1,5 @@
 import { DependencyRegistry } from '@travetto/di';
-import { AppError, Class } from '@travetto/runtime';
+import { AppError, castTo, Class, classConstruct } from '@travetto/runtime';
 
 import { isBulkSupported, isCrudSupported } from '../../src/internal/service/common';
 import { ModelType } from '../../src/types/model';
@@ -11,7 +11,7 @@ type ServiceClass = { serviceClass: { new(): unknown } };
 export abstract class BaseModelSuite<T> {
 
   static ifNot(pred: (svc: unknown) => boolean): (x: unknown) => Promise<boolean> {
-    return async (x: unknown) => !pred(new (x as ServiceClass).serviceClass());
+    return async (x: unknown) => !pred(classConstruct(castTo<ServiceClass>(x).serviceClass));
   }
 
   serviceClass: Class<T>;
@@ -36,7 +36,7 @@ export abstract class BaseModelSuite<T> {
       const res = await svc.processBulk(cls, items.map(x => ({ insert: x })));
       return res.counts.insert;
     } else if (isCrudSupported(svc)) {
-      const out = [] as Promise<M>[];
+      const out: Promise<M>[] = [];
       for (const el of items) {
         out.push(svc.create(cls, el));
       }

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);
+  }
+}

package/support/test/crud.ts

@@ -49,7 +49,7 @@ class User2 {
   name: string;
 
   prePersist() {
-    this.name = `${this.name}-suff`;
+    this.name = `${this.name}-suffix`;
   }
 }
 
@@ -193,7 +193,7 @@ export abstract class ModelCrudSuite extends BaseModelSuite<ModelCrudSupport> {
     }));
 
     assert(o.address === undefined);
-    assert(o.name === 'bob-suff');
+    assert(o.name === 'bob-suffix');
 
     await service.updatePartial(User2, User2.from({
       id: o.id,
@@ -217,7 +217,7 @@ export abstract class ModelCrudSuite extends BaseModelSuite<ModelCrudSupport> {
     assert(res.createdDate instanceof Date);
   }
 
-  @Test('verify prepersist on create/update')
+  @Test('verify pre-persist on create/update')
   async testPrePersist() {
     const service = await this.service;
     const res = await service.create(Dated, Dated.from({}));

package/support/test/polymorphism.ts

@@ -12,6 +12,7 @@ import { isIndexedSupported } from '../../src/internal/service/common';
 import { ExistsError } from '../../src/error/exists';
 
 import { BaseModelSuite } from './base';
+import { castTo } from '@travetto/runtime';
 
 @Model({ baseType: true })
 export class Worker {
@@ -70,7 +71,7 @@ export class IndexedEngineer extends IndexedWorker {
 }
 
 async function collect<T>(iterable: AsyncIterable<T>): Promise<T[]> {
-  const out = [] as T[];
+  const out: T[] = [];
   for await (const el of iterable) {
     out.push(el);
   }
@@ -116,12 +117,12 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
 
     const fire3 = all.find(x => x instanceof Firefighter);
     assert(fire3 instanceof Firefighter);
-    assert((fire3 as Firefighter).firehouse === 20);
+    assert(fire3.firehouse === 20);
     assert(fire3.name === 'rob');
 
     const eng3 = all.find(x => x instanceof Engineer);
     assert(eng3 instanceof Engineer);
-    assert((eng3 as Engineer).major === 'oranges');
+    assert(eng3.major === 'oranges');
     assert(eng3.name === 'cob');
 
     const engineers = await collect(service.list(Engineer));
@@ -161,7 +162,7 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
     );
 
     await assert.rejects(
-      () => service.update(Engineer, Doctor.from({ ...doc }) as unknown as Engineer),
+      () => service.update(Engineer, castTo(Doctor.from({ ...doc }))),
       (e: Error) => (e instanceof NotFoundError || e instanceof SubTypeNotSupportedError || e instanceof TypeMismatchError) ? undefined : e);
 
     await timers.setTimeout(15);
@@ -205,7 +206,7 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
 
   @Test('Polymorphic index', { skip: BaseModelSuite.ifNot(isIndexedSupported) })
   async polymorphicIndexGet() {
-    const service = (await this.service) as unknown as ModelIndexedSupport;
+    const service: ModelIndexedSupport = castTo(await this.service);
     const now = 30;
     const [doc, fire, eng] = [
       IndexedDoctor.from({ name: 'bob', specialty: 'feet', age: now }),
@@ -235,7 +236,7 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
 
   @Test('Polymorphic index', { skip: BaseModelSuite.ifNot(isIndexedSupported) })
   async polymorphicIndexDelete() {
-    const service = (await this.service) as unknown as ModelIndexedSupport;
+    const service: ModelIndexedSupport = castTo(await this.service);
     const now = 30;
     const [doc, fire, eng] = [
       IndexedDoctor.from({ name: 'bob', specialty: 'feet', age: now }),

package/support/test/suite.ts

@@ -3,8 +3,8 @@ import { DependencyRegistry } from '@travetto/di';
 import { RootRegistry } from '@travetto/registry';
 import { SuiteRegistry, TestFixtures } from '@travetto/test';
 
-import { isStorageSupported, isStreamSupported } from '../../src/internal/service/common';
-import { StreamModel } from '../../src/internal/service/stream';
+import { isBlobSupported, isStorageSupported } from '../../src/internal/service/common';
+import { MODEL_BLOB } from '../../src/internal/service/blob';
 import { ModelRegistry } from '../../src/registry/model';
 
 const Loaded = Symbol();
@@ -61,11 +61,11 @@ export function ModelSuite<T extends { configClass: Class<{ autoCreate?: boolean
                 }
               }
             }
-            if (isStreamSupported(service)) {
+            if (isBlobSupported(service)) {
               if (service.truncateModel) {
-                await service.truncateModel(StreamModel);
+                await service.truncateModel(MODEL_BLOB);
               } else if (service.deleteModel) {
-                await service.deleteModel(StreamModel);
+                await service.deleteModel(MODEL_BLOB);
               }
             }
           } else {

package/src/internal/service/stream.ts

@@ -1,22 +0,0 @@
-import { AppError, Class } from '@travetto/runtime';
-
-import { ModelType } from '../../types/model';
-import { StreamRange } from '../../service/stream';
-
-class Cls { id: string; }
-export const StreamModel: Class<ModelType> = Cls;
-export const STREAMS = '_streams';
-
-
-/**
- * Enforce byte range for stream stream/file of a certain size
- */
-export function enforceRange({ start, end }: StreamRange, size: number): Required<StreamRange> {
-  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 };
-}