@travetto/model 7.1.4 → 8.0.0-alpha.1

package/README.md

@@ -182,10 +182,10 @@ 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 metadata 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>;
+  upsertBlob(location: string, input: BinaryType, metadata?: BinaryMetadata, overwrite?: boolean): Promise<void>;
 
   /**
    * Get blob from storage
@@ -197,7 +197,7 @@ export interface ModelBlobSupport {
    * Get metadata for blob
    * @param location The location of the blob
    */
-  getBlobMeta(location: string): Promise<BlobMeta>;
+  getBlobMetadata(location: string): Promise<BinaryMetadata>;
 
   /**
    * Delete blob by location
@@ -208,25 +208,26 @@ export interface ModelBlobSupport {
   /**
    * Update blob metadata
    * @param location The location of the blob
+   * @param metadata The metadata to update
    */
-  updateBlobMeta(location: string, meta: BlobMeta): Promise<void>;
+  updateBlobMetadata(location: string, metadata: BinaryMetadata): Promise<void>;
 
   /**
    * Produces an externally usable URL for sharing limited read access to a specific resource
    *
    * @param location The asset location to read from
-   * @param exp Expiry
+   * @param expiresIn Expiry
    */
-  getBlobReadUrl?(location: string, exp?: TimeSpan): Promise<string>;
+  getBlobReadUrl?(location: string, expiresIn?: TimeSpan): Promise<string>;
 
   /**
    * Produces an externally usable URL for sharing allowing direct write access
    *
    * @param location The asset location to write to
-   * @param meta The metadata to associate with the final asset
-   * @param exp Expiry
+   * @param metadata The metadata to associate with the final asset
+   * @param expiresIn Expiry
    */
-  getBlobWriteUrl?(location: string, meta: BlobMeta, exp?: TimeSpan): Promise<string>;
+  getBlobWriteUrl?(location: string, metadata: BinaryMetadata, expiresIn?: TimeSpan): Promise<string>;
 }
 ```
 
@@ -278,7 +279,7 @@ To enforce that these contracts are honored, the module provides shared test sui
 **Code: Memory Service Test Configuration**
 ```typescript
 import { DependencyRegistryIndex } from '@travetto/di';
-import { AppError, castTo, type Class, classConstruct } from '@travetto/runtime';
+import { RuntimeError, castTo, type Class, classConstruct } from '@travetto/runtime';
 
 import { ModelBulkUtil } from '../../src/util/bulk.ts';
 import { ModelCrudUtil } from '../../src/util/crud.ts';
@@ -306,7 +307,7 @@ export abstract class BaseModelSuite<T> {
       }
       return i;
     } else {
-      throw new AppError(`Size is not supported for this service: ${this.serviceClass.name}`);
+      throw new RuntimeError(`Size is not supported for this service: ${this.serviceClass.name}`);
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model",
-  "version": "7.1.4",
+  "version": "8.0.0-alpha.1",
   "type": "module",
   "description": "Datastore abstraction for core operations.",
   "keywords": [
@@ -27,14 +27,14 @@
     "directory": "module/model"
   },
   "dependencies": {
-    "@travetto/config": "^7.1.4",
-    "@travetto/di": "^7.1.4",
-    "@travetto/registry": "^7.1.4",
-    "@travetto/schema": "^7.1.4"
+    "@travetto/config": "^8.0.0-alpha.1",
+    "@travetto/di": "^8.0.0-alpha.1",
+    "@travetto/registry": "^8.0.0-alpha.1",
+    "@travetto/schema": "^8.0.0-alpha.1"
   },
   "peerDependencies": {
-    "@travetto/cli": "^7.1.4",
-    "@travetto/test": "^7.1.4"
+    "@travetto/cli": "^8.0.0-alpha.1",
+    "@travetto/test": "^8.0.0-alpha.1"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/error/exists.ts

@@ -1,9 +1,9 @@
-import { type Class, AppError } from '@travetto/runtime';
+import { type Class, RuntimeError } from '@travetto/runtime';
 
 /**
  * Represents when a data item already exists
  */
-export class ExistsError extends AppError {
+export class ExistsError extends RuntimeError {
   constructor(cls: Class | string, id: string) {
     super(`${typeof cls === 'string' ? cls : cls.name} with id ${id} already exists`, {
       category: 'data',

package/src/error/invalid-index.ts

@@ -1,4 +1,4 @@
-import { type Class, AppError } from '@travetto/runtime';
+import { type Class, RuntimeError } from '@travetto/runtime';
 
 import type { IndexConfig } from '../registry/types.ts';
 import type { ModelType } from '../types/model.ts';
@@ -6,7 +6,7 @@ import type { ModelType } from '../types/model.ts';
 /**
  * Represents when an index is invalid
  */
-export class IndexNotSupported<T extends ModelType> extends AppError {
+export class IndexNotSupported<T extends ModelType> extends RuntimeError {
   constructor(cls: Class<T>, idx: IndexConfig<T>, message: string = '') {
     super(`${typeof cls === 'string' ? cls : cls.name} and index ${idx.name} of type ${idx.type} is not supported. ${message}`.trim(), { category: 'data' });
   }

package/src/error/invalid-sub-type.ts

@@ -1,9 +1,9 @@
-import { type Class, AppError } from '@travetto/runtime';
+import { type Class, RuntimeError } from '@travetto/runtime';
 
 /**
  * Represents when a model subtype class is unable to be used directly
  */
-export class SubTypeNotSupportedError extends AppError {
+export class SubTypeNotSupportedError extends RuntimeError {
   constructor(cls: Class | string) {
     super(`${typeof cls === 'string' ? cls : cls.name} cannot be used for this operation`, { category: 'data' });
   }

package/src/error/not-found.ts

@@ -1,9 +1,9 @@
-import { type Class, AppError } from '@travetto/runtime';
+import { type Class, RuntimeError } from '@travetto/runtime';
 
 /**
  * Represents when a model of cls and id cannot be found
  */
-export class NotFoundError extends AppError {
+export class NotFoundError extends RuntimeError {
   constructor(cls: Class | string, id: string, details: Record<string, unknown> = {}) {
     super(`${typeof cls === 'string' ? cls : cls.name} with id ${id} not found`, { category: 'notfound', details });
   }

package/src/registry/decorator.ts

@@ -1,4 +1,4 @@
-import { AppError, castTo, type Class, getClass } from '@travetto/runtime';
+import { RuntimeError, castTo, type Class, getClass } from '@travetto/runtime';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
 import type { ModelType } from '../types/model.ts';
@@ -30,7 +30,7 @@ export function Model(config: Partial<ModelConfig<ModelType>> | string = {}) {
  */
 export function Index<T extends ModelType>(...indices: IndexConfig<T>[]) {
   if (indices.some(config => config.fields.some(field => field === 'id'))) {
-    throw new AppError('Cannot create an index with the id field');
+    throw new RuntimeError('Cannot create an index with the id field');
   }
   return function (cls: Class<T>): void {
     ModelRegistryIndex.getForRegister(cls).register({ indices });

package/src/registry/registry-index.ts

@@ -1,5 +1,5 @@
 import { type RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
-import { AppError, castTo, type Class } from '@travetto/runtime';
+import { RuntimeError, castTo, type Class } from '@travetto/runtime';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
 import type { IndexConfig, IndexType, ModelConfig } from './types.ts';
@@ -77,7 +77,7 @@ export class ModelRegistryIndex implements RegistryIndex {
 
     // Don't allow two models with same class name, or same store name
     if (classes.size > 1) {
-      throw new AppError('Duplicate models with same store name', {
+      throw new RuntimeError('Duplicate models with same store name', {
         details: { classes: [...classes].toSorted() }
       });
     }
@@ -122,7 +122,7 @@ export class ModelRegistryIndex implements RegistryIndex {
   getExpiryFieldName<T extends ModelType>(cls: Class<T>): keyof T {
     const expiry = this.getConfig(cls).expiresAt;
     if (!expiry) {
-      throw new AppError(`${cls.name} is not configured with expiry support, please use @ExpiresAt to declare expiration behavior`);
+      throw new RuntimeError(`${cls.name} is not configured with expiry support, please use @ExpiresAt to declare expiration behavior`);
     }
     return castTo(expiry);
   }

package/src/registry/types.ts

@@ -1,7 +1,9 @@
-import type { Class, RetainPrimitiveFields } from '@travetto/runtime';
+import type { Class, Primitive, ValidFields } from '@travetto/runtime';
 
 import type { ModelType } from '../types/model.ts';
 
+type RetainPrimitiveFields<T> = Pick<T, ValidFields<T, Primitive | Date>>;
+
 export type SortClauseRaw<T> = {
   [P in keyof T]?:
   T[P] extends object ? SortClauseRaw<RetainPrimitiveFields<T[P]>> : 1 | -1;

package/src/types/blob.ts

@@ -1,4 +1,4 @@
-import type { BinaryInput, BlobMeta, ByteRange, TimeSpan } from '@travetto/runtime';
+import type { BinaryType, BinaryMetadata, ByteRange, TimeSpan } from '@travetto/runtime';
 
 /**
  * Support for Blobs CRUD.
@@ -11,10 +11,10 @@ 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 metadata 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>;
+  upsertBlob(location: string, input: BinaryType, metadata?: BinaryMetadata, overwrite?: boolean): Promise<void>;
 
   /**
    * Get blob from storage
@@ -26,7 +26,7 @@ export interface ModelBlobSupport {
    * Get metadata for blob
    * @param location The location of the blob
    */
-  getBlobMeta(location: string): Promise<BlobMeta>;
+  getBlobMetadata(location: string): Promise<BinaryMetadata>;
 
   /**
    * Delete blob by location
@@ -37,23 +37,24 @@ export interface ModelBlobSupport {
   /**
    * Update blob metadata
    * @param location The location of the blob
+   * @param metadata The metadata to update
    */
-  updateBlobMeta(location: string, meta: BlobMeta): Promise<void>;
+  updateBlobMetadata(location: string, metadata: BinaryMetadata): Promise<void>;
 
   /**
    * Produces an externally usable URL for sharing limited read access to a specific resource
    *
    * @param location The asset location to read from
-   * @param exp Expiry
+   * @param expiresIn Expiry
    */
-  getBlobReadUrl?(location: string, exp?: TimeSpan): Promise<string>;
+  getBlobReadUrl?(location: string, expiresIn?: TimeSpan): Promise<string>;
 
   /**
    * Produces an externally usable URL for sharing allowing direct write access
    *
    * @param location The asset location to write to
-   * @param meta The metadata to associate with the final asset
-   * @param exp Expiry
+   * @param metadata The metadata to associate with the final asset
+   * @param expiresIn Expiry
    */
-  getBlobWriteUrl?(location: string, meta: BlobMeta, exp?: TimeSpan): Promise<string>;
+  getBlobWriteUrl?(location: string, metadata: BinaryMetadata, expiresIn?: TimeSpan): Promise<string>;
 }

package/src/types/bulk.ts

@@ -1,4 +1,4 @@
-import { type Class, AppError } from '@travetto/runtime';
+import { type Class, RuntimeError } from '@travetto/runtime';
 import type { ValidationError, ValidationResultError } from '@travetto/schema';
 
 import type { ModelCrudSupport } from './crud.ts';
@@ -42,7 +42,7 @@ type BulkErrorItem = { message: string, type: string, errors?: ValidationError[]
 /**
  * Bulk processing error
  */
-export class BulkProcessError extends AppError<{ errors: BulkErrorItem[] }> {
+export class BulkProcessError extends RuntimeError<{ errors: BulkErrorItem[] }> {
   constructor(errors: { idx: number, error: ValidationResultError }[]) {
     super('Bulk processing errors have occurred', {
       category: 'data',

package/src/util/blob.ts

@@ -1,5 +1,4 @@
-import { Readable } from 'node:stream';
-import { AppError, type BinaryInput, BinaryUtil, type BlobMeta, type ByteRange, hasFunction } from '@travetto/runtime';
+import { hasFunction } from '@travetto/runtime';
 import type { ModelBlobSupport } from '../types/blob.ts';
 
 /**
@@ -13,37 +12,7 @@ export class ModelBlobUtil {
   static isSupported = hasFunction<ModelBlobSupport>('getBlob');
 
   /**
-   * Convert input to a Readable, and get what metadata is available
+   * Type guard for determining if service supports blob write urls
    */
-  static async getInput(input: BinaryInput, metadata: BlobMeta = {}): Promise<[Readable, BlobMeta]> {
-    let result: Readable;
-    if (input instanceof Blob) {
-      metadata = { ...BinaryUtil.getBlobMeta(input), ...metadata };
-      metadata.size ??= input.size;
-      result = Readable.fromWeb(input.stream());
-    } else if (typeof input === 'object' && 'pipeThrough' in input) {
-      result = Readable.fromWeb(input);
-    } else if (typeof input === 'object' && 'pipe' in input) {
-      result = input;
-    } else {
-      metadata.size = input.length;
-      result = Readable.from(input);
-    }
-
-    return [result, 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', { category: 'data' });
-    }
-
-    return { start, end };
-  }
+  static isWriteUrlSupported = hasFunction<ModelBlobSupport>('getBlobWriteUrl');
 }

package/src/util/crud.ts

@@ -1,4 +1,4 @@
-import { castTo, type Class, Util, AppError, hasFunction, JSONUtil } from '@travetto/runtime';
+import { castTo, type Class, Util, RuntimeError, hasFunction, BinaryUtil, type BinaryArray, JSONUtil } from '@travetto/runtime';
 import { DataUtil, SchemaRegistryIndex, SchemaValidator, type ValidationError, ValidationResultError } from '@travetto/schema';
 
 import { ModelRegistryIndex } from '../registry/registry-index.ts';
@@ -9,6 +9,8 @@ import { SubTypeNotSupportedError } from '../error/invalid-sub-type.ts';
 import type { DataHandler, PrePersistScope } from '../registry/types.ts';
 import type { ModelCrudSupport } from '../types/crud.ts';
 
+type ModelLoadInput = string | BinaryArray | object;
+
 export type ModelCrudProvider = {
   idSource: ModelIdSource;
 };
@@ -37,13 +39,11 @@ export class ModelCrudUtil {
    * @param cls Class to load model for
    * @param input Input as string or plain object
    */
-  static async load<T extends ModelType>(cls: Class<T>, input: Buffer | string | object, onTypeMismatch: 'notfound' | 'exists' = 'notfound'): Promise<T> {
-    let resolvedInput: object;
-    if (typeof input === 'string' || input instanceof Buffer) {
-      resolvedInput = JSONUtil.parseSafe(input);
-    } else {
-      resolvedInput = input;
-    }
+  static async load<T extends ModelType>(cls: Class<T>, input: ModelLoadInput, onTypeMismatch: 'notfound' | 'exists' = 'notfound'): Promise<T> {
+    const resolvedInput: object =
+      typeof input === 'string' ? JSONUtil.fromUTF8(input) :
+        BinaryUtil.isBinaryArray(input) ? JSONUtil.fromBinaryArray(input) :
+          input;
 
     const result = SchemaRegistryIndex.getBaseClass(cls).from(resolvedInput);
 
@@ -142,11 +142,11 @@ export class ModelCrudUtil {
    */
   static async prePartialUpdate<T extends ModelType>(cls: Class<T>, item: Partial<T>, view?: string): Promise<Partial<T>> {
     if (!DataUtil.isPlainObject(item)) {
-      throw new AppError(`A partial update requires a plain object, not an instance of ${castTo<Function>(item).constructor.name}`, { category: 'data' });
+      throw new RuntimeError(`A partial update requires a plain object, not an instance of ${castTo<Function>(item).constructor.name}`, { category: 'data' });
     }
     const keys = Object.keys(item);
     if ((keys.length === 1 && item.id) || keys.length === 0) {
-      throw new AppError('No fields to update');
+      throw new RuntimeError('No fields to update');
     } else {
       item = { ...item };
       delete item.id;

package/src/util/expiry.ts

@@ -34,7 +34,7 @@ export class ModelExpiryUtil {
   static registerCull(service: ModelExpirySupport & { readonly config?: { cullRate?: number | TimeSpan } }): void {
     const cullable = ModelRegistryIndex.getClasses().filter(cls => !!ModelRegistryIndex.getConfig(cls).expiresAt);
     if (service.deleteExpired && cullable.length) {
-      const cullInterval = TimeUtil.asMillis(service.config?.cullRate ?? '10m');
+      const cullInterval = TimeUtil.duration(service.config?.cullRate ?? '10m', 'ms');
 
       (async (): Promise<void> => {
         await Util.nonBlockingTimeout(1000);

package/src/util/indexed.ts

@@ -71,7 +71,6 @@ export class ModelIndexedUtil {
         if (empty === undefined || empty === Error) {
           throw new IndexNotSupported(cls, config, `Missing field value for ${parts.join('.')}`);
         }
-        itemRef = castTo(empty!);
       } else {
         if (field !== sortField || (opts.includeSortInFields ?? true)) {
           fields.push({ path: parts, value: castTo(itemRef) });

package/support/base-command.ts

@@ -1,7 +1,7 @@
 import { Env } from '@travetto/runtime';
-import { type CliValidationError, type CliCommandShape, cliTpl } from '@travetto/cli';
+import { type CliCommandShape, cliTpl, CliModuleFlag, CliProfilesFlag } from '@travetto/cli';
 import { Registry } from '@travetto/registry';
-import { Schema } from '@travetto/schema';
+import { Schema, type ValidationError } from '@travetto/schema';
 
 import type { ModelStorageSupport } from '../src/types/storage.ts';
 
@@ -13,9 +13,26 @@ import { ModelCandidateUtil } from './bin/candidate.ts';
 @Schema()
 export abstract class BaseModelCommand implements CliCommandShape {
 
+  static async validate(operation: keyof ModelStorageSupport, provider: string, models: string[]): Promise<ValidationError | undefined> {
+    const candidates = await ModelCandidateUtil.export(operation);
+    if (provider && !candidates.providers.includes(provider)) {
+      return { message: `provider: ${provider} is not a valid provider`, source: 'arg', kind: 'invalid', path: 'provider' };
+    }
+    const badModel = models.find(model => model !== '*' && !candidates.models.includes(model));
+    if (badModel) {
+      return { message: `model: ${badModel} is not a valid model`, source: 'arg', kind: 'invalid', path: 'models' };
+    }
+  }
+
+  @CliProfilesFlag()
+  profile: string[];
+
+  @CliModuleFlag({ short: 'm' })
+  module: string;
+
   abstract getOperation(): keyof ModelStorageSupport;
 
-  preMain(): void {
+  finalize(): void {
     Env.DEBUG.set(false);
   }
 
@@ -34,18 +51,5 @@ export abstract class BaseModelCommand implements CliCommandShape {
     ];
   }
 
-  async validate(provider: string, models: string[]): Promise<CliValidationError | undefined> {
-    await Registry.init();
-
-    const candidates = await ModelCandidateUtil.export(this.getOperation());
-    if (provider && !candidates.providers.includes(provider)) {
-      return { message: `provider: ${provider} is not a valid provider`, source: 'arg' };
-    }
-    const badModel = models.find(model => model !== '*' && !candidates.models.includes(model));
-    if (badModel) {
-      return { message: `model: ${badModel} is not a valid model`, source: 'arg' };
-    }
-  }
-
   abstract main(...args: unknown[]): ReturnType<CliCommandShape['main']>;
 }

package/support/cli.model_export.ts

@@ -1,4 +1,5 @@
 import { CliCommand } from '@travetto/cli';
+import { MethodValidator } from '@travetto/schema';
 
 import { BaseModelCommand } from './base-command.ts';
 import { ModelExportUtil } from './bin/export.ts';
@@ -7,11 +8,12 @@ import { ModelCandidateUtil } from './bin/candidate.ts';
 /**
  * Exports model schemas
  */
-@CliCommand({ with: { profiles: true, module: true } })
+@CliCommand()
 export class ModelExportCommand extends BaseModelCommand {
 
   getOperation(): 'exportModel' { return 'exportModel'; }
 
+  @MethodValidator(BaseModelCommand.validate.bind(null, 'exportModel'))
   async main(provider: string, models: string[]): Promise<void> {
     const resolved = await ModelCandidateUtil.resolve(provider, models);
     await ModelExportUtil.run(resolved.provider, resolved.models);

package/support/cli.model_install.ts

@@ -1,4 +1,5 @@
 import { CliCommand, cliTpl } from '@travetto/cli';
+import { MethodValidator } from '@travetto/schema';
 
 import { BaseModelCommand } from './base-command.ts';
 import { ModelInstallUtil } from './bin/install.ts';
@@ -7,11 +8,12 @@ import { ModelCandidateUtil } from './bin/candidate.ts';
 /**
  * Installing models
  */
-@CliCommand({ with: { profiles: true, module: true } })
+@CliCommand()
 export class ModelInstallCommand extends BaseModelCommand {
 
   getOperation(): 'upsertModel' { return 'upsertModel'; }
 
+  @MethodValidator(BaseModelCommand.validate.bind(null, 'upsertModel'))
   async main(provider: string, models: string[]): Promise<void> {
     const resolved = await ModelCandidateUtil.resolve(provider, models);
     await ModelInstallUtil.run(resolved.provider, resolved.models);

package/support/doc.support.tsx

@@ -22,7 +22,7 @@ export const Links = {
   Blob: toLink('Blob', toConcrete<ModelBlobSupport>()),
 };
 
-export const ModelTypes = (fn: | Function): DocJSXElement[] => {
+export const ModelTypes = (fn: Function): DocJSXElement[] => {
   const { content } = DocFileUtil.readSource(fn);
   const found: DocJSXElementByFn<'CodeLink'>[] = [];
   const seen = new Set<string>();

package/support/test/base.ts

@@ -1,5 +1,5 @@
 import { DependencyRegistryIndex } from '@travetto/di';
-import { AppError, castTo, type Class, classConstruct } from '@travetto/runtime';
+import { RuntimeError, castTo, type Class, classConstruct } from '@travetto/runtime';
 
 import { ModelBulkUtil } from '../../src/util/bulk.ts';
 import { ModelCrudUtil } from '../../src/util/crud.ts';
@@ -27,7 +27,7 @@ export abstract class BaseModelSuite<T> {
       }
       return i;
     } else {
-      throw new AppError(`Size is not supported for this service: ${this.serviceClass.name}`);
+      throw new RuntimeError(`Size is not supported for this service: ${this.serviceClass.name}`);
     }
   }
 

package/support/test/blob.ts

@@ -1,15 +1,13 @@
 import assert from 'node:assert';
 
 import { Suite, Test, TestFixtures } from '@travetto/test';
-import { BinaryUtil, Util } from '@travetto/runtime';
+import { BinaryMetadataUtil, BinaryUtil, Util } from '@travetto/runtime';
 
 import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
 
 import type { ModelBlobSupport } from '../../src/types/blob.ts';
 import { ModelBlobUtil } from '../../src/util/blob.ts';
 
-const meta = BinaryUtil.getBlobMeta;
-
 @Suite()
 export abstract class ModelBlobSuite extends BaseModelSuite<ModelBlobSupport> {
 
@@ -18,51 +16,51 @@ export abstract class ModelBlobSuite extends BaseModelSuite<ModelBlobSupport> {
   @Test()
   async writeBasic(): Promise<void> {
     const service = await this.service;
-    const buffer = await this.fixture.read('/asset.yml', true);
+    const buffer = await this.fixture.readBinaryArray('/asset.yml');
 
     const id = Util.uuid();
 
     await service.upsertBlob(id, buffer);
-    const m = await service.getBlobMeta(id);
-    const retrieved = await service.getBlobMeta(id);
+    const m = await service.getBlobMetadata(id);
+    const retrieved = await service.getBlobMetadata(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 buffer = await this.fixture.readBinaryArray('/asset.yml');
 
     const id = Util.uuid();
 
     await service.upsertBlob(id, buffer, { hash: '10' });
-    assert((await service.getBlobMeta(id)).hash === '10');
+    assert((await service.getBlobMetadata(id)).hash === '10');
 
     await service.upsertBlob(id, buffer, { hash: '20' });
-    assert((await service.getBlobMeta(id)).hash === '20');
+    assert((await service.getBlobMetadata(id)).hash === '20');
 
     await service.upsertBlob(id, buffer, { hash: '30' }, false);
-    assert((await service.getBlobMeta(id)).hash === '20');
+    assert((await service.getBlobMetadata(id)).hash === '20');
   }
 
   @Test()
   async writeStream(): Promise<void> {
     const service = await this.service;
-    const buffer = await this.fixture.read('/asset.yml', true);
+    const buffer = await this.fixture.readBinaryArray('/asset.yml');
 
     const id = Util.uuid();
     await service.upsertBlob(id, buffer);
-    const { hash } = await service.getBlobMeta(id);
+    const { hash } = await service.getBlobMetadata(id);
 
     const retrieved = await service.getBlob(id);
-    const { hash: received } = meta(retrieved)!;
+    const { hash: received } = BinaryMetadataUtil.read(retrieved)!;
     assert(hash === received);
   }
 
   @Test()
   async writeAndDelete(): Promise<void> {
     const service = await this.service;
-    const buffer = await this.fixture.read('/asset.yml', true);
+    const buffer = await this.fixture.readBinaryArray('/asset.yml');
 
     const id = Util.uuid();
     await service.upsertBlob(id, buffer);
@@ -77,7 +75,7 @@ export abstract class ModelBlobSuite extends BaseModelSuite<ModelBlobSupport> {
   @Test()
   async partialStream(): Promise<void> {
     const service = await this.service;
-    const buffer = await this.fixture.read('/text.txt', true);
+    const buffer = await this.fixture.readBinaryArray('/text.txt');
 
     const id = Util.uuid();
     await service.upsertBlob(id, buffer);
@@ -89,19 +87,19 @@ export abstract class ModelBlobSuite extends BaseModelSuite<ModelBlobSupport> {
 
     const partial = await service.getBlob(id, { start: 10, end: 20 });
     assert(partial.size === 11);
-    const partialMeta = meta(partial)!;
+    const partialMeta = BinaryMetadataUtil.read(partial)!;
     const subContent = await partial.text();
-    const range = await ModelBlobUtil.enforceRange({ start: 10, end: 20 }, partialMeta.size!);
+    const range = BinaryMetadataUtil.enforceRange({ start: 10, end: 20 }, partialMeta);
     assert(subContent.length === (range.end - range.start) + 1);
 
-    const og = await this.fixture.read('/text.txt');
+    const og = await this.fixture.readText('/text.txt');
 
     assert(subContent === og.substring(10, 21));
 
     const partialUnbounded = await service.getBlob(id, { start: 10 });
-    const partialUnboundedMeta = meta(partial)!;
+    const partialUnboundedMeta = BinaryMetadataUtil.read(partialUnbounded)!;
     const subContent2 = await partialUnbounded.text();
-    const range2 = await ModelBlobUtil.enforceRange({ start: 10 }, partialUnboundedMeta.size!);
+    const range2 = BinaryMetadataUtil.enforceRange({ start: 10 }, partialUnboundedMeta);
     assert(subContent2.length === (range2.end - range2.start) + 1);
     assert(subContent2.startsWith('klm'));
     assert(subContent2.endsWith('xyz'));
@@ -123,15 +121,16 @@ export abstract class ModelBlobSuite extends BaseModelSuite<ModelBlobSupport> {
   @Test()
   async writeAndGet() {
     const service = await this.service;
-    const buffer = await this.fixture.read('/asset.yml', true);
+    const buffer = await this.fixture.readBinaryArray('/asset.yml');
     await service.upsertBlob('orange', buffer, { contentType: 'text/yaml', filename: 'asset.yml' });
     const saved = await service.getBlob('orange');
-    const savedMeta = meta(saved)!;
+    const savedMeta = BinaryMetadataUtil.read(saved)!;
+    console.error(savedMeta);
 
     assert('text/yaml' === savedMeta.contentType);
-    assert(buffer.length === savedMeta.size);
+    assert(buffer.byteLength === savedMeta.size);
     assert('asset.yml' === savedMeta.filename);
-    assert(undefined === savedMeta.hash);
+    assert(!!savedMeta.hash);
   }
 
   @Test()
@@ -140,55 +139,54 @@ export abstract class ModelBlobSuite extends BaseModelSuite<ModelBlobSupport> {
 
     await this.writeAndGet();
 
-    await service.updateBlobMeta('orange', {
+    await service.updateBlobMetadata('orange', {
       contentType: 'text/yml',
       filename: 'orange.yml'
     });
 
-    const savedMeta = await service.getBlobMeta('orange');
+    const savedMeta = await service.getBlobMetadata('orange');
 
     assert('text/yml' === savedMeta.contentType);
     assert('orange.yml' === savedMeta.filename);
-    assert(undefined === savedMeta.hash);
+    assert(savedMeta.hash === undefined);
   }
 
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  @Test({ skip: (x: unknown) => !(x as ModelBlobSuite).serviceClass.prototype.getBlobWriteUrl })
+  @Test({ skip: ModelBlobSuite.ifNot(ModelBlobUtil.isWriteUrlSupported) })
   async signedUrl() {
     const service = await this.service;
 
-    const buffer = Buffer.alloc(1.5 * 10000);
-    for (let i = 0; i < buffer.length; i++) {
-      buffer.writeUInt8(Math.trunc(Math.random() * 255), i);
+    const bytes = BinaryUtil.binaryArrayToBuffer(BinaryUtil.makeBinaryArray(1.5 * 10000));
+    for (let i = 0; i < bytes.byteLength; i++) {
+      bytes.writeUInt8(Math.trunc(Math.random() * 255), i);
     }
 
     const writable = await service.getBlobWriteUrl!('largeFile/one', {
       contentType: 'image/jpeg',
     });
 
-    console.log(writable);
     assert(writable);
 
     const response = await fetch(writable, {
       method: 'PUT',
-      body: new File([buffer], 'gary', { type: 'image/jpeg' }),
+      body: new File([bytes], 'gary', { type: 'image/jpeg' }),
     });
 
     console.error(await response.text());
 
     assert(response.ok);
 
-    await service.updateBlobMeta('largeFile/one', {
+    await service.updateBlobMetadata('largeFile/one', {
       contentType: 'image/jpeg',
       title: 'orange',
       filename: 'gary',
-      size: buffer.length,
+      size: bytes.byteLength,
     });
 
     const found = await service.getBlob('largeFile/one');
-    assert(found.size === buffer.length);
+    const foundMeta = BinaryMetadataUtil.read(found);
+    assert(found.size === bytes.byteLength);
     assert(found.type === 'image/jpeg');
-    assert(BinaryUtil.getBlobMeta(found)?.title === 'orange');
-    assert(BinaryUtil.getBlobMeta(found)?.filename === 'gary');
+    assert(foundMeta.title === 'orange');
+    assert(foundMeta.filename === 'gary');
   }
 }

package/support/test/crud.ts

@@ -67,6 +67,13 @@ class Dated {
   updatedDate: Date;
 }
 
+@Model()
+class BigIntModel {
+  id: string;
+  largeNumber: bigint;
+  optionalBigInt?: bigint;
+}
+
 @Suite()
 export abstract class ModelCrudSuite extends BaseModelSuite<ModelCrudSupport> {
 
@@ -343,4 +350,39 @@ export abstract class ModelCrudSuite extends BaseModelSuite<ModelCrudSupport> {
     assert(o2.simples);
     assert(o2.simples.length === 1);
   }
+
+  @Test('Verify bigint storage and retrieval')
+  async testBigIntReadWrite() {
+    const service = await this.service;
+
+    // Create with bigint values
+    const created = await service.create(BigIntModel, BigIntModel.from({
+      largeNumber: 9007199254740991n, // Number.MAX_SAFE_INTEGER as bigint
+      optionalBigInt: 1234567890123456789n
+    }));
+
+    assert(created.id);
+    assert.strictEqual(created.largeNumber, 9007199254740991n);
+    assert.strictEqual(created.optionalBigInt, 1234567890123456789n);
+
+    // Retrieve and verify
+    const retrieved = await service.get(BigIntModel, created.id);
+    assert.strictEqual(retrieved.largeNumber, 9007199254740991n);
+    assert.strictEqual(retrieved.optionalBigInt, 1234567890123456789n);
+
+    // Update with new bigint value
+    const updated = await service.update(BigIntModel, BigIntModel.from({
+      id: created.id,
+      largeNumber: 18014398509481982n,
+      optionalBigInt: undefined
+    }));
+
+    assert.strictEqual(updated.largeNumber, 18014398509481982n);
+    assert.strictEqual(updated.optionalBigInt, undefined);
+
+    // Verify update persisted
+    const final = await service.get(BigIntModel, created.id);
+    assert.strictEqual(final.largeNumber, 18014398509481982n);
+    assert(!final.optionalBigInt);
+  }
 }

package/support/test/expiry.ts

@@ -2,7 +2,7 @@ import assert from 'node:assert';
 import timers from 'node:timers/promises';
 
 import { Suite, Test } from '@travetto/test';
-import { type TimeSpan, type TimeUnit, TimeUtil } from '@travetto/runtime';
+import { type TimeSpan, TimeUtil } from '@travetto/runtime';
 
 import { ExpiresAt, Model } from '../../src/registry/decorator.ts';
 import type { ModelExpirySupport } from '../../src/types/expiry.ts';
@@ -23,12 +23,12 @@ export abstract class ModelExpirySuite extends BaseModelSuite<ModelExpirySupport
 
   delayFactor: number = 1;
 
-  async wait(n: number | TimeSpan) {
-    await timers.setTimeout(TimeUtil.asMillis(n) * this.delayFactor);
+  async wait(input: TimeSpan | number | string) {
+    await timers.setTimeout(TimeUtil.duration(input, 'ms') * this.delayFactor);
   }
 
-  timeFromNow(v: number | TimeSpan, unit?: TimeUnit) {
-    return TimeUtil.fromNow(TimeUtil.asMillis(v, unit) * this.delayFactor);
+  timeFromNow(input: TimeSpan | number | string) {
+    return TimeUtil.fromNow(TimeUtil.duration(input, 'ms') * this.delayFactor);
   }
 
   @Test()

package/support/test/suite.ts

@@ -1,14 +1,81 @@
-import type { Class } from '@travetto/runtime';
+import { type Class } from '@travetto/runtime';
 import { DependencyRegistryIndex } from '@travetto/di';
 import { Registry } from '@travetto/registry';
-import { SuiteRegistryIndex, TestFixtures } from '@travetto/test';
+import { SuiteRegistryIndex, TestFixtures, type SuitePhaseHandler } from '@travetto/test';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
 import { ModelBlobUtil } from '../../src/util/blob.ts';
 import { ModelStorageUtil } from '../../src/util/storage.ts';
 import { ModelRegistryIndex } from '../../src/registry/registry-index.ts';
 
-const Loaded = Symbol();
+type ConfigType = { autoCreate?: boolean, namespace?: string };
+
+class ModelSuiteHandler<T extends { configClass: Class<ConfigType>, serviceClass: Class }> implements SuitePhaseHandler<T> {
+  qualifier?: symbol;
+  target: Class<T>;
+  constructor(target: Class<T>, qualifier?: symbol) {
+    this.qualifier = qualifier;
+    this.target = target;
+  }
+
+  async beforeAll(instance: T) {
+    await Registry.init();
+
+    const config = await DependencyRegistryIndex.getInstance<ConfigType>(instance.configClass);
+    if ('namespace' in config) {
+      config.namespace = `test_${Math.trunc(Math.random() * 10000)}`;
+    }
+
+    // We manually create
+    config.autoCreate = false;
+  }
+
+  async beforeEach(instance: T) {
+    const service = await DependencyRegistryIndex.getInstance<T>(instance.serviceClass, this.qualifier);
+    if (ModelStorageUtil.isSupported(service)) {
+      await service.createStorage();
+      if (service.upsertModel) {
+        await Promise.all(ModelRegistryIndex.getClasses()
+          .filter(cls => cls === SchemaRegistryIndex.getBaseClass(cls))
+          .map(modelCls => service.upsertModel!(modelCls)));
+      }
+    }
+  }
+
+  async afterEach(instance: T) {
+    const service = await DependencyRegistryIndex.getInstance<T>(instance.serviceClass, this.qualifier);
+    if (ModelStorageUtil.isSupported(service)) {
+      const models = ModelRegistryIndex.getClasses()
+        .filter(model => model === SchemaRegistryIndex.getBaseClass(model));
+
+      if (ModelBlobUtil.isSupported(service) && service.truncateBlob) {
+        await service.truncateBlob();
+      }
+
+      if (service.truncateModel) {
+        await Promise.all(models.map(model => service.truncateModel!(model)));
+      } else if (service.deleteModel) {
+        await Promise.all(models.map(model => service.deleteModel!(model)));
+      } else {
+        await service.deleteStorage(); // Purge it all
+      }
+    }
+  }
+
+  async afterAll(instance: T) {
+    const service = await DependencyRegistryIndex.getInstance<T>(instance.serviceClass, this.qualifier);
+    if (ModelStorageUtil.isSupported(service)) {
+      if (service.deleteModel) {
+        for (const model of ModelRegistryIndex.getClasses()) {
+          if (model === SchemaRegistryIndex.getBaseClass(model)) {
+            await service.deleteModel(model);
+          }
+        }
+      }
+      await service.deleteStorage();
+    }
+  }
+}
 
 /**
  * Model test suite decorator
@@ -21,69 +88,7 @@ export function ModelSuite<T extends { configClass: Class<{ autoCreate?: boolean
   return (target: Class<T>): void => {
     target.prototype.fixtures = fixtures;
     SuiteRegistryIndex.getForRegister(target).register({
-      beforeAll: [
-        async function (this: T & { [Loaded]?: boolean }) {
-          await Registry.init();
-
-          if (!this[Loaded]) {
-            const config = await DependencyRegistryIndex.getInstance(this.configClass);
-            if ('namespace' in config) {
-              config.namespace = `test_${Math.trunc(Math.random() * 10000)}`;
-            }
-            // We manually create
-            config.autoCreate = false;
-            this[Loaded] = true;
-          }
-        }
-      ],
-      beforeEach: [
-        async function (this: T) {
-          const service = await DependencyRegistryIndex.getInstance(this.serviceClass, qualifier);
-          if (ModelStorageUtil.isSupported(service)) {
-            await service.createStorage();
-            if (service.upsertModel) {
-              await Promise.all(ModelRegistryIndex.getClasses()
-                .filter(x => x === SchemaRegistryIndex.getBaseClass(x))
-                .map(m => service.upsertModel!(m)));
-            }
-          }
-        }
-      ],
-      afterEach: [
-        async function (this: T) {
-          const service = await DependencyRegistryIndex.getInstance(this.serviceClass, qualifier);
-          if (ModelStorageUtil.isSupported(service)) {
-            const models = ModelRegistryIndex.getClasses().filter(m => m === SchemaRegistryIndex.getBaseClass(m));
-
-            if (ModelBlobUtil.isSupported(service) && service.truncateBlob) {
-              await service.truncateBlob();
-            }
-
-            if (service.truncateModel) {
-              await Promise.all(models.map(x => service.truncateModel!(x)));
-            } else if (service.deleteModel) {
-              await Promise.all(models.map(x => service.deleteModel!(x)));
-            } else {
-              await service.deleteStorage(); // Purge it all
-            }
-          }
-        }
-      ],
-      afterAll: [
-        async function (this: T) {
-          const service = await DependencyRegistryIndex.getInstance(this.serviceClass, qualifier);
-          if (ModelStorageUtil.isSupported(service)) {
-            if (service.deleteModel) {
-              for (const m of ModelRegistryIndex.getClasses()) {
-                if (m === SchemaRegistryIndex.getBaseClass(m)) {
-                  await service.deleteModel(m);
-                }
-              }
-            }
-            await service.deleteStorage();
-          }
-        }
-      ]
+      phaseHandlers: [new ModelSuiteHandler(target, qualifier)]
     });
   };
 }