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

package/src/internal/service/indexed.ts

@@ -1,5 +1,4 @@
-import { Class } from '@travetto/base';
-import { DeepPartial } from '@travetto/schema';
+import { castTo, Class, DeepPartial, TypedObject } from '@travetto/runtime';
 
 import { IndexNotSupported } from '../../error/invalid-index';
 import { NotFoundError } from '../../error/not-found';
@@ -45,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) });
         }
       }
     }
@@ -84,7 +75,6 @@ export class ModelIndexedUtil {
     return { fields, sorted };
   }
 
-
   /**
    * Project item via index
    * @param cls Type to get index for
@@ -93,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;
     }
@@ -135,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

@@ -1,4 +1,4 @@
-import { Class, Env } from '@travetto/base';
+import { Class, Runtime } from '@travetto/runtime';
 import { SchemaChangeListener } from '@travetto/schema';
 
 import { ModelRegistry } from '../../registry/model';
@@ -12,15 +12,11 @@ export class ModelStorageUtil {
   /**
    * Register change listener on startup
    */
-  static async registerModelChangeListener(storage: ModelStorageSupport, target?: Class): Promise<void> {
-    if (!Env.dynamic || !(storage?.config?.autoCreate ?? !Env.production)) {
+  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/base';
+import { asConstructable, castTo, Class } from '@travetto/runtime';
 import { SchemaRegistry } from '@travetto/schema';
 
 import { ModelType } from '../types/model';
@@ -24,8 +24,7 @@ export function Model(conf: Partial<ModelOptions<ModelType>> | string = {}) {
 /**
  * Defines an index on a model
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function Index<T>(...indices: IndexConfig<any>[]) {
+export function Index<T extends ModelType>(...indices: IndexConfig<T>[]) {
   return function (target: Class<T>): void {
     ModelRegistry.getOrCreatePending(target).indices!.push(...indices);
   };
@@ -37,8 +36,7 @@ export function Index<T>(...indices: IndexConfig<any>[]) {
  */
 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 });
   };
 }
 
@@ -50,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)
       }]
     });
   };
@@ -62,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]);
         }
       }]
@@ -82,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,8 +1,7 @@
-import { RuntimeIndex } from '@travetto/manifest';
 import { SchemaRegistry } from '@travetto/schema';
 import { MetadataRegistry } from '@travetto/registry';
 import { DependencyRegistry } from '@travetto/di';
-import { AppError, Class } from '@travetto/base';
+import { AppError, castTo, Class, describeFunction, asFull } from '@travetto/runtime';
 import { AllViewⲐ } from '@travetto/schema/src/internal/types';
 
 import { IndexConfig, IndexType, ModelOptions } from './types';
@@ -52,7 +51,14 @@ class $ModelRegistry extends MetadataRegistry<ModelOptions<ModelType>> {
   }
 
   createPending(cls: Class): Partial<ModelOptions<ModelType>> {
-    return { class: cls, indices: [], autoCreate: true, baseType: RuntimeIndex.getFunctionMetadata(cls)?.abstract, postLoad: [], prePersist: [] };
+    return {
+      class: cls,
+      indices: [],
+      autoCreate: true,
+      baseType: describeFunction(cls).abstract,
+      postLoad: [],
+      prePersist: []
+    };
   }
 
   registerDataHandlers(cls: Class, pConfig?: Partial<ModelOptions<ModelType>>): void {
@@ -65,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;
@@ -97,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;
@@ -202,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/registry/types.ts

@@ -1,5 +1,4 @@
-import { Class } from '@travetto/base';
-import { Primitive } from '@travetto/schema';
+import type { Class, Primitive } from '@travetto/runtime';
 
 import { ModelType } from '../types/model';
 

package/src/service/basic.ts

@@ -1,4 +1,4 @@
-import { Class } from '@travetto/base';
+import { Class } from '@travetto/runtime';
 import { ModelType, OptionalId } from '../types/model';
 
 /**

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/service/bulk.ts

@@ -1,4 +1,4 @@
-import { Class, AppError } from '@travetto/base';
+import { Class, AppError } from '@travetto/runtime';
 import { ValidationResultError } from '@travetto/schema';
 
 import { ModelCrudSupport } from './crud';

package/src/service/crud.ts

@@ -1,4 +1,4 @@
-import { Class } from '@travetto/base';
+import { Class } from '@travetto/runtime';
 
 import { ModelType, OptionalId, ModelIdSource } from '../types/model';
 

package/src/service/expiry.ts

@@ -1,4 +1,4 @@
-import { Class } from '@travetto/base';
+import { Class } from '@travetto/runtime';
 
 import { ModelType } from '../types/model';
 import { ModelCrudSupport } from './crud';

package/src/service/indexed.ts

@@ -1,5 +1,4 @@
-import { Class } from '@travetto/base';
-import { DeepPartial } from '@travetto/schema';
+import { Class, DeepPartial } from '@travetto/runtime';
 
 import { ModelType, OptionalId } from '../types/model';
 import { ModelBasicSupport } from './basic';
@@ -7,6 +6,7 @@ import { ModelBasicSupport } from './basic';
 /**
  * Support for simple indexed activity
  *
+ *
  * @concrete ../internal/service/common#ModelIndexedSupportTarget
  */
 export interface ModelIndexedSupport extends ModelBasicSupport {

package/src/service/storage.ts

@@ -1,4 +1,4 @@
-import { Class } from '@travetto/base';
+import { Class } from '@travetto/runtime';
 import { SchemaChange } from '@travetto/schema';
 
 import { ModelType } from '../types/model';

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

@@ -1,4 +1,4 @@
-import { Env } from '@travetto/base';
+import { Env } from '@travetto/runtime';
 import { CliValidationError, CliCommandShape, cliTpl } from '@travetto/cli';
 import { RootRegistry } from '@travetto/registry';
 

package/support/bin/candidate.ts

@@ -1,4 +1,4 @@
-import { Class } from '@travetto/base';
+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/bin/export.ts

@@ -1,4 +1,4 @@
-import type { Class } from '@travetto/base';
+import type { Class } from '@travetto/runtime';
 import type { ModelStorageSupport } from '@travetto/model/src/service/storage';
 import type { ModelType } from '@travetto/model/src/types/model';
 

package/support/bin/install.ts

@@ -1,4 +1,4 @@
-import type { Class } from '@travetto/base';
+import type { Class } from '@travetto/runtime';
 import type { ModelStorageSupport } from '@travetto/model/src/service/storage';
 import type { ModelType } from '@travetto/model/src/types/model';
 

package/support/cli.model_export.ts

@@ -7,7 +7,7 @@ import { ModelCandidateUtil } from './bin/candidate';
 /**
  * Exports model schemas
  */
-@CliCommand({ addEnv: true, addModule: true })
+@CliCommand({ with: { env: true, module: true } })
 export class ModelExportCommand extends BaseModelCommand {
 
   getOp(): 'exportModel' { return 'exportModel'; }

package/support/cli.model_install.ts

@@ -7,7 +7,7 @@ import { ModelCandidateUtil } from './bin/candidate';
 /**
  * Installing models
  */
-@CliCommand({ addEnv: true, addModule: true })
+@CliCommand({ with: { env: true, module: true } })
 export class ModelInstallCommand extends BaseModelCommand {
 
   getOp(): 'createModel' { return 'createModel'; }

package/support/doc.support.tsx

@@ -1,8 +1,5 @@
 /** @jsxImportSource @travetto/doc */
-import { readFileSync } from 'node:fs';
-
-import { RuntimeIndex } from '@travetto/manifest';
-import { d, c, DocJSXElementByFn, DocJSXElement } from '@travetto/doc';
+import { d, c, DocJSXElementByFn, DocJSXElement, DocFileUtil } from '@travetto/doc';
 import { Config } from '@travetto/config';
 
 export const Links = {
@@ -11,17 +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 = (file: string | Function): DocJSXElement[] => {
-  if (typeof file !== 'string') {
-    file = RuntimeIndex.getFunctionMetadata(file)!.source;
-  }
-  const contents = readFileSync(file, 'utf8');
+export const ModelTypes = (fn: | Function): DocJSXElement[] => {
+  const { content } = DocFileUtil.readSource(fn);
   const found: DocJSXElementByFn<'CodeLink'>[] = [];
   const seen = new Set();
-  for (const [, key] of contents.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/base';
+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,117 @@
+import assert from 'node:assert';
+
+import { Suite, Test, TestFixtures } from '@travetto/test';
+import { BaseModelSuite } from '@travetto/model/support/test/base';
+import { Util } from '@travetto/runtime';
+
+import { ModelBlobSupport } from '../../src/service/blob';
+import { ModelBlobUtil } from '../../src/util/blob';
+
+@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 meta = await service.describeBlob(id);
+    const retrieved = await service.describeBlob(id);
+    assert.deepStrictEqual(meta, retrieved);
+  }
+
+  @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 meta = await service.describeBlob(id);
+
+    const retrieved = await service.getBlob(id);
+    const retrievedMeta = retrieved.meta!;
+    assert(meta.hash === retrievedMeta.hash);
+  }
+
+  @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 = partial.meta!;
+    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 = partial.meta!;
+    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 = saved.meta!;
+
+    assert('text/yaml' === savedMeta.contentType);
+    assert(buffer.length === savedMeta.size);
+    assert('asset.yml' === savedMeta.filename);
+    assert(undefined === savedMeta.hash);
+  }
+}