@travetto/model 8.0.0-alpha.9 → 8.0.1

package/README.md

@@ -13,10 +13,10 @@ npm install @travetto/model
 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.
+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.
 
 ## A Simple Model
-A model can be simply defined by usage of the [@Model](https://github.com/travetto/travetto/tree/main/module/model/src/registry/decorator.ts#L14) decorator, which opts it into the [Schema](https://github.com/travetto/travetto/tree/main/module/schema#readme "Data type registry for runtime validation, reflection and binding.") contracts, as well as making it available to the [ModelRegistryIndex](https://github.com/travetto/travetto/tree/main/module/model/src/registry/registry-index.ts#L16).
+A model can be simply defined by usage of the [@Model](https://github.com/travetto/travetto/tree/main/module/model/src/registry/decorator.ts#L14) decorator, which opts it into the [Schema](https://github.com/travetto/travetto/tree/main/module/schema#readme "Data type registry for runtime validation, reflection and binding.") contracts, as well as making it available to the [ModelRegistryIndex](https://github.com/travetto/travetto/tree/main/module/model/src/registry/registry-index.ts#L12).
 
 **Code: Basic Structure**
 ```typescript
@@ -30,18 +30,17 @@ export class SampleModel {
 }
 ```
 
-Once the model is defined, it can be leveraged with any of the services that implement the various model storage contracts.  These contracts allow for persisting and fetching of the associated model object.
+Once the model is defined, it can be leveraged with any of the services that implement the various model storage contracts. These contracts allow for persisting and fetching of the associated model object.
 
 ## 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/types/basic.ts#L8), [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/types/crud.ts#L11), [Indexed](https://github.com/travetto/travetto/tree/main/module/model/src/types/indexed.ts#L11), [Expiry](https://github.com/travetto/travetto/tree/main/module/model/src/types/expiry.ts#L10), [Blob](https://github.com/travetto/travetto/tree/main/module/model/src/types/blob.ts#L8) and [Bulk](https://github.com/travetto/travetto/tree/main/module/model/src/types/bulk.ts#L64).
+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/types/basic.ts#L9), [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/types/crud.ts#L10), [Expiry](https://github.com/travetto/travetto/tree/main/module/model/src/types/expiry.ts#L10), [Blob](https://github.com/travetto/travetto/tree/main/module/model/src/types/blob.ts#L8) and [Bulk](https://github.com/travetto/travetto/tree/main/module/model/src/types/bulk.ts#L60).
 
 ### 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/types/basic.ts#L8) contract to be able to participate in the model ecosystem.  This contract represents the bare minimum for a model service.
+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/types/basic.ts#L9) contract to be able to participate in the model ecosystem. This contract represents the bare minimum for a model service.
 
 **Code: Basic Contract**
 ```typescript
 export interface ModelBasicSupport<C = unknown> {
-
   /**
    * Id Source
    */
@@ -76,12 +75,11 @@ export interface ModelBasicSupport<C = unknown> {
 ```
 
 ### CRUD
-The [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/types/crud.ts#L11) contract, builds upon the basic contract, and is built around the idea of simple data retrieval and storage, to create a foundation for other services that need only basic support.  The model extension in [Authentication](https://github.com/travetto/travetto/tree/main/module/auth#readme "Authentication scaffolding for the Travetto framework"), is an example of a module that only needs create, read and delete, and so any implementation of [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") that honors this contract, can be used with the [Authentication](https://github.com/travetto/travetto/tree/main/module/auth#readme "Authentication scaffolding for the Travetto framework") model extension.
+The [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/types/crud.ts#L10) contract, builds upon the basic contract, and is built around the idea of simple data retrieval and storage, to create a foundation for other services that need only basic support. The model extension in [Authentication](https://github.com/travetto/travetto/tree/main/module/auth#readme "Authentication support for the Travetto framework"), is an example of a module that only needs create, read and delete, and so any implementation of [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") that honors this contract, can be used with the [Authentication](https://github.com/travetto/travetto/tree/main/module/auth#readme "Authentication support for the Travetto framework") model extension.
 
 **Code: Crud Contract**
 ```typescript
 export interface ModelCrudSupport extends ModelBasicSupport {
-
   /**
    * Update an item
    * @param item The document to update.
@@ -110,54 +108,21 @@ export interface ModelCrudSupport extends ModelBasicSupport {
   updatePartial<T extends ModelType>(cls: Class<T>, item: Partial<T> & { id: string }, view?: string): Promise<T>;
 
   /**
-   * List all items
+   * List all items of a collection, results returned in batches of items.
+   *
+   * Note: Batch size hint can be used to optimize batch size, but is not guaranteed.
+   *
+   * @param cls The class to list
+   * @param options Options for listing
    */
-  list<T extends ModelType>(cls: Class<T>): AsyncIterable<T>;
+  list<T extends ModelType>(cls: Class<T>, options?: ModelListOptions): AsyncIterable<T[]>;
 }
 ```
 
-### Indexed
-Additionally, an implementation may support the ability for basic [Indexed](https://github.com/travetto/travetto/tree/main/module/model/src/types/indexed.ts#L11) queries. This is not the full featured query support of [Data Model Querying](https://github.com/travetto/travetto/tree/main/module/model-query#readme "Datastore abstraction for advanced query support."), but allowing for indexed lookups.  This does not support listing by index, but may be added at a later date.
-
-**Code: Indexed Contract**
-```typescript
-export interface ModelIndexedSupport extends ModelBasicSupport {
-  /**
-   * Get entity by index as defined by fields of idx and the body fields
-   * @param cls The type to search by
-   * @param idx The index name to search against
-   * @param body The payload of fields needed to search
-   */
-  getByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<T>;
-
-  /**
-   * Delete entity by index as defined by fields of idx and the body fields
-   * @param cls The type to search by
-   * @param idx The index name to search against
-   * @param body The payload of fields needed to search
-   */
-  deleteByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<void>;
-
-  /**
-   * List entity by ranged index as defined by fields of idx and the body fields
-   * @param cls The type to search by
-   * @param idx The index name to search against
-   * @param body The payload of fields needed to search
-   */
-  listByIndex<T extends ModelType>(cls: Class<T>, idx: string, body?: DeepPartial<T>): AsyncIterable<T>;
-
-  /**
-   * Upsert by index, allowing the index to act as a primary key
-   * @param cls The type to create for
-   * @param idx The index name to use
-   * @param body The document to potentially store
-   */
-  upsertByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: OptionalId<T>): Promise<T>;
-}
-```
+The `list` operation returns batches of model records as an async stream. It also accepts listing options such as `limit` to cap how many records are produced, alongside other runtime controls such as abort signals and batch size hints.
 
 ### Expiry
-Certain implementations will also provide support for automatic [Expiry](https://github.com/travetto/travetto/tree/main/module/model/src/types/expiry.ts#L10) of data at runtime.  This is extremely useful for temporary data as, and is used in the [Caching](https://github.com/travetto/travetto/tree/main/module/cache#readme "Caching functionality with decorators for declarative use.") module for expiring data accordingly.
+Certain implementations will also provide support for automatic [Expiry](https://github.com/travetto/travetto/tree/main/module/model/src/types/expiry.ts#L10) of data at runtime. This is extremely useful for temporary data as, and is used in the [Caching](https://github.com/travetto/travetto/tree/main/module/cache#readme "Caching functionality with decorators for declarative use.") module for expiring data accordingly.
 
 **Code: Expiry Contract**
 ```typescript
@@ -172,12 +137,11 @@ export interface ModelExpirySupport extends ModelCrudSupport {
 ```
 
 ### 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/types/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.
+Some implementations also allow for the ability to read/write binary data as [Blob](https://github.com/travetto/travetto/tree/main/module/model/src/types/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: Blob Contract**
 ```typescript
 export interface ModelBlobSupport {
-
   /**
    * Upsert blob to storage
    * @param location The location of the blob
@@ -213,12 +177,13 @@ export interface ModelBlobSupport {
   updateBlobMetadata(location: string, metadata: BinaryMetadata): Promise<void>;
 
   /**
-   * Produces an externally usable URL for sharing limited read access to a specific resource
+   * Produces an externally usable URL for sharing limited read access to a specific resource.
+   * If expiresIn is explicitly set to false, returns a direct/public URL.
    *
    * @param location The asset location to read from
-   * @param expiresIn Expiry
+   * @param expiresIn Expiry or false for public/direct URL
    */
-  getBlobReadUrl?(location: string, expiresIn?: TimeSpan): Promise<string>;
+  getBlobReadUrl?(location: string, expiresIn?: TimeSpan | false): Promise<string>;
 
   /**
    * Produces an externally usable URL for sharing allowing direct write access
@@ -232,7 +197,7 @@ export interface ModelBlobSupport {
 ```
 
 ### Bulk
-Finally, there is support for [Bulk](https://github.com/travetto/travetto/tree/main/module/model/src/types/bulk.ts#L64) operations.  This is not to simply imply issuing many commands at in parallel, but implementation support for an atomic/bulk operation.  This should allow for higher throughput on data ingest, and potentially for atomic support on transactions.
+Finally, there is support for [Bulk](https://github.com/travetto/travetto/tree/main/module/model/src/types/bulk.ts#L60) operations. This is not to simply imply issuing many commands at in parallel, but implementation support for an atomic/bulk operation. This should allow for higher throughput on data ingest, and potentially for atomic support on transactions.
 
 **Code: Bulk Contract**
 ```typescript
@@ -242,7 +207,7 @@ export interface ModelBulkSupport extends ModelCrudSupport {
 ```
 
 ## Declaration
-Models are declared via the [@Model](https://github.com/travetto/travetto/tree/main/module/model/src/registry/decorator.ts#L14) decorator, which allows the system to know that this is a class that is compatible with the module.  The only requirement for a model is the [ModelType](https://github.com/travetto/travetto/tree/main/module/model/src/types/model.ts#L10)
+Models are declared via the [@Model](https://github.com/travetto/travetto/tree/main/module/model/src/registry/decorator.ts#L14) decorator, which allows the system to know that this is a class that is compatible with the module. The only requirement for a model is the [ModelType](https://github.com/travetto/travetto/tree/main/module/model/src/types/model.ts#L10)
 
 **Code: ModelType**
 ```typescript
@@ -256,7 +221,7 @@ 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.").
+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|Blob|Bulk|
@@ -272,25 +237,24 @@ The `id` is the only required field for a model, as this is a hard requirement o
 |[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. [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.
+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 { DependencyRegistryIndex } from '@travetto/di';
-import { RuntimeError, castTo, type Class, classConstruct } from '@travetto/runtime';
+import { type Class, castTo, classConstruct, RuntimeError } from '@travetto/runtime';
 
+import type { ModelType } from '../../src/types/model.ts';
 import { ModelBulkUtil } from '../../src/util/bulk.ts';
 import { ModelCrudUtil } from '../../src/util/crud.ts';
-import type { ModelType } from '../../src/types/model.ts';
 import { ModelSuite } from './suite.ts';
 
-type ServiceClass = { serviceClass: { new(): unknown } };
+type ServiceClass = { serviceClass: { new (): unknown } };
 
 @ModelSuite()
 export abstract class BaseModelSuite<T> {
-
   static ifNot(pred: (svc: unknown) => boolean): (x: unknown) => Promise<boolean> {
     return async (x: unknown) => !pred(classConstruct(castTo<ServiceClass>(x).serviceClass));
   }
@@ -299,11 +263,11 @@ export abstract class BaseModelSuite<T> {
   configClass: Class;
 
   async getSize<U extends ModelType>(cls: Class<U>): Promise<number> {
-    const svc = (await this.service);
+    const svc = await this.service;
     if (ModelCrudUtil.isSupported(svc)) {
       let i = 0;
-      for await (const __el of svc.list(cls)) {
-        i += 1;
+      for await (const batch of svc.list(cls)) {
+        i += batch.length;
       }
       return i;
     } else {
@@ -314,7 +278,10 @@ export abstract class BaseModelSuite<T> {
   async saveAll<M extends ModelType>(cls: Class<M>, items: M[]): Promise<number> {
     const svc = await this.service;
     if (ModelBulkUtil.isSupported(svc)) {
-      const result = await svc.processBulk(cls, items.map(x => ({ insert: x })));
+      const result = await svc.processBulk(
+        cls,
+        items.map(x => ({ insert: x }))
+      );
       return result.counts.insert;
     } else if (ModelCrudUtil.isSupported(svc)) {
       const out: Promise<M>[] = [];
@@ -332,58 +299,80 @@ export abstract class BaseModelSuite<T> {
     return DependencyRegistryIndex.getInstance(this.serviceClass);
   }
 
-  async toArray<U>(src: AsyncIterable<U> | AsyncGenerator<U>): Promise<U[]> {
-    const out: U[] = [];
+  async toArray<U>(src: AsyncIterable<U | U[]> | AsyncGenerator<U | U[]>): Promise<U[]> {
+    const out: (U | U[])[] = [];
     for await (const el of src) {
       out.push(el);
     }
-    return out;
+    return castTo(out.flat());
   }
 }
 ```
 
 ## CLI - model:export
-The module provides the ability to generate an export of the model structure from all the various [@Model](https://github.com/travetto/travetto/tree/main/module/model/src/registry/decorator.ts#L14)s within the application.  This is useful for being able to generate the appropriate files to manually create the data schemas in production.
+The module provides the ability to generate an export of the model structure from all the various [@Model](https://github.com/travetto/travetto/tree/main/module/model/src/registry/decorator.ts#L14)s within the application. This is useful for being able to generate the appropriate files to manually create the data schemas in production.
 
-**Terminal: Running model export**
+**Terminal: Help for model:export**
 ```bash
 $ trv model:export --help
 
-Usage: model:export [options] <provider:string> <models...:string>
-
-Options:
-  -p, --profile <string>  Application profiles
-  -m, --module <module>   Module to run for
-  --help                  display help for command
-
-Providers
---------------------
-  * SQL
-
-Models
---------------------
-  * samplemodel
+TypeError: Cannot redefine property: toJSON
+    at Object.defineProperty (<anonymous>)
+    at file://<workspace-root>/module/runtime/src/json.ts:17:8
+    at ModuleJob.run (node:internal/modules/esm/module_job:569:25)
+    at async node:internal/modules/esm/loader:650:26
+    at async $Runtime.importFrom (<workspace-root>/module/runtime/src/context.ts:136:22)
+    at async $Registry.#init (<workspace-root>/module/registry/src/registry.ts:88:9)
+    at async ModelExportCommand.help (./support/base-command.ts:38:5)
+    at async HelpUtil.getExtendedHelpMessage (<workspace-root>/module/cli/src/help.ts:121:30)
+    at async HelpUtil.renderCommandHelp (<workspace-root>/module/cli/src/help.ts:170:11)
+    at async ExecutionManager.getExecutionCommand (<workspace-root>/module/cli/src/execute.ts:49:22)
+    at async ExecutionManager.run (<workspace-root>/module/cli/src/execute.ts:67:23)
+
+TypeError: Cannot redefine property: toJSON
+    at Object.defineProperty (<anonymous>)
+    at file://<workspace-root>/module/runtime/src/json.ts:17:8
+    at ModuleJob.run (node:internal/modules/esm/module_job:569:25)
+    at async node:internal/modules/esm/loader:650:26
+    at async $Runtime.importFrom (<workspace-root>/module/runtime/src/context.ts:136:22)
+    at async $Registry.#init (<workspace-root>/module/registry/src/registry.ts:88:9)
+    at async ModelExportCommand.help (./support/base-command.ts:38:5)
+    at async HelpUtil.getExtendedHelpMessage (<workspace-root>/module/cli/src/help.ts:121:30)
+    at async HelpUtil.renderCommandHelp (<workspace-root>/module/cli/src/help.ts:170:11)
+    at async ExecutionManager.getExecutionCommand (<workspace-root>/module/cli/src/execute.ts:49:22)
+    at async ExecutionManager.run (<workspace-root>/module/cli/src/execute.ts:67:23)
 ```
 
 ## CLI - model:install
-The module provides the ability to install all the various [@Model](https://github.com/travetto/travetto/tree/main/module/model/src/registry/decorator.ts#L14)s within the application given the current configuration being targeted.  This is useful for being able to prepare the datastore manually.
+The module provides the ability to install all the various [@Model](https://github.com/travetto/travetto/tree/main/module/model/src/registry/decorator.ts#L14)s within the application given the current configuration being targeted. This is useful for being able to prepare the datastore manually.
 
-**Terminal: Running model install**
+**Terminal: Help for model:install**
 ```bash
 $ trv model:install --help
 
-Usage: model:install [options] <provider:string> <models...:string>
-
-Options:
-  -p, --profile <string>  Application profiles
-  -m, --module <module>   Module to run for
-  --help                  display help for command
-
-Providers
---------------------
-  * SQL
-
-Models
---------------------
-  * samplemodel
+TypeError: Cannot redefine property: toJSON
+    at Object.defineProperty (<anonymous>)
+    at file://<workspace-root>/module/runtime/src/json.ts:17:8
+    at ModuleJob.run (node:internal/modules/esm/module_job:569:25)
+    at async node:internal/modules/esm/loader:650:26
+    at async $Runtime.importFrom (<workspace-root>/module/runtime/src/context.ts:136:22)
+    at async $Registry.#init (<workspace-root>/module/registry/src/registry.ts:88:9)
+    at async ModelInstallCommand.help (./support/base-command.ts:38:5)
+    at async HelpUtil.getExtendedHelpMessage (<workspace-root>/module/cli/src/help.ts:121:30)
+    at async HelpUtil.renderCommandHelp (<workspace-root>/module/cli/src/help.ts:170:11)
+    at async ExecutionManager.getExecutionCommand (<workspace-root>/module/cli/src/execute.ts:49:22)
+    at async ExecutionManager.run (<workspace-root>/module/cli/src/execute.ts:67:23)
+
+TypeError: Cannot redefine property: toJSON
+    at Object.defineProperty (<anonymous>)
+    at file://<workspace-root>/module/runtime/src/json.ts:17:8
+    at ModuleJob.run (node:internal/modules/esm/module_job:569:25)
+    at async node:internal/modules/esm/loader:650:26
+    at async $Runtime.importFrom (<workspace-root>/module/runtime/src/context.ts:136:22)
+    at async $Registry.#init (<workspace-root>/module/registry/src/registry.ts:88:9)
+    at async ModelInstallCommand.help (./support/base-command.ts:38:5)
+    at async HelpUtil.getExtendedHelpMessage (<workspace-root>/module/cli/src/help.ts:121:30)
+    at async HelpUtil.renderCommandHelp (<workspace-root>/module/cli/src/help.ts:170:11)
+    at async ExecutionManager.getExecutionCommand (<workspace-root>/module/cli/src/execute.ts:49:22)
+    at async ExecutionManager.run (<workspace-root>/module/cli/src/execute.ts:67:23)
 ```

package/__index__.ts

@@ -1,25 +1,21 @@
+export * from './src/error/exists.ts';
+export * from './src/error/invalid-index.ts';
+export * from './src/error/invalid-sub-type.ts';
+export * from './src/error/not-found.ts';
+export * from './src/error/unique.ts';
 export * from './src/registry/decorator.ts';
-export * from './src/registry/registry-index.ts';
 export * from './src/registry/registry-adapter.ts';
+export * from './src/registry/registry-index.ts';
 export * from './src/registry/types.ts';
-export * from './src/types/model.ts';
-
 export * from './src/types/basic.ts';
 export * from './src/types/blob.ts';
 export * from './src/types/bulk.ts';
 export * from './src/types/crud.ts';
-export * from './src/types/indexed.ts';
 export * from './src/types/expiry.ts';
+export * from './src/types/model.ts';
 export * from './src/types/storage.ts';
-
 export * from './src/util/blob.ts';
 export * from './src/util/bulk.ts';
 export * from './src/util/crud.ts';
 export * from './src/util/expiry.ts';
-export * from './src/util/indexed.ts';
 export * from './src/util/storage.ts';
-
-export * from './src/error/exists.ts';
-export * from './src/error/not-found.ts';
-export * from './src/error/invalid-index.ts';
-export * from './src/error/invalid-sub-type.ts';

package/package.json

@@ -1,40 +1,43 @@
 {
   "name": "@travetto/model",
-  "version": "8.0.0-alpha.9",
-  "type": "module",
+  "version": "8.0.1",
   "description": "Datastore abstraction for core operations.",
   "keywords": [
     "datastore",
     "decorators",
     "schema",
-    "typescript",
-    "travetto"
+    "travetto",
+    "typescript"
   ],
   "homepage": "https://travetto.io",
   "license": "MIT",
   "author": {
-    "email": "travetto.framework@gmail.com",
-    "name": "Travetto Framework"
+    "name": "Travetto Framework",
+    "email": "travetto.framework@gmail.com"
+  },
+  "repository": {
+    "url": "git+https://github.com/travetto/travetto.git",
+    "directory": "module/model"
   },
   "files": [
     "__index__.ts",
     "src",
     "support"
   ],
+  "type": "module",
   "main": "__index__.ts",
-  "repository": {
-    "url": "git+https://github.com/travetto/travetto.git",
-    "directory": "module/model"
+  "publishConfig": {
+    "access": "public"
   },
   "dependencies": {
-    "@travetto/config": "^8.0.0-alpha.9",
-    "@travetto/di": "^8.0.0-alpha.9",
-    "@travetto/registry": "^8.0.0-alpha.9",
-    "@travetto/schema": "^8.0.0-alpha.9"
+    "@travetto/config": "^8.0.1",
+    "@travetto/di": "^8.0.1",
+    "@travetto/registry": "^8.0.1",
+    "@travetto/schema": "^8.0.1"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.14",
-    "@travetto/test": "^8.0.0-alpha.9"
+    "@travetto/cli": "^8.0.1",
+    "@travetto/test": "^8.0.1"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {
@@ -46,8 +49,5 @@
   },
   "travetto": {
     "displayName": "Data Modeling Support"
-  },
-  "publishConfig": {
-    "access": "public"
   }
 }

package/src/error/exists.ts

@@ -10,4 +10,4 @@ export class ExistsError extends RuntimeError {
       details: { id, type: typeof cls === 'string' ? cls : cls.name }
     });
   }
-}
+}

package/src/error/invalid-index.ts

@@ -7,7 +7,9 @@ import type { ModelType } from '../types/model.ts';
  * Represents when an index is invalid
  */
 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' });
+  constructor(cls: Class<T>, idx: IndexConfig, 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

@@ -7,4 +7,4 @@ 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

@@ -7,4 +7,4 @@ 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/error/unique.ts

@@ -0,0 +1,13 @@
+import { type Class, RuntimeError } from '@travetto/runtime';
+
+/**
+ * Represents when a data item violates a unique constraint or index
+ */
+export class UniqueError extends RuntimeError {
+  constructor(cls: Class | string, constraint: string, details: Record<string, unknown> = {}) {
+    super(`${typeof cls === 'string' ? cls : cls.name} violates unique constraint on ${constraint}`, {
+      category: 'data',
+      details: { constraint, type: typeof cls === 'string' ? cls : cls.name, ...details }
+    });
+  }
+}

package/src/registry/decorator.ts

@@ -1,9 +1,9 @@
-import { RuntimeError, castTo, type Class, getClass } from '@travetto/runtime';
+import { type Class, castTo, getClass } from '@travetto/runtime';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
 import type { ModelType } from '../types/model.ts';
-import type { DataHandler, IndexConfig, ModelConfig, PrePersistScope } from './types.ts';
 import { ModelRegistryIndex } from './registry-index.ts';
+import type { DataHandler, ModelConfig, PrePersistScope } from './types.ts';
 
 /**
  * Model decorator, extends `@Schema`
@@ -24,19 +24,6 @@ export function Model(config: Partial<ModelConfig<ModelType>> | string = {}) {
   };
 }
 
-/**
- * Defines an index on a model
- * @kind decorator
- */
-export function Index<T extends ModelType>(...indices: IndexConfig<T>[]) {
-  if (indices.some(config => config.fields.some(field => field === 'id'))) {
-    throw new RuntimeError('Cannot create an index with the id field');
-  }
-  return function (cls: Class<T>): void {
-    ModelRegistryIndex.getForRegister(cls).register({ indices });
-  };
-}
-
 /**
  * Model field decorator for denoting expiry date/time
  * @augments `@travetto/schema:Field`
@@ -56,10 +43,12 @@ export function ExpiresAt() {
 export function PrePersist<T>(handler: DataHandler<T>, scope: PrePersistScope = 'all') {
   return function (cls: Class<T>): void {
     ModelRegistryIndex.getForRegister(cls).register({
-      prePersist: [{
-        scope,
-        handler: castTo(handler)
-      }]
+      prePersist: [
+        {
+          scope,
+          handler: castTo(handler)
+        }
+      ]
     });
   };
 }
@@ -72,13 +61,15 @@ export function PrePersist<T>(handler: DataHandler<T>, scope: PrePersistScope =
 export function PersistValue<T>(handler: (current: T | undefined) => T, scope: PrePersistScope = 'all') {
   return function <K extends string, C extends Partial<Record<K, T>>>(instance: C, property: K): void {
     ModelRegistryIndex.getForRegister(getClass(instance)).register({
-      prePersist: [{
-        scope,
-        handler: (inst): void => {
-          const cInst: Record<K, T> = castTo(inst);
-          cInst[property] = handler(cInst[property]);
+      prePersist: [
+        {
+          scope,
+          handler: (inst): void => {
+            const cInst: Record<K, T> = castTo(inst);
+            cInst[property] = handler(cInst[property]);
+          }
         }
-      }]
+      ]
     });
   };
 }
@@ -91,13 +82,28 @@ export function PersistValue<T>(handler: (current: T | undefined) => T, scope: P
 export function Transient<T>() {
   return function <K extends string, C extends Partial<Record<K, T>>>(instance: C, property: K): void {
     ModelRegistryIndex.getForRegister(getClass(instance)).register({
-      prePersist: [{
-        scope: 'all',
-        handler: (inst): void => {
-          const cInst: Record<K, T> = castTo(inst);
-          delete cInst[property];
+      prePersist: [
+        {
+          scope: 'all',
+          handler: (inst): void => {
+            const cInst: Record<K, T> = castTo(inst);
+            delete cInst[property];
+          }
         }
-      }]
+      ]
+    });
+  };
+}
+
+/**
+ * Prevent a field from being persisted
+ * @augments `@travetto/schema:Field`
+ * @kind decorator
+ */
+export function TransientField() {
+  return function <K extends string, C extends Partial<Record<K, unknown>>>(instance: C, property: K): void {
+    ModelRegistryIndex.getForRegister(getClass(instance)).register({
+      transientFields: [property]
     });
   };
 }
@@ -111,4 +117,4 @@ export function PostLoad<T>(handler: DataHandler<T>) {
   return function (cls: Class<T>): void {
     ModelRegistryIndex.getForRegister(cls).register({ postLoad: [castTo(handler)] });
   };
-}
+}